@brimveyn/aimux 1.12.2 → 1.13.0

package/src/daemon/session-registry.ts

@@ -17,7 +17,7 @@ import {
   type WorkspaceSnapshotV1,
 } from '../state/types'
 
-type SessionRegistryEvents = {
+interface SessionRegistryEvents {
   render: [tabId: string, viewport: TerminalSnapshot, terminalModes: TerminalModeState]
   exit: [tabId: string, exitCode: number]
   error: [tabId: string, message: string]
@@ -81,7 +81,9 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
         this.tabs.set(tab.id, tab)
       }
       this.activeTabId =
-        snapshot.activeTabId && restoredTabs.some((tab) => tab.id === snapshot.activeTabId)
+        snapshot.activeTabId != null &&
+        snapshot.activeTabId !== '' &&
+        restoredTabs.some((tab) => tab.id === snapshot.activeTabId)
           ? snapshot.activeTabId
           : (restoredTabs[0]?.id ?? null)
     } else if (this.tabs.size > 0 && snapshot) {
@@ -90,9 +92,14 @@ export class SessionRegistry extends EventEmitter<SessionRegistryEvents> {
         if (existing) {
           existing.title = persisted.title
           existing.scrollIntent = persisted.scrollIntent ?? DEFAULT_SCROLL_INTENT
+          existing.worktreeId = persisted.worktreeId
         }
       }
-      if (snapshot.activeTabId && this.tabs.has(snapshot.activeTabId)) {
+      if (
+        snapshot.activeTabId != null &&
+        snapshot.activeTabId !== '' &&
+        this.tabs.has(snapshot.activeTabId)
+      ) {
         this.activeTabId = snapshot.activeTabId
       }
     }

package/src/diff-parser/parse-patch-files.ts

@@ -64,7 +64,7 @@ export function processFile(
     const lines = hunk.split(SPLIT_WITH_NEWLINES)
     const firstLine = lines.shift()
     if (firstLine == null) {
-      if (throwOnError) throw Error('parsePatchContent: invalid hunk')
+      if (throwOnError) throw new Error('parsePatchContent: invalid hunk')
       else console.error('parsePatchContent: invalid hunk', hunk)
       continue
     }
@@ -73,7 +73,7 @@ export function processFile(
     let deletionLines = 0
     if (fileHeaderMatch == null || currentFile == null) {
       if (currentFile != null) {
-        if (throwOnError) throw Error('parsePatchContent: Invalid hunk')
+        if (throwOnError) throw new Error('parsePatchContent: Invalid hunk')
         else console.error('parsePatchContent: Invalid hunk', hunk)
         continue
       }
@@ -139,8 +139,9 @@ export function processFile(
             currentFile.mode = line.replace('deleted file mode', '').trim()
           }
           if (line.startsWith('similarity index')) {
-            if (line.startsWith('similarity index 100%')) currentFile.type = 'rename-pure'
-            else currentFile.type = 'rename-changed'
+            currentFile.type = line.startsWith('similarity index 100%')
+              ? 'rename-pure'
+              : 'rename-changed'
           }
           if (line.startsWith('index ')) {
             const [, prevObjectId, newObjectId, mode] = line.trim().match(INDEX_LINE_METADATA) ?? []
@@ -162,24 +163,24 @@ export function processFile(
     let lastLineType: 'addition' | 'deletion' | 'context' | undefined
     while (
       lines.length > 0 &&
-      (lines[lines.length - 1] === '\n' ||
-        lines[lines.length - 1] === '\r' ||
-        lines[lines.length - 1] === '\r\n' ||
-        lines[lines.length - 1] === '')
+      (lines.at(-1) === '\n' ||
+        lines.at(-1) === '\r' ||
+        lines.at(-1) === '\r\n' ||
+        lines.at(-1) === '')
     ) {
       lines.pop()
     }
-    const additionStart = parseInt(fileHeaderMatch[3] ?? '')
-    const deletionStart = parseInt(fileHeaderMatch[1] ?? '')
+    const additionStart = parseInt(fileHeaderMatch[3] ?? '', 10)
+    const deletionStart = parseInt(fileHeaderMatch[1] ?? '', 10)
     deletionLineIndex = isPartial ? deletionLineIndex : deletionStart - 1
     additionLineIndex = isPartial ? additionLineIndex : additionStart - 1
     const hunkData = {
-      additionCount: parseInt(fileHeaderMatch[4] ?? '1'),
+      additionCount: parseInt(fileHeaderMatch[4] ?? '1', 10),
       additionLineIndex,
       additionLines,
       additionStart,
       collapsedBefore: 0,
-      deletionCount: parseInt(fileHeaderMatch[2] ?? '1'),
+      deletionCount: parseInt(fileHeaderMatch[2] ?? '1', 10),
       deletionLineIndex,
       deletionLines,
       deletionStart,
@@ -199,7 +200,7 @@ export function processFile(
       isNaN(hunkData.additionStart) ||
       isNaN(hunkData.deletionStart)
     ) {
-      if (throwOnError) throw Error('parsePatchContent: invalid hunk metadata')
+      if (throwOnError) throw new Error('parsePatchContent: invalid hunk metadata')
       else console.error('parsePatchContent: invalid hunk metadata', hunkData)
       continue
     }
@@ -285,7 +286,7 @@ export function processFile(
     currentFile.unifiedLineCount += hunkData.collapsedBefore + hunkData.unifiedLineCount
   }
   if (currentFile == null) return
-  const lastHunk = currentFile.hunks[currentFile.hunks.length - 1]
+  const lastHunk = currentFile.hunks.at(-1)
   if (
     lastHunk != null &&
     !isPartial &&
@@ -300,8 +301,7 @@ export function processFile(
   }
   if (!isGitDiff) {
     if (currentFile.prevName != null && currentFile.name !== currentFile.prevName) {
-      if (currentFile.hunks.length > 0) currentFile.type = 'rename-changed'
-      else currentFile.type = 'rename-pure'
+      currentFile.type = currentFile.hunks.length > 0 ? 'rename-changed' : 'rename-pure'
     } else if (newFile != null && newFile.contents === '') currentFile.type = 'deleted'
     else if (oldFile != null && oldFile.contents === '') currentFile.type = 'new'
   }
@@ -323,12 +323,12 @@ export function processPatch(
   for (const fileOrPatchMetadata of rawFiles) {
     if (isGitDiff && !GIT_DIFF_FILE_BREAK_REGEX.test(fileOrPatchMetadata)) {
       if (patchMetadata == null) patchMetadata = fileOrPatchMetadata
-      else if (throwOnError) throw Error('parsePatchContent: unknown file blob')
+      else if (throwOnError) throw new Error('parsePatchContent: unknown file blob')
       else console.error('parsePatchContent: unknown file blob:', fileOrPatchMetadata)
       continue
     } else if (!isGitDiff && !UNIFIED_DIFF_FILE_BREAK_REGEX.test(fileOrPatchMetadata)) {
       if (patchMetadata == null) patchMetadata = fileOrPatchMetadata
-      else if (throwOnError) throw Error('parsePatchContent: unknown file blob')
+      else if (throwOnError) throw new Error('parsePatchContent: unknown file blob')
       else console.error('parsePatchContent: unknown file blob:', fileOrPatchMetadata)
       continue
     }

package/src/git/command-queue.ts

@@ -1,6 +1,6 @@
 let tail: Promise<unknown> = Promise.resolve()
 
-export function enqueueGitOp<T>(op: () => Promise<T>): Promise<T> {
+export async function enqueueGitOp<T>(op: () => Promise<T>): Promise<T> {
   const next = tail.then(op, op)
   tail = next.catch(() => {})
   return next

package/src/git/divergence.ts

@@ -0,0 +1,46 @@
+import { $ } from 'bun'
+
+import type { BranchDivergence } from '../state/types'
+
+// Parses `git rev-list --left-right --count <base>...<branch>`, which prints two
+// whitespace-separated counts: "<left> <right>". With the `<base>...<branch>`
+// range the left count is commits in base but not branch (how far the branch is
+// *behind* its base) and the right count is commits in branch but not base (how
+// far it is *ahead*).
+export function parseDivergenceCount(output: string): BranchDivergence | undefined {
+  const match = /(\d+)\s+(\d+)/.exec(output.trim())
+  if (match == null) return undefined
+  return {
+    ahead: Number.parseInt(match[2] ?? '', 10),
+    behind: Number.parseInt(match[1] ?? '', 10),
+  }
+}
+
+// Commits a worktree branch is ahead/behind the ref it forked from. Returns
+// undefined when the refs can't be compared (missing ref, not a repo, …) so
+// callers can simply render nothing.
+export async function getBranchDivergence(
+  repoPath: string,
+  baseRef: string,
+  branch: string
+): Promise<BranchDivergence | undefined> {
+  const range = `${baseRef}...${branch}`
+  const result = await $`git -C ${repoPath} rev-list --left-right --count ${range}`
+    .quiet()
+    .nothrow()
+  if (result.exitCode !== 0) return undefined
+  return parseDivergenceCount(result.text())
+}
+
+// Fork point: the most recent commit shared by baseRef and ref. Diffing the
+// working tree against this shows everything the worktree changed since it
+// branched off (commits + staged + unstaged) — i.e. what a squash-move lands.
+export async function getMergeBase(
+  repoPath: string,
+  baseRef: string,
+  ref = 'HEAD'
+): Promise<string | undefined> {
+  const result = await $`git -C ${repoPath} merge-base ${baseRef} ${ref}`.quiet().nothrow()
+  if (result.exitCode !== 0) return undefined
+  return result.text().trim() || undefined
+}

package/src/git/git-diff.ts

@@ -5,7 +5,8 @@ import type { DiffData, DiffFileStatus, GitFileEntry } from '../state/types'
 import { imageFormatLabel, imageMimeFromPath, isImagePath } from './image-detect'
 
 function resolveStatus(entry: GitFileEntry): { status: DiffFileStatus; oldPath?: string } {
-  if (entry.renamedFrom) return { oldPath: entry.renamedFrom, status: 'renamed' }
+  if (entry.renamedFrom != null && entry.renamedFrom !== '')
+    return { oldPath: entry.renamedFrom, status: 'renamed' }
   if (entry.section === 'untracked' || entry.status === '?') return { status: 'new' }
   if (entry.status === 'D') return { status: 'deleted' }
   if (entry.status === 'A' && (entry.section === 'staged' || entry.section === 'historical')) {
@@ -85,13 +86,19 @@ async function rawUnifiedDiff(
   return result.text()
 }
 
+function resolveCompareRef(headOffset: number, compareRef: string | undefined): string {
+  if (compareRef != null && compareRef !== '') return compareRef
+  return headOffset > 0 ? `HEAD~${headOffset}` : 'HEAD'
+}
+
 export async function fetchDiff(
   cwd: string,
   file: GitFileEntry,
-  headOffset: number = 0
+  headOffset: number = 0,
+  compareRef?: string
 ): Promise<DiffData> {
   const { oldPath, status } = resolveStatus(file)
-  const ref = headOffset > 0 ? `HEAD~${headOffset}` : 'HEAD'
+  const ref = resolveCompareRef(headOffset, compareRef)
 
   if (isImagePath(file.path)) {
     const headPath = oldPath ?? file.path
@@ -112,7 +119,7 @@ export async function fetchDiff(
     }
     if (imageBytesBefore) data.imageBytesBefore = imageBytesBefore
     if (imageBytesAfter) data.imageBytesAfter = imageBytesAfter
-    if (oldPath) data.oldPath = oldPath
+    if (oldPath != null && oldPath !== '') data.oldPath = oldPath
     return data
   }
 
@@ -137,6 +144,6 @@ export async function fetchDiff(
     rawDiff,
     status,
   }
-  if (oldPath) data.oldPath = oldPath
+  if (oldPath != null && oldPath !== '') data.oldPath = oldPath
   return data
 }

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'
 }