@brimveyn/aimux 1.14.15 → 1.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.14.15",
+  "version": "1.15.0",
   "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.9",
+    "@brimveyn/aimux-config": "0.6.11",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@resvg/resvg-wasm": "^2.6.2",

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

@@ -19,13 +19,16 @@ import type { ThemeId } from '../ui/themes'
 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 { countDirtyFiles, moveWorktree } from '../git/move-worktree'
 import {
   createGitWorktree,
+  deleteGitBranch,
   getCurrentBranch,
   getHeadSha,
   getMainWorktreeRoot,
   listGitWorktrees,
+  listLocalBranches,
+  pruneGitWorktrees,
   removeGitWorktree,
 } from '../git/worktree'
 import { createPrefixedId } from '../platform/id'
@@ -419,6 +422,7 @@ async function launchAssistantInNewWorktree(
   worktreeName: string,
   branchName?: string,
   sourceWorktreeId?: string,
+  baseRef?: string,
   templateId?: string
 ): Promise<void> {
   const sessionId = ctx.state.currentSessionId
@@ -428,7 +432,7 @@ async function launchAssistantInNewWorktree(
     sessionId,
     worktreeName,
     branchName,
-    undefined,
+    baseRef,
     sourceWorktreeId
   )
   if (!worktree) return
@@ -665,6 +669,7 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       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') {
@@ -683,6 +688,7 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
                 worktreeName,
                 branchName,
                 sourceWorktreeId,
+                baseRef !== '' ? baseRef : undefined,
                 templateId
               )
             )
@@ -700,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
@@ -720,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
@@ -754,7 +784,9 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
               effect.sessionId,
               effect.sourceWorktreeId,
               effect.targetWorktreeId,
-              effect.deleteSource === true
+              effect.deleteSource === true,
+              effect.stashTarget === true,
+              effect.keepConflicts === true
             )
           )
         } catch (error) {
@@ -763,6 +795,22 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
       })()
       return
     }
+    case 'load-worktree-move-stats': {
+      void (async () => {
+        const session = state.sessions.find((entry) => entry.id === state.currentSessionId)
+        const worktrees = session?.worktrees ?? []
+        if (worktrees.length === 0) return
+        const counts = await Promise.all(
+          worktrees.map(async (worktree) => [worktree.id, await countDirtyFiles(worktree.path)])
+        )
+        if (ctx.getState().modal.type !== 'worktree-move') return
+        ctx.dispatch({
+          dirtyFiles: Object.fromEntries(counts),
+          type: 'set-worktree-move-stats',
+        })
+      })()
+      return
+    }
     case 'open-rename-selected-session': {
       openSelectedSessionRename(ctx)
       return
@@ -1544,7 +1592,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)
@@ -1554,36 +1603,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)
 }
 
