@brimveyn/aimux 1.14.14 → 1.14.16

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,6 +26,7 @@ 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',
 }
 
@@ -51,6 +52,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,6 +23,7 @@ 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'],
   'navigation': [
     'terminal-input',
@@ -30,6 +36,7 @@ const TRANSITIONS: Record<ModeId, readonly ModeId[]> = {
     'modal.rename-tab',
     'modal.update-available',
     'modal.ai-usage',
+    'modal.worktree-delete-confirm',
     'git-mode',
   ],
   'terminal-input': ['navigation', 'modal.split-picker', 'modal.ai-usage'],

package/src/input/modes/types.ts

@@ -9,6 +9,8 @@ export type ModeId =
   | 'git-mode'
   | 'modal.new-tab.command-edit'
   | 'modal.new-tab.editing-command'
+  | 'modal.new-tab.worktree-delete-confirm'
+  | 'modal.worktree-delete-confirm'
   | 'modal.session-picker.filtering'
   | 'modal.session-name'
   | 'modal.create-session'
@@ -28,6 +30,7 @@ export type ModeId =
 export type SideEffect =
   | { type: 'quit'; state: AppState }
   | { type: 'launch-selected-assistant' }
+  | { type: 'load-new-tab-base-branches' }
   | { type: 'edit-selected-assistant' }
   | { type: 'confirm-selected-session' }
   | { type: 'delete-selected-session' }
@@ -71,7 +74,18 @@ export type SideEffect =
   | { type: 'cycle-sidebar-item'; direction: 1 | -1 }
   | { type: 'switch-tab-by-index'; index: number }
   | { type: 'delete-session'; sessionId: string }
-  | { type: 'delete-worktree'; sessionId: string; worktreeId: string; force?: boolean }
+  | {
+      type: 'delete-worktree'
+      sessionId: string
+      worktreeId: string
+      // Force the git worktree removal (discards uncommitted changes in the
+      // worktree). Also implies closing the worktree's tabs.
+      force?: boolean
+      // Close the worktree's tabs without forcing the git removal. Lets the
+      // sidebar "Remove worktree" clean up tabs (avoiding orphans) while still
+      // refusing to discard uncommitted work in a temp worktree.
+      closeTabs?: boolean
+    }
   | {
       type: 'move-worktree'
       sessionId: string

package/src/state/reducers/modal-state.ts

@@ -6,7 +6,14 @@ import { collectHelpEntries } from '../../input/keymap/help-entries'
 import { getActiveKeymap } from '../../input/keymap/keymap-ref'
 import { getAllAssistantOptions } from '../../pty/command-registry'
 import { filterThemeIds } from '../../ui/filter-themes'
-import { filterAssistants, filterSessions, filterSnippets } from '../selectors'
+import {
+  type BaseRefOption,
+  buildBaseRefOptions,
+  filterAssistants,
+  filterSessions,
+  filterSnippets,
+  getTemplateNoneOffset,
+} from '../selectors'
 import { reduceAutoCommitState } from './auto-commit-state'
 
 function emptyModal() {
@@ -39,6 +46,17 @@ function getCurrentWorktreeIndex(state: AppState): number {
   )
 }
 
+function getNewTabBaseOptions(state: AppState, queryOverride?: string): BaseRefOption[] {
+  if (state.modal.type !== 'new-tab') return []
+  const worktrees =
+    state.sessions.find((entry) => entry.id === state.currentSessionId)?.worktrees ?? []
+  return buildBaseRefOptions(
+    worktrees,
+    state.modal.baseBranches,
+    queryOverride ?? state.modal.baseQuery
+  )
+}
+
 function getSelectedNewTabAssistant(state: AppState, assistantId?: string) {
   if (assistantId != null && assistantId !== '') {
     return getAllAssistantOptions(state.customCommands).find((entry) => entry.id === assistantId)
@@ -58,6 +76,9 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
         focusMode: 'command-edit',
         modal: {
           activeField: 'assistant',
+          baseBranches: [],
+          baseQuery: '',
+          baseRef: '',
           branchError: null,
           branchName: '',
           createWorktree: false,
@@ -70,19 +91,25 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
           step: 'assistant',
           targetWorktreeIndex,
           type: 'new-tab',
-          worktreeDeleteConfirmId: null,
-          worktreeDeleteMessage: null,
+          worktreeDeletePrompt: null,
           worktreeName: '',
         },
       }
     }
     case 'enter-new-tab-worktree-create': {
       if (state.modal.type !== 'new-tab') return state
+      // Default the base to the branch of the worktree we're forking from (the
+      // current target), preserving the previous always-fork-from-source
+      // behaviour until the user picks another base.
+      const session = state.sessions.find((entry) => entry.id === state.currentSessionId)
+      const sourceWorktree = session?.worktrees?.[state.modal.targetWorktreeIndex]
       return {
         ...state,
         modal: {
           ...state.modal,
           activeField: 'worktree-name',
+          baseQuery: '',
+          baseRef: sourceWorktree?.branch ?? '',
           createWorktree: true,
           cursorPos: state.modal.worktreeName.length,
           selectedIndex: 0,
@@ -90,14 +117,55 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
         },
       }
     }
-    case 'set-new-tab-worktree-delete-state': {
+    case 'set-new-tab-base-branches': {
+      if (state.modal.type !== 'new-tab') return state
+      const modalWithBranches = { ...state.modal, baseBranches: action.branches }
+      const withBranches: AppState = { ...state, modal: modalWithBranches }
+      // Backfill a default base if none resolved yet (e.g. detached source).
+      if (state.modal.baseRef !== '') return withBranches
+      const firstOption = getNewTabBaseOptions(withBranches)[0]
+      return {
+        ...withBranches,
+        modal: { ...modalWithBranches, baseRef: firstOption?.ref ?? '' },
+      }
+    }
+    case 'enter-new-tab-template-pick': {
       if (state.modal.type !== 'new-tab') return state
       return {
         ...state,
         modal: {
           ...state.modal,
-          worktreeDeleteConfirmId: action.confirmWorktreeId ?? null,
-          worktreeDeleteMessage: action.message,
+          activeField: 'target-worktree',
+          cursorPos: 0,
+          selectedIndex: 0,
+          step: 'template',
+        },
+      }
+    }
+    case 'enter-new-tab-template-shortcut': {
+      if (state.modal.type !== 'new-tab') return state
+      const defaultName = state.modal.worktreeName || 'wt-template'
+      return {
+        ...state,
+        modal: {
+          ...state.modal,
+          activeField: 'worktree-name',
+          createWorktree: true,
+          cursorPos: defaultName.length,
+          selectedAssistantId: null,
+          selectedIndex: 0,
+          step: 'worktree-create',
+          worktreeName: defaultName,
+        },
+      }
+    }
+    case 'set-new-tab-worktree-delete-prompt': {
+      if (state.modal.type !== 'new-tab') return state
+      return {
+        ...state,
+        modal: {
+          ...state.modal,
+          worktreeDeletePrompt: action.prompt,
         },
       }
     }
@@ -115,6 +183,32 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
     }
     case 'select-new-tab-assistant': {
       if (state.modal.type !== 'new-tab' || state.modal.editingCommand !== null) return state
+      if (
+        action.assistantId === undefined &&
+        state.modal.step === 'assistant' &&
+        state.worktreeTemplates.length > 0
+      ) {
+        const filtered = filterAssistants(
+          getAllAssistantOptions(state.customCommands),
+          state.modal.editBuffer
+        )
+        if (state.modal.selectedIndex >= filtered.length) {
+          const defaultName = state.modal.worktreeName || 'wt-template'
+          return {
+            ...state,
+            modal: {
+              ...state.modal,
+              activeField: 'worktree-name',
+              createWorktree: true,
+              cursorPos: defaultName.length,
+              selectedAssistantId: null,
+              selectedIndex: 0,
+              step: 'worktree-create',
+              worktreeName: defaultName,
+            },
+          }
+        }
+      }
       const option = getSelectedNewTabAssistant(state, action.assistantId)
       if (!option) return state
       const targetWorktreeIndex = getCurrentWorktreeIndex(state)
@@ -131,8 +225,7 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
           selectedIndex: worktreeCount === 0 ? 0 : targetWorktreeIndex,
           step: 'worktree',
           targetWorktreeIndex,
-          worktreeDeleteConfirmId: null,
-          worktreeDeleteMessage: null,
+          worktreeDeletePrompt: null,
           worktreeName: state.modal.worktreeName || `wt-${option.label}`,
         },
       }
@@ -167,8 +260,7 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
             : Math.min(state.modal.selectedIndex, Math.max(0, worktreeCount - 1)),
           step: option && createWorktree ? 'worktree' : state.modal.step,
           targetWorktreeIndex,
-          worktreeDeleteConfirmId: null,
-          worktreeDeleteMessage: null,
+          worktreeDeletePrompt: null,
           worktreeName: defaultName,
         },
       }
