@brimveyn/aimux 1.12.6 → 1.13.0

package/src/git/git-poller.ts

@@ -13,6 +13,9 @@ interface Options {
   enabled: boolean
   projectPath: string | undefined
   headOffset: number
+  // When set, diff the working tree against this ref (worktree fork point for
+  // review-vs-base) instead of HEAD/HEAD~N.
+  compareRef?: string
 }
 
 function tagFiles(files: GitFileEntry[], repoPath: string): GitFileEntry[] {
@@ -22,13 +25,23 @@ function tagFiles(files: GitFileEntry[], repoPath: string): GitFileEntry[] {
 async function collectAggregated(
   repos: DiscoveredRepo[],
   fallbackCwd: string,
-  headOffset: number
+  headOffset: number,
+  compareRef: string | undefined
 ): Promise<GitCollectResult> {
-  // Historical walking (HEAD~N) is per-repo and doesn't compose; fall back to
-  // the root/fallback repo when offset > 0 to preserve existing behaviour.
-  if (headOffset > 0) return collectGitStatus(fallbackCwd, { headOffset })
+  // Historical walking (HEAD~N) and review-vs-base are per-repo and don't
+  // compose; fall back to the root/fallback repo to preserve existing behaviour.
+  if ((compareRef != null && compareRef !== '') || headOffset > 0) {
+    const result = await collectGitStatus(fallbackCwd, { compareRef, headOffset })
+    if (result.kind !== 'ok') return result
+    return {
+      kind: 'ok',
+      payload: { ...result.payload, files: tagFiles(result.payload.files, fallbackCwd) },
+    }
+  }
 
-  const results = await Promise.all(repos.map((r) => collectGitStatus(r.path, { headOffset: 0 })))
+  const results = await Promise.all(
+    repos.map(async (r) => collectGitStatus(r.path, { headOffset: 0 }))
+  )
   const files: GitFileEntry[] = []
   let branch: string | null = null
   let ahead = 0
@@ -58,13 +71,18 @@ async function collectAggregated(
   return { kind: 'ok', payload }
 }
 
-export function useGitPanelPolling({ enabled, headOffset, projectPath }: Options): void {
+export function useGitPanelPolling({
+  compareRef,
+  enabled,
+  headOffset,
+  projectPath,
+}: Options): void {
   // Read repos from the store imperatively — changes trigger a fresh effect run
   // because the repos identity is stable across ticks until set-repos fires.
   const repos = useAppStore((s) => s.multiRepo.repos)
 
   useEffect(() => {
-    if (!enabled || !projectPath) return undefined
+    if (!enabled || !(projectPath != null && projectPath !== '')) return
 
     dispatchGlobal({ type: 'git-panel-reset' })
 
@@ -80,11 +98,15 @@ export function useGitPanelPolling({ enabled, headOffset, projectPath }: Options
     const tick = async () => {
       const result =
         repos.length > 0
-          ? await collectAggregated(repos, projectPath, headOffset)
-          : await collectGitStatus(projectPath, { headOffset })
+          ? await collectAggregated(repos, projectPath, headOffset, compareRef)
+          : await collectGitStatus(projectPath, { compareRef, headOffset })
       if (cancelled) return
       if (result.kind === 'ok') {
-        dispatchGlobal({ payload: result.payload, type: 'git-refresh-success' })
+        const payload =
+          repos.length === 0
+            ? { ...result.payload, files: tagFiles(result.payload.files, projectPath) }
+            : result.payload
+        dispatchGlobal({ payload, type: 'git-refresh-success' })
         delay = BASE_INTERVAL_MS
       } else if (result.kind === 'out-of-range') {
         dispatchGlobal({ offset: result.maxOffset, type: 'git-mode-set-head-offset' })
@@ -106,5 +128,5 @@ export function useGitPanelPolling({ enabled, headOffset, projectPath }: Options
       cancelled = true
       if (timer) clearTimeout(timer)
     }
-  }, [enabled, projectPath, headOffset, repos])
+  }, [enabled, projectPath, headOffset, compareRef, repos])
 }

package/src/git/git-status.ts

@@ -88,7 +88,7 @@ function buildEntry(
     removed = 0
   }
   const entry: GitFileEntry = { added, path, removed, section, status }
-  if (renamedFrom) entry.renamedFrom = renamedFrom
+  if (renamedFrom != null && renamedFrom !== '') entry.renamedFrom = renamedFrom
   return entry
 }
 
@@ -179,7 +179,7 @@ async function countUntrackedLines(cwd: string, path: string): Promise<number |
 async function annotateUntrackedCounts(cwd: string, files: GitFileEntry[]): Promise<void> {
   const untracked = files.filter((f) => f.section === 'untracked')
   if (untracked.length === 0) return
-  const counts = await Promise.all(untracked.map((f) => countUntrackedLines(cwd, f.path)))
+  const counts = await Promise.all(untracked.map(async (f) => countUntrackedLines(cwd, f.path)))
   for (let i = 0; i < untracked.length; i++) {
     const file = untracked[i]
     const count = counts[i]
@@ -192,6 +192,9 @@ async function annotateUntrackedCounts(cwd: string, files: GitFileEntry[]): Prom
 
 interface CollectOptions {
   headOffset?: number
+  // Explicit ref to diff the working tree against (e.g. a worktree's fork
+  // point). Takes precedence over headOffset when set.
+  compareRef?: string
 }
 
 function parseNameStatus(
@@ -208,7 +211,7 @@ function parseNameStatus(
     if (letter === 'R' || letter === 'C') {
       const from = parts[1]
       const to = parts[2]
-      if (!from || !to) continue
+      if (from == null || from === '' || !(to != null && to !== '')) continue
       rows.push({ path: to, renamedFrom: from, status })
     } else {
       const path = parts.slice(1).join('\t')
@@ -252,7 +255,13 @@ async function collectAgainstHistorical(
     const maxOffset = Number.isFinite(count) && count > 0 ? count - 1 : 0
     return { kind: 'out-of-range', maxOffset }
   }
+  return collectAgainstRef(cwd, ref)
+}
 
+// Diffs the working tree against an arbitrary ref (a HEAD~N commit, or a
+// worktree's fork point for review-vs-base), surfacing changed files as a
+// single `historical` section plus any untracked files.
+async function collectAgainstRef(cwd: string, ref: string): Promise<GitCollectResult> {
   const [statusResult, nameStatus, numstat, untrackedStatus] = await Promise.all([
     $`git -C ${cwd} status --porcelain=v2 -b -z --untracked-files=all`.quiet().nothrow(),
     $`git -C ${cwd} -c core.quotePath=false diff ${ref} --name-status`.quiet().nothrow(),
@@ -286,7 +295,9 @@ export async function collectGitStatus(
   options: CollectOptions = {}
 ): Promise<GitCollectResult> {
   const headOffset = options.headOffset ?? 0
+  const compareRef = options.compareRef
   try {
+    if (compareRef != null && compareRef !== '') return await collectAgainstRef(cwd, compareRef)
     return headOffset > 0
       ? await collectAgainstHistorical(cwd, headOffset)
       : await collectAgainstHead(cwd)

package/src/git/move-worktree.ts

@@ -0,0 +1,96 @@
+import { $ } from 'bun'
+
+export type MoveWorktreeResult =
+  | { kind: 'ok'; filesChanged: number }
+  | { kind: 'dirty-target' }
+  | { kind: 'conflict'; files: string[] }
+  | { kind: 'error'; message: string }
+
+async function workingTreeDirty(repoPath: string): Promise<boolean> {
+  const result = await $`git -C ${repoPath} status --porcelain`.quiet().nothrow()
+  if (result.exitCode !== 0) return false
+  return result.text().trim() !== ''
+}
+
+// Files left with conflict markers by a failed squash (unmerged index entries).
+async function conflictedFiles(repoPath: string): Promise<string[]> {
+  const result = await $`git -C ${repoPath} diff --name-only --diff-filter=U`.quiet().nothrow()
+  if (result.exitCode !== 0) return []
+  return result
+    .text()
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line !== '')
+}
+
+async function countStaged(repoPath: string): Promise<number> {
+  const result = await $`git -C ${repoPath} diff --cached --name-only`.quiet().nothrow()
+  if (result.exitCode !== 0) return 0
+  return result
+    .text()
+    .split('\n')
+    .filter((line) => line.trim() !== '').length
+}
+
+// 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> {
+  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()
+
+    // Capture uncommitted + untracked work in a throwaway commit so the squash
+    // includes everything; undone again before we return.
+    const tempCommitted = await workingTreeDirty(sourcePath)
+    if (tempCommitted) {
+      await $`git -C ${sourcePath} add -A`.quiet().nothrow()
+      const commit = await $`git -C ${sourcePath} commit -m ${'aimux: move WIP'} --no-verify`
+        .quiet()
+        .nothrow()
+      if (commit.exitCode !== 0) {
+        const message = commit.stderr.toString().trim()
+        return {
+          kind: 'error',
+          message: message !== '' ? message : 'failed to stage source changes',
+        }
+      }
+    }
+
+    const restoreSource = async (): Promise<void> => {
+      if (tempCommitted) {
+        await $`git -C ${sourcePath} reset --mixed ${sourceHead}`.quiet().nothrow()
+      }
+    }
+
+    const merge = await $`git -C ${targetPath} merge --squash ${sourceBranch}`.quiet().nothrow()
+    const conflicts = await conflictedFiles(targetPath)
+    if (merge.exitCode !== 0 || conflicts.length > 0) {
+      await $`git -C ${targetPath} merge --abort`.quiet().nothrow()
+      await $`git -C ${targetPath} reset --hard HEAD`.quiet().nothrow()
+      await restoreSource()
+      if (conflicts.length > 0) return { files: conflicts, kind: 'conflict' }
+      const message = merge.stderr.toString().trim()
+      return { kind: 'error', message: message !== '' ? message : 'merge failed' }
+    }
+
+    const filesChanged = await countStaged(targetPath)
+    await restoreSource()
+    return { filesChanged, kind: 'ok' }
+  } catch (error) {
+    return { kind: 'error', message: error instanceof Error ? error.message : String(error) }
+  }
+}

package/src/git/use-repo-discovery.ts

@@ -11,10 +11,11 @@ import { discoverRepos } from './repo-discovery'
 export function useRepoDiscovery(projectPath: string | undefined): void {
   useEffect(() => {
     const cfg = getMultiRepoConfig()
-    if (!cfg.enabled || !projectPath) {
+    if (!cfg.enabled || !(projectPath != null && projectPath !== '')) {
       dispatchGlobal({ type: 'multi-repo-clear' })
       return
     }
+    dispatchGlobal({ type: 'multi-repo-clear' })
     let cancelled = false
     void (async () => {
       const repos = await discoverRepos(projectPath, cfg.maxDepth)

package/src/git/worktree-divergence-poller.ts

@@ -0,0 +1,59 @@
+import { useEffect } from 'react'
+
+import type { BranchDivergence } from '../state/types'
+
+import { useAppStore } from '../state/app-store'
+import { dispatchGlobal } from '../state/dispatch-ref'
+import { getBranchDivergence } from './divergence'
+
+const INTERVAL_MS = 4000
+
+// Polls per-worktree base divergence for the current session while enabled and
+// dispatches it into worktreeDivergence. Only worktrees that record a baseRef
+// (the aimux-created ones) are measured; the primary and externally-discovered
+// worktrees have no recorded base and are left out.
+export function useWorktreeDivergencePolling(enabled: boolean): void {
+  const currentSessionId = useAppStore((s) => s.currentSessionId)
+  const sessions = useAppStore((s) => s.sessions)
+
+  useEffect(() => {
+    if (!enabled) return
+    const session =
+      currentSessionId != null && currentSessionId !== ''
+        ? sessions.find((s) => s.id === currentSessionId)
+        : undefined
+    const targets = (session?.worktrees ?? []).filter(
+      (w) => w.baseRef != null && w.baseRef !== '' && w.branch != null && w.branch !== ''
+    )
+    if (targets.length === 0) return
+
+    let cancelled = false
+    let timer: ReturnType<typeof setTimeout> | null = null
+
+    const tick = async () => {
+      const entries = await Promise.all(
+        targets.map(async (worktree) => {
+          const base = worktree.baseRef
+          const branch = worktree.branch
+          if (base == null || branch == null) return null
+          const divergence = await getBranchDivergence(worktree.repoRoot, base, branch)
+          return divergence != null ? ([worktree.id, divergence] as const) : null
+        })
+      )
+      if (cancelled) return
+      const next: Record<string, BranchDivergence> = {}
+      for (const entry of entries) {
+        if (entry != null) next[entry[0]] = entry[1]
+      }
+      dispatchGlobal({ divergence: next, type: 'set-worktree-divergence' })
+      timer = setTimeout(() => void tick(), INTERVAL_MS)
+    }
+
+    void tick()
+
+    return () => {
+      cancelled = true
+      if (timer != null) clearTimeout(timer)
+    }
+  }, [enabled, currentSessionId, sessions])
+}

package/src/git/worktree.ts

@@ -0,0 +1,99 @@
+import { $ } from 'bun'
+import { existsSync } from 'node:fs'
+
+import { isInsideAimuxWorktreeRoot } from '../platform/worktree-paths'
+
+export interface GitWorktreeInfo {
+  path: string
+  head?: string
+  branch?: string
+  // True when git still tracks the worktree but its directory is gone
+  // (e.g. a temp dir cleared on reboot). Such entries are stale admin junk.
+  prunable?: boolean
+}
+
+// Returns the main worktree's path, i.e. the original repository checkout.
+// `git worktree list` always reports the main worktree first, so this stays
+// correct even when called from inside a linked worktree — unlike
+// `rev-parse --show-toplevel`, which returns the *current* worktree's path.
+export async function getMainWorktreeRoot(cwd: string): Promise<string | undefined> {
+  const worktrees = await listGitWorktrees(cwd)
+  return worktrees[0]?.path
+}
+
+export async function getCurrentBranch(cwd: string): Promise<string | undefined> {
+  const result = await $`git -C ${cwd} branch --show-current`.quiet().nothrow()
+  if (result.exitCode !== 0) return undefined
+  return result.text().trim() || undefined
+}
+
+export async function getHeadSha(cwd: string): Promise<string | undefined> {
+  const result = await $`git -C ${cwd} rev-parse HEAD`.quiet().nothrow()
+  if (result.exitCode !== 0) return undefined
+  return result.text().trim() || undefined
+}
+
+export async function createGitWorktree({
+  baseRef,
+  branchName,
+  repoPath,
+  targetPath,
+}: {
+  repoPath: string
+  targetPath: string
+  branchName: string
+  baseRef: string
+}): Promise<void> {
+  const result = await $`git -C ${repoPath} worktree add -b ${branchName} ${targetPath} ${baseRef}`
+    .quiet()
+    .nothrow()
+  if (result.exitCode !== 0) {
+    throw new Error(result.stderr.toString().trim() || 'failed to create git worktree')
+  }
+}
+
+export async function removeGitWorktree({
+  force,
+  repoPath,
+  targetPath,
+}: {
+  repoPath: string
+  targetPath: string
+  force: boolean
+}): Promise<void> {
+  if (!isInsideAimuxWorktreeRoot(targetPath)) {
+    throw new Error(`refusing to delete worktree outside Aimux temp root: ${targetPath}`)
+  }
+  const result = force
+    ? await $`git -C ${repoPath} worktree remove --force ${targetPath}`.quiet().nothrow()
+    : await $`git -C ${repoPath} worktree remove ${targetPath}`.quiet().nothrow()
+  if (result.exitCode === 0) return
+  // The worktree directory may already be gone, leaving only stale admin state
+  // in the main repo. Pruning clears it so deletion still reaches its goal.
+  if (!existsSync(targetPath)) {
+    await $`git -C ${repoPath} worktree prune`.quiet().nothrow()
+    return
+  }
+  throw new Error(result.stderr.toString().trim() || 'failed to remove git worktree')
+}
+
+export async function listGitWorktrees(repoPath: string): Promise<GitWorktreeInfo[]> {
+  const result = await $`git -C ${repoPath} worktree list --porcelain`.quiet().nothrow()
+  if (result.exitCode !== 0) return []
+  const worktrees: GitWorktreeInfo[] = []
+  let current: GitWorktreeInfo | null = null
+  for (const line of result.text().split('\n')) {
+    if (line.startsWith('worktree ')) {
+      if (current) worktrees.push(current)
+      current = { path: line.slice('worktree '.length) }
+    } else if (current && line.startsWith('HEAD ')) {
+      current.head = line.slice('HEAD '.length)
+    } else if (current && line.startsWith('branch ')) {
+      current.branch = line.slice('branch '.length).replace(/^refs\/heads\//, '')
+    } else if (current && line.startsWith('prunable')) {
+      current.prunable = true
+    }
+  }
+  if (current) worktrees.push(current)
+  return worktrees
+}

package/src/index.tsx

@@ -77,7 +77,7 @@ logDebug('index.userConfigLoaded', {
 // plain code so we can re-tokenize on the snapshot. Set on process.env
 // before backend bootstrap so the spawned daemon (and its child PTYs)
 // inherit it.
-if (resolvedConfig.theme?.beta?.experimentalSyntaxHighlight) {
+if (resolvedConfig.theme?.beta?.experimentalSyntaxHighlight === true) {
   process.env.CLAUDE_CODE_SYNTAX_HIGHLIGHT = 'false'
 }
 

package/src/input/keymap/describe-bindings.ts

@@ -56,16 +56,22 @@ export function describeBindings(
   for (const binding of mode.bindings) {
     const keysDisplay = formatNotationForDisplay(binding.keys, leaderChord)
 
-    if (options.mergeAlternativesByDescription) {
+    if (options.mergeAlternativesByDescription === true) {
       const actionSignature = getActionSignature(binding.result)
-      const existingIndex = binding.description
-        ? resultIndexByDescription.get(binding.description)
-        : resultIndexByAction.get(actionSignature)
+      const existingIndex =
+        binding.description != null && binding.description !== ''
+          ? resultIndexByDescription.get(binding.description)
+          : resultIndexByAction.get(actionSignature)
 
       if (existingIndex === undefined) {
-        if (options.withDescriptionOnly && !binding.description) continue
+        if (
+          options.withDescriptionOnly === true &&
+          !(binding.description != null && binding.description !== '')
+        )
+          continue
         const nextIndex = result.length
-        if (binding.description) resultIndexByDescription.set(binding.description, nextIndex)
+        if (binding.description != null && binding.description !== '')
+          resultIndexByDescription.set(binding.description, nextIndex)
         resultIndexByAction.set(actionSignature, nextIndex)
         seenKeysDisplayByIndex.set(nextIndex, new Set([keysDisplay]))
         result.push({
@@ -83,7 +89,11 @@ export function describeBindings(
       seenKeysDisplay.add(keysDisplay)
       const existing = result[existingIndex]
       if (!existing) continue
-      if (!existing.description && binding.description) {
+      if (
+        (existing.description == null || existing.description === '') &&
+        binding.description != null &&
+        binding.description !== ''
+      ) {
         existing.description = binding.description
         existing.group = binding.group
         resultIndexByDescription.set(binding.description, existingIndex)
@@ -93,9 +103,17 @@ export function describeBindings(
       continue
     }
 
-    if (options.withDescriptionOnly && !binding.description) continue
+    if (
+      options.withDescriptionOnly === true &&
+      !(binding.description != null && binding.description !== '')
+    )
+      continue
 
-    if (options.dedupeByDescription && binding.description) {
+    if (
+      options.dedupeByDescription === true &&
+      binding.description != null &&
+      binding.description !== ''
+    ) {
       if (seenDescriptions.has(binding.description)) continue
       seenDescriptions.add(binding.description)
     }

package/src/input/keymap/key-chord.ts

@@ -77,7 +77,7 @@ export function parseKeyNotation(notation: string, leader?: KeyChord): KeyChord[
 
     // Handle <leader>
     if (inner.toLowerCase() === 'leader') {
-      if (!leader) {
+      if (!(leader != null && leader !== '')) {
         throw new Error('parseKeyNotation: <leader> used but no leader key configured')
       }
       chords.push(leader)
@@ -102,7 +102,7 @@ export function parseKeyNotation(notation: string, leader?: KeyChord): KeyChord[
 function parseAngleBracketToken(inner: string): KeyChord {
   // Check if it's a special name (no modifiers)
   const specialInner = SPECIAL_NAMES[inner]
-  if (specialInner) {
+  if (specialInner != null && specialInner !== '') {
     return specialInner
   }
 
@@ -120,11 +120,11 @@ function parseAngleBracketToken(inner: string): KeyChord {
     else if (mod === 'S') shift = true
   }
 
-  let keyName = parts[parts.length - 1] ?? ''
+  let keyName = parts.at(-1) ?? ''
 
   // Check if the key part is a special name
   const specialKey = SPECIAL_NAMES[keyName]
-  if (specialKey) {
+  if (specialKey != null && specialKey !== '') {
     keyName = specialKey
   }
 

package/src/input/keymap/key-format.ts

@@ -14,14 +14,14 @@ const SPECIAL_DISPLAY: Record<string, string> = {
 
 function formatModifierKey(baseName: string): string {
   const special = SPECIAL_DISPLAY[baseName]
-  if (special) return special
+  if (special != null && special !== '') return special
   if (baseName.length === 1) return baseName.toUpperCase()
   return baseName.charAt(0).toUpperCase() + baseName.slice(1)
 }
 
 /** Convert a single canonical KeyChord back to a human-readable label. */
 export function formatChord(chord: KeyChord, leader?: KeyChord): string {
-  if (leader && chord === leader) return '<leader>'
+  if (leader != null && leader !== '' && chord === leader) return '<leader>'
 
   let ctrl = false
   let meta = false

package/src/input/keymap/sequence-resolver.ts

@@ -135,7 +135,7 @@ export class SequenceResolver {
   }
 
   private updateRepeatOnResolve(chord: KeyChord, binding: TrieBinding): void {
-    if (binding.repeatable) {
+    if (binding.repeatable === true) {
       this.repeatTerminal = chord
       this.repeatBinding = binding
     } else {

package/src/input/keymap/trie.ts

@@ -52,7 +52,7 @@ export class KeyTrie {
   remove(sequence: KeyChord[]): boolean {
     if (sequence.length === 0) return false
 
-    const path: Array<{ node: TrieNode; chord: KeyChord }> = []
+    const path: { node: TrieNode; chord: KeyChord }[] = []
     let node = this.root
 
     for (const chord of sequence) {

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-move': 'modal.worktree-move',
 }
 
 export function deriveModeId(state: AppState): ModeId {
@@ -35,6 +36,12 @@ export function deriveModeId(state: AppState): ModeId {
     return 'modal.help.filtering'
   }
 
+  // Overlay on top of git mode without flipping focusMode (like help) — route
+  // input to the picker while it's open even though focus stays 'git'.
+  if (state.modal.type === 'worktree-move') {
+    return 'modal.worktree-move'
+  }
+
   const directMode = DIRECT_FOCUS_MODE_IDS[state.focusMode]
   if (directMode) {
     return directMode

package/src/input/modes/transitions.ts

@@ -1,7 +1,7 @@
 import type { ModeId } from './types'
 
 const TRANSITIONS: Record<ModeId, readonly ModeId[]> = {
-  'git-mode': ['navigation', 'modal.git-commit'],
+  'git-mode': ['navigation', 'modal.git-commit', 'modal.worktree-move'],
   'modal.ai-usage': ['navigation', 'terminal-input'],
   'modal.create-session': ['navigation', 'modal.session-picker.filtering'],
   'modal.git-commit': ['git-mode', 'modal.git-commit.confirm', 'modal.git-commit.generating'],
@@ -18,6 +18,7 @@ const TRANSITIONS: Record<ModeId, readonly ModeId[]> = {
   'modal.split-picker': ['navigation', 'terminal-input'],
   'modal.theme-picker.filtering': ['navigation'],
   'modal.update-available': ['navigation'],
+  'modal.worktree-move': ['git-mode', 'navigation'],
   'navigation': [
     'terminal-input',
     'modal.new-tab.command-edit',

package/src/input/modes/types.ts

@@ -1,5 +1,6 @@
 import type { KeyEvent } from '@opentui/core'
 
+import type { SplitDirection } from '../../state/layout-tree'
 import type { AppAction, AppState, GitFileListMode, TabSession } from '../../state/types'
 
 export type ModeId =
@@ -21,6 +22,7 @@ export type ModeId =
   | 'modal.git-commit.confirm'
   | 'modal.git-commit.generating'
   | 'modal.update-available'
+  | 'modal.worktree-move'
   | 'modal.ai-usage'
 
 export type SideEffect =
@@ -46,7 +48,7 @@ export type SideEffect =
   | { type: 'rename-session'; sessionId: string; name: string }
   | {
       type: 'split-pane'
-      direction: import('../../state/layout-tree').SplitDirection
+      direction: SplitDirection
       sourceTabId?: string
     }
   | { type: 'confirm-split' }
@@ -67,6 +69,14 @@ export type SideEffect =
   | { type: 'confirm-update-selection' }
   | { type: 'switch-session-by-index'; index: number }
   | { type: 'delete-session'; sessionId: string }
+  | { type: 'delete-worktree'; sessionId: string; worktreeId: string; force?: boolean }
+  | {
+      type: 'move-worktree'
+      sessionId: string
+      sourceWorktreeId: string
+      targetWorktreeId: string
+      deleteSource?: boolean
+    }
   | { type: 'toggle-transparent' }
   | { type: 'toggle-mode' }
   | { type: 'open-file-in-editor'; path: string }

package/src/input/raw-input-handler.ts

@@ -224,7 +224,7 @@ export function createRawInputHandler(deps: {
     }
 
     const activeTabId = deps.getActiveTabId()
-    if (!activeTabId) {
+    if (!(activeTabId != null && activeTabId !== '')) {
       return false
     }