@buildautomaton/cli 0.1.32 → 0.1.34

package/dist/index.js

@@ -23962,7 +23962,7 @@ function installBridgeProcessResilience() {
 }
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.32".length > 0 ? "0.1.32" : "0.0.0-dev";
+var CLI_VERSION = "0.1.34".length > 0 ? "0.1.34" : "0.0.0-dev";
 
 // src/connection/heartbeat/constants.ts
 var BRIDGE_APP_HEARTBEAT_INTERVAL_MS = 1e4;
@@ -25022,6 +25022,30 @@ function runPendingAuth(options) {
   };
 }
 
+// src/dev-servers/manager/dev-server-constants.ts
+var BRIDGE_CLOSE_DEV_SERVER_GRACE_MS = 0;
+var BRIDGE_SHUTDOWN_GRACE_MS = 8e3;
+
+// src/runtime/cli-process-interrupt.ts
+var cliImmediateShutdownRequested = false;
+function requestCliImmediateShutdown() {
+  cliImmediateShutdownRequested = true;
+}
+function isCliImmediateShutdownRequested() {
+  return cliImmediateShutdownRequested;
+}
+async function delayMsUnlessShutdownRequested(ms) {
+  if (ms <= 0) return true;
+  const end = Date.now() + ms;
+  while (Date.now() < end) {
+    if (isCliImmediateShutdownRequested()) return false;
+    const chunk = Math.min(50, end - Date.now());
+    if (chunk <= 0) break;
+    await new Promise((r) => setTimeout(r, chunk));
+  }
+  return !isCliImmediateShutdownRequested();
+}
+
 // src/sqlite/cli-database.ts
 import sqliteWasm from "node-sqlite3-wasm";
 
@@ -25325,6 +25349,12 @@ var { Database: SqliteDatabase } = sqliteWasm;
 var CLI_SQLITE_SYNC_RETRY_MAX = 40;
 var CLI_SQLITE_ASYNC_RETRY_MAX = 60;
 var CLI_SQLITE_ASYNC_BASE_DELAY_MS = 20;