@@ -223,6 +315,24 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
         modal: { ...state.modal, deleteSource: !state.modal.deleteSource },
       }
     }
+    case 'open-worktree-delete-confirm': {
+      return {
+        ...state,
+        focusMode: 'modal',
+        modal: {
+          closeTabs: action.closeTabs,
+          editBuffer: null,
+          force: action.force,
+          reason: action.reason,
+          selectedIndex: 0,
+          sessionId: action.sessionId,
+          sessionTargetId: null,
+          type: 'worktree-delete-confirm',
+          worktreeId: action.worktreeId,
+          worktreeLabel: action.worktreeLabel,
+        },
+      }
+    }
     case 'open-help-modal': {
       const keymap = getActiveKeymap()
       const scope = action.scope ?? null
@@ -555,18 +665,31 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
         return state
       }
       if (state.modal.type === 'new-tab' && state.modal.step === 'worktree-create') {
-        return state
+        if (state.modal.activeField !== 'base') return state
+        const options = getNewTabBaseOptions(state)
+        if (options.length === 0) return state
+        const next = (state.modal.selectedIndex + action.delta + options.length) % options.length
+        return {
+          ...state,
+          modal: {
+            ...state.modal,
+            baseRef: options[next]?.ref ?? state.modal.baseRef,
+            selectedIndex: next,
+          },
+        }
       }
       let optionCount: number
       if (state.modal.type === 'new-tab') {
         if (state.modal.step === 'worktree') {
           if (state.modal.activeField === 'worktree-name') return state
           optionCount = getCurrentWorktreeCount(state) + 1
+        } else if (state.modal.step === 'template') {
+          optionCount =
+            state.worktreeTemplates.length + getTemplateNoneOffset(state.modal.selectedAssistantId)
         } else {
-          optionCount = filterAssistants(
-            getAllAssistantOptions(state.customCommands),
-            state.modal.editBuffer
-          ).length
+          optionCount =
+            filterAssistants(getAllAssistantOptions(state.customCommands), state.modal.editBuffer)
+              .length + (state.worktreeTemplates.length > 0 ? 1 : 0)
         }
       } else if (state.modal.type === 'split-picker') {
         optionCount = getAllAssistantOptions(state.customCommands).length
@@ -598,8 +721,7 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
                 createWorktree:
                   (state.modal.selectedIndex + action.delta + optionCount) % optionCount ===
                   optionCount - 1,
-                worktreeDeleteConfirmId: null,
-                worktreeDeleteMessage: null,
+                worktreeDeletePrompt: null,
               }
             : null),
         },
