@brimveyn/aimux 1.14.14 → 1.14.16

package/src/state/selectors.ts

@@ -1,5 +1,59 @@
 import type { AssistantOption } from '../pty/command-registry'
-import type { 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
+ * was picked — typical for the template shortcut path), 1 otherwise. Shared
+ * by the modal reducer, the side-effect that resolves templateId, and the
+ * picker UI so the three stay in sync.
+ */
+export function getTemplateNoneOffset(selectedAssistantId: AssistantId | null): 0 | 1 {
+  return selectedAssistantId == null ? 0 : 1
+}
 
 export function filterAssistants(
   options: AssistantOption[],

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/store.ts

@@ -1,3 +1,5 @@
+import type { WorktreeTemplate } from '../config'
+
 import { reduceAutoCommit } from './reducers/auto-commit-state'
 import { emptyGitMode, reduceGitModeState } from './reducers/git-mode-state'
 import { emptyGitPanel, reduceGitPanelState } from './reducers/git-panel-state'
@@ -31,6 +33,7 @@ export interface InitialStateOverrides {
   gitPane?: Partial<GitPaneState>
   sidebar?: Pick<AppState['sidebar'], 'visible' | 'width'>
   sessionBarVisible?: boolean
+  worktreeTemplates?: WorktreeTemplate[]
 }
 
 const DEFAULT_GIT_PANE: GitPaneState = {
@@ -116,6 +119,7 @@ export function createInitialState(
     tabGroupMap: {},
     tabs: [],
     worktreeDivergence: {},
+    worktreeTemplates: overrides.worktreeTemplates ?? [],
   }
 }
 

package/src/state/types.ts

@@ -1,6 +1,7 @@
 import type { ModeId, SnippetVar } from '@brimveyn/aimux-config'
 import type { ThemedToken } from 'shiki'
 
+import type { WorktreeTemplate } from '../config'
 import type { LayoutNode, SplitDirection } from './layout-tree'
 
 export type BuiltinAssistantId = 'claude' | 'codex' | 'opencode' | 'terminal' | 'antigravity'
@@ -46,6 +47,7 @@ export type ModalType =
   | 'update-available'
   | 'ai-usage'
   | 'worktree-move'
+  | 'worktree-delete-confirm'
   | null
 
 export interface TerminalSpan {
@@ -322,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'
+  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 {
@@ -416,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 {
@@ -439,6 +462,7 @@ export type ModalState =
   | ModalUpdateAvailable
   | ModalAIUsage
   | ModalWorktreeMove
+  | ModalWorktreeDeleteConfirm
 
 export interface LayoutState {
   terminalCols: number
@@ -504,6 +528,8 @@ export interface AppState {
   lastActiveTabByWorktree: Record<string, string>
   /** Chord prefix the sequence resolver is currently waiting on, or null when idle. */
   pendingChords: string[] | null
+  /** User-defined templates applied at worktree creation. Loaded from aimux.json. */
+  worktreeTemplates: WorktreeTemplate[]
 }
 
 // -- Modal actions --
@@ -512,11 +538,13 @@ 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' }
   | { type: 'select-new-tab-assistant'; assistantId?: AssistantId }
   | { type: 'toggle-new-tab-worktree'; assistantId?: AssistantId }
   | { type: 'open-edit-custom-command'; assistantId: AssistantId }
@@ -548,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 =
@@ -565,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'
@@ -590,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) {

package/src/ui/components/layout/top-tab-bar.tsx

@@ -1,6 +1,10 @@
-import type { MouseEvent as OtuiMouseEvent, ScrollBoxRenderable } from '@opentui/core'
+import type {
+  BoxRenderable,
+  MouseEvent as OtuiMouseEvent,
+  ScrollBoxRenderable,
+} from '@opentui/core'
 
-import { memo, type ReactNode, useCallback, useMemo, useRef } from 'react'
+import { memo, type ReactNode, useCallback, useMemo, useRef, useState } from 'react'
 
 import type { FocusMode, TabSession } from '../../../state/types'
 
@@ -8,7 +12,8 @@ import { useWorktreeDivergencePolling } from '../../../git/worktree-divergence-p
 import { useAppStore } from '../../../state/app-store'
 import { dispatchGlobal, runSideEffectGlobal } from '../../../state/dispatch-ref'
 import { filterTabsForActiveWorktree } from '../../../state/session-worktrees'
-import { buildTabEntries, type GroupEntry } from '../../../state/tab-entries'
+import { buildTabEntries, type GroupEntry, type TabEntry } from '../../../state/tab-entries'
+import { moveIdToIdPosition } from '../../session-ordering'
 import { useTheme } from '../../theme'
 import { ContextMenuBox } from '../overlays/context-menu/context-menu-box'
 import { TabItem } from './sidebar/tab-item'
@@ -43,27 +48,51 @@ const TopTabCell = memo(function TopTabCell({
   backgroundColor,
   children,
   entryId,
-  onActivate,
+  onDrag,
+  onDragCancel,
+  onDragStart,
+  onDrop,
+  setCellRef,
 }: {
   entryId: string
   active: boolean
   backgroundColor: string | undefined
-  onActivate?: (entryId: string) => void
+  setCellRef: (entryId: string, ref: BoxRenderable | null) => void
+  onDragStart: (entryId: string) => void
+  onDrag: (event: OtuiMouseEvent) => void
+  onDrop: () => void
+  onDragCancel: () => void
   children: ReactNode
 }) {
+  const handleRef = useCallback(
+    (r: BoxRenderable | null) => setCellRef(entryId, r),
+    [setCellRef, entryId]
+  )
   const handleMouseDown = useCallback(
     (event: OtuiMouseEvent) => {
+      event.preventDefault()
       event.stopPropagation()
-      onActivate?.(entryId)
+      onDragStart(entryId)
+    },
+    [onDragStart, entryId]
+  )
+  const handleMouseUp = useCallback(
+    (event: OtuiMouseEvent) => {
+      event.preventDefault()
+      onDrop()
     },
-    [onActivate, entryId]
+    [onDrop]
   )
   return (
     <box
+      ref={handleRef}
       backgroundColor={backgroundColor}
       flexDirection="row"
       flexShrink={0}
       onMouseDown={handleMouseDown}
+      onMouseDrag={onDrag}
+      onMouseUp={handleMouseUp}
+      onMouseDragEnd={onDragCancel}
       data-active={active ? 'true' : undefined}
     >
       {children}
@@ -147,6 +176,19 @@ function GroupTabItem({
   )
 }
 
+function arraysEqual(a: string[], b: string[]): boolean {
+  if (a.length !== b.length) return false
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false
+  }
+  return true
+}
+
+/** Flatten an entry into the underlying tab ids, in display order. */
+function entryTabIds(entry: TabEntry): string[] {
+  return entry.kind === 'single' ? [entry.tab.id] : entry.tabs.map((tab) => tab.id)
+}
+
 export function TopTabBar({ forceVisible = false }: TopTabBarProps) {
   const t = useTheme()
   const headerBg = t.backgroundPanel
@@ -214,6 +256,89 @@ export function TopTabBar({ forceVisible = false }: TopTabBarProps) {
     [entries, activeTabId]
   )
 
+  // --- Drag-and-drop reorder of the tab strip ---------------------------------
+  // Mirrors the workspace-list drag, but on the horizontal axis: entries are
+  // laid out left-to-right inside a scrollX box, so hit-testing is on x/width.
+  const [draggingId, setDraggingId] = useState<string | null>(null)
+  const [dragOrder, setDragOrder] = useState<string[] | null>(null)
+  const lastSwapWithRef = useRef<string | null>(null)
+  const cellRefs = useRef(new Map<string, BoxRenderable>())
+
+  const baselineOrder = useMemo(() => entries.map((e) => e.id), [entries])
+
+  const setCellRef = useCallback((id: string, ref: BoxRenderable | null): void => {
+    if (ref) cellRefs.current.set(id, ref)
+    else cellRefs.current.delete(id)
+  }, [])
+
+  const findEntryAtX = useCallback((x: number): string | null => {
+    for (const [id, ref] of cellRefs.current) {
+      if (x >= ref.x && x < ref.x + ref.width) return id
+    }
+    return null
+  }, [])
+
+  const handleDragStart = useCallback(
+    (id: string) => {
+      setDraggingId(id)
+      setDragOrder(baselineOrder)
+      lastSwapWithRef.current = null
+    },
+    [baselineOrder]
+  )
+
+  const handleDrag = useCallback(
+    (event: OtuiMouseEvent) => {
+      if (!(draggingId != null && draggingId !== '')) return
+      const hit = findEntryAtX(event.x)
+      if (hit === null || hit === draggingId) {
+        lastSwapWithRef.current = null
+        return
+      }
+      if (hit === lastSwapWithRef.current) return
+      setDragOrder((prev) => (prev ? moveIdToIdPosition(prev, draggingId, hit) : prev))
+      lastSwapWithRef.current = hit
+    },
+    [draggingId, findEntryAtX]
+  )
+
+  const commitDrop = useCallback(() => {
+    const source = draggingId
+    const finalOrder = dragOrder
+    setDraggingId(null)
+    setDragOrder(null)
+    lastSwapWithRef.current = null
+
+    if (source == null || source === '' || !finalOrder) return
+
+    if (!arraysEqual(finalOrder, baselineOrder)) {
+      // Expand entries (groups collapse multiple tabs) back into a flat tab-id
+      // order, then let the reducer rewrite only the visible tabs' slots.
+      const byId = new Map(entries.map((e) => [e.id, e]))
+      const orderedTabIds = finalOrder.flatMap((id) => {
+        const entry = byId.get(id)
+        return entry ? entryTabIds(entry) : []
+      })
+      dispatchGlobal({ orderedTabIds, type: 'reorder-tabs' })
+      return
+    }
+
+    // No reorder happened → treat as a plain click on the entry.
+    handleEntryActivate(source)
+  }, [baselineOrder, dragOrder, draggingId, entries, handleEntryActivate])
+
+  const cancelDrag = useCallback(() => {
+    setDraggingId(null)
+    setDragOrder(null)
+    lastSwapWithRef.current = null
+  }, [])
+
+  const visibleEntries = useMemo(() => {
+    if (dragOrder === null) return entries
+    const byId = new Map(entries.map((e) => [e.id, e]))
+    return dragOrder.map((id) => byId.get(id)).filter((e): e is TabEntry => e != null)
+  }, [dragOrder, entries])
+
   const handleNewTab = useCallback((e: OtuiMouseEvent) => {
     e.stopPropagation()
     dispatchGlobal({ type: 'open-new-tab-modal' })
@@ -245,10 +370,11 @@ export function TopTabBar({ forceVisible = false }: TopTabBarProps) {
         viewportCulling
         contentOptions={ROW_CONTENT_OPTIONS}
       >
-        {entries.map((entry, index) => {
+        {visibleEntries.map((entry, index) => {
           // [N] is shown only for the first 9 entries — that's the range
           // Leader+1..9 can address.
           const indexLabel = index < 9 ? `[${index + 1}]` : undefined
+          const dragging = entry.id === draggingId
           if (entry.kind === 'single') {
             const tab: TabSession = entry.tab
             const isActive = tab.id === activeTabId
@@ -257,8 +383,12 @@ export function TopTabBar({ forceVisible = false }: TopTabBarProps) {
                 key={entry.id}
                 entryId={entry.id}
                 active={isActive}
-                onActivate={handleEntryActivate}
-                backgroundColor={isActive ? t.backgroundElement : undefined}
+                setCellRef={setCellRef}
+                onDragStart={handleDragStart}
+                onDrag={handleDrag}
+                onDrop={commitDrop}
+                onDragCancel={cancelDrag}
+                backgroundColor={isActive || dragging ? t.backgroundElement : undefined}
               >
                 <TabItem
                   id={`top-tab-${tab.id}`}
@@ -277,8 +407,12 @@ export function TopTabBar({ forceVisible = false }: TopTabBarProps) {
               key={entry.id}
               entryId={entry.id}
               active={isActive}
-              onActivate={handleEntryActivate}
-              backgroundColor={isActive ? t.backgroundElement : undefined}
+              setCellRef={setCellRef}
+              onDragStart={handleDragStart}
+              onDrag={handleDrag}
+              onDrop={commitDrop}
+              onDragCancel={cancelDrag}
+              backgroundColor={isActive || dragging ? t.backgroundElement : undefined}
             >
               <GroupTabItem
                 entry={entry}

package/src/ui/components/modals/shared/worktree-delete-confirm.tsx

@@ -0,0 +1,39 @@
+import type { ModeId } from '@brimveyn/aimux-config'
+
+import { useTheme } from '../../../theme'
+import { uiTokens } from '../../../ui-tokens'
+import { Form } from './form'
+
+interface WorktreeDeleteConfirmProps {
+  keybindsModeId: ModeId
+  reason: string
+  worktreeLabel: string
+}
+
+/**
+ * Shared confirmation dialog for a recoverable worktree delete. Used both inside
+ * the new-tab picker and as a standalone modal (sidebar "Remove worktree"); the
+ * keybinds mode wires Enter/y to confirm and Esc/n to cancel for each context.
+ */
+export function WorktreeDeleteConfirm({
+  keybindsModeId,
+  reason,
+  worktreeLabel,
+}: WorktreeDeleteConfirmProps) {
+  const t = useTheme()
+  return (
+    <Form
+      title="Delete worktree?"
+      keybindsModeId={keybindsModeId}
+      width={uiTokens.modalWidth.md}
+      footer={<text fg={t.textMuted}>Enter / y to delete · Esc / n to cancel</text>}
+    >
+      <box flexDirection="column" gap={1}>
+        <text fg={t.text}>
+          Delete <strong>{worktreeLabel}</strong>?
+        </text>
+        <text fg={t.warning}>{reason}</text>
+      </box>
+    </Form>
+  )
+}