@brimveyn/aimux 1.14.15 → 1.14.16

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

@@ -7,6 +7,8 @@ import { getActiveKeymap } from '../../input/keymap/keymap-ref'
 import { getAllAssistantOptions } from '../../pty/command-registry'
 import { filterThemeIds } from '../../ui/filter-themes'
 import {
+  type BaseRefOption,
+  buildBaseRefOptions,
   filterAssistants,
   filterSessions,
   filterSnippets,
@@ -44,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)
@@ -63,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,
@@ -75,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,
@@ -95,6 +117,18 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
         },
       }
     }
+    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 {
@@ -125,14 +159,13 @@ export function reduceModalState(state: AppState, action: AppAction): AppState |
         },
       }
     }
-    case 'set-new-tab-worktree-delete-state': {
+    case 'set-new-tab-worktree-delete-prompt': {
       if (state.modal.type !== 'new-tab') return state
       return {
         ...state,
         modal: {
           ...state.modal,
-          worktreeDeleteConfirmId: action.confirmWorktreeId ?? null,
-          worktreeDeleteMessage: action.message,
+          worktreeDeletePrompt: action.prompt,
         },
       }
     }
@@ -192,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}`,
         },
       }
@@ -228,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,
         },
       }
@@ -284,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
@@ -616,7 +665,18 @@ 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') {
@@ -661,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),
         },
@@ -683,7 +742,19 @@ 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') {
@@ -724,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,
           },
         }
       }
@@ -770,6 +840,8 @@ 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 (
@@ -821,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' ||
@@ -901,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,
             },
           }
         }
@@ -991,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(
         {

package/src/state/selectors.ts

@@ -1,5 +1,49 @@
 import type { AssistantOption } from '../pty/command-registry'
-import type { AssistantId, SessionRecord, SnippetRecord } from './types'
+import type { AssistantId, SessionRecord, SnippetRecord, WorktreeRecord } from './types'
+
+export interface BaseRefOption {
+  /** Git ref the new worktree is forked from. */
+  ref: string
+  label: string
+  kind: 'worktree' | 'branch'
+  /** Worktree name, for the 'worktree' kind. */
+  detail?: string
+}
+
+/**
+ * Ordered, filtered base-ref candidates for the worktree-create "Base" picker:
+ * branches checked out in the session's worktrees first (labelled with the
+ * worktree name), then the remaining local branches. A branch already surfaced
+ * via a worktree is not repeated. Throwaway `aimux/` branches are skipped unless
+ * a live worktree is on them — `git worktree remove` leaves the branch behind,
+ * so deleted temp worktrees would otherwise haunt the list as orphan branches.
+ */
+export function buildBaseRefOptions(
+  worktrees: WorktreeRecord[],
+  localBranches: string[],
+  query: string
+): BaseRefOption[] {
+  const seen = new Set<string>()
+  const options: BaseRefOption[] = []
+  for (const worktree of worktrees) {
+    if (worktree.branch == null || worktree.branch === '' || seen.has(worktree.branch)) continue
+    seen.add(worktree.branch)
+    options.push({
+      detail: worktree.name,
+      kind: 'worktree',
+      label: worktree.branch,
+      ref: worktree.branch,
+    })
+  }
+  for (const branch of localBranches) {
+    if (seen.has(branch) || branch.startsWith('aimux/')) continue
+    seen.add(branch)
+    options.push({ kind: 'branch', label: branch, ref: branch })
+  }
+  const trimmed = query.trim().toLowerCase()
+  if (trimmed === '') return options
+  return options.filter((option) => option.label.toLowerCase().includes(trimmed))
+}
 
 /**
  * 0 when the template picker should NOT show the "None" fallback (no assistant

package/src/state/session-persistence.ts

@@ -72,6 +72,27 @@ export interface RestoreOptions {
   // will overwrite the status with daemon truth — leaving the flag on would
   // briefly flash the "Restored snapshot" hint on every j/k cycle.
   forceDisconnected?: boolean
+  // When provided, drop tabs pinned to a worktree id that the session no
+  // longer owns. Some delete paths (notably the sidebar's "Remove worktree")
+  // historically removed the worktree record without closing its tabs, leaving
+  // orphans bound to a vanished id. Those orphans are invisible (filtered out
+  // by the active-worktree filter) yet keep a worktree id that a *future*
+  // delete can collide with — exactly what closes "another worktree's" tabs.
+  // Pruning them on restore both repairs corrupted catalogs and prevents the
+  // collision. Tabs with no worktree id (legacy/unbound) are always kept.
+  validWorktreeIds?: ReadonlySet<string>
+}
+
+// Drop tabs bound to a worktree id the session no longer owns. Unbound tabs
+// (no worktreeId) are kept — they surface under the primary worktree.
+function pruneOrphanedTabs(
+  tabs: TabSession[],
+  validWorktreeIds: ReadonlySet<string> | undefined
+): TabSession[] {
+  if (!validWorktreeIds) return tabs
+  return tabs.filter(
+    (tab) => tab.worktreeId == null || tab.worktreeId === '' || validWorktreeIds.has(tab.worktreeId)
+  )
 }
 
 export function restoreTabsFromWorkspace(
@@ -84,7 +105,7 @@ export function restoreTabsFromWorkspace(
 
   const forceDisconnected = options.forceDisconnected ?? true
 
-  return snapshot.tabs
+  const restored: TabSession[] = snapshot.tabs
     .filter(
       (tab): tab is typeof tab & { status: Exclude<typeof tab.status, 'exited'> } =>
         tab.status !== 'exited'
@@ -103,6 +124,7 @@ export function restoreTabsFromWorkspace(
       viewport: tab.viewport,
       worktreeId: tab.worktreeId,
     }))
+  return pruneOrphanedTabs(restored, options.validWorktreeIds)
 }
 
 export function restoreLayoutTrees(

package/src/state/types.ts

@@ -47,6 +47,7 @@ export type ModalType =
   | 'update-available'
   | 'ai-usage'
   | 'worktree-move'
+  | 'worktree-delete-confirm'
   | null
 
 export interface TerminalSpan {
@@ -323,16 +324,21 @@ export interface ModalClosed extends ModalBase {
 export interface ModalNewTab extends ModalBase {
   type: 'new-tab'
   editingCommand: AssistantId | null
-  activeField: 'assistant' | 'branch-name' | 'target-worktree' | 'worktree-name'
+  activeField: 'assistant' | 'branch-name' | 'target-worktree' | 'worktree-name' | 'base'
   branchError: string | null
   branchName: string
   createWorktree: boolean
   selectedAssistantId: AssistantId | null
   step: 'assistant' | 'worktree' | 'worktree-create' | 'template'
   targetWorktreeIndex: number
-  worktreeDeleteConfirmId: string | null
-  worktreeDeleteMessage: string | null
+  worktreeDeletePrompt: { worktreeId: string; reason: string } | null
   worktreeName: string
+  /** Filter text typed into the "Base" picker on the worktree-create step. */
+  baseQuery: string
+  /** Resolved base ref the new worktree is forked from (branch of a worktree or a local branch). */
+  baseRef: string
+  /** Local branches available as base refs, loaded when the create step opens. */
+  baseBranches: string[]
 }
 
 export interface ModalSessionPicker extends ModalBase {
@@ -417,6 +423,22 @@ export interface ModalWorktreeMove extends ModalBase {
   deleteSource: boolean
 }
 
+/**
+ * Standalone confirmation for a recoverable worktree delete failure triggered
+ * outside the new-tab picker (e.g. the sidebar's "Remove worktree"). Carries the
+ * params needed to re-run the delete with force once confirmed.
+ */
+export interface ModalWorktreeDeleteConfirm extends ModalBase {
+  type: 'worktree-delete-confirm'
+  sessionId: string
+  worktreeId: string
+  worktreeLabel: string
+  reason: string
+  closeTabs: boolean
+  /** Whether confirming force-deletes — true only after a recoverable failure. */
+  force: boolean
+}
+
 export type DirectoryResultType = 'git-repo' | 'worktree' | 'workspace'
 
 export interface DirectoryResult {
@@ -440,6 +462,7 @@ export type ModalState =
   | ModalUpdateAvailable
   | ModalAIUsage
   | ModalWorktreeMove
+  | ModalWorktreeDeleteConfirm
 
 export interface LayoutState {
   terminalCols: number
@@ -515,10 +538,10 @@ export type ModalAction =
   | { type: 'open-new-tab-modal' }
   | { type: 'set-new-tab-branch-error'; message: string | null }
   | {
-      type: 'set-new-tab-worktree-delete-state'
-      confirmWorktreeId?: string | null
-      message: string | null
+      type: 'set-new-tab-worktree-delete-prompt'
+      prompt: { worktreeId: string; reason: string } | null
     }
+  | { type: 'set-new-tab-base-branches'; branches: string[] }
   | { type: 'enter-new-tab-worktree-create' }
   | { type: 'enter-new-tab-template-pick' }
   | { type: 'enter-new-tab-template-shortcut' }
@@ -553,6 +576,15 @@ export type ModalAction =
   | { type: 'open-ai-usage-modal' }
   | { type: 'open-worktree-move-modal'; sourceWorktreeId: string }
   | { type: 'toggle-worktree-move-delete' }
+  | {
+      type: 'open-worktree-delete-confirm'
+      sessionId: string
+      worktreeId: string
+      worktreeLabel: string
+      reason: string
+      closeTabs: boolean
+      force: boolean
+    }
 
 // -- Session actions --
 export type SessionAction =
@@ -570,7 +602,6 @@ export type SessionAction =
   | { type: 'reorder-active-session'; delta: number }
   | { type: 'set-session-status'; sessionId: string; status: SessionStatus }
   | { type: 'add-worktree-record'; sessionId: string; worktree: WorktreeRecord; activate?: boolean }
-  | { type: 'remove-worktree-record'; sessionId: string; worktreeId: string }
   | { type: 'set-active-worktree'; sessionId: string; worktreeId: string }
   | {
       type: 'update-worktree-record'
@@ -595,6 +626,7 @@ export type TabAction =
   | { type: 'set-active-tab'; tabId: string }
   | { type: 'move-active-tab'; delta: number }
   | { type: 'reorder-active-tab'; delta: number }
+  | { type: 'reorder-tabs'; orderedTabIds: string[] }
   | { type: 'reset-tab-session'; tabId: string }
   | { type: 'rename-tab'; tabId: string; title: string }
   | { type: 'append-tab-buffer'; tabId: string; chunk: string }

package/src/ui/components/layout/sidebar/worktree-row.tsx

@@ -68,14 +68,24 @@ export const WorktreeRow = memo(function WorktreeRow({
       [
         'Remove worktree',
         () =>
+          // Always confirm first. Confirming routes through the full delete side
+          // effect (closes the worktree's tabs, disposes their PTYs, prunes the
+          // snapshot, removes the git worktree). closeTabs (not force) cleans up
+          // the tabs while keeping the non-force `git worktree remove`, so
+          // uncommitted work in a temp worktree is still protected — a dirty
+          // worktree re-prompts for an explicit force-delete.
           dispatchGlobal({
+            closeTabs: true,
+            force: false,
+            reason: 'Its assistant tabs will be closed and the worktree removed.',
             sessionId: session.id,
-            type: 'remove-worktree-record',
+            type: 'open-worktree-delete-confirm',
             worktreeId: worktree.id,
+            worktreeLabel: worktree.branch ?? worktree.name,
           }),
       ],
     ]
-  }, [session.id, worktree.id, worktree.source])
+  }, [session.id, worktree.branch, worktree.id, worktree.name, worktree.source])
 
   let bgColor: string | undefined
   if (isActiveItem) {