diff --git a/src/main/runtime/rpc/methods/orchestration.test.ts b/src/main/runtime/rpc/methods/orchestration.test.ts
index 7793cb160f2..27553ed97aa 100644
--- a/src/main/runtime/rpc/methods/orchestration.test.ts
+++ b/src/main/runtime/rpc/methods/orchestration.test.ts
@@ -1450,109 +1450,6 @@ describe('orchestration RPC methods', () => {
       expect(db.getTask(result.task.id)?.coordinator_run_id).toBeNull()
       expect(db.getTask(result.task.id)?.target_key).toBeNull()
     })
-
-    it('stamps target_key from --target-worktree (#9 recipe director path)', async () => {
-      setup()
-      // The renderer recipe director has the director worktree id, not a terminal
-      // handle, so it passes a worktree selector. It resolves through the SAME
-      // resolveOrchestrationTargetKey the run uses, so the keys match for adoption.
-      const targetSpy = vi
-        .spyOn(runtime, 'resolveOrchestrationTargetKey')
-        .mockResolvedValue('worktree:director1')
-      const terminalSpy = vi.spyOn(runtime, 'resolveOrchestrationTargetKeyForTerminal')
-
-      const result = (await call('orchestration.taskCreate', {
-        spec: 'implement',
-        targetWorktree: 'id:director1'
-      })) as { task: { id: string } }
-
-      expect(targetSpy).toHaveBeenCalledWith('id:director1')
-      // --target-worktree wins: the terminal resolver is not consulted.
-      expect(terminalSpy).not.toHaveBeenCalled()
-      expect(db.getTask(result.task.id)?.target_key).toBe('worktree:director1')
-    })
-
-    it('refuses a task whose --target-worktree does not resolve (fail closed)', async () => {
-      setup()
-      vi.spyOn(runtime, 'resolveOrchestrationTargetKey').mockRejectedValue(
-        new Error('selector_not_found')
-      )
-
-      await expect(
-        call('orchestration.taskCreate', { spec: 'x', targetWorktree: 'id:gone' })
-      ).rejects.toThrow(/selector_not_found/)
-    })
-  })
-
-  describe('orchestration.taskCreate ↔ run target_key adoption (#9 end-to-end)', () => {
-    // Why (#9, F1 clash seam): the task path (taskCreate --target-worktree) and the
-    // run path (orchestration.run --worktree) must resolve the SAME target_key, or
-    // run-start adoption silently fails to claim the task and the recipe never
-    // dispatches. These tests prove the binding through the REAL resolver and the
-    // REAL db.adoptUnownedTasks — not a mocked resolver returning a matched literal.
-    // Only the lowest-level filesystem worktree lookup is stubbed (id:X → worktree
-    // X); resolveOrchestrationTargetKey and adoptUnownedTasks run their real code.
-    function stubWorktreeLookup(): void {
-      ;(
-        runtime as unknown as {
-          resolveWorktreeSelector: (selector: string) => Promise<{ id: string }>
-        }
-      ).resolveWorktreeSelector = async (selector) => ({ id: selector.replace(/^id:/, '') })
-    }
-
-    it('adopts a task stamped via --target-worktree into a run on the same worktree', async () => {
-      setup()
-      stubWorktreeLookup()
-
-      // Task path: the renderer recipe director stamps the task by worktree id.
-      const { task } = (await call('orchestration.taskCreate', {
-        spec: 'implement',
-        targetWorktree: 'id:W'
-      })) as { task: { id: string; target_key: string | null } }
-
-      // Run path: resolve target_key the EXACT way orchestration.run does, start
-      // the run, then adopt the EXACT way the coordinator's executeLoop does.
-      const runTargetKey = await runtime.resolveOrchestrationTargetKey('id:W')
-      const run = db.startCoordinatorRun({
-        spec: 'recipe:implement_then_review',
-        coordinatorHandle: 'coordinator-e2e',
-        targetKey: runTargetKey,
-        worktreeBacked: true,
-        workerAgent: 'claude'
-      })
-      const bound = db.adoptUnownedTasks(run.id, db.getCoordinatorRun(run.id)?.target_key ?? null)
-
-      // Both paths resolved worktree:W → adoption binds the task to the run.
-      expect(task.target_key).toBe('worktree:W')
-      expect(bound).toBe(1)
-      expect(db.getTask(task.id)?.coordinator_run_id).toBe(run.id)
-    })
-
-    it('does NOT adopt a task stamped to a different worktree (fails if keys ever diverge)', async () => {
-      setup()
-      stubWorktreeLookup()
-
-      // Stamped to a DIFFERENT worktree than the run targets. This is the negative
-      // control: it makes the positive test meaningful — if taskCreate and run ever
-      // resolved the same key for different worktree inputs (the divergence we
-      // guard against), this task would wrongly bind and this assertion would fail.
-      const { task } = (await call('orchestration.taskCreate', {
-        spec: 'implement',
-        targetWorktree: 'id:OTHER'
-      })) as { task: { id: string } }
-
-      const runTargetKey = await runtime.resolveOrchestrationTargetKey('id:W')
-      const run = db.startCoordinatorRun({
-        spec: 'recipe',
-        coordinatorHandle: 'coordinator-e2e-2',
-        targetKey: runTargetKey,
-        worktreeBacked: true,
-        workerAgent: 'claude'
-      })
-      db.adoptUnownedTasks(run.id, db.getCoordinatorRun(run.id)?.target_key ?? null)
-
-      expect(db.getTask(task.id)?.coordinator_run_id).toBeNull()
-    })
   })
 
   describe('orchestration.reset', () => {
diff --git a/src/main/runtime/rpc/methods/orchestration.ts b/src/main/runtime/rpc/methods/orchestration.ts
index 5dc15a1cedc..29ce0520944 100644
--- a/src/main/runtime/rpc/methods/orchestration.ts
+++ b/src/main/runtime/rpc/methods/orchestration.ts
@@ -128,12 +128,7 @@ const TaskCreateParams = z.object({
   displayName: OptionalString,
   deps: OptionalString,
   parent: OptionalString,
-  callerTerminalHandle: OptionalString,
-  // Why (#9): the recipe director runs in the renderer and holds the director
-  // worktree id, not a live terminal handle. A worktree selector lets it stamp
-  // the task's target directly — symmetric with orchestration.run's `worktree`,
-  // and using the SAME resolver so the keys match and run-start adoption binds.
-  targetWorktree: OptionalString
+  callerTerminalHandle: OptionalString
 })
 
 const TaskListParams = z.object({
@@ -392,13 +387,9 @@ export const ORCHESTRATION_METHODS: RpcMethod[] = [
       // Why (#12): stamp the task with its OWN target (the creating terminal's
       // worktree) so adoption only binds it to a same-target run — never poached
       // by a concurrent run on another target.
-      // Why (#9): an explicit --target-worktree wins (the renderer recipe director
-      // has a worktree id, not a terminal handle) and resolves through the same
-      // resolveOrchestrationTargetKey that orchestration.run uses, so the task's
-      // key matches the run's and run-start adoptUnownedTasks claims it.
-      const targetKey = params.targetWorktree
-        ? await runtime.resolveOrchestrationTargetKey(params.targetWorktree)
-        : await runtime.resolveOrchestrationTargetKeyForTerminal(params.callerTerminalHandle)
+      const targetKey = await runtime.resolveOrchestrationTargetKeyForTerminal(
+        params.callerTerminalHandle
+      )
       // Why (#12): a task created while a run is active belongs to that run so
       // the coordinator's run-scoped listTasks sees it — but only the run on the
       // SAME target (getActiveCoordinatorRunForTarget, not the global latest).
diff --git a/src/renderer/src/components/OrchestratorLaunchModal.tsx b/src/renderer/src/components/OrchestratorLaunchModal.tsx
index ed1695eaef0..e7a74900bf4 100644
--- a/src/renderer/src/components/OrchestratorLaunchModal.tsx
+++ b/src/renderer/src/components/OrchestratorLaunchModal.tsx
@@ -17,13 +17,7 @@ import { buildNewWorkspaceCreateTargetOptions } from '@/lib/new-workspace-projec
 import { getComposerEligibleRepos } from '@/lib/new-workspace-composer-repo'
 import { getAgentCatalog } from '@/lib/agent-catalog'
 import { filterEnabledTuiAgents } from '../../../shared/tui-agent-selection'
-import { DirectorTypePicker } from '@/components/director/DirectorTypePicker'
-import {
-  LlmDirectorBackend,
-  RecipeDirectorBackend,
-  type DirectorKind
-} from '@/lib/director-backend'
-import { getRecipes } from '@/lib/recipe-director-recipes'
+import { launchOrchestratorForProject } from '@/lib/orchestrator-launch'
 import { translate } from '@/i18n/i18n'
 import type { TuiAgent } from '../../../shared/types'
 
@@ -55,11 +49,6 @@ export default function OrchestratorLaunchModal(): React.JSX.Element | null {
   const detectedAgentIds = useAppStore((s) => s.detectedAgentIds)
   const disabledTuiAgents = useAppStore((s) => s.settings?.disabledTuiAgents)
   const defaultTuiAgent = useAppStore((s) => s.settings?.defaultTuiAgent ?? null)
-  // Why: #11 owns the gate — the Recipe director option only appears under the
-  // experimental flag; with it off the modal behaves exactly as it did before.
-  const experimentalOrchestrators = useAppStore(
-    (s) => s.settings?.experimentalOrchestrators ?? false
-  )
 
   const nameId = useId()
   const promptId = useId()
@@ -101,13 +90,10 @@ export default function OrchestratorLaunchModal(): React.JSX.Element | null {
         : null,
     [projectOptions, prefillProjectId]
   )
-  const recipes = useMemo(() => getRecipes(), [])
   const [selectedOptionId, setSelectedOptionId] = useState<string | null>(null)
   const [name, setName] = useState('')
   const [agent, setAgent] = useState<TuiAgent | null>(null)
   const [prompt, setPrompt] = useState('')
-  const [directorKind, setDirectorKind] = useState<DirectorKind>('llm')
-  const [recipeName, setRecipeName] = useState<string | null>(null)
 
   useEffect(() => {
     if (visible) {
@@ -115,8 +101,6 @@ export default function OrchestratorLaunchModal(): React.JSX.Element | null {
       setAgent(defaultTuiAgent && defaultTuiAgent !== 'blank' ? defaultTuiAgent : null)
       setName(prefillName)
       setPrompt(prefillPrompt)
-      setDirectorKind('llm')
-      setRecipeName(recipes[0]?.name ?? null)
     }
   }, [
     visible,
@@ -124,8 +108,7 @@ export default function OrchestratorLaunchModal(): React.JSX.Element | null {
     prefilledProjectOptionId,
     defaultTuiAgent,
     prefillName,
-    prefillPrompt,
-    recipes
+    prefillPrompt
   ])
 
   if (!visible) {
@@ -138,28 +121,15 @@ export default function OrchestratorLaunchModal(): React.JSX.Element | null {
       ? (projects.find((p) => p.id === selectedOption.projectId) ?? null)
       : null
 
-  // The Recipe director is gated; if the flag is off, only the Smart path is live.
-  const isRecipe = directorKind === 'recipe' && experimentalOrchestrators
-
   const handleLaunch = (): void => {
     if (!project) {
       return
     }
-    // Dispatch through the DirectorBackend abstraction (#8) instead of branching
-    // on the kind at the call site.
-    if (isRecipe) {
-      const recipe = recipes.find((entry) => entry.name === recipeName)
-      if (!recipe) {
-        return
-      }
-      void new RecipeDirectorBackend(recipe).launch(project, { name: name.trim() || undefined })
-    } else {
-      void new LlmDirectorBackend().launch(project, {
-        name: name.trim() || undefined,
-        agent: agent ?? undefined,
-        prompt: prompt.trim() || undefined
-      })
-    }
+    void launchOrchestratorForProject(project, {
+      name: name.trim() || undefined,
+      agent: agent ?? undefined,
+      prompt: prompt.trim() || undefined
+    })
     closeModal()
   }
 
@@ -214,16 +184,6 @@ export default function OrchestratorLaunchModal(): React.JSX.Element | null {
               )}
             />
           </div>
-          {experimentalOrchestrators && (
-            <DirectorTypePicker
-              kind={directorKind}
-              onKindChange={setDirectorKind}
-              showRecipeOption={experimentalOrchestrators}
-              recipes={recipes}
-              selectedRecipeName={recipeName}
-              onRecipeChange={setRecipeName}
-            />
-          )}
           <div className="space-y-2">
             <Label htmlFor={nameId} className="text-xs">
               {translate('auto.components.OrchestratorLaunchModal.name', 'Name')}
@@ -239,43 +199,36 @@ export default function OrchestratorLaunchModal(): React.JSX.Element | null {
               }
             />
           </div>
-          {/* Why: agent + task are the Smart director's coordinator-LLM inputs. The
-              Recipe director runs a fixed, token-free workflow with no director LLM
-              to seed, so these are hidden in recipe mode. */}
-          {!isRecipe && (
-            <>
-              <div className="space-y-2">
-                <Label className="text-xs">
-                  {translate('auto.components.OrchestratorLaunchModal.agent', 'Agent')}
-                </Label>
-                <AgentCombobox agents={agents} value={agent} onValueChange={setAgent} />
-              </div>
-              <div className="space-y-2">
-                <Label htmlFor={promptId} className="text-xs">
-                  {translate(
-                    'auto.components.OrchestratorLaunchModal.task',
-                    'What should it orchestrate?'
-                  )}
-                </Label>
-                <textarea
-                  id={promptId}
-                  value={prompt}
-                  onChange={(event) => setPrompt(event.target.value)}
-                  rows={4}
-                  placeholder={translate(
-                    'auto.components.OrchestratorLaunchModal.task_placeholder',
-                    'Describe the work — the director plans how to split it into worktrees/PRs. Optional.'
-                  )}
-                  className="flex w-full resize-none rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-xs transition-[color,box-shadow] outline-none placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50"
-                />
-              </div>
-            </>
-          )}
+          <div className="space-y-2">
+            <Label className="text-xs">
+              {translate('auto.components.OrchestratorLaunchModal.agent', 'Agent')}
+            </Label>
+            <AgentCombobox agents={agents} value={agent} onValueChange={setAgent} />
+          </div>
+          <div className="space-y-2">
+            <Label htmlFor={promptId} className="text-xs">
+              {translate(
+                'auto.components.OrchestratorLaunchModal.task',
+                'What should it orchestrate?'
+              )}
+            </Label>
+            <textarea
+              id={promptId}
+              value={prompt}
+              onChange={(event) => setPrompt(event.target.value)}
+              rows={4}
+              placeholder={translate(
+                'auto.components.OrchestratorLaunchModal.task_placeholder',
+                'Describe the work — the director plans how to split it into worktrees/PRs. Optional.'
+              )}
+              className="flex w-full resize-none rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-xs transition-[color,box-shadow] outline-none placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50"
+            />
+          </div>
           <DialogFooter>
             <Button type="button" variant="ghost" onClick={closeModal}>
               {translate('auto.components.OrchestratorLaunchModal.cancel', 'Cancel')}
             </Button>
-            <Button type="submit" disabled={!project || (isRecipe && !recipeName)}>
+            <Button type="submit" disabled={!project}>
               {translate('auto.components.OrchestratorLaunchModal.launch', 'Launch Orcastrator')}
             </Button>
           </DialogFooter>
diff --git a/src/renderer/src/components/director/DirectorTypePicker.test.tsx b/src/renderer/src/components/director/DirectorTypePicker.test.tsx
deleted file mode 100644
index 6632ff3d9ec..00000000000
--- a/src/renderer/src/components/director/DirectorTypePicker.test.tsx
+++ /dev/null
@@ -1,74 +0,0 @@
-// @vitest-environment happy-dom
-
-import type { ReactNode } from 'react'
-import { renderToStaticMarkup } from 'react-dom/server'
-import { describe, expect, it, vi } from 'vitest'
-import { DirectorTypePicker } from './DirectorTypePicker'
-import { getRecipes } from '@/lib/recipe-director-recipes'
-
-vi.mock('@/i18n/i18n', () => ({
-  translate: (_key: string, fallback: string) => fallback
-}))
-
-// Render the Radix Select as plain inline markup so its items are assertable
-// without opening the portal (the picker only needs the option list to be present).
-vi.mock('@/components/ui/select', () => ({
-  Select: ({ children }: { children: ReactNode }) => <div data-select>{children}</div>,
-  SelectContent: ({ children }: { children: ReactNode }) => <div>{children}</div>,
-  SelectItem: ({ value, children }: { value: string; children: ReactNode }) => (
-    <div data-recipe-item={value}>{children}</div>
-  ),
-  SelectTrigger: ({ children }: { children: ReactNode }) => <div>{children}</div>,
-  SelectValue: ({ placeholder }: { placeholder?: string }) => <span>{placeholder}</span>
-}))
-
-const noop = (): void => {}
-
-function render(props: Partial<Parameters<typeof DirectorTypePicker>[0]>): string {
-  return renderToStaticMarkup(
-    <DirectorTypePicker
-      kind="llm"
-      onKindChange={noop}
-      showRecipeOption={false}
-      recipes={getRecipes()}
-      selectedRecipeName={getRecipes()[0]?.name ?? null}
-      onRecipeChange={noop}
-      {...props}
-    />
-  )
-}
-
-describe('DirectorTypePicker', () => {
-  it('always offers the Smart director option', () => {
-    const html = render({ showRecipeOption: false })
-    expect(html).toContain('Smart director')
-  })
-
-  it('hides the Recipe director option when the experimental flag is off', () => {
-    const html = render({ showRecipeOption: false })
-    expect(html).not.toContain('Recipe director')
-  })
-
-  it('offers the Recipe director option only when the flag is on', () => {
-    const html = render({ showRecipeOption: true })
-    expect(html).toContain('Smart director')
-    expect(html).toContain('Recipe director')
-    // The copy hook that justifies a token-free director.
-    expect(html).toContain('No director LLM; runs a fixed workflow.')
-  })
-
-  it('does not render the recipe dropdown while Smart is selected', () => {
-    const html = render({ kind: 'llm', showRecipeOption: true })
-    expect(html).not.toContain('data-select')
-  })
-
-  it('lists every recipe from getRecipes() when Recipe is selected', () => {
-    const recipes = getRecipes()
-    expect(recipes.length).toBeGreaterThan(0)
-    const html = render({ kind: 'recipe', showRecipeOption: true, recipes })
-    for (const recipe of recipes) {
-      expect(html).toContain(`data-recipe-item="${recipe.name}"`)
-      expect(html).toContain(recipe.name)
-    }
-  })
-})
diff --git a/src/renderer/src/components/director/DirectorTypePicker.tsx b/src/renderer/src/components/director/DirectorTypePicker.tsx
deleted file mode 100644
index 0539c437f97..00000000000
--- a/src/renderer/src/components/director/DirectorTypePicker.tsx
+++ /dev/null
@@ -1,191 +0,0 @@
-import type React from 'react'
-import { ListChecks, Sparkles } from 'lucide-react'
-import { Select, SelectContent, SelectItem, SelectTrigger } from '@/components/ui/select'
-import { Label } from '@/components/ui/label'
-import { translate } from '@/i18n/i18n'
-import type { DirectorKind } from '@/lib/director-backend'
-import type { Recipe } from '@/lib/recipe-director-recipes'
-
-// Why (#11): the `+` in ORCASTRATORS now picks the DIRECTOR TYPE first, then
-// dispatches through the DirectorBackend (#8). Smart is the existing LLM
-// coordinator; Recipe is the token-free fixed workflow. The Recipe option is the
-// gate for `experimentalOrchestrators` — `launchRecipeDirector` is ungated by
-// design, so the picker is where the flag is enforced (option hidden when off).
-
-type DirectorOption = {
-  kind: DirectorKind
-  icon: React.ReactNode
-  title: string
-  caption: string
-}
-
-type DirectorTypePickerProps = {
-  kind: DirectorKind
-  onKindChange: (kind: DirectorKind) => void
-  /** Gate: when false the Recipe option is hidden and only Smart is offered
-   *  (the pre-#11 behavior). Driven by `experimentalOrchestrators`. */
-  showRecipeOption: boolean
-  recipes: Recipe[]
-  selectedRecipeName: string | null
-  onRecipeChange: (recipeName: string) => void
-}
-
-export function DirectorTypePicker({
-  kind,
-  onKindChange,
-  showRecipeOption,
-  recipes,
-  selectedRecipeName,
-  onRecipeChange
-}: DirectorTypePickerProps): React.JSX.Element {
-  // Smart is always available; Recipe only under the experimental gate.
-  const options: DirectorOption[] = [
-    {
-      kind: 'llm',
-      icon: <Sparkles className="size-4" strokeWidth={1.75} />,
-      title: translate('auto.components.director.DirectorTypePicker.smart_title', 'Smart director'),
-      caption: translate(
-        'auto.components.director.DirectorTypePicker.smart_caption',
-        'Uses your default LLM and /orcastrate to plan and run the work.'
-      )
-    }
-  ]
-  if (showRecipeOption) {
-    options.push({
-      kind: 'recipe',
-      icon: <ListChecks className="size-4" strokeWidth={1.75} />,
-      title: translate(
-        'auto.components.director.DirectorTypePicker.recipe_title',
-        'Recipe director'
-      ),
-      // Why: this framing answers "why spend tokens on a director?" up front.
-      caption: translate(
-        'auto.components.director.DirectorTypePicker.recipe_caption',
-        'No director LLM; runs a fixed workflow.'
-      )
-    })
-  }
-
-  // Arrow keys move the radio selection across the visible options.
-  const moveSelection = (direction: 1 | -1): void => {
-    const index = options.findIndex((option) => option.kind === kind)
-    const next = options[(index + direction + options.length) % options.length]
-    if (next) {
-      onKindChange(next.kind)
-    }
-  }
-
-  return (
-    <div className="space-y-3">
-      <div
-        role="radiogroup"
-        aria-label={translate(
-          'auto.components.director.DirectorTypePicker.group_label',
-          'Director type'
-        )}
-        className="grid gap-2"
-      >
-        {options.map((option) => {
-          const selected = option.kind === kind
-          return (
-            <button
-              key={option.kind}
-              type="button"
-              role="radio"
-              aria-checked={selected}
-              tabIndex={selected ? 0 : -1}
-              onClick={() => onKindChange(option.kind)}
-              onKeyDown={(event) => {
-                if (
-                  event.key === 'ArrowDown' ||
-                  event.key === 'ArrowRight' ||
-                  event.key === 'ArrowUp' ||
-                  event.key === 'ArrowLeft'
-                ) {
-                  event.preventDefault()
-                  moveSelection(event.key === 'ArrowDown' || event.key === 'ArrowRight' ? 1 : -1)
-                } else if (event.key === ' ' || event.key === 'Enter') {
-                  event.preventDefault()
-                  onKindChange(option.kind)
-                }
-              }}
-              data-kind={option.kind}
-              className={`group relative flex cursor-pointer items-start gap-3 rounded-md border px-3.5 py-3 text-left transition-colors outline-none focus-visible:ring-[3px] focus-visible:ring-ring/50 ${
-                selected ? 'border-foreground/30 bg-accent' : 'border-border hover:bg-accent/50'
-              }`}
-            >
-              <span
-                className={`inline-flex size-8 shrink-0 items-center justify-center rounded-md border transition-colors ${
-                  selected
-                    ? 'border-foreground/20 bg-background/60 text-foreground'
-                    : 'border-border/70 bg-background/30 text-muted-foreground group-hover:text-foreground'
-                }`}
-              >
-                {option.icon}
-              </span>
-              <span className="min-w-0">
-                <span className="block text-[13px] font-medium leading-tight">{option.title}</span>
-                <span className="mt-0.5 block text-[11px] leading-snug text-muted-foreground">
-                  {option.caption}
-                </span>
-              </span>
-            </button>
-          )
-        })}
-      </div>
-      {kind === 'recipe' && showRecipeOption && (
-        <div className="space-y-2">
-          <Label className="text-xs">
-            {translate('auto.components.director.DirectorTypePicker.recipe_label', 'Recipe')}
-          </Label>
-          <Select value={selectedRecipeName ?? undefined} onValueChange={onRecipeChange}>
-            {/* Why: show only the selected recipe NAME in the trigger. The menu's
-                rich two-line name+description is single-line + `whitespace-nowrap`
-                here, so mirroring it via SelectValue blew the field — and the whole
-                dialog grid (min-width:auto) — far past the modal width. The
-                description stays in the menu (mirrors the Project combobox). */}
-            <SelectTrigger
-              size="sm"
-              className="w-full min-w-0 text-xs"
-              aria-label={translate(
-                'auto.components.director.DirectorTypePicker.recipe_label',
-                'Recipe'
-              )}
-            >
-              <span className="truncate">
-                {selectedRecipeName ?? (
-                  <span className="text-muted-foreground">
-                    {translate(
-                      'auto.components.director.DirectorTypePicker.recipe_placeholder',
-                      'Select a recipe'
-                    )}
-                  </span>
-                )}
-              </span>
-            </SelectTrigger>
-            {/* Why: popper + trigger-width keeps the menu bounded to the field and
-                collision-aware so long recipe descriptions don't spill past the
-                modal edge or cover the Cancel/Launch row (mirrors the Project
-                combobox above). */}
-            <SelectContent
-              position="popper"
-              align="start"
-              className="w-[var(--radix-select-trigger-width)]"
-            >
-              {recipes.map((recipe) => (
-                <SelectItem key={recipe.name} value={recipe.name}>
-                  <span className="flex flex-col">
-                    <span className="text-[13px]">{recipe.name}</span>
-                    <span className="text-[11px] leading-snug text-muted-foreground">
-                      {recipe.description}
-                    </span>
-                  </span>
-                </SelectItem>
-              ))}
-            </SelectContent>
-          </Select>
-        </div>
-      )}
-    </div>
-  )
-}
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index b53e541979e..80eb635f8e9 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -11819,17 +11819,6 @@
         "task_placeholder": "Describe the work — the director plans how to split it into worktrees/PRs. Optional.",
         "cancel": "Cancel",
         "launch": "Launch Orcastrator"
-      },
-      "director": {
-        "DirectorTypePicker": {
-          "smart_title": "Smart director",
-          "smart_caption": "Uses your default LLM and /orcastrate to plan and run the work.",
-          "recipe_title": "Recipe director",
-          "recipe_caption": "No director LLM; runs a fixed workflow.",
-          "group_label": "Director type",
-          "recipe_label": "Recipe",
-          "recipe_placeholder": "Select a recipe"
-        }
       }
     },
     "i18n": {
diff --git a/src/renderer/src/i18n/locales/es.json b/src/renderer/src/i18n/locales/es.json
index 313cac48e5f..4efbc0f32a0 100644
--- a/src/renderer/src/i18n/locales/es.json
+++ b/src/renderer/src/i18n/locales/es.json
@@ -11819,17 +11819,6 @@
         "task_placeholder": "Describe the work — the director plans how to split it into worktrees/PRs. Optional.",
         "cancel": "Cancel",
         "launch": "Launch Orcastrator"
-      },
-      "director": {
-        "DirectorTypePicker": {
-          "smart_title": "Smart director",
-          "smart_caption": "Uses your default LLM and /orcastrate to plan and run the work.",
-          "recipe_title": "Recipe director",
-          "recipe_caption": "No director LLM; runs a fixed workflow.",
-          "group_label": "Director type",
-          "recipe_label": "Recipe",
-          "recipe_placeholder": "Select a recipe"
-        }
       }
     },
     "i18n": {
diff --git a/src/renderer/src/i18n/locales/ja.json b/src/renderer/src/i18n/locales/ja.json
index 3c5aa540a93..819435fbb20 100644
--- a/src/renderer/src/i18n/locales/ja.json
+++ b/src/renderer/src/i18n/locales/ja.json
@@ -11819,17 +11819,6 @@
         "task_placeholder": "Describe the work — the director plans how to split it into worktrees/PRs. Optional.",
         "cancel": "Cancel",
         "launch": "Launch Orcastrator"
-      },
-      "director": {
-        "DirectorTypePicker": {
-          "smart_title": "Smart director",
-          "smart_caption": "Uses your default LLM and /orcastrate to plan and run the work.",
-          "recipe_title": "Recipe director",
-          "recipe_caption": "No director LLM; runs a fixed workflow.",
-          "group_label": "Director type",
-          "recipe_label": "Recipe",
-          "recipe_placeholder": "Select a recipe"
-        }
       }
     },
     "i18n": {
diff --git a/src/renderer/src/i18n/locales/ko.json b/src/renderer/src/i18n/locales/ko.json
index 50a6933aadb..69c891bf887 100644
--- a/src/renderer/src/i18n/locales/ko.json
+++ b/src/renderer/src/i18n/locales/ko.json
@@ -11819,17 +11819,6 @@
         "task_placeholder": "Describe the work — the director plans how to split it into worktrees/PRs. Optional.",
         "cancel": "Cancel",
         "launch": "Launch Orcastrator"
-      },
-      "director": {
-        "DirectorTypePicker": {
-          "smart_title": "Smart director",
-          "smart_caption": "Uses your default LLM and /orcastrate to plan and run the work.",
-          "recipe_title": "Recipe director",
-          "recipe_caption": "No director LLM; runs a fixed workflow.",
-          "group_label": "Director type",
-          "recipe_label": "Recipe",
-          "recipe_placeholder": "Select a recipe"
-        }
       }
     },
     "i18n": {
diff --git a/src/renderer/src/i18n/locales/zh.json b/src/renderer/src/i18n/locales/zh.json
index 765b283e4f1..f7fb95950b2 100644
--- a/src/renderer/src/i18n/locales/zh.json
+++ b/src/renderer/src/i18n/locales/zh.json
@@ -11819,17 +11819,6 @@
         "task_placeholder": "Describe the work — the director plans how to split it into worktrees/PRs. Optional.",
         "cancel": "Cancel",
         "launch": "Launch Orcastrator"
-      },
-      "director": {
-        "DirectorTypePicker": {
-          "smart_title": "Smart director",
-          "smart_caption": "Uses your default LLM and /orcastrate to plan and run the work.",
-          "recipe_title": "Recipe director",
-          "recipe_caption": "No director LLM; runs a fixed workflow.",
-          "group_label": "Director type",
-          "recipe_label": "Recipe",
-          "recipe_placeholder": "Select a recipe"
-        }
       }
     },
     "i18n": {
diff --git a/src/renderer/src/lib/director-backend.test.ts b/src/renderer/src/lib/director-backend.test.ts
deleted file mode 100644
index 13217d53bb6..00000000000
--- a/src/renderer/src/lib/director-backend.test.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import type { Project } from '../../../shared/types'
-
-const harness = vi.hoisted(() => ({
-  launchOrchestrator: vi.fn(),
-  launchRecipe: vi.fn()
-}))
-
-vi.mock('@/lib/orchestrator-launch', () => ({
-  launchOrchestratorForProject: (...args: unknown[]) => harness.launchOrchestrator(...args)
-}))
-
-vi.mock('@/lib/recipe-director-launch', () => ({
-  launchRecipeDirector: (...args: unknown[]) => harness.launchRecipe(...args)
-}))
-
-import { LlmDirectorBackend, RecipeDirectorBackend } from './director-backend'
-import type { Recipe } from './recipe-director-recipes'
-
-const PROJECT: Project = { id: 'proj_1', displayName: 'Demo' } as unknown as Project
-const RECIPE: Recipe = { name: 'implement_then_review', description: 'desc', tasks: [] }
-
-beforeEach(() => {
-  vi.clearAllMocks()
-  harness.launchOrchestrator.mockResolvedValue(true)
-  harness.launchRecipe.mockResolvedValue(true)
-})
-
-describe('LlmDirectorBackend', () => {
-  it('is the llm kind and dispatches to launchOrchestratorForProject', async () => {
-    const backend = new LlmDirectorBackend()
-    expect(backend.kind).toBe('llm')
-
-    const opts = { name: 'My director', agent: 'codex' as const, prompt: 'do the thing' }
-    const ok = await backend.launch(PROJECT, opts)
-
-    expect(ok).toBe(true)
-    expect(harness.launchOrchestrator).toHaveBeenCalledTimes(1)
-    expect(harness.launchOrchestrator).toHaveBeenCalledWith(PROJECT, opts)
-    expect(harness.launchRecipe).not.toHaveBeenCalled()
-  })
-})
-
-describe('RecipeDirectorBackend', () => {
-  it('is the recipe kind and dispatches to launchRecipeDirector with its recipe', async () => {
-    const backend = new RecipeDirectorBackend(RECIPE)
-    expect(backend.kind).toBe('recipe')
-
-    const opts = { name: 'My recipe director' }
-    const ok = await backend.launch(PROJECT, opts)
-
-    expect(ok).toBe(true)
-    expect(harness.launchRecipe).toHaveBeenCalledTimes(1)
-    expect(harness.launchRecipe).toHaveBeenCalledWith(PROJECT, RECIPE, opts)
-    expect(harness.launchOrchestrator).not.toHaveBeenCalled()
-  })
-
-  it('carries the specific recipe it was constructed with', async () => {
-    const other: Recipe = { name: 'ship_it', description: 'other', tasks: [] }
-    await new RecipeDirectorBackend(other).launch(PROJECT)
-    expect(harness.launchRecipe).toHaveBeenCalledWith(PROJECT, other, undefined)
-  })
-})
diff --git a/src/renderer/src/lib/director-backend.ts b/src/renderer/src/lib/director-backend.ts
deleted file mode 100644
index c1f2a7060f0..00000000000
--- a/src/renderer/src/lib/director-backend.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import {
-  launchOrchestratorForProject,
-  type LaunchOrchestratorOptions
-} from '@/lib/orchestrator-launch'
-import {
-  launchRecipeDirector,
-  type LaunchRecipeDirectorOptions
-} from '@/lib/recipe-director-launch'
-import type { Recipe } from '@/lib/recipe-director-recipes'
-import type { Project } from '../../../shared/types'
-
-// Why (#8): the director-type picker (#11) dispatches the user's choice through a
-// single abstraction instead of branching on a string at the call site. This is
-// deliberately THIN — it wraps the two existing launch functions, it does not
-// reimplement them — and earns its keep only because the picker dispatches through
-// it. No Hybrid backend yet: add a kind when there's a launch path to wrap.
-
-export type DirectorKind = 'llm' | 'recipe'
-
-/** Superset of both launchers' options so the picker can pass one bag of fields;
- *  each backend forwards only the ones its launcher understands. */
-export type DirectorLaunchOptions = LaunchOrchestratorOptions & LaunchRecipeDirectorOptions
-
-export type DirectorBackend = {
-  readonly kind: DirectorKind
-  /** Launch the director for `project`. Resolves true on success (mirrors the
-   *  wrapped launchers). */
-  launch(project: Project, options?: DirectorLaunchOptions): Promise<boolean>
-}
-
-/** The Smart director: a coordinator LLM that plans via `/orcastrate`. Wraps the
- *  existing `launchOrchestratorForProject` unchanged. */
-export class LlmDirectorBackend implements DirectorBackend {
-  readonly kind = 'llm' as const
-
-  launch(project: Project, options?: DirectorLaunchOptions): Promise<boolean> {
-    return launchOrchestratorForProject(project, options)
-  }
-}
-
-/** The Recipe director: a fixed, token-free workflow (no director LLM). Carries the
- *  chosen recipe and wraps `launchRecipeDirector`. */
-export class RecipeDirectorBackend implements DirectorBackend {
-  readonly kind = 'recipe' as const
-
-  constructor(private readonly recipe: Recipe) {}
-
-  launch(project: Project, options?: DirectorLaunchOptions): Promise<boolean> {
-    return launchRecipeDirector(project, this.recipe, options)
-  }
-}
diff --git a/src/renderer/src/lib/recipe-director-launch.test.ts b/src/renderer/src/lib/recipe-director-launch.test.ts
deleted file mode 100644
index d1612a9ae0a..00000000000
--- a/src/renderer/src/lib/recipe-director-launch.test.ts
+++ /dev/null
@@ -1,149 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import type { Project } from '../../../shared/types'
-
-// A mutable harness the mocked modules read, reset per test.
-const harness = vi.hoisted(() => ({
-  createWorktree: vi.fn(),
-  registerOrchestrator: vi.fn(),
-  settings: { defaultTuiAgent: 'codex' } as { defaultTuiAgent?: string },
-  activate: vi.fn(),
-  taskCreate: vi.fn(),
-  run: vi.fn(),
-  runtimeCall: vi.fn(),
-  toastError: vi.fn()
-}))
-
-vi.mock('@/store', () => ({
-  useAppStore: Object.assign((selector: (state: unknown) => unknown) => selector(harness), {
-    getState: () => ({
-      createWorktree: harness.createWorktree,
-      registerOrchestrator: harness.registerOrchestrator,
-      repos: [],
-      settings: harness.settings
-    })
-  })
-}))
-
-vi.mock('@/lib/worktree-activation', () => ({
-  activateAndRevealWorktree: (...args: unknown[]) => harness.activate(...args)
-}))
-
-// The shell helper is exercised separately; here we stub it so the launch test
-// stays focused on the compile → taskCreate → run wiring and the token-free path.
-vi.mock('@/lib/director-worktree-shell', () => ({
-  createDirectorWorktreeShell: vi.fn(async () => ({ worktreeId: 'wt_director', setup: undefined }))
-}))
-
-vi.mock('@/i18n/i18n', () => ({
-  translate: (_key: string, fallback: string) => fallback
-}))
-
-vi.mock('sonner', () => ({
-  toast: { error: (...args: unknown[]) => harness.toastError(...args) }
-}))
-
-import { launchRecipeDirector } from './recipe-director-launch'
-import { IMPLEMENT_THEN_REVIEW } from './recipe-director-recipes'
-
-const PROJECT: Project = {
-  id: 'proj_1',
-  displayName: 'Demo',
-  sourceRepoIds: ['repo_1']
-} as unknown as Project
-
-beforeEach(() => {
-  vi.clearAllMocks()
-  harness.settings = { defaultTuiAgent: 'codex' }
-  harness.activate.mockReturnValue({ primaryTabId: 'tab_1' })
-  let n = 0
-  harness.taskCreate.mockImplementation(async () => ({ task: { id: `task_${++n}` } }))
-  harness.run.mockResolvedValue({ runId: 'run_1', status: 'running' })
-  harness.runtimeCall.mockResolvedValue({ ok: true, result: { handle: 'coordinator_term' } })
-  // window.api wiring
-  ;(globalThis as unknown as { window: unknown }).window = {
-    api: {
-      orchestration: { taskCreate: harness.taskCreate, run: harness.run },
-      runtime: { call: harness.runtimeCall }
-    }
-  }
-})
-
-describe('launchRecipeDirector', () => {
-  it('compiles the recipe into ordered taskCreate calls stamped to the shell', async () => {
-    const ok = await launchRecipeDirector(PROJECT, IMPLEMENT_THEN_REVIEW)
-    expect(ok).toBe(true)
-
-    expect(harness.taskCreate).toHaveBeenCalledTimes(2)
-    const [implementCall] = harness.taskCreate.mock.calls[0]
-    const [reviewCall] = harness.taskCreate.mock.calls[1]
-
-    // implement: first, no deps, stamped to the director worktree.
-    expect(implementCall.taskTitle).toBe('implement')
-    expect(implementCall.deps).toBeUndefined()
-    expect(implementCall.targetWorktree).toBe('id:wt_director')
-    expect(implementCall.spec).toMatch(/^track: \S+/)
-
-    // review: depends on implement's created id, same target.
-    expect(reviewCall.taskTitle).toBe('review')
-    expect(reviewCall.deps).toBe(JSON.stringify(['task_1']))
-    expect(reviewCall.targetWorktree).toBe('id:wt_director')
-  })
-
-  it('starts a worktree-backed run anchored on the shell with the default worker agent', async () => {
-    await launchRecipeDirector(PROJECT, IMPLEMENT_THEN_REVIEW)
-
-    expect(harness.run).toHaveBeenCalledTimes(1)
-    expect(harness.run).toHaveBeenCalledWith(
-      expect.objectContaining({
-        spec: 'recipe:implement_then_review',
-        worktree: 'id:wt_director',
-        worktreeBacked: true,
-        workerAgent: 'codex',
-        from: 'coordinator_term'
-      })
-    )
-    // Tasks are created BEFORE the run starts (so run-start adoption sees them).
-    expect(harness.taskCreate.mock.invocationCallOrder[1]).toBeLessThan(
-      harness.run.mock.invocationCallOrder[0]
-    )
-  })
-
-  it('is token-free: never seeds an agent or prompt into the director shell', async () => {
-    await launchRecipeDirector(PROJECT, IMPLEMENT_THEN_REVIEW)
-
-    // The shell is activated with NO startup payload — no agent command, no
-    // /orcastrate paste. The only agent in the whole flow is the run's workerAgent.
-    expect(harness.activate).toHaveBeenCalledTimes(1)
-    const [worktreeId, opts] = harness.activate.mock.calls[0]
-    expect(worktreeId).toBe('wt_director')
-    expect(opts.startup).toBeUndefined()
-    expect(opts.issueCommand).toBeUndefined()
-    // Programmatic launch reveals the shell without yanking the user's active tab.
-    expect(opts.suppressActivation).toBe(true)
-  })
-
-  it('falls back to claude when the default agent is a blank shell', async () => {
-    harness.settings = { defaultTuiAgent: 'blank' }
-    await launchRecipeDirector(PROJECT, IMPLEMENT_THEN_REVIEW)
-    expect(harness.run).toHaveBeenCalledWith(expect.objectContaining({ workerAgent: 'claude' }))
-  })
-
-  it('still starts the run when the shell terminal handle cannot be resolved', async () => {
-    harness.runtimeCall.mockResolvedValue({ ok: false, error: { message: 'no_active_terminal' } })
-    const ok = await launchRecipeDirector(PROJECT, IMPLEMENT_THEN_REVIEW)
-    expect(ok).toBe(true)
-    const [runParams] = harness.run.mock.calls[0]
-    expect(runParams.from).toBeUndefined()
-    expect(runParams.worktreeBacked).toBe(true)
-  })
-
-  it('aborts (no tasks, no run) when the shell cannot be created', async () => {
-    const shellModule = await import('@/lib/director-worktree-shell')
-    vi.mocked(shellModule.createDirectorWorktreeShell).mockResolvedValueOnce(null)
-
-    const ok = await launchRecipeDirector(PROJECT, IMPLEMENT_THEN_REVIEW)
-    expect(ok).toBe(false)
-    expect(harness.taskCreate).not.toHaveBeenCalled()
-    expect(harness.run).not.toHaveBeenCalled()
-  })
-})
diff --git a/src/renderer/src/lib/recipe-director-launch.ts b/src/renderer/src/lib/recipe-director-launch.ts
deleted file mode 100644
index 2893d243e35..00000000000
--- a/src/renderer/src/lib/recipe-director-launch.ts
+++ /dev/null
@@ -1,158 +0,0 @@
-import { toast } from 'sonner'
-import { useAppStore } from '@/store'
-import { activateAndRevealWorktree } from '@/lib/worktree-activation'
-import { createDirectorWorktreeShell } from '@/lib/director-worktree-shell'
-import { translate } from '@/i18n/i18n'
-import { compileRecipe, type Recipe } from './recipe-director-recipes'
-import type { Project, TuiAgent } from '../../../shared/types'
-
-// Why (#9): the recipe director runs a FIXED recipe with ZERO director LLM tokens.
-// It creates the same hidden worktree shell the LLM Orcastrator uses, but leaves it
-// agent-free; the merged worktree-backed coordinator then creates per-track child
-// worktrees and launches the real WORKER agents (the only LLM cost) — review
-// continues implement's branch (one PR) because same-track tasks share a worktree.
-
-// Why: the worker agent does the actual coding, so it must be a real agent (the run
-// rejects a worktree-backed run without one). A 'blank' default means "plain shell"
-// — fall back to Claude Code, the same resolution the LLM coordinator uses.
-function resolveWorkerAgent(defaultTuiAgent: TuiAgent | 'blank' | null | undefined): TuiAgent {
-  return defaultTuiAgent && defaultTuiAgent !== 'blank' ? defaultTuiAgent : 'claude'
-}
-
-// Why: the run's coordinator inbox AND the live Control Panel key on the director
-// pane (getPaneKeyForTerminalHandle(coordinator_handle)). Binding the run's `from`
-// to the shell's terminal handle surfaces the DAG under the director and routes
-// worker_done/heartbeat to a real inbox.
-//
-// Opportunistic by design: we do NOT await terminal readiness before resolving the
-// active handle (unlike the LLM path, which waits via pasteDraftWhenAgentReady — it
-// has an agent to wait for; a blank shell has no readiness signal). On a cold shell
-// the resolve can miss, in which case the run derives its own coordinator handle —
-// the run still works correctly, the DAG just isn't pane-anchored to the director
-// (cosmetic). Pane-anchoring is owned by the #11 picker, which can await readiness.
-async function resolveDirectorShellHandle(worktreeSelector: string): Promise<string | undefined> {
-  try {
-    const response = await window.api.runtime.call({
-      method: 'terminal.resolveActive',
-      params: { worktree: worktreeSelector }
-    })
-    if (!response.ok) {
-      return undefined
-    }
-    const handle = (response.result as { handle?: unknown } | null)?.handle
-    return typeof handle === 'string' ? handle : undefined
-  } catch {
-    return undefined
-  }
-}
-
-export type LaunchRecipeDirectorOptions = {
-  /** Human name for the director (shown in the ORCASTRATORS list). */
-  name?: string
-  /** Worker agent override; defaults to the user's default coding agent. */
-  workerAgent?: TuiAgent
-}
-
-/**
- * Launch a token-free recipe director for a project. Flow:
- *  1. create the no-LLM director worktree shell (no agent, no prompt);
- *  2. compile the recipe and create one task per recipe task (track hint in the
- *     spec, deps wired key→created id), stamped to the shell worktree so the run
- *     adopts them;
- *  3. start a worktree-backed coordinator run anchored on the shell.
- * The director shell itself runs no agent → no director LLM tokens. The live
- * Control Panel renders the run automatically.
- *
- * GATING: this function is intentionally UNGATED. The `experimentalOrchestrators`
- * gate belongs at the call site — the #11 director-type picker, which does not
- * exist yet. The caller (#11) MUST check `experimentalOrchestrators` before
- * invoking this; do not call it from any always-on UI path.
- */
-export async function launchRecipeDirector(
-  project: Project,
-  recipe: Recipe,
-  options?: LaunchRecipeDirectorOptions
-): Promise<boolean> {
-  const store = useAppStore.getState()
-  const settings = store.settings
-  const workerAgent = resolveWorkerAgent(options?.workerAgent ?? settings?.defaultTuiAgent)
-  const label = options?.name?.trim() || `${project.displayName} · ${recipe.name}`
-
-  // Compile FIRST so a malformed recipe fails before we create any worktree.
-  const compiled = compileRecipe(recipe)
-
-  const shell = await createDirectorWorktreeShell(project, { label })
-  if (!shell) {
-    return false
-  }
-
-  // Why: activate WITHOUT any agent startup payload — a blank terminal, no agent,
-  // no /orcastrate. This is the token-free invariant: nothing here seeds an LLM
-  // into the director shell. It still gives the shell a focusable surface (and a
-  // terminal handle for pane-anchoring the run).
-  // Why: a recipe director is launched programmatically — reveal it (sidebar +
-  // Mission Control DAG) but suppress the active-tab switch so spawning the
-  // director does not yank the user off their current worktree.
-  const activation = activateAndRevealWorktree(shell.worktreeId, {
-    sidebarRevealBehavior: 'auto',
-    setup: shell.setup,
-    suppressActivation: true
-  })
-  if (!activation) {
-    toast.error(
-      translate('auto.lib.orchestrator.launch.no_workspace', 'Could not open the Orcastrator.')
-    )
-    return false
-  }
-
-  store.registerOrchestrator({
-    id: shell.worktreeId,
-    projectId: project.id,
-    projectName: label,
-    worktreeId: shell.worktreeId,
-    tabId: activation.primaryTabId ?? '',
-    launchedAt: Date.now()
-  })
-
-  const worktreeSelector = `id:${shell.worktreeId}`
-
-  // Create tasks in dependency order, resolving each recipe-local dependsOn key to
-  // the real task id returned by the previous create. targetWorktree stamps the
-  // task to the shell so run-start adoptUnownedTasks claims it.
-  const idByKey = new Map<string, string>()
-  for (const task of compiled) {
-    // Why: compileRecipe already topo-sorts and validates deps, so every dependsOn
-    // key MUST already be in idByKey. Throw on a miss rather than silently dropping
-    // it — a dropped dep would let review go ready before implement and surface far
-    // downstream as the coordinator's confusing same-track ordering refusal.
-    const depIds = task.dependsOn.map((key) => {
-      const id = idByKey.get(key)
-      if (id === undefined) {
-        throw new Error(
-          `Recipe '${recipe.name}' task '${task.key}' depends on unmapped key '${key}'`
-        )
-      }
-      return id
-    })
-    const { task: created } = await window.api.orchestration.taskCreate({
-      spec: task.spec,
-      taskTitle: task.key,
-      displayName: `${recipe.name}: ${task.key}`,
-      deps: depIds.length > 0 ? JSON.stringify(depIds) : undefined,
-      targetWorktree: worktreeSelector
-    })
-    idByKey.set(task.key, created.id)
-  }
-
-  const coordinatorHandle = await resolveDirectorShellHandle(worktreeSelector)
-
-  await window.api.orchestration.run({
-    spec: `recipe:${recipe.name}`,
-    worktree: worktreeSelector,
-    worktreeBacked: true,
-    workerAgent,
-    ...(coordinatorHandle ? { from: coordinatorHandle } : {})
-  })
-
-  return true
-}
diff --git a/src/renderer/src/lib/recipe-director-recipes.test.ts b/src/renderer/src/lib/recipe-director-recipes.test.ts
deleted file mode 100644
index bfdf2796827..00000000000
--- a/src/renderer/src/lib/recipe-director-recipes.test.ts
+++ /dev/null
@@ -1,185 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import {
-  compileRecipe,
-  getRecipes,
-  IMPLEMENT_THEN_REVIEW,
-  REPRO_FIX_VERIFY,
-  SINGLE_WORKER_PR,
-  type Recipe
-} from './recipe-director-recipes'
-
-// Mirror the coordinator's track-hint contract (parseTrackFromSpec): a leading
-// `track: <key>` line on its own line. Kept local so this renderer test does not
-// import main-side code across the layer boundary.
-function trackHintOf(spec: string): string | null {
-  const match = spec.match(/^[ \t]*track:[ \t]*(\S+)[ \t]*$/im)
-  return match ? match[1] : null
-}
-
-describe('compileRecipe', () => {
-  it('compiles implement_then_review to two same-track tasks with review after implement', () => {
-    const compiled = compileRecipe(IMPLEMENT_THEN_REVIEW)
-
-    expect(compiled.map((t) => t.key)).toEqual(['implement', 'review'])
-
-    const implement = compiled[0]
-    const review = compiled[1]
-
-    // Review waits on implement → one ordered chain (satisfies the coordinator's
-    // same-track safe-ordering guard) and a real implement→review handoff.
-    expect(implement.dependsOn).toEqual([])
-    expect(review.dependsOn).toEqual(['implement'])
-
-    // Both carry a `track:` hint the coordinator parses, and it is the SAME track
-    // → one worktree, one branch, one PR.
-    const implementTrack = trackHintOf(implement.spec)
-    const reviewTrack = trackHintOf(review.spec)
-    expect(implementTrack).not.toBeNull()
-    expect(implementTrack).toBe(reviewTrack)
-  })
-
-  it('puts the track hint on the first line so the worker spec follows it', () => {
-    const compiled = compileRecipe(IMPLEMENT_THEN_REVIEW)
-    for (const task of compiled) {
-      // First line is the hint; the body (worker instructions) follows after it.
-      expect(task.spec).toMatch(/^track: \S+\n/)
-      const body = task.spec.replace(/^track: \S+\n+/, '')
-      expect(body).not.toMatch(/^track:/m)
-      expect(body.trim().length).toBeGreaterThan(0)
-    }
-  })
-
-  it('emits dependencies before dependents regardless of declaration order', () => {
-    const recipe: Recipe = {
-      name: 'r',
-      description: 'd',
-      tasks: [
-        { key: 'b', spec: 'b', dependsOn: ['a'] },
-        { key: 'a', spec: 'a' }
-      ]
-    }
-    expect(compileRecipe(recipe).map((t) => t.key)).toEqual(['a', 'b'])
-  })
-
-  it('rejects an unknown dependency', () => {
-    const recipe: Recipe = {
-      name: 'r',
-      description: 'd',
-      tasks: [{ key: 'a', spec: 'a', dependsOn: ['missing'] }]
-    }
-    expect(() => compileRecipe(recipe)).toThrow(/unknown task 'missing'/)
-  })
-
-  it('rejects a dependency cycle', () => {
-    const recipe: Recipe = {
-      name: 'r',
-      description: 'd',
-      tasks: [
-        { key: 'a', spec: 'a', dependsOn: ['b'] },
-        { key: 'b', spec: 'b', dependsOn: ['a'] }
-      ]
-    }
-    expect(() => compileRecipe(recipe)).toThrow(/cycle/)
-  })
-
-  it('rejects a self-dependency', () => {
-    const recipe: Recipe = {
-      name: 'r',
-      description: 'd',
-      tasks: [{ key: 'a', spec: 'a', dependsOn: ['a'] }]
-    }
-    expect(() => compileRecipe(recipe)).toThrow(/depends on itself/)
-  })
-
-  it('rejects duplicate task keys', () => {
-    const recipe: Recipe = {
-      name: 'r',
-      description: 'd',
-      tasks: [
-        { key: 'a', spec: 'a' },
-        { key: 'a', spec: 'a2' }
-      ]
-    }
-    expect(() => compileRecipe(recipe)).toThrow(/duplicate task keys/)
-  })
-
-  it('compiles single_worker_pr to one task with its own per-task track and no deps', () => {
-    const compiled = compileRecipe(SINGLE_WORKER_PR)
-
-    expect(compiled.map((t) => t.key)).toEqual(['deliver'])
-    expect(compiled[0].dependsOn).toEqual([])
-    // No explicit track → track defaults to the task key → its own worktree/PR.
-    expect(trackHintOf(compiled[0].spec)).toBe('deliver')
-  })
-
-  it('compiles repro_fix_verify to three same-track tasks chained repro→fix→verify', () => {
-    const compiled = compileRecipe(REPRO_FIX_VERIFY)
-
-    expect(compiled.map((t) => t.key)).toEqual(['repro', 'fix', 'verify'])
-
-    const [repro, fix, verify] = compiled
-    expect(repro.dependsOn).toEqual([])
-    expect(fix.dependsOn).toEqual(['repro'])
-    expect(verify.dependsOn).toEqual(['fix'])
-
-    // All three share one track → one worktree, one branch, one PR.
-    const tracks = compiled.map((t) => trackHintOf(t.spec))
-    expect(tracks.every((t) => t !== null)).toBe(true)
-    expect(new Set(tracks).size).toBe(1)
-  })
-
-  it('repro_fix_verify deps form a total order on its single track', () => {
-    const compiled = compileRecipe(REPRO_FIX_VERIFY)
-
-    // The coordinator refuses same-track tasks that are not totally ordered by
-    // deps. Verify the chain is a strict total order: each task (after the first)
-    // transitively depends on every earlier same-track task, with no ties.
-    const indexByKey = new Map(compiled.map((t, i) => [t.key, i]))
-    const depsByKey = new Map(compiled.map((t) => [t.key, t.dependsOn]))
-
-    const dependsTransitively = (from: string, on: string): boolean => {
-      const stack = [...(depsByKey.get(from) ?? [])]
-      while (stack.length > 0) {
-        const next = stack.pop()!
-        if (next === on) {
-          return true
-        }
-        stack.push(...(depsByKey.get(next) ?? []))
-      }
-      return false
-    }
-
-    // For every ordered pair (earlier, later), the later one must depend on the
-    // earlier one — that is exactly what "totally ordered by deps" means.
-    for (let i = 0; i < compiled.length; i++) {
-      for (let j = i + 1; j < compiled.length; j++) {
-        const earlier = compiled[i].key
-        const later = compiled[j].key
-        expect(dependsTransitively(later, earlier)).toBe(true)
-      }
-    }
-    // Sanity: compile order matches dependency order.
-    expect(indexByKey.get('repro')).toBeLessThan(indexByKey.get('fix')!)
-    expect(indexByKey.get('fix')).toBeLessThan(indexByKey.get('verify')!)
-  })
-})
-
-describe('getRecipes', () => {
-  it('returns all three built-in recipes by name', () => {
-    const names = getRecipes().map((r) => r.name)
-    expect(names).toEqual(['implement_then_review', 'single_worker_pr', 'repro_fix_verify'])
-  })
-
-  it('exposes a name and a non-empty description per recipe (picker shape)', () => {
-    for (const recipe of getRecipes()) {
-      expect(recipe.name.length).toBeGreaterThan(0)
-      expect(recipe.description.trim().length).toBeGreaterThan(0)
-    }
-  })
-
-  it('returns a fresh array so callers cannot mutate the registry', () => {
-    const first = getRecipes()
-    first.pop()
-    expect(getRecipes()).toHaveLength(3)
-  })
-})
diff --git a/src/renderer/src/lib/recipe-director-recipes.ts b/src/renderer/src/lib/recipe-director-recipes.ts
deleted file mode 100644
index b4793b91d06..00000000000
--- a/src/renderer/src/lib/recipe-director-recipes.ts
+++ /dev/null
@@ -1,210 +0,0 @@
-// Built-in recipes for the token-free recipe director (#9). A recipe is a fixed,
-// deterministic task DAG the director compiles into orchestration.taskCreate calls
-// — no director LLM tokens are spent (the worker agents do the coding). User-
-// editable recipes (YAML), the full starter set (#10), and the DirectorBackend
-// abstraction (#8) are deliberately out of scope: this module ships the concrete
-// `implement_then_review` recipe and the pure compiler the launch path uses.
-
-/** A single unit of work in a recipe. Compiled 1:1 into an orchestration task. */
-export type RecipeTask = {
-  /** Stable, recipe-local key. Used to wire `dependsOn` to created task ids and
-   *  (when no explicit `track`) as the worktree-track hint. */
-  key: string
-  /** The worker's task instructions — the `--- TASK ---` block they receive. */
-  spec: string
-  /** Worktree-track hint. Same-track tasks share one worktree/branch/PR (the
-   *  implement→review handoff). Defaults to `key` (per-task track) when unset. */
-  track?: string
-  /** Recipe-local keys of tasks that must FINISH before this one runs. Same-track
-   *  tasks MUST be totally ordered by deps or the coordinator refuses the run. */
-  dependsOn?: string[]
-  // Per-task agent override is intentionally omitted: #9 runs every task with the
-  // run's single workerAgent. Re-add when #10/#11 need heterogeneous agents (it
-  // also needs a per-task agent param on orchestration.taskCreate/dispatch).
-}
-
-/** A fixed, deterministic task DAG the director runs without spending LLM tokens. */
-export type Recipe = {
-  name: string
-  description: string
-  tasks: RecipeTask[]
-}
-
-// Why: implement and review share ONE track so they run in the same worktree —
-// review continues implement's branch → one PR, a real handoff. review.dependsOn
-// = [implement] both encodes that handoff AND satisfies the coordinator's
-// same-track safe-ordering guard (two unordered same-track tasks are refused
-// because they would race into one checkout).
-const IMPLEMENT_THEN_REVIEW_TRACK = 'implement-review'
-
-/** The one canonical recipe this PR ships: implement, then review, on a single
- *  track (one worktree → one PR) with review gated on implement finishing. */
-export const IMPLEMENT_THEN_REVIEW: Recipe = {
-  name: 'implement_then_review',
-  description:
-    'Implement the change, then review it on the same branch — one worktree, one PR, ' +
-    'with the reviewer handed the implementer’s finished work.',
-  tasks: [
-    {
-      key: 'implement',
-      track: IMPLEMENT_THEN_REVIEW_TRACK,
-      spec:
-        'Implement the requested change end to end. Make focused commits, keep the ' +
-        'build/tests green, and open a PR for your branch. When done, report what you ' +
-        'changed and call out anything the reviewer should scrutinize.'
-    },
-    {
-      key: 'review',
-      track: IMPLEMENT_THEN_REVIEW_TRACK,
-      dependsOn: ['implement'],
-      spec:
-        'Review the implementation on this branch. Check correctness, tests, and ' +
-        'adherence to the repo’s conventions. Apply small fixes directly; for larger ' +
-        'concerns, leave clear review notes. Confirm the PR is ready (or say why not).'
-    }
-  ]
-}
-
-/** The simplest recipe: a single worker does the whole job and opens a PR. No
- *  track or deps — its track defaults to the task key, so it gets its own
- *  worktree/branch and produces exactly one PR. */
-export const SINGLE_WORKER_PR: Recipe = {
-  name: 'single_worker_pr',
-  description: 'One worker does the whole job end to end on its own branch and opens a single PR.',
-  tasks: [
-    {
-      key: 'deliver',
-      spec:
-        'Carry out the requested change from start to finish. Make focused commits, ' +
-        'keep the build and tests green, and open a PR for your branch. When done, ' +
-        'report what you changed and anything a reviewer should scrutinize.'
-    }
-  ]
-}
-
-// Why: repro → fix → verify all share ONE track so they run in the same worktree
-// (one branch → one PR), and each builds on the previous one's committed artifact.
-// The dependsOn chain (fix waits on repro, verify waits on fix) is a TOTAL order on
-// the track — which the coordinator's same-track guard requires (it refuses
-// same-track tasks not totally ordered by deps, since they would race one checkout).
-const REPRO_FIX_VERIFY_TRACK = 'repro-fix-verify'
-
-/** Bug-fix workflow as a single-track dependency chain: reproduce with a failing
- *  test, fix until it passes, then independently verify. Each step commits its
- *  artifact so the next step (same worktree) sees it. */
-export const REPRO_FIX_VERIFY: Recipe = {
-  name: 'repro_fix_verify',
-  description:
-    'Reproduce the bug with a failing test, fix it, then verify — one worktree, one PR, ' +
-    'each step chained after the last so they share the same branch in order.',
-  tasks: [
-    {
-      key: 'repro',
-      track: REPRO_FIX_VERIFY_TRACK,
-      spec:
-        'Reproduce the reported bug by writing a failing test (or a minimal repro) that ' +
-        'captures it. Commit the failing test so the next step sees it on this branch. ' +
-        'Report exactly how the bug manifests and what the test asserts.'
-    },
-    {
-      key: 'fix',
-      track: REPRO_FIX_VERIFY_TRACK,
-      dependsOn: ['repro'],
-      spec:
-        'Make the failing test from the previous step pass with the smallest correct ' +
-        'change. Keep the rest of the build and tests green. Commit the fix so the verify ' +
-        'step sees it on this branch, and report what you changed and why.'
-    },
-    {
-      key: 'verify',
-      track: REPRO_FIX_VERIFY_TRACK,
-      dependsOn: ['fix'],
-      spec:
-        'Independently verify the fix on this branch: run the full test suite, confirm the ' +
-        'previously failing test now passes, and check for regressions or missed edge ' +
-        'cases. Commit any follow-up test or fixup, then confirm the PR is ready (or say ' +
-        'why not).'
-    }
-  ]
-}
-
-/** Every built-in recipe, keyed by name. The picker (#11) lists these; the launch
- *  path compiles the selected one. Order is the intended display order. */
-const BUILT_IN_RECIPES: Recipe[] = [IMPLEMENT_THEN_REVIEW, SINGLE_WORKER_PR, REPRO_FIX_VERIFY]
-
-/** All built-in recipes, in display order. Returns a fresh array so callers can
- *  sort/filter without mutating the registry. */
-export function getRecipes(): Recipe[] {
-  return [...BUILT_IN_RECIPES]
-}
-
-/** A recipe task lowered to the inputs `orchestration.taskCreate` needs, minus the
- *  resolved dependency ids (those exist only after each create returns, so the
- *  launch path resolves `dependsOn` keys → ids as it goes). */
-export type CompiledRecipeTask = {
-  key: string
-  /** Final spec including the `track:` hint line the coordinator parses + strips. */
-  spec: string
-  /** Recipe-local keys this task waits on (resolved to task ids at launch). */
-  dependsOn: string[]
-}
-
-// Why (slice 2 / coordinator §3.3): a task declares its track in the spec text via
-// a leading `track: <key>` line — the same low-friction channel the coordinator
-// parses (and strips before the worker sees the spec). Put it on its own first
-// line so parseTrackFromSpec matches it.
-function prependTrackHint(spec: string, track: string): string {
-  return `track: ${track}\n\n${spec}`
-}
-
-/**
- * Compile a recipe into dependency-ordered taskCreate inputs. Pure and
- * deterministic: the launch path walks the result in order, calling taskCreate
- * for each and mapping `key → created id` so later tasks' `dependsOn` keys resolve
- * to real ids. Throws on an unknown/self/cyclic dependency so a malformed recipe
- * fails fast at compile time rather than producing a stuck run.
- */
-export function compileRecipe(recipe: Recipe): CompiledRecipeTask[] {
-  const byKey = new Map(recipe.tasks.map((task) => [task.key, task]))
-  if (byKey.size !== recipe.tasks.length) {
-    throw new Error(`Recipe '${recipe.name}' has duplicate task keys`)
-  }
-
-  // Why: same-track tasks must be totally ordered for the coordinator, and deps
-  // drive that order — so emit tasks in a topological order. A stable DFS keeps
-  // the output deterministic (tests can assert exact ordering).
-  const ordered: CompiledRecipeTask[] = []
-  const state = new Map<string, 'visiting' | 'done'>()
-
-  const visit = (key: string): void => {
-    const phase = state.get(key)
-    if (phase === 'done') {
-      return
-    }
-    if (phase === 'visiting') {
-      throw new Error(`Recipe '${recipe.name}' has a dependency cycle at task '${key}'`)
-    }
-    const task = byKey.get(key)
-    if (!task) {
-      throw new Error(`Recipe '${recipe.name}' references unknown task '${key}'`)
-    }
-    state.set(key, 'visiting')
-    for (const dep of task.dependsOn ?? []) {
-      if (dep === key) {
-        throw new Error(`Recipe '${recipe.name}' task '${key}' depends on itself`)
-      }
-      visit(dep)
-    }
-    state.set(key, 'done')
-    ordered.push({
-      key: task.key,
-      spec: prependTrackHint(task.spec, task.track ?? task.key),
-      dependsOn: [...(task.dependsOn ?? [])]
-    })
-  }
-
-  for (const task of recipe.tasks) {
-    visit(task.key)
-  }
-  return ordered
-}
diff --git a/src/shared/orchestration-binding.ts b/src/shared/orchestration-binding.ts
index 81b300c4d26..36f7e00d497 100644
--- a/src/shared/orchestration-binding.ts
+++ b/src/shared/orchestration-binding.ts
@@ -77,12 +77,6 @@ export type OrchestrationTaskCreateParams = {
   deps?: string
   parent?: string
   callerTerminalHandle?: string
-  // Why (#9): a worktree selector (e.g. `id:<worktreeId>`) that stamps the task's
-  // target_key via the same resolver orchestration.run uses for `worktree`. Lets
-  // the renderer recipe director — which has the director worktree id, not a live
-  // terminal handle — create tasks the run will adopt. Takes precedence over
-  // `callerTerminalHandle` in the handler.
-  targetWorktree?: string
 }
 
 /** Result of orchestration.taskCreate. */