@@ -620,17 +742,34 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
         return state
       }
       if (state.modal.type === 'new-tab' && state.modal.step === 'worktree-create') {
-        return state
+        if (state.modal.activeField !== 'base') return state
+        const options = getNewTabBaseOptions(state)
+        if (options.length === 0) return state
+        const clamped = Math.max(0, Math.min(options.length - 1, action.index))
+        if (clamped === state.modal.selectedIndex) return state
+        return {
+          ...state,
+          modal: {
+            ...state.modal,
+            baseRef: options[clamped]?.ref ?? state.modal.baseRef,
+            selectedIndex: clamped,
+          },
+        }
       }
       let optionCount: number
       if (state.modal.type === 'help') {
         optionCount = state.modal.entryCount
       } else if (state.modal.type === 'new-tab') {
-        optionCount =
-          state.modal.step === 'worktree'
-            ? getCurrentWorktreeCount(state) + 1
-            : filterAssistants(getAllAssistantOptions(state.customCommands), state.modal.editBuffer)
-                .length
+        if (state.modal.step === 'worktree') {
+          optionCount = getCurrentWorktreeCount(state) + 1
+        } else if (state.modal.step === 'template') {
+          optionCount =
+            state.worktreeTemplates.length + getTemplateNoneOffset(state.modal.selectedAssistantId)
+        } else {
+          optionCount =
+            filterAssistants(getAllAssistantOptions(state.customCommands), state.modal.editBuffer)
+              .length + (state.worktreeTemplates.length > 0 ? 1 : 0)
+        }
       } else if (state.modal.type === 'split-picker') {
         optionCount = getAllAssistantOptions(state.customCommands).length
       } else if (state.modal.type === 'create-session') {
@@ -656,8 +795,7 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
             ...state.modal,
             createWorktree: clamped === optionCount - 1,
             selectedIndex: clamped,
-            worktreeDeleteConfirmId: null,
-            worktreeDeleteMessage: null,
+            worktreeDeletePrompt: null,
           },
         }
       }
