From b5a26fc33a8cd578847ec02a5865d96b65fb2a8a Mon Sep 17 00:00:00 2001
From: zaridan <1617679+zaridan@users.noreply.github.com>
Date: Tue, 23 Jun 2026 21:08:30 -0700
Subject: [PATCH] feat(orchestration): director-type picker + DirectorBackend
 abstraction (#11, #8)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

#8 — new src/renderer/src/lib/director-backend.ts: a thin DirectorBackend
abstraction wrapping the two existing launchers, not reimplementing them.
LlmDirectorBackend wraps launchOrchestratorForProject (the Smart/LLM director);
RecipeDirectorBackend carries a Recipe and wraps launchRecipeDirector (#9). It
earns its keep because the picker dispatches the user's choice through it.

#11 — the ORCASTRATORS `+` modal now picks the director TYPE first via a new
DirectorTypePicker (shadcn cards + recipe Select, tokens, i18n): Smart director
(default LLM + /orcastrate) vs Recipe director ("No director LLM; runs a fixed
workflow"), with a recipe dropdown sourced from getRecipes(). The picker is the
gate for experimentalOrchestrators — launchRecipeDirector is ungated by design,
so the Recipe option only appears under the flag; with it off the modal behaves
exactly as before. On confirm the modal dispatches via the DirectorBackend.

Tests: director-backend (Smart -> LlmDirectorBackend -> launchOrchestratorForProject;
Recipe+recipe -> RecipeDirectorBackend(recipe) -> launchRecipeDirector with that
recipe) and DirectorTypePicker (Smart always; Recipe only under the flag; dropdown
lists getRecipes()). vitest + typecheck + electron-vite build + oxlint green.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../components/OrchestratorLaunchModal.tsx    | 113 ++++++++----
 .../director/DirectorTypePicker.test.tsx      |  74 ++++++++
 .../director/DirectorTypePicker.tsx           | 173 ++++++++++++++++++
 src/renderer/src/i18n/locales/en.json         |  11 ++
 src/renderer/src/i18n/locales/es.json         |  11 ++
 src/renderer/src/i18n/locales/ja.json         |  11 ++
 src/renderer/src/i18n/locales/ko.json         |  11 ++
 src/renderer/src/i18n/locales/zh.json         |  11 ++
 src/renderer/src/lib/director-backend.test.ts |  63 +++++++
 src/renderer/src/lib/director-backend.ts      |  51 ++++++
 10 files changed, 496 insertions(+), 33 deletions(-)
 create mode 100644 src/renderer/src/components/director/DirectorTypePicker.test.tsx
 create mode 100644 src/renderer/src/components/director/DirectorTypePicker.tsx
 create mode 100644 src/renderer/src/lib/director-backend.test.ts
 create mode 100644 src/renderer/src/lib/director-backend.ts

diff --git a/src/renderer/src/components/OrchestratorLaunchModal.tsx b/src/renderer/src/components/OrchestratorLaunchModal.tsx
index e7a74900bf4..ed1695eaef0 100644
--- a/src/renderer/src/components/OrchestratorLaunchModal.tsx
+++ b/src/renderer/src/components/OrchestratorLaunchModal.tsx
@@ -17,7 +17,13 @@ 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 { launchOrchestratorForProject } from '@/lib/orchestrator-launch'
+import { DirectorTypePicker } from '@/components/director/DirectorTypePicker'
+import {
+  LlmDirectorBackend,
+  RecipeDirectorBackend,
+  type DirectorKind
+} from '@/lib/director-backend'
+import { getRecipes } from '@/lib/recipe-director-recipes'
 import { translate } from '@/i18n/i18n'
 import type { TuiAgent } from '../../../shared/types'
 
@@ -49,6 +55,11 @@ 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()
@@ -90,10 +101,13 @@ 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) {
@@ -101,6 +115,8 @@ 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,
@@ -108,7 +124,8 @@ export default function OrchestratorLaunchModal(): React.JSX.Element | null {
     prefilledProjectOptionId,
     defaultTuiAgent,
     prefillName,
-    prefillPrompt
+    prefillPrompt,
+    recipes
   ])
 
   if (!visible) {
@@ -121,15 +138,28 @@ 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
     }
-    void launchOrchestratorForProject(project, {
-      name: name.trim() || undefined,
-      agent: agent ?? undefined,
-      prompt: prompt.trim() || undefined
-    })
+    // 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
+      })
+    }
     closeModal()
   }
 
@@ -184,6 +214,16 @@ 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')}
@@ -199,36 +239,43 @@ export default function OrchestratorLaunchModal(): React.JSX.Element | null {
               }
             />
           </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>
+          {/* 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>
+            </>
+          )}
           <DialogFooter>
             <Button type="button" variant="ghost" onClick={closeModal}>
               {translate('auto.components.OrchestratorLaunchModal.cancel', 'Cancel')}
             </Button>
-            <Button type="submit" disabled={!project}>
+            <Button type="submit" disabled={!project || (isRecipe && !recipeName)}>
               {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
new file mode 100644
index 00000000000..6632ff3d9ec
--- /dev/null
+++ b/src/renderer/src/components/director/DirectorTypePicker.test.tsx
@@ -0,0 +1,74 @@
+// @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
new file mode 100644
index 00000000000..a45c9327503
--- /dev/null
+++ b/src/renderer/src/components/director/DirectorTypePicker.tsx
@@ -0,0 +1,173 @@
+import type React from 'react'
+import { ListChecks, Sparkles } from 'lucide-react'
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue
+} 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}>
+            <SelectTrigger size="sm" className="w-full text-xs">
+              <SelectValue
+                placeholder={translate(
+                  'auto.components.director.DirectorTypePicker.recipe_placeholder',
+                  'Select a recipe'
+                )}
+              />
+            </SelectTrigger>
+            <SelectContent>
+              {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 80eb635f8e9..b53e541979e 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -11819,6 +11819,17 @@
         "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 4efbc0f32a0..313cac48e5f 100644
--- a/src/renderer/src/i18n/locales/es.json
+++ b/src/renderer/src/i18n/locales/es.json
@@ -11819,6 +11819,17 @@
         "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 819435fbb20..3c5aa540a93 100644
--- a/src/renderer/src/i18n/locales/ja.json
+++ b/src/renderer/src/i18n/locales/ja.json
@@ -11819,6 +11819,17 @@
         "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 69c891bf887..50a6933aadb 100644
--- a/src/renderer/src/i18n/locales/ko.json
+++ b/src/renderer/src/i18n/locales/ko.json
@@ -11819,6 +11819,17 @@
         "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 f7fb95950b2..765b283e4f1 100644
--- a/src/renderer/src/i18n/locales/zh.json
+++ b/src/renderer/src/i18n/locales/zh.json
@@ -11819,6 +11819,17 @@
         "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
new file mode 100644
index 00000000000..13217d53bb6
--- /dev/null
+++ b/src/renderer/src/lib/director-backend.test.ts
@@ -0,0 +1,63 @@
+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
new file mode 100644
index 00000000000..c1f2a7060f0
--- /dev/null
+++ b/src/renderer/src/lib/director-backend.ts
@@ -0,0 +1,51 @@
+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)
+  }
+}