@@ -1610,7 +1666,9 @@ async function runMoveWorktree(
   sessionId: string,
   sourceWorktreeId: string,
   targetWorktreeId: string,
-  deleteSource: boolean
+  deleteSource: boolean,
+  stashTarget: boolean,
+  keepConflicts: boolean
 ): Promise<void> {
   const session = ctx.state.sessions.find((entry) => entry.id === sessionId)
   const source = session?.worktrees?.find((entry) => entry.id === sourceWorktreeId)
@@ -1628,20 +1686,38 @@ async function runMoveWorktree(
   const sourceLabel = source.branch ?? source.name
   const targetLabel = target.branch ?? target.name
   const result = await moveWorktree({
+    keepConflicts,
     sourceBranch: source.branch,
     sourcePath: source.path,
+    stashTarget,
     targetPath: target.path,
   })
 
-  // Toasts surface the outcome everywhere — the picker can be opened outside git
-  // mode (from a tab menu), where the git-pane message would never be seen.
-  if (result.kind === 'dirty-target') {
-    toast.warning(`Target ${targetLabel} has uncommitted changes — commit or stash it first`)
+  // Recoverable failures open a confirm dialog carrying retry params; both
+  // worktrees are already back in their original state, so confirming simply
+  // re-dispatches move-worktree with the matching flag.
+  if (result.kind === 'needs-stash' || result.kind === 'conflict') {
+    ctx.dispatch({
+      deleteSource,
+      files: result.files,
+      sessionId,
+      sourceLabel,
+      sourceWorktreeId,
+      targetLabel,
+      targetWorktreeId,
+      type: 'open-worktree-move-confirm',
+      variant: result.kind === 'needs-stash' ? 'stash-target' : 'keep-conflicts',
+    })
     return
   }
-  if (result.kind === 'conflict') {
+  if (result.kind === 'conflict-kept') {
+    // Never delete the source here — its work only landed half-resolved. The
+    // auto-commit driver is safe against this state: git refuses to commit
+    // with unmerged index entries, so it fails loudly instead of committing
+    // conflict markers.
+    handleSwitchWorktree({ ...ctx, state: ctx.getState() }, sessionId, targetWorktreeId)
     toast.warning(
-      `Move hit conflicts in ${result.files.length} file(s) — left ${sourceLabel} untouched`
+      `Left conflict markers in ${targetLabel} (${result.files.length} file(s)) — resolve & commit there; ${sourceLabel} kept`
     )
     return
   }
@@ -1664,8 +1740,11 @@ async function runMoveWorktree(
   } else {
     handleSwitchWorktree({ ...ctx, state: ctx.getState() }, sessionId, targetWorktreeId)
   }
+  const stashNote = result.stashedTarget
+    ? ` · target's previous changes stashed (recover with git stash pop)`
+    : ''
   toast.success(
-    `Moved ${sourceLabel} → ${targetLabel} · ${result.filesChanged} file(s) staged — review & commit`
+    `Moved ${sourceLabel} → ${targetLabel} · ${result.filesChanged} file(s) staged — review & commit${stashNote}`
   )
 }
 
@@ -1694,7 +1773,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 {
@@ -1706,7 +1785,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 {
@@ -250,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

@@ -64,6 +64,8 @@ export interface AimuxConfig {
   sessionBarVisible?: boolean
   workspaceSnapshot?: WorkspaceSnapshotV1
   skippedUpdateVersion?: string
+  /** One-shot guard: orphan `aimux/` branches were pruned from existing repos. */
+  prunedOrphanAimuxBranches?: boolean
   worktreeTemplates?: WorktreeTemplate[]
 }
 
@@ -255,6 +257,7 @@ export function loadConfigResult(): ConfigLoadResult {
       sessionBarVisible?: unknown
       workspaceSnapshot?: unknown
       skippedUpdateVersion?: unknown
+      prunedOrphanAimuxBranches?: unknown
       worktreeTemplates?: unknown
     }
 
@@ -350,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,

package/src/git/move-worktree.ts

@@ -1,15 +1,36 @@
 import { $ } from 'bun'
 
+export interface MoveWorktreeOptions {
+  sourcePath: string
+  sourceBranch: string
+  targetPath: string
+  /** Stash the target's uncommitted (incl. untracked) changes before merging. The stash is kept. */
+  stashTarget?: boolean
+  /** On conflict, leave the conflicted squash state in the target for manual resolution. */
+  keepConflicts?: boolean
+}
+
 export type MoveWorktreeResult =
-  | { kind: 'ok'; filesChanged: number }
-  | { kind: 'dirty-target' }
+  | { kind: 'ok'; filesChanged: number; stashedTarget: boolean }
+  /** Target dirty/untracked files would be overwritten by the move; nothing was touched. */
+  | { kind: 'needs-stash'; files: string[] }
+  /** Conflict; target and source fully restored. */
   | { kind: 'conflict'; files: string[] }
+  /** Conflict markers left in the target on purpose; source restored. */
+  | { kind: 'conflict-kept'; files: string[] }
   | { kind: 'error'; message: string }
 
-async function workingTreeDirty(repoPath: string): Promise<boolean> {
+export async function countDirtyFiles(repoPath: string): Promise<number> {
   const result = await $`git -C ${repoPath} status --porcelain`.quiet().nothrow()
-  if (result.exitCode !== 0) return false
-  return result.text().trim() !== ''
+  if (result.exitCode !== 0) return 0
+  return result
+    .text()
+    .split('\n')
+    .filter((line) => line.trim() !== '').length
+}
+
+async function workingTreeDirty(repoPath: string): Promise<boolean> {
+  return (await countDirtyFiles(repoPath)) > 0
 }
 
 // Files left with conflict markers by a failed squash (unmerged index entries).
@@ -32,27 +53,63 @@ async function countStaged(repoPath: string): Promise<number> {
     .filter((line) => line.trim() !== '').length
 }
 
+// Git refuses a merge up front (working tree untouched) when local changes
+// overlap the incoming ones, listing the files tab-indented under either
+// "Your local changes to the following files would be overwritten by merge:"
+// or "The following untracked working tree files would be overwritten by merge:".
+function parseOverwrittenFiles(output: string): string[] {
+  const files: string[] = []
+  let collecting = false
+  for (const line of output.split('\n')) {
+    if (line.includes('would be overwritten by merge')) {
+      collecting = true
+      continue
+    }
+    if (!collecting) continue
+    if (line.startsWith('\t')) {
+      const file = line.trim()
+      if (file !== '') files.push(file)
+    } else {
+      collecting = false
+    }
+  }
+  return files
+}
+
 // Squashes everything a source worktree changed since its fork point into the
 // target worktree's working tree (staged, uncommitted) — committed work plus
 // any uncommitted/untracked changes. The source is left exactly as it was; the
-// caller decides whether to delete it. The target must be clean so two change
-// sets are never silently fused. On conflict nothing is kept: the target is
-// reset and the source restored.
-export async function moveWorktree(opts: {
-  sourcePath: string
-  sourceBranch: string
-  targetPath: string
-}): Promise<MoveWorktreeResult> {
+// caller decides whether to delete it. The target may be dirty as long as its
+// local changes don't overlap the incoming ones: on overlap the move stops
+// before touching anything (needs-stash) unless stashTarget is set. On
+// conflict nothing is kept — target reset, source restored — unless
+// keepConflicts is set, in which case the conflicted squash state is left in
+// the target for manual resolution.
+export async function moveWorktree(opts: MoveWorktreeOptions): Promise<MoveWorktreeResult> {
   const { sourceBranch, sourcePath, targetPath } = opts
   try {
-    if (await workingTreeDirty(targetPath)) return { kind: 'dirty-target' }
-
     const headResult = await $`git -C ${sourcePath} rev-parse HEAD`.quiet().nothrow()
     if (headResult.exitCode !== 0) {
       return { kind: 'error', message: 'could not resolve source HEAD' }
     }
     const sourceHead = headResult.text().trim()
 
+    let stashedTarget = false
+    if (opts.stashTarget === true && (await workingTreeDirty(targetPath))) {
+      const stashMessage = `aimux: backup before move from ${sourceBranch}`
+      const stash = await $`git -C ${targetPath} stash push --include-untracked -m ${stashMessage}`
+        .quiet()
+        .nothrow()
+      if (stash.exitCode !== 0) {
+        const message = stash.stderr.toString().trim()
+        return {
+          kind: 'error',
+          message: message !== '' ? message : 'failed to stash target changes',
+        }
+      }
+      stashedTarget = true
+    }
+
     // Capture uncommitted + untracked work in a throwaway commit so the squash
     // includes everything; undone again before we return.
     const tempCommitted = await workingTreeDirty(sourcePath)
@@ -79,8 +136,21 @@ export async function moveWorktree(opts: {
     const merge = await $`git -C ${targetPath} merge --squash ${sourceBranch}`.quiet().nothrow()
     const conflicts = await conflictedFiles(targetPath)
     if (merge.exitCode !== 0 || conflicts.length > 0) {
+      if (conflicts.length > 0 && opts.keepConflicts === true) {
+        await restoreSource()
+        return { files: conflicts, kind: 'conflict-kept' }
+      }
+      if (conflicts.length === 0) {
+        const overwritten = parseOverwrittenFiles(merge.stderr.toString() + merge.stdout.toString())
+        if (overwritten.length > 0) {
+          // Git refused up front — the target working tree was never touched.
+          await restoreSource()
+          return { files: overwritten, kind: 'needs-stash' }
+        }
+      }
       await $`git -C ${targetPath} merge --abort`.quiet().nothrow()
-      await $`git -C ${targetPath} reset --hard HEAD`.quiet().nothrow()
+      // --merge (not --hard): unrelated dirty files in the target must survive.
+      await $`git -C ${targetPath} reset --merge HEAD`.quiet().nothrow()
       await restoreSource()
       if (conflicts.length > 0) return { files: conflicts, kind: 'conflict' }
       const message = merge.stderr.toString().trim()
@@ -89,7 +159,7 @@ export async function moveWorktree(opts: {
 
     const filesChanged = await countStaged(targetPath)
     await restoreSource()
-    return { filesChanged, kind: 'ok' }
+    return { filesChanged, kind: 'ok', stashedTarget }
   } catch (error) {
     return { kind: 'error', message: error instanceof Error ? error.message : String(error) }
   }

package/src/git/worktree.ts

@@ -33,6 +33,24 @@ export async function getHeadSha(cwd: string): Promise<string | undefined> {
   return result.text().trim() || undefined
 }
 
+// Local branch names, ordered most-recently-committed first so the likely base
+// surfaces near the top of the picker.
+export async function listLocalBranches(cwd: string): Promise<string[]> {
+  // The format must be interpolated, not inlined: Bun's shell parses a bare
+  // `%(refname:short)` and chokes on the parentheses.
+  const format = '%(refname:short)'
+  const result =
+    await $`git -C ${cwd} for-each-ref --sort=-committerdate refs/heads --format=${format}`
+      .quiet()
+      .nothrow()
+  if (result.exitCode !== 0) return []
+  return result
+    .text()
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line !== '')
+}
+
 export async function createGitWorktree({
   baseRef,
   branchName,
@@ -52,6 +70,33 @@ export async function createGitWorktree({
   }
 }
 
+// Force-delete a local branch. Returns false (without throwing) when git
+// refuses — notably when the branch is still checked out in a live worktree,
+// which is exactly how orphan-pruning stays safe.
+export async function deleteGitBranch(repoPath: string, branch: string): Promise<boolean> {
+  const result = await $`git -C ${repoPath} branch -D ${branch}`.quiet().nothrow()
+  return result.exitCode === 0
+}
+
+export async function pruneGitWorktrees(repoPath: string): Promise<void> {
+  await $`git -C ${repoPath} worktree prune`.quiet().nothrow()
+}
+
+// Drop every `aimux/` branch left behind by deleted temp worktrees. git refuses
+// to delete branches still checked out in a live worktree, so this only removes
+// true orphans. Returns the number of branches removed.
+export async function pruneOrphanAimuxBranches(repoPath: string): Promise<number> {
+  await pruneGitWorktrees(repoPath)
+  const branches = (await listLocalBranches(repoPath)).filter((branch) =>
+    branch.startsWith('aimux/')
+  )
+  let removed = 0
+  for (const branch of branches) {
+    if (await deleteGitBranch(repoPath, branch)) removed++
+  }
+  return removed
+}
+
 export async function removeGitWorktree({
   force,
   repoPath,

package/src/input/modes/bridge.ts

@@ -26,7 +26,9 @@ const COMMAND_EDIT_MODE_IDS: Partial<Record<SupportedModalType, ModeId>> = {
 const MODAL_MODE_IDS: Partial<Record<SupportedModalType, ModeId>> = {
   'ai-usage': 'modal.ai-usage',
   'update-available': 'modal.update-available',
+  'worktree-delete-confirm': 'modal.worktree-delete-confirm',
   'worktree-move': 'modal.worktree-move',
+  'worktree-move-confirm': 'modal.worktree-move-confirm',
 }
 
 export function deriveModeId(state: AppState): ModeId {
@@ -51,6 +53,9 @@ export function deriveModeId(state: AppState): ModeId {
     if (state.modal.type === 'new-tab' && state.modal.editingCommand !== null) {
       return 'modal.new-tab.editing-command'
     }
+    if (state.modal.type === 'new-tab' && state.modal.worktreeDeletePrompt !== null) {
+      return 'modal.new-tab.worktree-delete-confirm'
+    }
     if (state.modal.type === 'git-commit' && state.modal.stage === 'confirm') {
       return 'modal.git-commit.confirm'
     }

package/src/input/modes/transitions.ts

@@ -8,8 +8,13 @@ const TRANSITIONS: Record<ModeId, readonly ModeId[]> = {
   'modal.git-commit.confirm': ['modal.git-commit', 'git-mode'],
   'modal.git-commit.generating': ['modal.git-commit', 'modal.git-commit.confirm', 'git-mode'],
   'modal.help.filtering': ['navigation'],
-  'modal.new-tab.command-edit': ['navigation', 'modal.new-tab.editing-command'],
+  'modal.new-tab.command-edit': [
+    'navigation',
+    'modal.new-tab.editing-command',
+    'modal.new-tab.worktree-delete-confirm',
+  ],
   'modal.new-tab.editing-command': ['navigation', 'modal.new-tab.command-edit'],
+  'modal.new-tab.worktree-delete-confirm': ['navigation', 'modal.new-tab.command-edit'],
   'modal.rename-tab': ['navigation'],
   'modal.session-name': ['modal.session-picker.filtering', 'navigation'],
   'modal.session-picker.filtering': ['navigation', 'modal.session-name', 'modal.create-session'],
@@ -18,7 +23,9 @@ const TRANSITIONS: Record<ModeId, readonly ModeId[]> = {
   'modal.split-picker': ['navigation', 'terminal-input'],
   'modal.theme-picker.filtering': ['navigation'],
   'modal.update-available': ['navigation'],
+  'modal.worktree-delete-confirm': ['navigation'],
   'modal.worktree-move': ['git-mode', 'navigation'],
+  'modal.worktree-move-confirm': ['navigation'],
   'navigation': [
     'terminal-input',
     'modal.new-tab.command-edit',
@@ -30,6 +37,8 @@ const TRANSITIONS: Record<ModeId, readonly ModeId[]> = {
     'modal.rename-tab',
     'modal.update-available',
     'modal.ai-usage',
+    'modal.worktree-delete-confirm',
+    'modal.worktree-move-confirm',
     'git-mode',
   ],
   'terminal-input': ['navigation', 'modal.split-picker', 'modal.ai-usage'],