@@ -677,8 +815,8 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
       if (
         state.modal.type === 'new-tab' &&
         state.modal.editingCommand === null &&
-        state.modal.step === 'worktree' &&
-        state.modal.activeField === 'target-worktree'
+        (state.modal.step === 'template' ||
+          (state.modal.step === 'worktree' && state.modal.activeField === 'target-worktree'))
       ) {
         return state
       }
@@ -702,13 +840,15 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
           buffer = state.modal.worktreeName
         } else if (state.modal.activeField === 'branch-name') {
           buffer = state.modal.branchName
+        } else if (state.modal.activeField === 'base') {
+          buffer = state.modal.baseQuery
         }
       }
       if (
         state.modal.type === 'new-tab' &&
         state.modal.editingCommand === null &&
-        state.modal.step === 'worktree' &&
-        state.modal.activeField === 'target-worktree'
+        (state.modal.step === 'template' ||
+          (state.modal.step === 'worktree' && state.modal.activeField === 'target-worktree'))
       ) {
         return state
       }
@@ -753,6 +893,24 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
           },
         }
       }
+      if (
+        state.modal.type === 'new-tab' &&
+        state.modal.editingCommand === null &&
+        state.modal.activeField === 'base'
+      ) {
+        // Re-filter and snap the selection/base to the top match as the query changes.
+        const topOption = getNewTabBaseOptions(state, nextBuffer)[0]
+        return {
+          ...state,
+          modal: {
+            ...state.modal,
+            baseQuery: nextBuffer,
+            baseRef: topOption?.ref ?? state.modal.baseRef,
+            cursorPos: nextCursor,
+            selectedIndex: 0,
+          },
+        }
+      }
       const resetIndex =
         !isNewTabEditing &&
         (state.modal.type === 'session-picker' ||
@@ -785,6 +943,18 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
         }
       }
       if (state.modal.type === 'new-tab') {
+        if (state.modal.step === 'template') {
+          return {
+            ...state,
+            modal: {
+              ...state.modal,
+              activeField: 'worktree-name',
+              cursorPos: state.modal.worktreeName.length,
+              selectedIndex: 0,
+              step: 'worktree-create',
+            },
+          }
+        }
         if (state.modal.step === 'worktree-create') {
           const optionCount = getCurrentWorktreeCount(state) + 1
           return {
@@ -821,8 +991,7 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
               cursorPos: state.modal.editBuffer?.length ?? 0,
               selectedIndex: Math.max(0, assistantIndex),
               step: 'assistant',
-              worktreeDeleteConfirmId: null,
-              worktreeDeleteMessage: null,
+              worktreeDeletePrompt: null,
             },
           }
         }
