@brimveyn/aimux 1.6.0 → 1.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brimveyn/aimux",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "A terminal multiplexer for AI CLIs. Run Claude, Codex, OpenCode side-by-side with tabbed navigation, split panes, and persistent sessions.",
   "keywords": [
     "ai",
@@ -61,7 +61,7 @@
     "generate-themes": "bun run scripts/generate-themes.ts"
   },
   "dependencies": {
-    "@brimveyn/aimux-config": "0.4.0",
+    "@brimveyn/aimux-config": "0.4.2",
     "@opentui/core": "^0.1.90",
     "@opentui/react": "^0.1.90",
     "@xterm/headless": "^6.0.0",

package/src/app-runtime/side-effects.ts

@@ -471,6 +471,7 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
           mode: persistedGitPane?.mode ?? 'embedded',
           position: persistedGitPane?.position ?? 'bottom',
           ratio: persistedGitPane?.ratio ?? 0.5,
+          treeCompaction: persistedGitPane?.treeCompaction,
           visible: persistedGitPane?.visible ?? true,
         },
       })
@@ -487,6 +488,24 @@ export function executeSideEffect(effect: SideEffect, ctx: SideEffectContext): v
           mode: persistedGitPane?.mode ?? 'embedded',
           position: persistedGitPane?.position ?? 'bottom',
           ratio: persistedGitPane?.ratio ?? 0.5,
