@brimveyn/aimux 1.14.14 → 1.14.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.14.14",
+  "version": "1.14.16",
   "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",
@@ -60,7 +60,7 @@
     "bump": "bun run scripts/bump.ts"
   },
   "dependencies": {
-    "@brimveyn/aimux-config": "0.6.8",
+    "@brimveyn/aimux-config": "0.6.10",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@resvg/resvg-wasm": "^2.6.2",

package/src/app-runtime/side-effects.ts

@@ -16,16 +16,19 @@ import type { SessionBackend } from '../session-backend/types'
 import type { AppAction, AppState, AssistantId, TabSession, WorktreeRecord } from '../state/types'
 import type { ThemeId } from '../ui/themes'
 
-import { loadConfig, saveConfig } from '../config'
+import { loadConfig, saveConfig, type WorktreeTemplate, type WorktreeTemplatePane } from '../config'
 import { logInputDebug } from '../debug/input-log'
 import { enqueueGitOp } from '../git/command-queue'
 import { moveWorktree } from '../git/move-worktree'
 import {
   createGitWorktree,
+  deleteGitBranch,
   getCurrentBranch,
   getHeadSha,
   getMainWorktreeRoot,
   listGitWorktrees,
+  listLocalBranches,
+  pruneGitWorktrees,
   removeGitWorktree,
 } from '../git/worktree'
 import { createPrefixedId } from '../platform/id'
@@ -54,7 +57,12 @@ import {
   type SplitDirection,
   splitNode,
 } from '../state/layout-tree'
-import { filterAssistants, filterSessions, filterSnippets } from '../state/selectors'
+import {
+  filterAssistants,
+  filterSessions,
+  filterSnippets,
+  getTemplateNoneOffset,
+} from '../state/selectors'
 import { saveSessionCatalog } from '../state/session-catalog'
 import { pruneSnapshotOfWorktree } from '../state/session-persistence'
 import {
@@ -73,6 +81,7 @@ import { filterThemeIds } from '../ui/filter-themes'
 import { scrollGitDiff } from '../ui/git-view-controls'
 import { applyTheme, getCurrentMode, getTransparent, setMode, setTransparent } from '../ui/theme'
 import { triggerAutoCommitNow } from './auto-commit-ref'
+import { writeToTab } from './pty-write'
 import {
   handleCreateSessionEffect,
   handleDeleteSessionEffect,
@@ -88,6 +97,15 @@ import {
 } from './snippet-actions'
 
 const STARTUP_GRACE_MS = 5_000
+/**
+ * Delay before injecting a template pane's `send` payload into its PTY.
+ * Short enough that shells (which print a prompt within ~100 ms) receive the
+ * command after their prompt is drawn; long enough to clear most PTY init
+ * races. Not tied to STARTUP_GRACE_MS because that is the assistant timeout,
+ * not a readiness signal. See review note: a `tab.status === 'running'`
+ * subscription would be more robust and is the planned follow-up.
+ */
+const TEMPLATE_SEND_DELAY_MS = 600
 
 export interface SideEffectContext {
   state: AppState
@@ -403,7 +421,9 @@ async function launchAssistantInNewWorktree(
   assistant: AssistantId,
   worktreeName: string,
   branchName?: string,
-  sourceWorktreeId?: string
+  sourceWorktreeId?: string,
+  baseRef?: string,
+  templateId?: string
 ): Promise<void> {
   const sessionId = ctx.state.currentSessionId
   if (!(sessionId != null && sessionId !== '')) return
@@ -412,14 +432,27 @@ async function launchAssistantInNewWorktree(
     sessionId,
     worktreeName,
     branchName,
-    undefined,
+    baseRef,
     sourceWorktreeId
   )
   if (!worktree) return
+
+  const template =
+    templateId != null && templateId !== ''
+      ? ctx.state.worktreeTemplates.find((entry) => entry.id === templateId)
+      : undefined
+
+  ctx.dispatch({ type: 'close-modal' })
+
+  if (template) {
+    applyWorktreeTemplate(ctx, template, worktree.id, worktree.path)
+    ctx.dispatch({ focusMode: 'terminal-input', type: 'set-focus-mode' })
+    return
+  }
+
   const customCommand = ctx.state.customCommands[assistant]
   const tab = createTabSession(assistant, customCommand, ctx.state.customCommands, worktree.id)
   ctx.dispatch({ tab, type: 'add-tab' })
-  ctx.dispatch({ type: 'close-modal' })
   ctx.dispatch({ focusMode: 'terminal-input', type: 'set-focus-mode' })
   startTabSession(
     ctx.backend,
@@ -433,6 +466,126 @@ async function launchAssistantInNewWorktree(
   )
 }
 
+function applyWorktreeTemplate(
+  ctx: SideEffectContext,
+  template: WorktreeTemplate,
+  worktreeId: string,
+  worktreePath: string
+): void {
+  let firstTabId: string | null = null
+
+  for (const templateTab of template.tabs) {
+    const localToTabId = new Map<string, string>()
+
+    for (let i = 0; i < templateTab.panes.length; i++) {
+      const pane = templateTab.panes[i]
+      if (!pane) continue
+      const tab = createPaneTab(ctx, pane, worktreeId)
+      localToTabId.set(pane.id, tab.id)
+
+      if (i === 0) {
+        if (firstTabId == null) firstTabId = tab.id
+        ctx.dispatch({ tab, type: 'add-tab' })
+        startTabSession(
+          ctx.backend,
+          ctx.dispatch,
+          ctx.clearStartupGrace,
+          (tabId) => ctx.startStartupGrace(tabId, STARTUP_GRACE_MS),
+          tab,
+          ctx.state.layout.terminalCols,
+          ctx.state.layout.terminalRows,
+          worktreePath
+        )
+      } else {
+        const splitFromId =
+          pane.splitFrom != null && pane.splitFrom !== ''
+            ? localToTabId.get(pane.splitFrom)
+            : undefined
+        const direction: SplitDirection = pane.direction ?? 'vertical'
+        if (splitFromId == null || splitFromId === '') {
+          logInputDebug('template.splitFrom.unresolved', {
+            paneId: pane.id,
+            splitFrom: pane.splitFrom ?? null,
+            templateId: template.id,
+          })
+          continue
+        }
+        splitFromTab(ctx, splitFromId, direction, tab, worktreePath)
+        if (pane.ratio != null) {
+          const sourceRatio = clampSplitRatio(1 - pane.ratio)
+          ctx.dispatch({
+            axis: direction,
+            ratio: sourceRatio,
+            tabId: tab.id,
+            type: 'set-split-ratio',
+          })
+        }
+      }
+
+      if (pane.send != null && pane.send !== '') {
+        const payload = `${pane.send}\n`
+        const targetTabId = tab.id
+        setTimeout(() => {
+          const latest = ctx.getState()
+          const latestTab = latest.tabs.find((entry) => entry.id === targetTabId)
+          writeToTab(ctx.backend, targetTabId, latestTab, payload)
+        }, TEMPLATE_SEND_DELAY_MS)
+      }
+    }
+  }
+
+  if (firstTabId != null) {
+    ctx.dispatch({ tabId: firstTabId, type: 'set-active-tab' })
+  }
+}
+
+function createPaneTab(
+  ctx: SideEffectContext,
+  pane: WorktreeTemplatePane,
+  worktreeId: string
+): TabSession {
+  // Accept `'shell'` as an alias for the registered `'terminal'` assistant so
+  // template examples using the more intuitive name don't silently fall back
+  // to Claude (createTabSession's unknown-id fallback resolves to index 0).
+  const assistantId = (pane.assistant === 'shell' ? 'terminal' : pane.assistant) as AssistantId
+  const customCommand = ctx.state.customCommands[assistantId]
+  return createTabSession(assistantId, customCommand, ctx.state.customCommands, worktreeId)
+}
+
+function splitFromTab(
+  ctx: SideEffectContext,
+  baseTabId: string,
+  direction: SplitDirection,
+  newTab: TabSession,
+  cwd?: string
+): void {
+  ctx.dispatch({ tabId: baseTabId, type: 'set-active-tab' })
+
+  const latest = ctx.getState()
+  const existingTree = getTreeForTab(latest.layoutTrees, latest.tabGroupMap, baseTabId)
+  const baseTree = existingTree ?? createLeaf(baseTabId)
+  const newTree = splitNode(baseTree, baseTabId, direction, newTab.id)
+  const bounds = createTerminalBounds(latest.layout.terminalCols, latest.layout.terminalRows)
+  const paneRect = computePaneRects(newTree, bounds).get(newTab.id)
+
+  ctx.dispatch({ direction, newTab, type: 'split-pane' })
+  startTabSession(
+    ctx.backend,
+    ctx.dispatch,
+    ctx.clearStartupGrace,
+    (tabId) => ctx.startStartupGrace(tabId, STARTUP_GRACE_MS),
+    newTab,
+    Math.max(1, (paneRect?.cols ?? latest.layout.terminalCols) - PANE_BORDER * 2),
+    Math.max(1, (paneRect?.rows ?? latest.layout.terminalRows) - PANE_BORDER * 2),
+    cwd
+  )
+}
+
+function clampSplitRatio(value: number): number {
+  if (!Number.isFinite(value)) return 0.5
+  return Math.min(0.85, Math.max(0.15, value))
+}
+
 function getTabProjectPath(
   ctx: SideEffectContext,
   tab: Pick<TabSession, 'worktreeId'>
@@ -504,11 +657,28 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       return
     }
     case 'launch-selected-assistant': {
+      if (
+        state.modal.type === 'new-tab' &&
+        state.modal.step === 'worktree-create' &&
+        state.worktreeTemplates.length > 0
+      ) {
+        dispatch({ type: 'enter-new-tab-template-pick' })
+        return
+      }
       const option = getSelectedAssistantOption(state)
       if (state.modal.type === 'new-tab' && state.modal.createWorktree) {
         const worktreeName = state.modal.worktreeName
         const branchName = state.modal.branchName
+        const baseRef = state.modal.baseRef
         const sourceWorktreeId = getNewTabTargetWorktreeId(state)
+        let templateId: string | undefined
+        if (state.modal.step === 'template') {
+          const templateIndex =
+            state.modal.selectedIndex - getTemplateNoneOffset(state.modal.selectedAssistantId)
+          if (templateIndex >= 0) {
+            templateId = state.worktreeTemplates[templateIndex]?.id
+          }
+        }
         void (async () => {
           try {
             await enqueueGitOp(async () =>
@@ -517,7 +687,9 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
                 option.id,
                 worktreeName,
                 branchName,
-                sourceWorktreeId
+                sourceWorktreeId,
+                baseRef !== '' ? baseRef : undefined,
+                templateId
               )
             )
           } catch (error) {
@@ -534,6 +706,17 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       dispatch({ assistantId: option.id, type: 'open-edit-custom-command' })
       return
     }
+    case 'load-new-tab-base-branches': {
+      void (async () => {
+        const session = state.sessions.find((entry) => entry.id === state.currentSessionId)
+        const sourcePath = getActiveWorktree(session)?.path ?? getSessionProjectPath(session)
+        if (!(sourcePath != null && sourcePath !== '')) return
+        const branches = await listLocalBranches(sourcePath)
+        if (ctx.getState().modal.type !== 'new-tab') return
+        ctx.dispatch({ branches, type: 'set-new-tab-base-branches' })
+      })()
+      return
+    }
     case 'confirm-selected-session': {
       handleSessionSelection(ctx)
       return
@@ -554,27 +737,40 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
               { ...ctx, state: ctx.getState() },
               effect.sessionId,
               effect.worktreeId,
-              !!(effect.force === true)
+              !!(effect.force === true),
+              !!(effect.closeTabs === true)
             )
           )
         } catch (error) {
           const message = error instanceof Error ? error.message : String(error)
-          const forceable = isForceableWorktreeDeleteError(message)
+          // Real errors surface as a toast. Recoverable failures (dirty tree,
+          // active tabs, …) open a confirmation so the user can opt into a
+          // force-delete: in-place inside the new-tab worktree picker (preserving
+          // it), or as a standalone modal elsewhere (e.g. the sidebar's "Remove
+          // worktree").
+          if (!isForceableWorktreeDeleteError(message)) {
+            toast.error(`Could not delete worktree: ${message}`)
+            return
+          }
           const latest = ctx.getState()
           if (latest.modal.type === 'new-tab' && latest.modal.step === 'worktree') {
-            const session = latest.sessions.find((entry) => entry.id === effect.sessionId)
-            const selected = session?.worktrees?.[latest.modal.selectedIndex]
-            if (selected && selected.id !== effect.worktreeId) {
-              ctx.dispatch({ message, type: 'git-mode-set-message' })
-              return
-            }
+            ctx.dispatch({
+              prompt: { reason: message, worktreeId: effect.worktreeId },
+              type: 'set-new-tab-worktree-delete-prompt',
+            })
+            return
           }
+          const session = latest.sessions.find((entry) => entry.id === effect.sessionId)
+          const worktree = session?.worktrees?.find((entry) => entry.id === effect.worktreeId)
           ctx.dispatch({
-            confirmWorktreeId: forceable ? effect.worktreeId : null,
-            message: forceable ? message : `Could not delete worktree: ${message}`,
-            type: 'set-new-tab-worktree-delete-state',
+            closeTabs: effect.closeTabs === true,
+            force: true,
+            reason: message,
+            sessionId: effect.sessionId,
+            type: 'open-worktree-delete-confirm',
+            worktreeId: effect.worktreeId,
+            worktreeLabel: worktree?.branch ?? worktree?.name ?? 'this worktree',
           })
-          ctx.dispatch({ message, type: 'git-mode-set-message' })
         }
       })()
       return
@@ -1378,7 +1574,8 @@ async function runDeleteWorktree(
   ctx: SideEffectContext,
   sessionId: string,
   worktreeId: string,
-  force: boolean
+  force: boolean,
+  closeTabs = false
 ): Promise<void> {
   const session = ctx.state.sessions.find((entry) => entry.id === sessionId)
   const worktree = session?.worktrees?.find((entry) => entry.id === worktreeId)
@@ -1388,36 +1585,43 @@ async function runDeleteWorktree(
   if (worktree.source === 'primary') throw new Error('root worktree cannot be deleted')
 
   const tabsInWorktree = ctx.state.tabs.filter((tab) => tab.worktreeId === worktreeId)
-  if (tabsInWorktree.length > 0 && !force) {
+  // The active-tabs guard asks the modal user to confirm before closing tabs.
+  // `closeTabs` (the sidebar's "Remove worktree") opts into closing them
+  // directly without forcing the git removal, so dirty temp worktrees are still
+  // protected by the non-force `git worktree remove`.
+  if (tabsInWorktree.length > 0 && !force && !closeTabs) {
     throw new ActiveWorktreeTabsError(tabsInWorktree.length)
   }
   disposeWorktreeTabs(ctx, worktreeId)
 
-  if (
-    worktree.source === 'aimux-temp' &&
-    worktree.createdByAimux &&
-    isInsideAimuxWorktreeRoot(worktree.path) &&
-    !existsSync(worktree.path)
-  ) {
+  const repoPath = resolveWorktreeGitDir(session, worktree)
+  const isAimuxTemp = worktree.source === 'aimux-temp' && worktree.createdByAimux
+  // Drop the throwaway aimux branch alongside the worktree so deleted temp
+  // worktrees don't accumulate in the repo or haunt the base picker. Scoped to
+  // the `aimux/` namespace (matches the picker filter); best-effort.
+  const cleanupAimuxBranch = async (): Promise<void> => {
+    const branch = worktree.branch
+    if (isAimuxTemp && branch != null && branch !== '' && branch.startsWith('aimux/')) {
+      await deleteGitBranch(repoPath, branch)
+    }
+  }
+
+  if (isAimuxTemp && isInsideAimuxWorktreeRoot(worktree.path) && !existsSync(worktree.path)) {
+    // The dir vanished but git may still pin the branch to a stale worktree entry.
+    await pruneGitWorktrees(repoPath)
+    await cleanupAimuxBranch()
     removeWorktreeRecordFromSession(ctx, sessionId, session, worktreeId)
     return
   }
 
-  if (
-    worktree.source === 'aimux-temp' &&
-    worktree.createdByAimux &&
-    isInsideAimuxWorktreeRoot(worktree.path)
-  ) {
+  if (isAimuxTemp && isInsideAimuxWorktreeRoot(worktree.path)) {
     await assertSafeAimuxWorktreePath(worktree.path)
-    await removeGitWorktree({
-      force,
-      repoPath: resolveWorktreeGitDir(session, worktree),
-      targetPath: worktree.path,
-    })
+    await removeGitWorktree({ force, repoPath, targetPath: worktree.path })
   } else if (worktree.source === 'aimux-temp' || worktree.createdByAimux) {
     throw new Error(`refusing unsafe worktree delete: ${worktree.path}`)
   }
 
+  await cleanupAimuxBranch()
   removeWorktreeRecordFromSession(ctx, sessionId, session, worktreeId)
 }
 
@@ -1528,7 +1732,7 @@ function removeWorktreeRecordFromSession(
       type: 'set-modal-selection-index',
     })
   }
-  ctx.dispatch({ message: null, type: 'set-new-tab-worktree-delete-state' })
+  ctx.dispatch({ prompt: null, type: 'set-new-tab-worktree-delete-prompt' })
 }
 
 function isForceableWorktreeDeleteError(message: string): boolean {
@@ -1540,7 +1744,7 @@ function isForceableWorktreeDeleteError(message: string): boolean {
 class ActiveWorktreeTabsError extends Error {
   constructor(tabCount: number) {
     super(
-      `active assistant tabs are using this worktree (${tabCount}). Click [del] again to close them and delete the worktree.`
+      `active assistant tabs are using this worktree (${tabCount}) — they will be closed if you confirm.`
     )
   }
 }

package/src/app.tsx

@@ -22,7 +22,9 @@ import { useMouseHandlers } from './app-runtime/use-mouse-handlers'
 import { useRendererBindings } from './app-runtime/use-renderer-bindings'
 import { useTerminalResize } from './app-runtime/use-terminal-resize'
 import { useWorkspaceAutosave } from './app-runtime/use-workspace-autosave'
-import { loadConfig } from './config'
+import { loadConfig, saveConfig } from './config'
+import { enqueueGitOp } from './git/command-queue'
+import { pruneOrphanAimuxBranches } from './git/worktree'
 import { setActiveKeymap } from './input/keymap/keymap-ref'
 import { deriveModeId } from './input/modes/bridge'
 import { registerAllModes } from './input/modes/handlers'
@@ -39,6 +41,7 @@ import { findMostRecentSession, loadSessionCatalog } from './state/session-catal
 import { getSessionProjectPath } from './state/session-worktrees'
 import { loadSnippetCatalog, mergeConfigSnippets } from './state/snippet-catalog'
 import { createInitialState } from './state/store'
+import { toast } from './state/toast-store'
 import { KeymapContext } from './ui/keymap-context'
 import { RootView } from './ui/root'
 import {
@@ -152,6 +155,10 @@ export function App({
         gitPane: gitPaneOverrides,
         sessionBarVisible,
         sidebar: sidebarOverrides,
+        worktreeTemplates:
+          resolvedConfig.worktreeTemplates.length > 0
+            ? resolvedConfig.worktreeTemplates
+            : json.worktreeTemplates,
       }
     )
     // Replace the module-level default with the fully-resolved initial state.
@@ -246,6 +253,28 @@ export function App({
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [])
 
+  useEffect(() => {
+    // One-shot cleanup: prune `aimux/` branches orphaned by temp worktrees that
+    // were deleted before delete-time branch cleanup existed. Gated by a config
+    // flag so it runs once per machine. All git calls are best-effort (nothrow)
+    // and git protects branches still checked out in a live worktree.
+    if (loadConfig().prunedOrphanAimuxBranches === true) return
+    void (async () => {
+      const repoRoots = new Set<string>()
+      for (const session of loadSessionCatalog()) {
+        for (const worktree of session.worktrees ?? []) {
+          if (worktree.repoRoot !== '') repoRoots.add(worktree.repoRoot)
+        }
+      }
+      let removed = 0
+      for (const repoRoot of repoRoots) {
+        removed += await enqueueGitOp(() => pruneOrphanAimuxBranches(repoRoot))
+      }
+      saveConfig({ ...loadConfig(), prunedOrphanAimuxBranches: true })
+      if (removed > 0) toast.success(`Cleaned ${removed} orphaned aimux branch(es)`)
+    })()
+  }, [])
+
   const resizingRef = useRef(false)
   // Seeded with state.layout's DEFAULT 80x24; reassigned below once
   // useTerminalResize has produced the open-loop estimate from real dimensions.

package/src/config.ts

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 
+import type { SplitDirection } from './state/layout-tree'
 import type { GitFileListMode, WorkspaceSnapshotV1 } from './state/types'
 
 import { logDebug } from './debug/input-log'
@@ -32,6 +33,26 @@ export interface PersistedSidebar {
   width: number
 }
 
+export interface WorktreeTemplatePane {
+  id: string
+  assistant: string
+  splitFrom?: string
+  direction?: SplitDirection
+  ratio?: number
+  send?: string
+}
+
+export interface WorktreeTemplateTab {
+  panes: WorktreeTemplatePane[]
+}
+
+export interface WorktreeTemplate {
+  id: string
+  name: string
+  description?: string
+  tabs: WorktreeTemplateTab[]
+}
+
 export interface AimuxConfig {
   version: 2
   customCommands: Record<string, string>
@@ -43,6 +64,9 @@ export interface AimuxConfig {
   sessionBarVisible?: boolean
   workspaceSnapshot?: WorkspaceSnapshotV1
   skippedUpdateVersion?: string
+  /** One-shot guard: orphan `aimux/` branches were pruned from existing repos. */
+  prunedOrphanAimuxBranches?: boolean
+  worktreeTemplates?: WorktreeTemplate[]
 }
 
 function isPersistedGitPane(value: unknown): value is PersistedGitPane {
@@ -105,6 +129,77 @@ function isPersistedGitPane(value: unknown): value is PersistedGitPane {
   return true
 }
 
+function isRatioValid(value: unknown): boolean {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0.15 && value < 0.85
+}
+
+function isWorktreeTemplateTab(value: unknown): value is WorktreeTemplateTab {
+  if (typeof value !== 'object' || value === null) return false
+  const v = value as Record<string, unknown>
+  if (!Array.isArray(v.panes) || v.panes.length === 0) return false
+  const seenIds = new Set<string>()
+  for (let i = 0; i < v.panes.length; i++) {
+    const rawPane = v.panes[i]
+    if (typeof rawPane !== 'object' || rawPane === null) return false
+    const pane = rawPane as Record<string, unknown>
+    if (typeof pane.id !== 'string' || pane.id.length === 0) return false
+    if (seenIds.has(pane.id)) return false
+    seenIds.add(pane.id)
+    if (typeof pane.assistant !== 'string' || pane.assistant.length === 0) return false
+    if (i === 0) {
+      if (pane.splitFrom !== undefined) return false
+      if (pane.direction !== undefined) return false
+      if (pane.ratio !== undefined) return false
+    } else {
+      if (typeof pane.splitFrom !== 'string' || !seenIds.has(pane.splitFrom)) return false
+      if (pane.splitFrom === pane.id) return false
+      if (pane.direction !== 'horizontal' && pane.direction !== 'vertical') return false
+      if (pane.ratio !== undefined && !isRatioValid(pane.ratio)) return false
+    }
+    if (pane.send !== undefined && typeof pane.send !== 'string') return false
+  }
+  return true
+}
+
+export function isWorktreeTemplate(value: unknown): value is WorktreeTemplate {
+  if (typeof value !== 'object' || value === null) return false
+  const v = value as Record<string, unknown>
+  if (typeof v.id !== 'string' || v.id.length === 0) return false
+  if (typeof v.name !== 'string' || v.name.length === 0) return false
+  if (v.description !== undefined && typeof v.description !== 'string') return false
+  if (!Array.isArray(v.tabs) || v.tabs.length === 0) return false
+  for (const tab of v.tabs) {
+    if (!isWorktreeTemplateTab(tab)) return false
+  }
+  return true
+}
+
+export function parseWorktreeTemplates(
+  value: unknown,
+  issues: string[]
+): WorktreeTemplate[] | undefined {
+  if (value === undefined) return undefined
+  if (!Array.isArray(value)) {
+    issues.push('ignored invalid worktreeTemplates (not an array)')
+    return undefined
+  }
+  const seen = new Set<string>()
+  const valid: WorktreeTemplate[] = []
+  for (const entry of value) {
+    if (!isWorktreeTemplate(entry)) {
+      issues.push('ignored invalid worktreeTemplate entry')
+      continue
+    }
+    if (seen.has(entry.id)) {
+      issues.push(`ignored duplicate worktreeTemplate id "${entry.id}"`)
+      continue
+    }
+    seen.add(entry.id)
+    valid.push(entry)
+  }
+  return valid.length > 0 ? valid : undefined
+}
+
 function isPersistedSidebar(value: unknown): value is PersistedSidebar {
   if (typeof value !== 'object' || value === null) return false
   const v = value as Record<string, unknown>
@@ -162,6 +257,8 @@ export function loadConfigResult(): ConfigLoadResult {
       sessionBarVisible?: unknown
       workspaceSnapshot?: unknown
       skippedUpdateVersion?: unknown
+      prunedOrphanAimuxBranches?: unknown
+      worktreeTemplates?: unknown
     }
 
     const issues: string[] = []
@@ -246,6 +343,8 @@ export function loadConfigResult(): ConfigLoadResult {
       issues.push('ignored invalid skippedUpdateVersion')
     }
 
+    const validWorktreeTemplates = parseWorktreeTemplates(parsed.worktreeTemplates, issues)
+
     if (issues.length > 0) {
       logDebug('config.load.validationIssue', { issues, path: CONFIG_PATH })
     }
@@ -254,6 +353,7 @@ export function loadConfigResult(): ConfigLoadResult {
       config: {
         customCommands: isCustomCommandsRecord(parsed.customCommands) ? parsed.customCommands : {},
         gitPane: validGitPane,
+        prunedOrphanAimuxBranches: parsed.prunedOrphanAimuxBranches === true ? true : undefined,
         sessionBarVisible: validSessionBarVisible,
         sidebar: validSidebar,
         skippedUpdateVersion: validSkippedUpdateVersion,
@@ -264,6 +364,7 @@ export function loadConfigResult(): ConfigLoadResult {
         workspaceSnapshot: isWorkspaceSnapshotV1(parsed.workspaceSnapshot)
           ? parsed.workspaceSnapshot
           : undefined,
+        worktreeTemplates: validWorktreeTemplates,
       },
       issues,
       source: 'file',