@@ -911,8 +1080,38 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
       if (state.modal.type === 'new-tab') {
         if (state.modal.step === 'assistant') return state
         if (state.modal.step === 'worktree-create') {
-          const nextField: typeof state.modal.activeField =
-            state.modal.activeField === 'worktree-name' ? 'branch-name' : 'worktree-name'
+          const cycle: Record<
+            'worktree-name' | 'branch-name' | 'base',
+            typeof state.modal.activeField
+          > = {
+            'base': 'worktree-name',
+            'branch-name': 'base',
+            'worktree-name': 'branch-name',
+          }
+          const nextField =
+            state.modal.activeField === 'worktree-name' ||
+            state.modal.activeField === 'branch-name' ||
+            state.modal.activeField === 'base'
+              ? cycle[state.modal.activeField]
+              : 'worktree-name'
+          if (nextField === 'base') {
+            // Highlight the row matching the resolved base ref when entering it.
+            const currentBaseRef = state.modal.baseRef
+            const options = getNewTabBaseOptions(state)
+            const baseIndex = Math.max(
+              0,
+              options.findIndex((option) => option.ref === currentBaseRef)
+            )
+            return {
+              ...state,
+              modal: {
+                ...state.modal,
+                activeField: nextField,
+                cursorPos: state.modal.baseQuery.length,
+                selectedIndex: baseIndex,
+              },
+            }
+          }
           const nextValue =
             nextField === 'branch-name' ? state.modal.branchName : state.modal.worktreeName
           return {

package/src/state/reducers/session-state.ts

@@ -18,15 +18,23 @@ export function reduceSessionState(state: AppState, action: AppAction): AppState
       const snapshot =
         action.workspaceSnapshot ??
         state.sessions.find((entry) => entry.id === action.sessionId)?.workspaceSnapshot
-      const restored = restoreWorkspaceState(state, snapshot, {
-        forceDisconnected: action.forceDisconnected ?? true,
-      })
       // The session's activeWorktreeId may have been patched right before
       // this load (e.g. the cross-workspace branch of handleCycleSidebarItem
       // sets it to the worktree the user just clicked). The snapshot's
       // activeTabId still reflects the *last* worktree they were on, so
       // honor the patched worktree by filtering the restored tab list.
       const loadedSession = state.sessions.find((entry) => entry.id === action.sessionId)
+      const loadedWorktrees = loadedSession?.worktrees ?? []
+      const restored = restoreWorkspaceState(state, snapshot, {
+        forceDisconnected: action.forceDisconnected ?? true,
+        // Drop tabs bound to worktrees this session no longer owns so a stale
+        // id can't be caught by a later worktree delete (closing "another
+        // worktree's" tabs) and so corrupted catalogs self-heal on load. Only
+        // prune once the session has worktrees — an empty list means it hasn't
+        // been initialized yet, and pruning then would wrongly drop bound tabs.
+        validWorktreeIds:
+          loadedWorktrees.length > 0 ? new Set(loadedWorktrees.map((w) => w.id)) : undefined,
+      })
       const visible = filterTabsForActiveWorktree(restored.tabs, loadedSession)
       // Prefer the snapshot's tab; if it isn't visible under the active
       // worktree (e.g. a multi-worktree session restored onto a different
@@ -188,22 +196,6 @@ export function reduceSessionState(state: AppState, action: AppAction): AppState
             : withActiveWorktree(next, action.worktree.id)
         }),
       }
-    case 'remove-worktree-record':
-      return {
-        ...state,
-        sessions: state.sessions.map((session) => {
-          if (session.id !== action.sessionId) return session
-          const remaining = (session.worktrees ?? []).filter((w) => w.id !== action.worktreeId)
-          if (remaining.length === 0) return session
-          if (session.activeWorktreeId !== action.worktreeId) {
-            return { ...session, updatedAt: new Date().toISOString(), worktrees: remaining }
-          }
-          return withActiveWorktree(
-            { ...session, activeWorktreeId: remaining[0]?.id, worktrees: remaining },
-            remaining[0]?.id ?? ''
-          )
-        }),
-      }
     case 'set-active-worktree': {
       const sessions = state.sessions.map((session) =>
         session.id === action.sessionId ? withActiveWorktree(session, action.worktreeId) : session

package/src/state/reducers/tab-state.ts

@@ -469,6 +469,23 @@ export function reduceTabState(state: AppState, action: AppAction): AppState | n
       }
       return { ...state, tabs }
     }
+    case 'reorder-tabs': {
+      // Drag-and-drop reorder of the visible tab strip. `orderedTabIds` is the
+      // flattened new order of the currently-visible tabs (group members already
+      // expanded into contiguous runs). We only rewrite the slots those tabs
+      // occupy in `state.tabs`, leaving tabs from other worktrees anchored in
+      // place. Because group members arrive contiguous, splits stay intact.
+      const visibleSet = new Set(action.orderedTabIds)
+      const byId = new Map(state.tabs.map((tab) => [tab.id, tab]))
+      let cursor = 0
+      const tabs = state.tabs.map((tab) => {
+        if (!visibleSet.has(tab.id)) return tab
+        const nextId = action.orderedTabIds[cursor]
+        cursor++
+        return (nextId != null ? byId.get(nextId) : undefined) ?? tab
+      })
+      return { ...state, tabs }
+    }
     case 'reset-tab-session':
       return withActiveTabWorktree(
         {