+          treeCompaction: persistedGitPane?.treeCompaction,
+          visible: persistedGitPane?.visible ?? true,
+        },
+      })
+      return
+    }
+    case 'persist-git-tree-compaction': {
+      const config = loadConfig()
+      const persistedGitPane = config.gitPane
+      saveConfig({
+        ...config,
+        gitPane: {
+          diffModeRatio: persistedGitPane?.diffModeRatio,
+          fileListMode: persistedGitPane?.fileListMode,
+          mode: persistedGitPane?.mode ?? 'embedded',
+          position: persistedGitPane?.position ?? 'bottom',
+          ratio: persistedGitPane?.ratio ?? 0.5,
+          treeCompaction: effect.enabled,
           visible: persistedGitPane?.visible ?? true,
         },
       })

package/src/app.tsx

@@ -88,10 +88,14 @@ export function App({
     const userGitPane = resolvedConfig.gitPane
     const fileListMode = userGitPane?.fileListMode ?? json.gitPane?.fileListMode ?? 'tree'
     const diffModeRatio = userGitPane?.diffModeRatio ?? json.gitPane?.diffModeRatio ?? 0.35
+    const treeCompaction = userGitPane?.treeCompaction ?? json.gitPane?.treeCompaction ?? true
+    const prefetchRadius = userGitPane?.prefetchRadius ?? json.gitPane?.prefetchRadius ?? 5
     const gitPaneOverrides = {
       ...json.gitPane,
       diffModeRatio,
       fileListMode,
+      prefetchRadius,
+      treeCompaction,
       ...(userGitPane?.visible !== undefined ? { visible: userGitPane.visible } : {}),
       ...(userGitPane?.mode !== undefined ? { mode: userGitPane.mode } : {}),
       ...(userGitPane?.position !== undefined ? { position: userGitPane.position } : {}),

package/src/config.ts

@@ -25,6 +25,8 @@ export const CONFIG_PATH = `${getProfileConfigDir()}/aimux.json`
 export interface PersistedGitPane {
   diffModeRatio?: number
   fileListMode?: GitFileListMode
+  treeCompaction?: boolean
+  prefetchRadius?: number
   visible: boolean
   mode: 'embedded' | 'pane'
   position: 'top' | 'bottom' | 'left' | 'right'
@@ -62,7 +64,23 @@ function isPersistedGitPane(value: unknown): value is PersistedGitPane {
   const visibleOk = typeof v.visible === 'boolean'
   const fileListModeOk =
     v.fileListMode === undefined || v.fileListMode === 'tree' || v.fileListMode === 'flat'
-  if (!modeOk || !positionOk || !ratioOk || !diffModeRatioOk || !visibleOk || !fileListModeOk) {
+  const treeCompactionOk = v.treeCompaction === undefined || typeof v.treeCompaction === 'boolean'
+  const prefetchRadiusOk =
+    v.prefetchRadius === undefined ||
+    (typeof v.prefetchRadius === 'number' &&
+      Number.isFinite(v.prefetchRadius) &&
+      v.prefetchRadius >= 0 &&
+      v.prefetchRadius <= 50)
+  if (
+    !modeOk ||
+    !positionOk ||
+    !ratioOk ||
+    !diffModeRatioOk ||
+    !visibleOk ||
+    !fileListModeOk ||
+    !treeCompactionOk ||
+    !prefetchRadiusOk
+  ) {
     return false
   }
   // cross-field coherence: embedded => top|bottom; pane => left|right

package/src/git/diff-hash.ts

@@ -0,0 +1,10 @@
+// FNV-1a 32-bit hash. Fast, non-crypto, used to detect stale cached diff
+// artefacts (parsed file, syntax highlights) when the raw diff text changes.
+export function diffHash(input: string): string {
+  let h = 0x811c9dc5
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i)
+    h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0
+  }
+  return h.toString(16)
+}

package/src/git/git-diff.ts

@@ -6,12 +6,14 @@ function resolveStatus(entry: GitFileEntry): { status: DiffFileStatus; oldPath?:
   if (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') return { status: 'new' }
+  if (entry.status === 'A' && (entry.section === 'staged' || entry.section === 'historical')) {
+    return { status: 'new' }
+  }
   return { status: 'modified' }
 }
 
-async function isBinary(cwd: string, path: string): Promise<boolean> {
-  const result = await $`git -C ${cwd} diff HEAD --numstat -- ${path}`.quiet().nothrow()
+async function isBinary(cwd: string, ref: string, path: string): Promise<boolean> {
+  const result = await $`git -C ${cwd} diff ${ref} --numstat -- ${path}`.quiet().nothrow()
   if (result.exitCode !== 0) return false
   const text = result.text().trim()
   if (!text) return false
@@ -19,8 +21,8 @@ async function isBinary(cwd: string, path: string): Promise<boolean> {
   return first.startsWith('-\t-\t')
 }
 
-async function readHeadSize(cwd: string, path: string): Promise<number> {
-  const result = await $`git -C ${cwd} show HEAD:${path}`.quiet().nothrow()
+async function readHeadSize(cwd: string, ref: string, path: string): Promise<number> {
+  const result = await $`git -C ${cwd} show ${ref}:${path}`.quiet().nothrow()
   if (result.exitCode !== 0) return 0
   return result.text().length
 }
@@ -33,9 +35,14 @@ async function readWorkingSize(cwd: string, path: string): Promise<number> {
   return 0
 }
 
-async function rawUnifiedDiff(cwd: string, path: string, status: DiffFileStatus): Promise<string> {
+async function rawUnifiedDiff(
+  cwd: string,
+  ref: string,
+  path: string,
+  status: DiffFileStatus
+): Promise<string> {
   if (status === 'new') {
-    const result = await $`git -C ${cwd} diff HEAD --no-color --no-textconv -- ${path}`
+    const result = await $`git -C ${cwd} diff ${ref} --no-color --no-textconv -- ${path}`
       .quiet()
       .nothrow()
     if (result.exitCode === 0 && result.text().length > 0) return result.text()
@@ -47,19 +54,24 @@ async function rawUnifiedDiff(cwd: string, path: string, status: DiffFileStatus)
   }
 
   const result =
-    await $`git -C ${cwd} diff HEAD --unified=99999 --no-color --no-textconv -- ${path}`
+    await $`git -C ${cwd} diff ${ref} --unified=99999 --no-color --no-textconv -- ${path}`
       .quiet()
       .nothrow()
   if (result.exitCode !== 0) return ''
   return result.text()
 }
 
-export async function fetchDiff(cwd: string, file: GitFileEntry): Promise<DiffData> {
+export async function fetchDiff(
+  cwd: string,
+  file: GitFileEntry,
+  headOffset: number = 0
+): Promise<DiffData> {
   const { oldPath, status } = resolveStatus(file)
+  const ref = headOffset > 0 ? `HEAD~${headOffset}` : 'HEAD'
 
-  if (await isBinary(cwd, file.path)) {
+  if (await isBinary(cwd, ref, file.path)) {
     const [binarySizeBefore, binarySizeAfter] = await Promise.all([
-      readHeadSize(cwd, file.path),
+      readHeadSize(cwd, ref, file.path),
       readWorkingSize(cwd, file.path),
     ])
     return {
@@ -71,7 +83,7 @@ export async function fetchDiff(cwd: string, file: GitFileEntry): Promise<DiffDa
     }
   }
 
-  const rawDiff = await rawUnifiedDiff(cwd, file.path, status)
+  const rawDiff = await rawUnifiedDiff(cwd, ref, file.path, status)
 
   const data: DiffData = {
     path: file.path,

package/src/git/git-poller.ts

@@ -9,9 +9,10 @@ const MAX_INTERVAL_MS = 30_000
 interface Options {
   enabled: boolean
   projectPath: string | undefined
+  headOffset: number
 }
 
-export function useGitPanelPolling({ enabled, projectPath }: Options): void {
+export function useGitPanelPolling({ enabled, headOffset, projectPath }: Options): void {
   useEffect(() => {
     if (!enabled || !projectPath) return undefined
 
@@ -27,11 +28,18 @@ export function useGitPanelPolling({ enabled, projectPath }: Options): void {
     }
 
     const tick = async () => {
-      const result = await collectGitStatus(projectPath)
+      const result = await collectGitStatus(projectPath, { headOffset })
       if (cancelled) return
       if (result.kind === 'ok') {
         dispatchGlobal({ payload: result.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' })
+        dispatchGlobal({
+          message: `no older commit — clamped to HEAD~${result.maxOffset}`,
+          type: 'git-mode-set-message',
+        })
+        delay = BASE_INTERVAL_MS
       } else {
         dispatchGlobal({ kind: result.error, type: 'git-refresh-error' })
         delay = Math.min(delay * 2, MAX_INTERVAL_MS)
@@ -45,5 +53,5 @@ export function useGitPanelPolling({ enabled, projectPath }: Options): void {
       cancelled = true
       if (timer) clearTimeout(timer)
     }
-  }, [enabled, projectPath])
+  }, [enabled, projectPath, headOffset])
 }

package/src/git/git-status.ts

@@ -16,6 +16,7 @@ interface NumstatRow {
 export type GitCollectResult =
   | { kind: 'ok'; payload: GitRefreshPayload }
   | { kind: 'error'; error: GitPanelError }
+  | { kind: 'out-of-range'; maxOffset: number }
 
 const STATUS_CODES = new Set(['M', 'A', 'D', 'R', 'C', 'U', '?'])
 
@@ -189,26 +190,106 @@ async function annotateUntrackedCounts(cwd: string, files: GitFileEntry[]): Prom
   }
 }
 
-export async function collectGitStatus(cwd: string): Promise<GitCollectResult> {
-  try {
-    const [statusResult, unstagedDiff, stagedDiff] = await Promise.all([
-      $`git -C ${cwd} status --porcelain=v2 -b -z --untracked-files=all`.quiet().nothrow(),
-      $`git -C ${cwd} -c core.quotePath=false diff --numstat`.quiet().nothrow(),
-      $`git -C ${cwd} -c core.quotePath=false diff --cached --numstat`.quiet().nothrow(),
-    ])
-
-    if (statusResult.exitCode !== 0) {
-      return { error: 'not-a-repo', kind: 'error' }
+interface CollectOptions {
+  headOffset?: number
+}
+
+function parseNameStatus(
+  output: string
+): { path: string; status: GitFileStatus; renamedFrom?: string }[] {
+  const rows: { path: string; status: GitFileStatus; renamedFrom?: string }[] = []
+  for (const raw of output.split('\n')) {
+    if (!raw) continue
+    const parts = raw.split('\t')
+    const code = parts[0] ?? ''
+    const letter = code[0] ?? ''
+    const status = toStatus(letter)
+    if (!status) continue
+    if (letter === 'R' || letter === 'C') {
+      const from = parts[1]
+      const to = parts[2]
+      if (!from || !to) continue
+      rows.push({ path: to, renamedFrom: from, status })
+    } else {
+      const path = parts.slice(1).join('\t')
+      if (!path) continue
+      rows.push({ path, status })
     }
+  }
+  return rows
+}
+
+async function collectAgainstHead(cwd: string): Promise<GitCollectResult> {
+  const [statusResult, unstagedDiff, stagedDiff] = await Promise.all([
+    $`git -C ${cwd} status --porcelain=v2 -b -z --untracked-files=all`.quiet().nothrow(),
+    $`git -C ${cwd} -c core.quotePath=false diff --numstat`.quiet().nothrow(),
+    $`git -C ${cwd} -c core.quotePath=false diff --cached --numstat`.quiet().nothrow(),
+  ])
 
-    const statusText = statusResult.text()
-    const { ahead, behind, branch } = parseBranchLines(statusText)
-    const unstagedNumstat = parseNumstat(unstagedDiff.text())
-    const stagedNumstat = parseNumstat(stagedDiff.text())
-    const files = parsePorcelainEntries(statusText, stagedNumstat, unstagedNumstat)
-    await annotateUntrackedCounts(cwd, files)
+  if (statusResult.exitCode !== 0) {
+    return { error: 'not-a-repo', kind: 'error' }
+  }
+
+  const statusText = statusResult.text()
+  const { ahead, behind, branch } = parseBranchLines(statusText)
+  const unstagedNumstat = parseNumstat(unstagedDiff.text())
+  const stagedNumstat = parseNumstat(stagedDiff.text())
+  const files = parsePorcelainEntries(statusText, stagedNumstat, unstagedNumstat)
+  await annotateUntrackedCounts(cwd, files)
 
-    return { kind: 'ok', payload: { ahead, behind, branch, files } }
+  return { kind: 'ok', payload: { ahead, behind, branch, files } }
+}
+
+async function collectAgainstHistorical(
+  cwd: string,
+  headOffset: number
+): Promise<GitCollectResult> {
+  const ref = `HEAD~${headOffset}`
+  const revParse = await $`git -C ${cwd} rev-parse ${ref}`.quiet().nothrow()
+  if (revParse.exitCode !== 0) {
+    const countResult = await $`git -C ${cwd} rev-list --count HEAD`.quiet().nothrow()
+    const count = countResult.exitCode === 0 ? Number.parseInt(countResult.text().trim(), 10) : NaN
+    const maxOffset = Number.isFinite(count) && count > 0 ? count - 1 : 0
+    return { kind: 'out-of-range', maxOffset }
+  }
+
+  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(),
+    $`git -C ${cwd} -c core.quotePath=false diff ${ref} --numstat`.quiet().nothrow(),
+    $`git -C ${cwd} status --porcelain=v2 -z --untracked-files=all`.quiet().nothrow(),
+  ])
+
+  if (statusResult.exitCode !== 0) {
+    return { error: 'not-a-repo', kind: 'error' }
+  }
+
+  const { ahead, behind, branch } = parseBranchLines(statusResult.text())
+  const stats = parseNumstat(numstat.text())
+  const rows = parseNameStatus(nameStatus.text())
+  const files: GitFileEntry[] = rows.map((row) =>
+    buildEntry('historical', row.status, row.path, stats, row.renamedFrom)
+  )
+
+  // Untracked files live outside any commit — still surface them so `?` files
+  // don't vanish when the user walks history.
+  const porcelain = parsePorcelainEntries(untrackedStatus.text(), new Map(), new Map())
+  const untracked = porcelain.filter((f) => f.section === 'untracked')
+  await annotateUntrackedCounts(cwd, untracked)
+  files.push(...untracked)
+
+  return { kind: 'ok', payload: { ahead, behind, branch, files } }
+}
+
+export async function collectGitStatus(
+  cwd: string,
+  options: CollectOptions = {}
+): Promise<GitCollectResult> {
+  const headOffset = options.headOffset ?? 0
+  try {
+    return headOffset > 0
+      ? await collectAgainstHistorical(cwd, headOffset)
+      : await collectAgainstHead(cwd)
   } catch {
     return { error: 'unknown', kind: 'error' }
   }

package/src/input/modes/types.ts

@@ -49,6 +49,7 @@ export type SideEffect =
   | { type: 'scroll-git-diff'; delta: number }
   | { type: 'persist-git-diff-mode-ratio'; ratio: number }
   | { type: 'persist-git-file-list-mode'; mode: GitFileListMode }
+  | { type: 'persist-git-tree-compaction'; enabled: boolean }
   | { type: 'git-stage'; path: string }
   | { type: 'git-unstage'; path: string }
   | { type: 'git-restore'; path: string }

package/src/pty/terminal-snapshot.ts

@@ -2,7 +2,7 @@ import type { Terminal } from '@xterm/headless'
 
 import type { TerminalLine, TerminalSnapshot, TerminalSpan } from '../state/types'
 
-import { theme } from '../ui/theme'
+import { getCurrentTheme } from '../ui/theme'
 
 const ANSI_PALETTE = [
   '#000000',
@@ -113,15 +113,15 @@ function buildLine(
     let bg = getColorHex(current.getBgColor(), bgMode)
 
     if (current.isInverse()) {
-      const resolvedFg = fg ?? theme.colors['editor.foreground']
-      const resolvedBg = bg ?? theme.colors['editor.background']
+      const resolvedFg = fg ?? getCurrentTheme().colors['editor.foreground']
+      const resolvedBg = bg ?? getCurrentTheme().colors['editor.background']
       ;[fg, bg] = [resolvedBg, resolvedFg]
     }
 
     const isCursorCell = cursorVisible && cursorColumn === column
     if (isCursorCell) {
-      const resolvedFg = fg ?? theme.colors['editor.foreground']
-      const resolvedBg = bg ?? theme.colors['editor.background']
+      const resolvedFg = fg ?? getCurrentTheme().colors['editor.foreground']
+      const resolvedBg = bg ?? getCurrentTheme().colors['editor.background']
       ;[fg, bg] = [resolvedBg, resolvedFg]
     }
 

package/src/state/git-tree.ts

@@ -1,6 +1,6 @@
 import type { GitFileEntry, GitFileListMode, GitFileSection } from './types'
 
-const SECTION_ORDER: GitFileSection[] = ['staged', 'unstaged', 'untracked']
+const SECTION_ORDER: GitFileSection[] = ['historical', 'staged', 'unstaged', 'untracked']
 
 interface GitTreeNode {
   files: GitFileEntry[]
@@ -53,7 +53,8 @@ export function gitFolderKey(section: GitFileSection, folderPath: string): strin
 export function buildGitTreeRows(
   files: GitFileEntry[],
   collapsedFolders: Record<string, true>,
-  fileListMode: GitFileListMode = 'tree'
+  fileListMode: GitFileListMode = 'tree',
+  compact: boolean = false
 ): GitTreeRows {
   const sections = SECTION_ORDER.map((section) => {
     const sectionFiles = files.filter((file) => file.section === section)
@@ -68,7 +69,7 @@ export function buildGitTreeRows(
               kind: 'file' as const,
               section,
             }))
-          : flattenSectionRows(sectionFiles, collapsedFolders),
+          : flattenSectionRows(sectionFiles, collapsedFolders, compact),
       section,
     }
   })
@@ -81,10 +82,16 @@ export function getSelectedGitRow(
     collapsedFolders: Record<string, true>
     fileListMode: GitFileListMode
     selectedEntryKey: string | null
+    compact?: boolean
   }
 ): GitTreeRow | null {
   if (!options.selectedEntryKey) return null
-  const { visibleRows } = buildGitTreeRows(files, options.collapsedFolders, options.fileListMode)
+  const { visibleRows } = buildGitTreeRows(
+    files,
+    options.collapsedFolders,
+    options.fileListMode,
+    options.compact ?? false
+  )
   return visibleRows.find((row) => row.key === options.selectedEntryKey) ?? null
 }
 
@@ -94,6 +101,7 @@ export function getSelectedGitFile(
     collapsedFolders: Record<string, true>
     fileListMode: GitFileListMode
     selectedEntryKey: string | null
+    compact?: boolean
   }
 ): GitFileEntry | null {
   const row = getSelectedGitRow(files, options)
@@ -105,9 +113,10 @@ export function reconcileSelectedGitEntryKey(
   collapsedFolders: Record<string, true>,
   fileListMode: GitFileListMode,
   selectedEntryKey: string | null | undefined,
-  preferredKeys: string[] = []
+  preferredKeys: string[] = [],
+  compact: boolean = false
 ): string | null {
-  const { visibleRows } = buildGitTreeRows(files, collapsedFolders, fileListMode)
+  const { visibleRows } = buildGitTreeRows(files, collapsedFolders, fileListMode, compact)
   if (visibleRows.length === 0) return null
   const candidates = [...preferredKeys, selectedEntryKey ?? '']
   for (const key of candidates) {
@@ -122,9 +131,10 @@ export function moveGitSelection(
   collapsedFolders: Record<string, true>,
   fileListMode: GitFileListMode,
   selectedEntryKey: string | null,
-  delta: -1 | 1
+  delta: -1 | 1,
+  compact: boolean = false
 ): string | null {
-  const { visibleRows } = buildGitTreeRows(files, collapsedFolders, fileListMode)
+  const { visibleRows } = buildGitTreeRows(files, collapsedFolders, fileListMode, compact)
   const total = visibleRows.length
   if (total === 0) return null
   const current = visibleRows.findIndex((row) => row.key === selectedEntryKey)
@@ -137,9 +147,10 @@ export function moveGitFileSelection(
   collapsedFolders: Record<string, true>,
   fileListMode: GitFileListMode,
   selectedEntryKey: string | null,
-  delta: -1 | 1
+  delta: -1 | 1,
+  compact: boolean = false
 ): string | null {
-  const { visibleRows } = buildGitTreeRows(files, collapsedFolders, fileListMode)
+  const { visibleRows } = buildGitTreeRows(files, collapsedFolders, fileListMode, compact)
   const fileRows = visibleRows.filter((row) => row.kind === 'file')
   const total = fileRows.length
   if (total === 0) return null
@@ -153,13 +164,14 @@ export function moveGitFileSelection(
 
 function flattenSectionRows(
   files: GitFileEntry[],
-  collapsedFolders: Record<string, true>
+  collapsedFolders: Record<string, true>,
+  compact: boolean
 ): GitTreeRow[] {
   if (files.length === 0) return []
   const section = files[0]?.section
   if (!section) return []
   const root = buildSectionTree(files, section)
-  return flattenTreeNode(root, collapsedFolders, 0)
+  return flattenTreeNode(root, collapsedFolders, 0, undefined, compact)
 }
 
 function buildSectionTree(files: GitFileEntry[], section: GitFileSection): GitTreeNode {
@@ -187,16 +199,28 @@ function flattenTreeNode(
   node: GitTreeNode,
   collapsedFolders: Record<string, true>,
   depth: number,
-  parentKey?: string
+  parentKey: string | undefined,
+  compact: boolean
 ): GitTreeRow[] {
   const rows: GitTreeRow[] = []
   for (const child of node.folders.values()) {
-    const name = child.path.split('/').pop() ?? child.path
-    const key = gitFolderKey(node.section, child.path)
+    // Compaction: while a folder has exactly one child folder and no direct
+    // files, fold the chain into a single row ("src/keymap/keymap.ts" instead
+    // of three nested rows).
+    let current = child
+    const segments: string[] = [current.path.split('/').pop() ?? current.path]
+    while (compact && current.files.length === 0 && current.folders.size === 1) {
+      const next = current.folders.values().next().value
+      if (!next) break
+      segments.push(next.path.split('/').pop() ?? next.path)
+      current = next
+    }
+    const name = segments.join('/')
+    const key = gitFolderKey(node.section, current.path)
     const isCollapsed = key in collapsedFolders
     rows.push({
       depth,
-      folderPath: child.path,
+      folderPath: current.path,
       isCollapsed,
       key,
       kind: 'folder',
@@ -204,7 +228,9 @@ function flattenTreeNode(
       parentKey,
       section: node.section,
     })
-    if (!isCollapsed) rows.push(...flattenTreeNode(child, collapsedFolders, depth + 1, key))
+    if (!isCollapsed) {
+      rows.push(...flattenTreeNode(current, collapsedFolders, depth + 1, key, compact))
+    }
   }
   for (const file of node.files) {
     rows.push({

package/src/state/reducers/diff-cache.ts

@@ -0,0 +1,64 @@
+import type { AppState } from '../types'
+
+export function clearDiffCacheForPath(state: AppState, path: string): AppState {
+  return clearDiffCacheForPaths(state, new Set([path]))
+}
+
+// Drops every cache slice derived from the given file paths: diffs, folds,
+// loading flags, parsed patches, and per-theme highlight tokens. Called when
+// a file's on-disk content shifts or a file disappears from git status.
+export function clearDiffCacheForPaths(state: AppState, paths: Set<string>): AppState {
+  if (paths.size === 0) return state
+  const nextDiffs = { ...state.gitMode.diffs }
+  const nextFolds = { ...state.gitMode.folds }
+  const nextLoading = { ...state.gitMode.loading }
+  const nextParsed = { ...state.gitMode.parsedFiles }
+  const nextHighlights = { ...state.gitMode.highlights }
+  let changed = false
+  const keyMatches = (key: string): boolean => {
+    for (const path of paths) {
+      if (key.endsWith(`:${path}`) || key.startsWith(`${path}|`) || key.includes(`:${path}|`)) {
+        return true
+      }
+    }
+    return false
+  }
+  for (const key of Object.keys(nextDiffs)) {
+    const entry = nextDiffs[key]
+    if (!entry || !paths.has(entry.path)) continue
+    delete nextDiffs[key]
+    changed = true
+  }
+  for (const key of Object.keys(nextFolds)) {
+    if (!keyMatches(key)) continue
+    delete nextFolds[key]
+    changed = true
+  }
+  for (const key of Object.keys(nextLoading)) {
+    if (!keyMatches(key)) continue
+    delete nextLoading[key]
+    changed = true
+  }
+  for (const key of Object.keys(nextParsed)) {
+    if (!keyMatches(key)) continue
+    delete nextParsed[key]
+    changed = true
+  }
+  for (const key of Object.keys(nextHighlights)) {
+    if (!keyMatches(key)) continue
+    delete nextHighlights[key]
+    changed = true
+  }
+  if (!changed) return state
+  return {
+    ...state,
+    gitMode: {
+      ...state.gitMode,
+      diffs: nextDiffs,
+      folds: nextFolds,
+      highlights: nextHighlights,
+      loading: nextLoading,
+      parsedFiles: nextParsed,
+    },
+  }
+}