+var CliSqliteInterrupted = class extends Error {
+  name = "CliSqliteInterrupted";
+  constructor() {
+    super("CLI SQLite interrupted (shutdown)");
+  }
+};
 function applyCliSqliteConcurrencyPragmas(db) {
   try {
     db.exec("PRAGMA journal_mode = WAL");
@@ -25335,7 +25365,7 @@ function applyCliSqliteConcurrencyPragmas(db) {
   } catch {
   }
   try {
-    db.run("PRAGMA busy_timeout = 8000");
+    db.run("PRAGMA busy_timeout = 500");
   } catch {
   }
 }
@@ -25356,26 +25386,42 @@ function safeCloseCliSqliteDatabase(db) {
 function closeAllCliSqliteConnections() {
 }
 function isCliSqliteLockError(e) {
+  if (e instanceof CliSqliteInterrupted) return false;
   const msg = e instanceof Error ? e.message : String(e);
   const lower = msg.toLowerCase();
   return lower.includes("database is locked") || lower.includes("sqlite_busy") || lower.includes("sqlite3_busy") || lower.includes("database") && lower.includes("locked");
 }
 function syncSleepMs(ms) {
   if (ms <= 0) return;
-  try {
-    const sab = new SharedArrayBuffer(4);
-    const ia = new Int32Array(sab);
-    Atomics.wait(ia, 0, 0, Math.min(ms, 1e4));
-  } catch {
-    const end = Date.now() + ms;
-    while (Date.now() < end) {
+  const deadline = Date.now() + ms;
+  while (Date.now() < deadline) {
+    if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+    const chunk = Math.min(80, deadline - Date.now());
+    if (chunk <= 0) break;
+    try {
+      const sab = new SharedArrayBuffer(4);
+      const ia = new Int32Array(sab);
+      Atomics.wait(ia, 0, 0, chunk);
+    } catch {
+      const end = Date.now() + chunk;
+      while (Date.now() < end) {
+        if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+      }
     }
   }
 }
-function asyncDelayMs(ms) {
-  return new Promise((resolve18) => setTimeout(resolve18, ms));
+async function asyncDelayMsInterruptible(ms) {
+  const end = Date.now() + ms;
+  while (Date.now() < end) {
+    if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+    const chunk = Math.min(50, end - Date.now());
+    if (chunk <= 0) break;
+    await new Promise((r) => setTimeout(r, chunk));
+    await yieldToEventLoop();
+  }
 }
 function openCliSqliteConnection(options) {
+  if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
   const sqlitePath = getCliSqlitePath();
   ensureCliSqliteParentDir(sqlitePath);
   const db = new SqliteDatabase(sqlitePath);
@@ -25392,6 +25438,7 @@ function openCliSqliteConnection(options) {
 }
 function withCliSqliteSync(fn, options) {
   for (let attempt = 1; attempt <= CLI_SQLITE_SYNC_RETRY_MAX; attempt++) {
+    if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
     let db;
     try {
       db = openCliSqliteConnection(options);
@@ -25402,6 +25449,7 @@ function withCliSqliteSync(fn, options) {
       }
     } catch (e) {
       safeCloseCliSqliteDatabase(db);
+      if (e instanceof CliSqliteInterrupted) throw e;
       if (!isCliSqliteLockError(e) || attempt === CLI_SQLITE_SYNC_RETRY_MAX) throw e;
       syncSleepMs(Math.min(500, 12 * attempt));
     }
@@ -25411,6 +25459,7 @@ function withCliSqliteSync(fn, options) {
 async function withCliSqlite(fn, options) {
   let lastError;
   for (let attempt = 1; attempt <= CLI_SQLITE_ASYNC_RETRY_MAX; attempt++) {
+    if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
     let db;
     try {
       db = openCliSqliteConnection(options);
@@ -25422,9 +25471,10 @@ async function withCliSqlite(fn, options) {
     } catch (e) {
       lastError = e;
       safeCloseCliSqliteDatabase(db);
+      if (e instanceof CliSqliteInterrupted) throw e;
       if (!isCliSqliteLockError(e) || attempt === CLI_SQLITE_ASYNC_RETRY_MAX) throw e;
       const delayMs = Math.min(600, CLI_SQLITE_ASYNC_BASE_DELAY_MS * attempt);
-      await asyncDelayMs(delayMs);
+      await asyncDelayMsInterruptible(delayMs);
       await yieldToEventLoop();
     }
   }
@@ -25437,9 +25487,9 @@ async function ensureCliSqliteInitialized(options) {
 
 // src/connection/close-bridge-connection.ts
 async function closeBridgeConnection(state, acpManager, devServerManager, log2) {
+  requestCliImmediateShutdown();
   const say = log2 ?? logImmediate;
   say("Cleaning up connections\u2026");
-  await new Promise((resolve18) => setImmediate(resolve18));
   state.closedByUser = true;
   clearReconnectQuietTimer(state.mainQuiet);
   clearReconnectQuietTimer(state.firehoseQuiet);
@@ -25476,7 +25526,7 @@ async function closeBridgeConnection(state, acpManager, devServerManager, log2)
   }
   if (devServerManager) {
     say("Stopping local dev server processes\u2026");
-    await devServerManager.shutdownAllGraceful();
+    await devServerManager.shutdownAllGraceful({ graceMs: BRIDGE_CLOSE_DEV_SERVER_GRACE_MS });
   }
   try {
     closeAllCliSqliteConnections();
@@ -25500,17 +25550,13 @@ function resolveSessionParentPathForAgentProcess(resolvedSessionParentPath) {
   return getBridgeRoot();
 }
 
-// src/git/session-git-queue.ts
-import { execFile as execFile7 } from "node:child_process";
+// src/git/snapshot/session-git-queue.ts
 import { readFile, stat } from "node:fs/promises";
-import { promisify as promisify7 } from "node:util";
 import * as path15 from "node:path";
 
-// src/git/pre-turn-snapshot.ts
+// src/git/snapshot/pre-turn-snapshot.ts
 import * as fs14 from "node:fs";
 import * as path14 from "node:path";
-import { execFile as execFile6 } from "node:child_process";
-import { promisify as promisify6 } from "node:util";
 
 // src/git/discover-repos.ts
 import * as fs13 from "node:fs";
@@ -30075,12 +30121,68 @@ function gitInstanceFactory(baseDir, options) {
 init_git_response_error();
 var simpleGit = gitInstanceFactory;
 
+// src/git/git-runtime.ts
+var activeGitChildProcesses = /* @__PURE__ */ new Set();
+function abortActiveGitChildProcesses() {
+  for (const child of activeGitChildProcesses) {
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+  }
+}
+var GitOperationAbortedError = class extends Error {
+  constructor(message = "Git operation aborted") {
+    super(message);
+    this.name = "GitOperationAbortedError";
+  }
+};
+function throwIfGitShutdownRequested() {
+  if (isCliImmediateShutdownRequested()) {
+    abortActiveGitChildProcesses();
+    throw new GitOperationAbortedError();
+  }
+}
+async function runGitTask(fn) {
+  throwIfGitShutdownRequested();
+  try {
+    const result = await fn();
+    throwIfGitShutdownRequested();
+    return result;
+  } catch (e) {
+    if (isCliImmediateShutdownRequested()) {
+      throw new GitOperationAbortedError();
+    }
+    throw e;
+  }
+}
+async function yieldToEventLoop2() {
+  throwIfGitShutdownRequested();
+  await new Promise((resolve18) => {
+    setImmediate(resolve18);
+  });
+  throwIfGitShutdownRequested();
+}
+async function forEachWithGitYield(items, fn) {
+  for (let i = 0; i < items.length; i++) {
+    if (i > 0 || items.length > 1) await yieldToEventLoop2();
+    await fn(items[i], i);
+  }
+}
+
 // src/git/cli-simple-git.ts
 function cliSimpleGit(baseDir) {
-  const git = simpleGit({ baseDir });
+  const git = simpleGit({
+    baseDir,
+    trimmed: true,
+    spawnOptions: {}
+  });
   git.outputHandler((command, stdout, stderr) => {
     const trace = isCliTrace();
     const onChunk = (label) => (chunk) => {
+      if (isCliImmediateShutdownRequested()) {
+        abortActiveGitChildProcesses();
+      }
       const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
       const line = text.replace(/\s+$/, "");
       if (trace && line) {
@@ -30169,17 +30271,37 @@ async function discoverGitReposUnderRoot(rootPath) {
   return out;
 }
 
-// src/git/pre-turn-snapshot.ts
+// src/git/git-exec.ts
+import { execFile as execFile6, spawn as spawn4 } from "node:child_process";
+import { promisify as promisify6 } from "node:util";
 var execFileAsync5 = promisify6(execFile6);
+async function execGitFile(args, options) {
+  throwIfGitShutdownRequested();
+  try {
+    const result = await execFileAsync5("git", args, {
+      maxBuffer: 10 * 1024 * 1024,
+      ...options
+    });
+    throwIfGitShutdownRequested();
+    return {
+      stdout: String(result.stdout ?? ""),
+      stderr: String(result.stderr ?? "")
+    };
+  } catch (e) {
+    if (isCliImmediateShutdownRequested()) {
+      throw new GitOperationAbortedError();
+    }
+    throw e;
+  }
+}
+
+// src/git/snapshot/pre-turn-snapshot.ts
 function snapshotsDirForCwd(agentCwd) {
   return path14.join(agentCwd, ".buildautomaton", "snapshots");
 }
 async function gitStashCreate(repoRoot, log2) {
   try {
-    const { stdout } = await execFileAsync5("git", ["stash", "create"], {
-      cwd: repoRoot,
-      maxBuffer: 10 * 1024 * 1024
-    });
+    const { stdout } = await execGitFile(["stash", "create"], { cwd: repoRoot });
     return stdout.trim();
   } catch (e) {
     log2(
@@ -30190,7 +30312,7 @@ async function gitStashCreate(repoRoot, log2) {
 }
 async function gitRun(repoRoot, args, log2, label) {
   try {
-    await execFileAsync5("git", args, { cwd: repoRoot, maxBuffer: 10 * 1024 * 1024 });
+    await execGitFile(args, { cwd: repoRoot });
     return { ok: true };
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
@@ -30224,10 +30346,10 @@ async function capturePreTurnSnapshot(options) {
     return { ok: false, error: "No git repos to snapshot" };
   }
   const repos = [];
-  for (const root of repoRoots) {
+  await forEachWithGitYield(repoRoots, async (root) => {
     const stashSha = await gitStashCreate(root, log2);
     repos.push({ path: root, stashSha });
-  }
+  });
   const dir = snapshotsDirForCwd(agentCwd);
   try {
     fs14.mkdirSync(dir, { recursive: true });
@@ -30262,17 +30384,25 @@ async function applyPreTurnSnapshot(filePath, log2) {
   if (!Array.isArray(data.repos)) {
     return { ok: false, error: "Invalid snapshot file" };
   }
-  for (const r of data.repos) {
-    if (!r.path) continue;
+  let applyError = null;
+  await forEachWithGitYield(data.repos, async (r) => {
+    if (applyError || !r.path) return;
     const reset = await gitRun(r.path, ["reset", "--hard", "HEAD"], log2, "reset --hard");
-    if (!reset.ok) return reset;
+    if (!reset.ok) {
+      applyError = reset;
+      return;
+    }
     const clean = await gitRun(r.path, ["clean", "-fd"], log2, "clean -fd");
-    if (!clean.ok) return clean;
+    if (!clean.ok) {
+      applyError = clean;
+      return;
+    }
     if (r.stashSha) {
       const ap = await gitRun(r.path, ["stash", "apply", r.stashSha], log2, "stash apply");
-      if (!ap.ok) return ap;
+      if (!ap.ok) applyError = ap;
     }
-  }
+  });
+  if (applyError?.ok === false) return applyError;
   log2(`[snapshot] Restored pre-turn state for ${data.runId.slice(0, 8)}\u2026`);
   return { ok: true };
 }
@@ -30280,8 +30410,7 @@ function snapshotFilePath(agentCwd, runId) {
   return path14.join(snapshotsDirForCwd(agentCwd), `${runId}.json`);
 }
 
-// src/git/session-git-queue.ts
-var execFileAsync6 = promisify7(execFile7);
+// src/git/snapshot/session-git-queue.ts
 var MAX_FULL_FILE_TEXT_BYTES = 512 * 1024;
 async function readWorkspaceFileAsUtf8(absPath) {
   try {
@@ -30310,35 +30439,28 @@ async function collectTurnGitDiffFromPreTurnSnapshot(options) {
     return;
   }
   const multiRepo = data.repos.length > 1;
-  for (const repo of data.repos) {
-    if (!repo.stashSha) continue;
+  await forEachWithGitYield(data.repos, async (repo) => {
+    if (!repo.stashSha) return;
     let namesRaw;
     try {
-      const { stdout } = await execFileAsync6("git", ["diff", "--name-only", repo.stashSha], {
-        cwd: repo.path,
-        maxBuffer: 10 * 1024 * 1024
-      });
+      const { stdout } = await execGitFile(["diff", "--name-only", repo.stashSha], { cwd: repo.path });
       namesRaw = stdout;
     } catch (e) {
       log2(
         `[session-git-queue] Git diff --name-only failed in ${repo.path}: ${e instanceof Error ? e.message : String(e)}`
       );
-      continue;
+      return;
     }
     const lines = namesRaw.split("\n").map((l) => l.trim()).filter(Boolean);
     const slug = path15.basename(repo.path).replace(/[^\w.-]+/g, "_") || "repo";
-    for (const rel of lines) {
-      if (rel.includes("..")) continue;
+    await forEachWithGitYield(lines, async (rel) => {
+      if (rel.includes("..")) return;
       try {
-        const { stdout: patchContent } = await execFileAsync6(
-          "git",
+        const { stdout: patchContent } = await execGitFile(
           ["diff", "--no-color", repo.stashSha, "--", rel],
-          {
-            cwd: repo.path,
-            maxBuffer: 50 * 1024 * 1024
-          }
+          { cwd: repo.path }
         );
-        if (!patchContent.trim()) continue;
+        if (!patchContent.trim()) return;
         const displayPath = multiRepo ? `${slug}/${rel}` : rel;
         const workspaceFilePath = path15.join(repo.path, rel);
         const newText = await readWorkspaceFileAsUtf8(workspaceFilePath);
@@ -30355,8 +30477,8 @@ async function collectTurnGitDiffFromPreTurnSnapshot(options) {
           `[session-git-queue] Git diff failed for ${rel}: ${e instanceof Error ? e.message : String(e)}`
         );
       }
-    }
-  }
+    });
+  });
 }
 
 // src/agents/acp/put-summarize-change-summaries.ts
@@ -30722,34 +30844,50 @@ __export(claude_code_acp_client_exports, {
   createClaudeCodeAcpClient: () => createClaudeCodeAcpClient,
   detectLocalAgentPresence: () => detectLocalAgentPresence
 });
-import { execFile as execFile9 } from "node:child_process";
-import { promisify as promisify9 } from "node:util";
 
 // src/agents/acp/clients/detect-command-on-path.ts
-import { execFile as execFile8 } from "node:child_process";
-import { promisify as promisify8 } from "node:util";
-var execFileAsync7 = promisify8(execFile8);
-async function isCommandOnPath(command, timeoutMs = 4e3) {
+import { execFile as execFile7 } from "node:child_process";
+import { promisify as promisify7 } from "node:util";
+var execFileAsync6 = promisify7(execFile7);
+var COMMAND_ON_PATH_PROBE_TIMEOUT_MS = 750;
+async function execFileShutdownAware(file2, args, timeoutMs) {
+  if (isCliImmediateShutdownRequested()) throw new Error("shutdown");
+  const ac = new AbortController();
+  const shutdownPoll = setInterval(() => {
+    if (isCliImmediateShutdownRequested()) ac.abort();
+  }, 50);
+  shutdownPoll.unref?.();
+  try {
+    await execFileAsync6(file2, args, { timeout: timeoutMs, signal: ac.signal });
+  } finally {
+    clearInterval(shutdownPoll);
+  }
+}
+async function isCommandOnPath(command, timeoutMs = COMMAND_ON_PATH_PROBE_TIMEOUT_MS) {
+  if (isCliImmediateShutdownRequested()) return false;
   try {
-    await execFileAsync7("which", [command], { timeout: timeoutMs });
+    await execFileShutdownAware("which", [command], timeoutMs);
     return true;
   } catch {
     return false;
   }
 }
-
-// src/agents/acp/clients/claude-code-acp-client.ts
-var execFileAsync8 = promisify9(execFile9);
-var BACKEND_LOCAL_AGENT_TYPE = "claude-code";
-async function detectLocalAgentPresence() {
-  if (await isCommandOnPath("claude")) return true;
+async function execProbeShutdownAware(file2, args, timeoutMs) {
+  if (isCliImmediateShutdownRequested()) return false;
   try {
-    await execFileAsync8("npx", ["--yes", "@anthropic-ai/claude-code", "--version"], { timeout: 25e3 });
+    await execFileShutdownAware(file2, args, timeoutMs);
     return true;
   } catch {
     return false;
   }
 }
+
+// src/agents/acp/clients/claude-code-acp-client.ts
+var BACKEND_LOCAL_AGENT_TYPE = "claude-code";
+async function detectLocalAgentPresence() {
+  if (await isCommandOnPath("claude")) return true;
+  return execProbeShutdownAware("npx", ["--yes", "@anthropic-ai/claude-code", "--version"], 3e3);
+}
 function buildClaudeCodeAcpSpawnCommand(base, _sessionMode) {
   return [...base];
 }
@@ -30800,7 +30938,7 @@ __export(cursor_acp_client_exports, {
   createCursorAcpClient: () => createCursorAcpClient,
   detectLocalAgentPresence: () => detectLocalAgentPresence3
 });
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 import * as readline from "node:readline";
 
 // src/agents/acp/format-session-update-kind-for-log.ts
@@ -30870,7 +31008,7 @@ async function createCursorAcpClient(options) {
   } = options;
   const dbgFs = process.env.BUILDAUTOMATON_DEBUG_ACP_FS === "1";
   const isWindows = process.platform === "win32";
-  const child = spawn4(command[0], command.slice(1), {
+  const child = spawn5(command[0], command.slice(1), {
     cwd,
     stdio: ["pipe", "pipe", "pipe"],
     env: process.env,
@@ -32316,7 +32454,7 @@ import os8 from "node:os";
 import * as fs17 from "node:fs";
 import * as path20 from "node:path";
 
-// src/git/worktree-add.ts
+// src/git/worktrees/worktree-add.ts
 async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch) {
   const mainGit = cliSimpleGit(mainRepoPath);
   await mainGit.raw(["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
@@ -32421,7 +32559,7 @@ async function prepareNewSessionWorktrees(options) {
   };
 }
 
-// src/git/rename-branch.ts
+// src/git/branches/rename-branch.ts
 async function gitRenameCurrentBranch(repoDir, newName) {
   const g = cliSimpleGit(repoDir);
   await g.raw(["branch", "-m", newName]);
@@ -32445,10 +32583,10 @@ async function renameSessionWorktreeBranches(paths, newBranch, log2) {
 // src/worktrees/remove-session-worktrees.ts
 import * as fs20 from "node:fs";
 
-// src/git/worktree-remove.ts
+// src/git/worktrees/worktree-remove.ts
 import * as fs19 from "node:fs";
 
-// src/git/resolve-main-repo-from-git-file.ts
+// src/git/worktrees/resolve-main-repo-from-git-file.ts
 import * as fs18 from "node:fs";
 import * as path21 from "node:path";
 function resolveMainRepoFromWorktreeGitFile(wt) {
@@ -32462,7 +32600,7 @@ function resolveMainRepoFromWorktreeGitFile(wt) {
   return path21.dirname(gitDir);
 }
 
-// src/git/worktree-remove.ts
+// src/git/worktrees/worktree-remove.ts
 async function gitWorktreeRemoveForce(worktreePath) {
   const mainRepo = resolveMainRepoFromWorktreeGitFile(worktreePath);
   if (mainRepo) {
@@ -32488,7 +32626,88 @@ async function removeSessionWorktrees(paths, log2) {
   }
 }
 
-// src/git/working-directory/status/working-tree-status.ts
+// src/git/changes/lib/parse-git-status.ts
+function parseNameStatusLines(lines) {
+  const m = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const tabParts = line.split("	");
+    if (tabParts.length < 2) continue;
+    const status = tabParts[0].trim();
+    const code = status[0];
+    if (code === "A") {
+      m.set(tabParts[tabParts.length - 1], "added");
+    } else if (code === "D") {
+      m.set(tabParts[tabParts.length - 1], "removed");
+    } else if (code === "R" || code === "C") {
+      if (tabParts.length >= 3) m.set(tabParts[tabParts.length - 1], "modified");
+    } else if (code === "M" || code === "U" || code === "T") {
+      m.set(tabParts[tabParts.length - 1], "modified");
+    }
+  }
+  return m;
+}
+function parseNumstatFirstLine(line) {
+  const parts = line.split("	");
+  if (parts.length < 3) return null;
+  const [a, d] = parts;
+  const additions = a === "-" ? 0 : parseInt(String(a), 10) || 0;
+  const deletions = d === "-" ? 0 : parseInt(String(d), 10) || 0;
+  return { additions, deletions };
+}
+function parseNumstat(lines) {
+  const m = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const parts = line.split("	");
+    if (parts.length < 3) continue;
+    const [a, d, p] = parts;
+    const additions = a === "-" ? 0 : parseInt(String(a), 10) || 0;
+    const deletions = d === "-" ? 0 : parseInt(String(d), 10) || 0;
+    m.set(p, { additions, deletions });
+  }
+  return m;
+}
+async function numstatFromGitNoIndex(g, pathInRepo) {
+  const devNull = process.platform === "win32" ? "NUL" : "/dev/null";
+  try {
+    const out = await g.raw(["diff", "--numstat", "--no-index", "--", devNull, pathInRepo]);
+    const first2 = String(out).split("\n").find((l) => l.trim()) ?? "";
+    return parseNumstatFirstLine(first2);
+  } catch {
+    return null;
+  }
+}
+
+// src/git/changes/lib/working-tree-changed-path-count.ts
+function workingTreeChangedPathCount(nameStatusLines, numstatLines, untrackedLines) {
+  const kindByPath = parseNameStatusLines(nameStatusLines);
+  const numByPath = parseNumstat(numstatLines);
+  const paths = /* @__PURE__ */ new Set([...kindByPath.keys(), ...numByPath.keys()]);
+  for (const p of untrackedLines.map((s) => s.trim()).filter(Boolean)) {
+    paths.add(p);
+  }
+  return paths.size;
+}
+
+// src/git/changes/count-working-tree-changed-files.ts
+async function countWorkingTreeChangedFilesForRepo(repoGitCwd) {
+  return runGitTask(async () => {
+    const g = cliSimpleGit(repoGitCwd);
+    const [nameStatusRaw, numstatRaw, untrackedRaw] = await Promise.all([
+      g.raw(["diff", "--name-status", "HEAD"]).catch(() => ""),
+      g.raw(["diff", "HEAD", "--numstat"]).catch(() => ""),
+      g.raw(["ls-files", "--others", "--exclude-standard"]).catch(() => "")
+    ]);
+    return workingTreeChangedPathCount(
+      String(nameStatusRaw).split("\n"),
+      String(numstatRaw).split("\n"),
+      String(untrackedRaw).split("\n")
+    );
+  });
+}
+
+// src/git/commits/resolve-remote-tracking.ts
 async function tryConfigGet(g, key) {
   try {
     const out = await g.raw(["config", "--get", key]);
@@ -32571,30 +32790,6 @@ async function resolveBaseShaForUnpushedCommits(g) {
   if (!defaultRef) return null;
   return revParseSafe(g, defaultRef);
 }
-function parseLogShaDateSubjectLines(raw) {
-  const out = [];
-  for (const line of String(raw).split("\n")) {
-    const l = line.trimEnd();
-    if (!l.trim()) continue;
-    const parts = l.split("	");
-    if (parts.length < 3) continue;
-    const sha = parts[0].trim();
-    const committedAt = parts[1].trim();
-    const subject = parts.slice(2).join("	").trim();
-    if (!/^[0-9a-f]{7,40}$/i.test(sha)) continue;
-    out.push({ sha, shortSha: sha.slice(0, 7), subject, committedAt });
-  }
-  return out;
-}
-async function gitLogNotReachableFromBase(g, baseSha, headSha) {
-  if (baseSha === headSha) return [];
-  try {
-    const logOut = await g.raw(["log", "--format=%H	%cI	%s", `${baseSha}..${headSha}`]);
-    return parseLogShaDateSubjectLines(logOut);
-  } catch {
-    return [];
-  }
-}
 async function commitsAheadOfRemoteTracking(repoDir) {
   const g = cliSimpleGit(repoDir);
   const headSha = await revParseSafe(g, "HEAD");
@@ -32609,44 +32804,41 @@ async function commitsAheadOfRemoteTracking(repoDir) {
     return 0;
   }
 }
+
+// src/git/status/working-tree-status.ts
 async function getRepoWorkingTreeStatus(repoDir) {
-  const g = cliSimpleGit(repoDir);
-  const st = await g.status();
-  const hasUncommittedChanges = (st.files?.length ?? 0) > 0;
-  const ahead = await commitsAheadOfRemoteTracking(repoDir);
-  return { hasUncommittedChanges, hasUnpushedCommits: ahead > 0 };
-}
-async function listUnpushedCommits(repoDir) {
-  const g = cliSimpleGit(repoDir);
-  const headSha = await revParseSafe(g, "HEAD");
-  if (!headSha) return [];
-  const baseSha = await resolveBaseShaForUnpushedCommits(g);
-  if (!baseSha) return [];
-  return gitLogNotReachableFromBase(g, baseSha, headSha);
+  return runGitTask(async () => {
+    const uncommittedFileCount = await countWorkingTreeChangedFilesForRepo(repoDir);
+    const hasUncommittedChanges = uncommittedFileCount > 0;
+    const ahead = await commitsAheadOfRemoteTracking(repoDir);
+    return { hasUncommittedChanges, hasUnpushedCommits: ahead > 0, uncommittedFileCount };
+  });
 }
 async function aggregateSessionPathsWorkingTreeStatus(paths) {
   let hasUncommittedChanges = false;
   let hasUnpushedCommits = false;
-  for (const p of paths) {
+  let uncommittedFileCount = 0;
+  await forEachWithGitYield(paths, async (p) => {
     const s = await getRepoWorkingTreeStatus(p);
+    uncommittedFileCount += s.uncommittedFileCount;
     if (s.hasUncommittedChanges) hasUncommittedChanges = true;
     if (s.hasUnpushedCommits) hasUnpushedCommits = true;
-  }
-  return { hasUncommittedChanges, hasUnpushedCommits };
+  });
+  return { hasUncommittedChanges, hasUnpushedCommits, uncommittedFileCount };
 }
 async function pushAheadOfUpstreamForPaths(paths) {
-  for (const p of paths) {
+  await forEachWithGitYield(paths, async (p) => {
     const g = cliSimpleGit(p);
     const ahead = await commitsAheadOfRemoteTracking(p);
-    if (ahead <= 0) continue;
+    if (ahead <= 0) return;
     await g.push();
-  }
+  });
 }
 
-// src/git/working-directory/changes/types.ts
+// src/git/changes/types.ts
 var MAX_PATCH_CHARS = 35e4;
 
-// src/git/working-directory/changes/repo-format.ts
+// src/git/changes/lib/repo-format.ts
 function posixJoinDirFile(dir, file2) {
   const d = dir === "." || dir === "" ? "" : dir.replace(/\\/g, "/").replace(/\/+$/, "");
   const f = file2.replace(/\\/g, "/").replace(/^\/+/, "");
@@ -32700,63 +32892,80 @@ function formatRemoteDisplayLabel(remoteUrl) {
   return `origin \xB7 ${hostPath}`;
 }
 
-// src/git/working-directory/changes/get-working-tree-change-repo-details.ts
+// src/git/changes/get-working-tree-change-repo-details.ts
 import * as path23 from "node:path";
 
-// src/git/working-directory/changes/parse-git-status.ts
-function parseNameStatusLines(lines) {
-  const m = /* @__PURE__ */ new Map();
-  for (const line of lines) {
-    if (!line.trim()) continue;
-    const tabParts = line.split("	");
-    if (tabParts.length < 2) continue;
-    const status = tabParts[0].trim();
-    const code = status[0];
-    if (code === "A") {
-      m.set(tabParts[tabParts.length - 1], "added");
-    } else if (code === "D") {
-      m.set(tabParts[tabParts.length - 1], "removed");
-    } else if (code === "R" || code === "C") {
-      if (tabParts.length >= 3) m.set(tabParts[tabParts.length - 1], "modified");
-    } else if (code === "M" || code === "U" || code === "T") {
-      m.set(tabParts[tabParts.length - 1], "modified");
-    }
+// src/git/commits/lib/parse-log-lines.ts
+function parseLogShaDateSubjectLines(raw) {
+  const out = [];
+  for (const line of String(raw).split("\n")) {
+    const l = line.trimEnd();
+    if (!l.trim()) continue;
+    const parts = l.split("	");
+    if (parts.length < 3) continue;
+    const sha = parts[0].trim();
+    const committedAt = parts[1].trim();
+    const subject = parts.slice(2).join("	").trim();
+    if (!/^[0-9a-f]{7,40}$/i.test(sha)) continue;
+    out.push({ sha, shortSha: sha.slice(0, 7), subject, committedAt });
   }
-  return m;
-}
-function parseNumstatFirstLine(line) {
-  const parts = line.split("	");
-  if (parts.length < 3) return null;
-  const [a, d] = parts;
-  const additions = a === "-" ? 0 : parseInt(String(a), 10) || 0;
-  const deletions = d === "-" ? 0 : parseInt(String(d), 10) || 0;
-  return { additions, deletions };
+  return out;
 }
-function parseNumstat(lines) {
-  const m = /* @__PURE__ */ new Map();
-  for (const line of lines) {
-    if (!line.trim()) continue;
-    const parts = line.split("	");
-    if (parts.length < 3) continue;
-    const [a, d, p] = parts;
-    const additions = a === "-" ? 0 : parseInt(String(a), 10) || 0;
-    const deletions = d === "-" ? 0 : parseInt(String(d), 10) || 0;
-    m.set(p, { additions, deletions });
+
+// src/git/commits/list-unpushed-commits.ts
+async function gitLogNotReachableFromBase(g, baseSha, headSha) {
+  if (baseSha === headSha) return [];
+  try {
+    const logOut = await g.raw(["log", "--format=%H	%cI	%s", `${baseSha}..${headSha}`]);
+    return parseLogShaDateSubjectLines(logOut);
+  } catch {
+    return [];
   }
-  return m;
 }
-async function numstatFromGitNoIndex(g, pathInRepo) {
-  const devNull = process.platform === "win32" ? "NUL" : "/dev/null";
+async function listUnpushedCommits(repoDir) {
+  const g = cliSimpleGit(repoDir);
+  const headSha = await revParseSafe(g, "HEAD");
+  if (!headSha) return [];
+  const baseSha = await resolveBaseShaForUnpushedCommits(g);
+  if (!baseSha) return [];
+  return gitLogNotReachableFromBase(g, baseSha, headSha);
+}
+
+// src/git/commits/lib/sanitize-recent-commits-limit.ts
+var RECENT_COMMITS_LIMIT_MIN = 1;
+var RECENT_COMMITS_LIMIT_MAX = 50;
+var RECENT_COMMITS_LIMIT_DEFAULT = 2;
+function sanitizeRecentCommitsLimit(value) {
+  const n = typeof value === "number" ? value : typeof value === "string" ? Number.parseInt(value.trim(), 10) : Number.NaN;
+  if (!Number.isFinite(n)) return RECENT_COMMITS_LIMIT_DEFAULT;
+  return Math.min(RECENT_COMMITS_LIMIT_MAX, Math.max(RECENT_COMMITS_LIMIT_MIN, Math.trunc(n)));
+}
+
+// src/git/commits/list-recent-commits.ts
+async function listRecentCommits(repoDir, limitInput) {
+  const limit = sanitizeRecentCommitsLimit(limitInput);
+  const g = cliSimpleGit(repoDir);
+  const headSha = await revParseSafe(g, "HEAD");
+  if (!headSha) return { commits: [], hasMore: false };
+  const unpushedSet = new Set((await listUnpushedCommits(repoDir)).map((c) => c.sha));
   try {
-    const out = await g.raw(["diff", "--numstat", "--no-index", "--", devNull, pathInRepo]);
-    const first2 = String(out).split("\n").find((l) => l.trim()) ?? "";
-    return parseNumstatFirstLine(first2);
+    const logOut = await g.raw(["log", "--format=%H	%cI	%s", `-n`, String(limit), "HEAD"]);
+    const commits = parseLogShaDateSubjectLines(logOut).map((c) => ({
+      ...c,
+      needsPush: unpushedSet.has(c.sha)
+    }));
+    let hasMore = false;
+    if (commits.length === limit) {
+      const nextOut = await g.raw(["log", "-n", "1", `--skip=${limit}`, "--format=%H", "HEAD"]);
+      hasMore = /^[0-9a-f]{7,40}$/i.test(String(nextOut).trim());
+    }
+    return { commits, hasMore };
   } catch {
-    return null;
+    return { commits: [], hasMore: false };
   }
 }
 
-// src/git/working-directory/changes/patch-truncate.ts
+// src/git/changes/lib/patch-truncate.ts
 function truncatePatch(s) {
   if (s.length <= MAX_PATCH_CHARS) return s;
   return `${s.slice(0, MAX_PATCH_CHARS)}
@@ -32764,7 +32973,7 @@ function truncatePatch(s) {
 \u2026 (diff truncated)`;
 }
 
-// src/git/working-directory/changes/list-changed-files-for-commit.ts
+// src/git/commits/list-changed-files-for-commit.ts
 var EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 async function parentForCommitDiff(g, sha) {
   try {
@@ -32790,7 +32999,7 @@ async function listChangedFilesForCommit(repoGitCwd, repoRelPath, commitSha) {
   const paths = new Set([...kindByPath.keys(), ...numByPath.keys()].filter(Boolean));
   const rows = [];
   const normRel = repoRelPath === "." || repoRelPath === "" ? "." : repoRelPath;
-  for (const pathInRepo of paths) {
+  await forEachWithGitYield([...paths], async (pathInRepo) => {
     const relLauncher = posixJoinDirFile(normRel, pathInRepo.replace(/\\/g, "/"));
     const nums = numByPath.get(pathInRepo);
     let additions = nums?.additions ?? 0;
@@ -32802,8 +33011,8 @@ async function listChangedFilesForCommit(repoGitCwd, repoRelPath, commitSha) {
       else change = "modified";
     }
     rows.push({ pathRelLauncher: relLauncher, additions, deletions, change });
-  }
-  for (const row of rows) {
+  });
+  await forEachWithGitYield(rows, async (row) => {
     let pathInRepo;
     if (normRel === ".") {
       pathInRepo = row.pathRelLauncher;
@@ -32815,16 +33024,16 @@ async function listChangedFilesForCommit(repoGitCwd, repoRelPath, commitSha) {
     const raw = await g.raw(["diff", "-U20000", range, "--", pathInRepo]).catch(() => "");
     const t = String(raw).trim();
     row.patchContent = t ? truncatePatch(t) : void 0;
-  }
+  });
   rows.sort((a, b) => a.pathRelLauncher.localeCompare(b.pathRelLauncher));
   return rows;
 }
 
-// src/git/working-directory/changes/list-changed-files-for-repo.ts
+// src/git/changes/list-changed-files-for-repo.ts
 import * as fs22 from "node:fs";
 import * as path22 from "node:path";
 
-// src/git/working-directory/changes/count-lines.ts
+// src/git/changes/lib/count-lines.ts
 import { createReadStream } from "node:fs";
 import * as readline2 from "node:readline";
 async function countTextFileLines(filePath) {
@@ -32845,7 +33054,7 @@ async function countTextFileLines(filePath) {
   return lines;
 }
 
-// src/git/working-directory/changes/hydrate-patch.ts
+// src/git/changes/hydrate-patch.ts
 import * as fs21 from "node:fs";
 var UNIFIED_HUNK_HEADER_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
 var MAX_HYDRATE_LINES_PER_GAP = 8e3;
@@ -32961,26 +33170,16 @@ async function hydrateUnifiedPatchWithFileContext(patch, filePath, repoGitCwd, p
   return truncatePatch(out.join("\n"));
 }
 
-// src/git/working-directory/changes/unified-diff-for-file.ts
+// src/git/changes/unified-diff-for-file.ts
 async function unifiedDiffForFile(repoCwd, pathInRepo, change) {
   const g = cliSimpleGit(repoCwd);
-  try {
-    let raw;
-    if (change === "added") {
-      const devNull = process.platform === "win32" ? "NUL" : "/dev/null";
-      raw = await g.raw(["diff", "--no-index", "--", devNull, pathInRepo]);
-    } else {
-      raw = await g.raw(["diff", "HEAD", "--", pathInRepo]);
-    }
-    const t = String(raw).trim();
-    if (!t) return void 0;
-    return truncatePatch(t);
-  } catch {
-    return void 0;
-  }
+  const args = change === "added" ? ["diff", "--no-color", "HEAD", "--", pathInRepo] : change === "removed" ? ["diff", "--no-color", "HEAD", "--", pathInRepo] : ["diff", "--no-color", "HEAD", "--", pathInRepo];
+  const raw = await g.raw([...args]).catch(() => "");
+  const t = String(raw).trim();
+  return t ? truncatePatch(t) : void 0;
 }
 
-// src/git/working-directory/changes/list-changed-files-for-repo.ts
+// src/git/changes/list-changed-files-for-repo.ts
 async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
   const g = cliSimpleGit(repoGitCwd);
   const [nameStatusRaw, numstatRaw, untrackedRaw] = await Promise.all([
@@ -32994,7 +33193,7 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
   const untracked = String(untrackedRaw).split("\n").map((s) => s.trim()).filter(Boolean);
   for (const p of untracked) paths.add(p);
   const rows = [];
-  for (const pathInRepo of paths) {
+  await forEachWithGitYield([...paths], async (pathInRepo) => {
     const relLauncher = posixJoinDirFile(repoRelPath, pathInRepo.replace(/\\/g, "/"));
     const repoFilePath = path22.join(repoGitCwd, pathInRepo);
     const nums = numByPath.get(pathInRepo);
@@ -33024,9 +33223,9 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
       else change = "modified";
     }
     rows.push({ pathRelLauncher: relLauncher, additions, deletions, change });
-  }
+  });
   const normRel = repoRelPath === "." || repoRelPath === "" ? "." : repoRelPath;
-  for (const row of rows) {
+  await forEachWithGitYield(rows, async (row) => {
     let pathInRepo;
     if (normRel === ".") {
       pathInRepo = row.pathRelLauncher;
@@ -33041,11 +33240,11 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
       patch = await hydrateUnifiedPatchWithFileContext(patch, filePath, repoGitCwd, pathInRepo, row.change);
     }
     row.patchContent = patch;
-  }
+  });
   return rows;
 }
 
-// src/git/working-directory/changes/get-working-tree-change-repo-details.ts
+// src/git/changes/get-working-tree-change-repo-details.ts
 function normRepoRel(p) {
   const x = p.replace(/\\/g, "/").trim();
   return x === "" ? "." : x;
@@ -33064,7 +33263,9 @@ async function getWorkingTreeChangeRepoDetails(options) {
     throw new Error("commit sha is required for commit changes");
   }
   const basis = filter == null && basisInput.kind === "commit" ? { kind: "working" } : basisInput;
-  for (const target of options.commitTargetPaths) {
+  for (let i = 0; i < options.commitTargetPaths.length; i++) {
+    if (i > 0) await yieldToEventLoop2();
+    const target = options.commitTargetPaths[i];
     const t = path23.resolve(target);
     if (!await isGitRepoDirectory(t)) continue;
     const g = cliSimpleGit(t);
@@ -33098,7 +33299,10 @@ async function getWorkingTreeChangeRepoDetails(options) {
     const files = basis.kind === "commit" ? await listChangedFilesForCommit(t, relForList, basis.sha.trim()) : await listChangedFilesForRepo(t, relForList);
     const st = await g.status();
     const hasUncommittedChanges = (st.files?.length ?? 0) > 0;
-    const unpushedCommits = await listUnpushedCommits(t);
+    const [unpushedCommits, recentCommitList] = await Promise.all([
+      listUnpushedCommits(t),
+      listRecentCommits(t, options.recentCommitsLimit)
+    ]);
     out.push({
       repoRelPath: norm,
       repoDisplayName,
@@ -33108,6 +33312,8 @@ async function getWorkingTreeChangeRepoDetails(options) {
       files,
       hasUncommittedChanges,
       unpushedCommits,
+      recentCommits: recentCommitList.commits,
+      recentCommitsHasMore: recentCommitList.hasMore,
       changesView: basis.kind === "commit" ? "commit" : "working",
       changesCommitSha: basis.kind === "commit" ? basis.sha.trim() : null
     });
@@ -33116,7 +33322,7 @@ async function getWorkingTreeChangeRepoDetails(options) {
   return out;
 }
 
-// src/git/commit-and-push.ts
+// src/git/branches/commit-and-push.ts
 async function gitCommitAllIfDirty(repoDir, message, options) {
   const g = cliSimpleGit(repoDir);
   const st = await g.status();
@@ -33540,7 +33746,8 @@ var SessionWorktreeManager = class {
       sessionWorktreeRootPath: sessionWorkingTreeRelRoot,
       legacyRepoNestedSessionLayout: legacyNested,
       repoFilterRelPath: opts?.repoRelPath?.trim() ? opts.repoRelPath.trim() : null,
-      basis: opts?.basis
+      basis: opts?.basis,
+      recentCommitsLimit: opts?.recentCommitsLimit
     });
   }
   async pushSessionUpstream(sessionId) {
@@ -33577,30 +33784,39 @@ import path27 from "node:path";
 function shouldSkipWorkspaceWalkEntry(name) {
   return name.startsWith(".");
 }
-function walkWorkspaceTreeSync(dir, baseDir, onFile) {
+async function walkWorkspaceTreeAsync(dir, baseDir, onFile, state) {
   let names;
   try {
-    names = fs24.readdirSync(dir);
+    names = await fs24.promises.readdir(dir);
   } catch {
     return;
   }
   for (const name of names) {
     if (shouldSkipWorkspaceWalkEntry(name)) continue;
+    if (state.n > 0 && state.n % INDEX_WORK_YIELD_EVERY === 0) {
+      if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+      await yieldToEventLoop();
+      if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+    }
+    state.n++;
     const full = path27.join(dir, name);
     let stat2;
     try {
-      stat2 = fs24.statSync(full);
+      stat2 = await fs24.promises.stat(full);
     } catch {
       continue;
     }
     const relative5 = path27.relative(baseDir, full).replace(/\\/g, "/");
     if (stat2.isDirectory()) {
-      walkWorkspaceTreeSync(full, baseDir, onFile);
+      await walkWorkspaceTreeAsync(full, baseDir, onFile, state);
     } else if (stat2.isFile()) {
       onFile(relative5);
     }
   }
 }
+function createWalkYieldState() {
+  return { n: 0 };
+}
 
 // src/files/index/file-index-sqlite-lock.ts
 import fs25 from "node:fs";
@@ -33633,29 +33849,28 @@ function withFileIndexSqliteLock(fn) {
 }
 
 // src/files/index/build-file-index.ts
-var FILE_INDEX_INSERT_BUFFER = 2048;
-function persistFileIndexForResolvedCwd(resolved) {
+var FILE_INDEX_INTERRUPT_CHECK_EVERY = 256;
+function assertNotShutdown() {
+  if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+}
+function persistFileIndexPaths(resolved, paths) {
   return withCliSqliteSync((db) => {
     const h = getCwdHashForFileIndex(resolved);
-    const buf = [];
     let pathCount = 0;
     db.run("BEGIN IMMEDIATE");
     try {
       db.run("DELETE FROM file_index_path WHERE cwd_hash = ?", [h]);
       const ins = db.prepare("INSERT INTO file_index_path (cwd_hash, path) VALUES (?, ?)");
       try {
-        const flushBuf = () => {
-          for (const rel of buf) {
-            ins.run([h, rel]);
+        let batch = 0;
+        for (const rel of paths) {
+          if (++batch >= FILE_INDEX_INTERRUPT_CHECK_EVERY) {
+            batch = 0;
+            assertNotShutdown();
           }
-          pathCount += buf.length;
-          buf.length = 0;
-        };
-        walkWorkspaceTreeSync(resolved, resolved, (rel) => {
-          buf.push(rel);
-          if (buf.length >= FILE_INDEX_INSERT_BUFFER) flushBuf();
-        });
-        flushBuf();
+          ins.run([h, rel]);
+          pathCount += 1;
+        }
       } finally {
         ins.finalize();
       }
@@ -33670,12 +33885,24 @@ function persistFileIndexForResolvedCwd(resolved) {
     return pathCount;
   });
 }
+async function collectWorkspacePathsAsync(resolved) {
+  const paths = [];
+  const state = createWalkYieldState();
+  await walkWorkspaceTreeAsync(resolved, resolved, (rel) => {
+    assertNotShutdown();
+    paths.push(rel);
+  }, state);
+  return paths;
+}
 async function buildFileIndexAsync(cwd) {
   return withFileIndexSqliteLock(async () => {
     const resolved = path28.resolve(cwd);
     await yieldToEventLoop();
-    const pathCount = persistFileIndexForResolvedCwd(resolved);
+    assertNotShutdown();
+    const paths = await collectWorkspacePathsAsync(resolved);
     await yieldToEventLoop();
+    assertNotShutdown();
+    const pathCount = persistFileIndexPaths(resolved, paths);
     return { pathCount };
   });
 }
@@ -33779,11 +34006,13 @@ function createFsWatcher(resolved, schedule) {
 function startFileIndexWatcher(cwd = getBridgeRoot()) {
   const resolved = path30.resolve(cwd);
   void buildFileIndexAsync(resolved).catch((e) => {
+    if (e instanceof CliSqliteInterrupted) return;
     console.error("[file-index] Initial index build failed:", e);
   });
   let timer = null;
   const runRebuild = () => {
     void buildFileIndexAsync(resolved).catch((e) => {
+      if (e instanceof CliSqliteInterrupted) return;
       console.error("[file-index] Watch rebuild failed:", e);
     });
   };
@@ -34048,7 +34277,7 @@ function pipedStdoutStderrFor(attemptStdio) {
 }
 
 // src/dev-servers/manager/shell-spawn/try-spawn-piped-via-sh.ts
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 function trySpawnPipedViaSh(command, env, cwd, signal) {
   const attempts = [
     { stdio: [devNullReadFd(), "pipe", "pipe"], endStdin: false },
@@ -34069,9 +34298,9 @@ function trySpawnPipedViaSh(command, env, cwd, signal) {
       if (process.platform === "win32") {
         opts.windowsHide = true;
         const com = process.env.ComSpec || "cmd.exe";
-        proc = spawn5(com, ["/d", "/s", "/c", command], opts);
+        proc = spawn6(com, ["/d", "/s", "/c", command], opts);
       } else {
-        proc = spawn5("/bin/sh", ["-c", command], opts);
+        proc = spawn6("/bin/sh", ["-c", command], opts);
       }
       if (attempt.endStdin) {
         proc.stdin?.end();
@@ -34091,7 +34320,7 @@ function trySpawnPipedViaSh(command, env, cwd, signal) {
 }
 
 // src/dev-servers/manager/shell-spawn/try-spawn-shell-true-piped.ts
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 function trySpawnShellTruePiped(command, env, cwd, devNullFd, signal) {
   try {
     const opts = {
@@ -34104,7 +34333,7 @@ function trySpawnShellTruePiped(command, env, cwd, devNullFd, signal) {
     if (process.platform === "win32") {
       opts.windowsHide = true;
     }
-    return spawn6(command, opts);
+    return spawn7(command, opts);
   } catch (e) {
     if (isSpawnEbadf(e)) return null;
     throw e;
@@ -34112,7 +34341,7 @@ function trySpawnShellTruePiped(command, env, cwd, devNullFd, signal) {
 }
 
 // src/dev-servers/manager/shell-spawn/try-spawn-merged-log-file.ts
-import { spawn as spawn7 } from "node:child_process";
+import { spawn as spawn8 } from "node:child_process";
 import fs28 from "node:fs";
 import { tmpdir } from "node:os";
 import path31 from "node:path";
@@ -34130,7 +34359,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
   try {
     let proc;
     if (process.platform === "win32") {
-      proc = spawn7(process.env.ComSpec || "cmd.exe", ["/d", "/s", "/c", command], {
+      proc = spawn8(process.env.ComSpec || "cmd.exe", ["/d", "/s", "/c", command], {
         env,
         cwd,
         stdio,
@@ -34138,7 +34367,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
         ...signal ? { signal } : {}
       });
     } else {
-      proc = spawn7("/bin/sh", ["-c", command], { env, cwd, stdio, ...signal ? { signal } : {} });
+      proc = spawn8("/bin/sh", ["-c", command], { env, cwd, stdio, ...signal ? { signal } : {} });
     }
     fs28.closeSync(logFd);
     return {
@@ -34159,7 +34388,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
 }
 
 // src/dev-servers/manager/shell-spawn/try-spawn-shell-script-log-redirect.ts
-import { spawn as spawn8 } from "node:child_process";
+import { spawn as spawn9 } from "node:child_process";
 import fs29 from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import path32 from "node:path";
@@ -34182,7 +34411,7 @@ cd ${shSingleQuote(cwd)}
 /bin/sh ${shSingleQuote(innerPath)} >>${shSingleQuote(logPath)} 2>&1
 `
     );
-    const proc = spawn8("/bin/sh", [runnerPath], {
+    const proc = spawn9("/bin/sh", [runnerPath], {
       env,
       cwd: tmpRoot,
       stdio: "ignore",
@@ -34214,7 +34443,7 @@ CD /D ${q(cwd)}\r
 ${command} >> ${q(logPath)} 2>&1\r
 `
     );
-    const proc = spawn8(com, ["/d", "/s", "/c", q(runnerPath)], {
+    const proc = spawn9(com, ["/d", "/s", "/c", q(runnerPath)], {
       env,
       cwd: tmpRoot,
       stdio: "ignore",
@@ -34235,7 +34464,7 @@ ${command} >> ${q(logPath)} 2>&1\r
 }
 
 // src/dev-servers/manager/shell-spawn/try-spawn-inherit.ts
-import { spawn as spawn9 } from "node:child_process";
+import { spawn as spawn10 } from "node:child_process";
 function trySpawnInheritStdio(command, env, cwd, signal) {
   const opts = {
     env,
@@ -34247,9 +34476,9 @@ function trySpawnInheritStdio(command, env, cwd, signal) {
   if (process.platform === "win32") {
     opts.windowsHide = true;
     const com = process.env.ComSpec || "cmd.exe";
-    proc = spawn9(com, ["/d", "/s", "/c", command], opts);
+    proc = spawn10(com, ["/d", "/s", "/c", command], opts);
   } else {
-    proc = spawn9("/bin/sh", ["-c", command], opts);
+    proc = spawn10("/bin/sh", ["-c", command], opts);
   }
   return { proc, pipedStdoutStderr: false };
 }
@@ -34317,9 +34546,6 @@ var StreamTail = class {
   }
 };
 
-// src/dev-servers/manager/dev-server-constants.ts
-var BRIDGE_SHUTDOWN_GRACE_MS = 8e3;
-
 // src/dev-servers/manager/dev-server-firehose-messages.ts
 function buildFirehoseSnapshotMessage(params) {
   const payload = {
@@ -34605,22 +34831,23 @@ var DevServerManager = class {
     }
     this.start(serverId);
   }
-  async shutdownAllGraceful() {
+  async shutdownAllGraceful(opts) {
+    const graceMs = opts?.graceMs ?? BRIDGE_SHUTDOWN_GRACE_MS;
     const pairs = [...this.processes.entries()];
     if (pairs.length === 0) return;
     this.log(
       `[dev-server] Stopping ${pairs.length} local dev server process${pairs.length === 1 ? "" : "es"}\u2026`
     );
-    await Promise.all(pairs.map(([serverId, proc]) => this.gracefulTerminateOrUnknown(serverId, proc)));
+    await Promise.all(pairs.map(([serverId, proc]) => this.gracefulTerminateOrUnknown(serverId, proc, graceMs)));
   }
-  async gracefulTerminateOrUnknown(serverId, proc) {
+  async gracefulTerminateOrUnknown(serverId, proc, graceMs) {
     const shortId = `${serverId.slice(0, 8)}\u2026`;
-    await sigtermAndWaitForExit(proc, BRIDGE_SHUTDOWN_GRACE_MS, this.log, shortId);
+    await sigtermAndWaitForExit(proc, graceMs, this.log, shortId);
     if (!this.processes.has(serverId) || this.processes.get(serverId) !== proc) {
       return;
     }
     this.bumpGeneration(serverId);
-    forceKillChild(proc, this.log, shortId, BRIDGE_SHUTDOWN_GRACE_MS);
+    forceKillChild(proc, this.log, shortId, graceMs);
     this.processes.delete(serverId);
     this.clearPoll(serverId);
     this.pipedCaptureByServerId.delete(serverId);
@@ -35047,10 +35274,13 @@ var LOCAL_AGENT_ACP_MODULES = [
 ];
 async function detectLocalAgentTypes() {
   try {
+    if (isCliImmediateShutdownRequested()) return [];
     const out = [];
     for (let i = 0; i < LOCAL_AGENT_ACP_MODULES.length; i++) {
+      if (isCliImmediateShutdownRequested()) return out;
       if (i > 0) {
         await yieldToEventLoop();
+        if (isCliImmediateShutdownRequested()) return out;
       }
       const mod = LOCAL_AGENT_ACP_MODULES[i];
       try {
@@ -35083,6 +35313,7 @@ function createSendLocalSkillsReport(getWs, logFn) {
 }
 function createReportAutoDetectedAgents(getWs, logFn) {
   return async () => {
+    if (isCliImmediateShutdownRequested()) return;
     try {
       const types = await detectLocalAgentTypes();
       const socket = getWs();
@@ -35182,6 +35413,7 @@ var handleBridgeIdentified = (msg, deps) => {
   });
   setImmediate(() => {
     void (async () => {
+      if (isCliImmediateShutdownRequested()) return;
       try {
         await deps.reportAutoDetectedAgents?.();
       } catch (e) {
@@ -35189,6 +35421,7 @@ var handleBridgeIdentified = (msg, deps) => {
           `[Bridge service] Auto-detect agents failed: ${e instanceof Error ? e.message : String(e)}`
         );
       }
+      if (isCliImmediateShutdownRequested()) return;
       try {
         await deps.warmupAgentCapabilitiesOnConnect?.();
       } catch (e) {
@@ -35199,6 +35432,7 @@ var handleBridgeIdentified = (msg, deps) => {
     })();
   });
   setImmediate(() => {
+    if (isCliImmediateShutdownRequested()) return;
     try {
       deps.sendLocalSkillsReport?.();
     } catch (e) {
@@ -35500,12 +35734,12 @@ function createBridgePromptSenders(deps, getWs) {
 }
 
 // src/agents/acp/from-bridge/bridge-prompt-preamble.ts
-import { execFile as execFile10 } from "node:child_process";
-import { promisify as promisify10 } from "node:util";
-var execFileAsync9 = promisify10(execFile10);
+import { execFile as execFile8 } from "node:child_process";
+import { promisify as promisify8 } from "node:util";
+var execFileAsync7 = promisify8(execFile8);
 async function readGitBranch(cwd) {
   try {
-    const { stdout } = await execFileAsync9("git", ["branch", "--show-current"], { cwd, maxBuffer: 64 * 1024 });
+    const { stdout } = await execFileAsync7("git", ["branch", "--show-current"], { cwd, maxBuffer: 64 * 1024 });
     const b = stdout.trim();
     return b || null;
   } catch {
@@ -36215,7 +36449,8 @@ var handleSessionGitRequestMessage = (msg, deps) => {
         reply({
           ok: true,
           hasUncommittedChanges: r.hasUncommittedChanges,
-          hasUnpushedCommits: r.hasUnpushedCommits
+          hasUnpushedCommits: r.hasUnpushedCommits,
+          uncommittedFileCount: r.uncommittedFileCount
         });
         return;
       }
@@ -36229,7 +36464,12 @@ var handleSessionGitRequestMessage = (msg, deps) => {
             return;
           }
         }
-        const opts = repoRel && view === "commit" && commitSha ? { repoRelPath: repoRel, basis: { kind: "commit", sha: commitSha } } : repoRel ? { repoRelPath: repoRel, basis: { kind: "working" } } : void 0;
+        const recentCommitsLimit = typeof msg.changesRecentCommitsLimit === "number" || typeof msg.changesRecentCommitsLimit === "string" ? msg.changesRecentCommitsLimit : void 0;
+        const opts = repoRel && view === "commit" && commitSha ? {
+          repoRelPath: repoRel,
+          basis: { kind: "commit", sha: commitSha },
+          recentCommitsLimit
+        } : repoRel ? { repoRelPath: repoRel, basis: { kind: "working" }, recentCommitsLimit } : recentCommitsLimit !== void 0 ? { recentCommitsLimit } : void 0;
         const repos = await deps.sessionWorktreeManager.getSessionWorkingTreeChangeDetails(sessionId, opts);
         reply({
           ok: true,
@@ -36247,7 +36487,8 @@ var handleSessionGitRequestMessage = (msg, deps) => {
         reply({
           ok: true,
           hasUncommittedChanges: st2.hasUncommittedChanges,
-          hasUnpushedCommits: st2.hasUnpushedCommits
+          hasUnpushedCommits: st2.hasUnpushedCommits,
+          uncommittedFileCount: st2.uncommittedFileCount
         });
         return;
       }
@@ -36272,7 +36513,8 @@ var handleSessionGitRequestMessage = (msg, deps) => {
       reply({
         ok: true,
         hasUncommittedChanges: st.hasUncommittedChanges,
-        hasUnpushedCommits: st.hasUnpushedCommits
+        hasUnpushedCommits: st.hasUnpushedCommits,
+        uncommittedFileCount: st.uncommittedFileCount
       });
     } catch (e) {
       reply({ ok: false, error: e instanceof Error ? e.message : String(e) });
@@ -36876,6 +37118,7 @@ import * as path39 from "node:path";
 import * as path38 from "node:path";
 async function probeOneAgentTypeForCapabilities(params) {
   const { agentType, cwd, workspaceId, log: log2, reportAgentCapabilities, bridgeReport = true } = params;
+  if (isCliImmediateShutdownRequested()) return false;
   const resolved = resolveAgentCommand(agentType);
   if (!resolved) return false;
   let sqliteChanged = false;
@@ -36909,6 +37152,7 @@ async function probeOneAgentTypeForCapabilities(params) {
   }, 28e3);
   killTimer.unref?.();
   try {
+    if (isCliImmediateShutdownRequested()) return false;
     handle = await resolved.createClient({
       command: resolved.command,
       cwd: path38.resolve(cwd),
@@ -36928,7 +37172,7 @@ async function probeOneAgentTypeForCapabilities(params) {
       onSessionUpdate: () => {
       }
     });
-    await new Promise((r) => setTimeout(r, 1200));
+    if (!await delayMsUnlessShutdownRequested(1200)) return false;
   } catch (e) {
     log2(
       `[Bridge service] Agent capability probe (${agentType}): ${e instanceof Error ? e.message : String(e)}`
@@ -36956,6 +37200,7 @@ async function probeAgentCapabilitiesForDetectedTypes(params) {
   } = params;
   let changedCount = 0;
   for (let i = 0; i < agentTypes.length; i++) {
+    if (isCliImmediateShutdownRequested()) return changedCount;
     if (i > 0) await yieldToEventLoop();
     const agentType = agentTypes[i];
     if (!agentType.trim()) continue;
@@ -36983,6 +37228,7 @@ async function probeAgentCapabilitiesForDetectedTypes(params) {
 // src/agents/capabilities/warmup-agent-capabilities-on-connect.ts
 async function warmupAgentCapabilitiesOnConnect(params) {
   const { workspaceId, log: log2, getWs } = params;
+  if (isCliImmediateShutdownRequested()) return;
   const cwd = path39.resolve(getBridgeRoot());
   async function sendBatchFromCache() {
     const socket = getWs();
@@ -36995,18 +37241,21 @@ async function warmupAgentCapabilitiesOnConnect(params) {
         items: rows.map((r) => ({ agentType: r.agentType, configOptions: r.configOptions }))
       });
     } catch (e) {
+      if (e instanceof CliSqliteInterrupted) return;
       log2(
         `[Bridge service] Agent capability batch to bridge failed: ${e instanceof Error ? e.message : String(e)}`
       );
     }
   }
   await sendBatchFromCache();
+  if (isCliImmediateShutdownRequested()) return;
   let types = [];
   try {
     types = [...await detectLocalAgentTypes()];
   } catch (e) {
     log2(`[Bridge service] detectLocalAgentTypes failed: ${e instanceof Error ? e.message : String(e)}`);
   }
+  if (isCliImmediateShutdownRequested()) return;
   try {
     const n = await probeAgentCapabilitiesForDetectedTypes({
       agentTypes: types,
@@ -37018,11 +37267,13 @@ async function warmupAgentCapabilitiesOnConnect(params) {
     });
     if (n > 0) await sendBatchFromCache();
   } catch (e) {
+    if (e instanceof CliSqliteInterrupted) return;
     log2(`[Bridge service] Agent capability probe (missing cache) failed: ${e instanceof Error ? e.message : String(e)}`);
   }
   void (async () => {
     try {
       await yieldToEventLoop();
+      if (isCliImmediateShutdownRequested()) return;
       const n = await probeAgentCapabilitiesForDetectedTypes({
         agentTypes: types,
         cwd,
@@ -37033,6 +37284,7 @@ async function warmupAgentCapabilitiesOnConnect(params) {
       });
       if (n > 0) await sendBatchFromCache();
     } catch (e) {
+      if (e instanceof CliSqliteInterrupted) return;
       log2(`[Bridge service] Agent capability lazy refresh failed: ${e instanceof Error ? e.message : String(e)}`);
     }
   })();
@@ -37080,7 +37332,8 @@ async function createBridgeConnection(options) {
           configOptions: info.configOptions
         })
       );
-    } catch {
+    } catch (e) {
+      if (e instanceof CliSqliteInterrupted) return;
     }
     if (!changed) return;
     const socket = getWs();
@@ -37163,6 +37416,7 @@ async function createBridgeConnection(options) {
   const stopFileIndexWatcher = startFileIndexWatcher(getBridgeRoot());
   return {
     close: async () => {
+      requestCliImmediateShutdown();
       stopFileIndexWatcher();
       bridgeHeartbeat.stop();
       await closeBridgeConnection(state, acpManager, devServerManager, logFn);
@@ -37236,47 +37490,61 @@ async function runConnectedBridge(options, restartWithoutAuth) {
   } = options;
   const firehoseServerUrl = options.firehoseServerUrl ?? options.proxyServerUrl;
   let cleanupKeyCommand;
-  const handle = await createBridgeConnection({
-    apiUrl,
-    workspaceId,
-    authToken,
-    refreshToken,
-    firehoseServerUrl,
-    justAuthenticated,
-    worktreesRootPath,
-    e2eCertificate,
-    log,
-    persistTokens: (t) => {
-      writeConfigForApi(apiUrl, {
-        workspaceId,
-        token: t.token,
-        refreshToken: t.refreshToken
-      });
-    },
-    onAuthInvalid: () => {
-      cleanupKeyCommand?.();
-      log("[Bridge service] Access token invalid or revoked; re-authenticating\u2026");
-      clearConfigForApi(apiUrl);
-      void handle.close().then(() => {
-        void restartWithoutAuth({ apiUrl, firehoseServerUrl, worktreesRootPath, e2eCertificate });
-      });
-    }
-  });
+  let bridgeClose = null;
   const onSignal = (kind) => {
+    requestCliImmediateShutdown();
+    abortActiveGitChildProcesses();
     cleanupKeyCommand?.();
     logImmediate(
       kind === "interrupt" ? "Keyboard interrupt (Ctrl+C) \u2014 stopping\u2026" : "Stop requested \u2014 shutting down\u2026"
     );
-    setImmediate(() => {
-      void handle.close().then(() => {
-        process.exit(0);
-      });
-    });
+    if (bridgeClose) {
+      void bridgeClose().then(() => process.exit(0));
+      return;
+    }
+    process.exit(0);
   };
   const onSigInt = () => onSignal("interrupt");
   const onSigTerm = () => onSignal("stop");
   process.on("SIGINT", onSigInt);
   process.on("SIGTERM", onSigTerm);
+  let handle;
+  try {
+    handle = await createBridgeConnection({
+      apiUrl,
+      workspaceId,
+      authToken,
+      refreshToken,
+      firehoseServerUrl,
+      justAuthenticated,
+      worktreesRootPath,
+      e2eCertificate,
+      log,
+      persistTokens: (t) => {
+        writeConfigForApi(apiUrl, {
+          workspaceId,
+          token: t.token,
+          refreshToken: t.refreshToken
+        });
+      },
+      onAuthInvalid: () => {
+        cleanupKeyCommand?.();
+        log("[Bridge service] Access token invalid or revoked; re-authenticating\u2026");
+        clearConfigForApi(apiUrl);
+        void handle.close().then(() => {
+          void restartWithoutAuth({ apiUrl, firehoseServerUrl, worktreesRootPath, e2eCertificate });
+        });
+      }
+    });
+  } catch (e) {
+    process.off("SIGINT", onSigInt);
+    process.off("SIGTERM", onSigTerm);
+    if (e instanceof CliSqliteInterrupted) {
+      process.exit(0);
+    }
+    throw e;
+  }
+  bridgeClose = () => handle.close();
   if (e2eCertificate) {
     let openingCertificate = false;
     cleanupKeyCommand = installE2eCertificateKeyCommand({
@@ -37321,6 +37589,7 @@ async function runBridge(options) {
       }
     });
     const onSignal = (kind) => {
+      requestCliImmediateShutdown();
       logImmediate(
         kind === "interrupt" ? "Keyboard interrupt (Ctrl+C) \u2014 stopping\u2026" : "Stop requested \u2014 shutting down\u2026"
       );