@buildautomaton/cli 0.1.31 → 0.1.33

package/dist/cli.js

@@ -25064,7 +25064,7 @@ var {
 } = import_index.default;
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.31".length > 0 ? "0.1.31" : "0.0.0-dev";
+var CLI_VERSION = "0.1.33".length > 0 ? "0.1.33" : "0.0.0-dev";
 
 // src/cli/defaults.ts
 var DEFAULT_API_URL = process.env.BUILDAUTOMATON_API_URL ?? "https://api.buildautomaton.com";
@@ -26696,9 +26696,38 @@ 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";
 
+// src/runtime/yield-to-event-loop.ts
+function yieldToEventLoop() {
+  return new Promise((resolve20) => setImmediate(resolve20));
+}
+
 // src/sqlite/cli-sqlite-paths.ts
 import fs8 from "node:fs";
 import path5 from "node:path";
@@ -26991,6 +27020,29 @@ function migrateCliSqlite(db) {
 
 // src/sqlite/cli-database.ts
 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");
+  } catch {
+  }
+  try {
+    db.run("PRAGMA synchronous = NORMAL");
+  } catch {
+  }
+  try {
+    db.run("PRAGMA busy_timeout = 500");
+  } catch {
+  }
+}
 function applyCliSqliteMemoryPragmas(db) {
   try {
     db.run("PRAGMA cache_size = -8192");
@@ -26998,18 +27050,6 @@ function applyCliSqliteMemoryPragmas(db) {
   } catch {
   }
 }
-var openDatabases = /* @__PURE__ */ new Map();
-var processExitCloseRegistered = false;
-function registerProcessExitSqliteClose() {
-  if (processExitCloseRegistered) return;
-  processExitCloseRegistered = true;
-  process.once("exit", () => {
-    for (const db of openDatabases.values()) {
-      safeCloseCliSqliteDatabase(db);
-    }
-    openDatabases.clear();
-  });
-}
 function safeCloseCliSqliteDatabase(db) {
   if (db == null) return;
   try {
@@ -27018,22 +27058,49 @@ function safeCloseCliSqliteDatabase(db) {
   }
 }
 function closeAllCliSqliteConnections() {
-  for (const db of openDatabases.values()) {
-    safeCloseCliSqliteDatabase(db);
+}
+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;
+  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();
+      }
+    }
   }
-  openDatabases.clear();
 }
-function getCliDatabase(options) {
-  const sqlitePath = getCliSqlitePath();
-  const existing = openDatabases.get(sqlitePath);
-  if (existing?.isOpen) return existing;
-  if (existing && !existing.isOpen) {
-    safeCloseCliSqliteDatabase(existing);
-    openDatabases.delete(sqlitePath);
+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);
   try {
+    applyCliSqliteConcurrencyPragmas(db);
     applyCliSqliteMemoryPragmas(db);
     migrateCliSqlite(db);
     importCliSqliteLegacyDiskData(db, options?.logLegacyMigration);
@@ -27041,16 +27108,62 @@ function getCliDatabase(options) {
     safeCloseCliSqliteDatabase(db);
     throw e;
   }
-  openDatabases.set(sqlitePath, db);
-  registerProcessExitSqliteClose();
   return db;
 }
+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);
+      try {
+        return fn(db);
+      } finally {
+        safeCloseCliSqliteDatabase(db);
+      }
+    } 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));
+    }
+  }
+  throw new Error("withCliSqliteSync: exhausted retries");
+}
+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);
+      try {
+        return await Promise.resolve(fn(db));
+      } finally {
+        safeCloseCliSqliteDatabase(db);
+      }
+    } 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 asyncDelayMsInterruptible(delayMs);
+      await yieldToEventLoop();
+    }
+  }
+  if (lastError instanceof Error) throw lastError;
+  throw new Error(String(lastError));
+}
+async function ensureCliSqliteInitialized(options) {
+  await withCliSqlite(() => void 0, 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((resolve20) => setImmediate(resolve20));
   state.closedByUser = true;
   clearReconnectQuietTimer(state.mainQuiet);
   clearReconnectQuietTimer(state.firehoseQuiet);
@@ -27087,7 +27200,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();
@@ -32866,16 +32979,38 @@ __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) {
+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 execFileAsync7(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 execFileShutdownAware("which", [command], timeoutMs);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function execProbeShutdownAware(file2, args, timeoutMs) {
+  if (isCliImmediateShutdownRequested()) return false;
   try {
-    await execFileAsync7("which", [command], { timeout: timeoutMs });
+    await execFileShutdownAware(file2, args, timeoutMs);
     return true;
   } catch {
     return false;
@@ -33636,16 +33771,10 @@ async function createSdkStdioAcpClient(options) {
 }
 
 // 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;
-  try {
-    await execFileAsync8("npx", ["--yes", "@anthropic-ai/claude-code", "--version"], { timeout: 25e3 });
-    return true;
-  } catch {
-    return false;
-  }
+  return execProbeShutdownAware("npx", ["--yes", "@anthropic-ai/claude-code", "--version"], 3e3);
 }
 function buildClaudeCodeAcpSpawnCommand(base, _sessionMode) {
   return [...base];
@@ -34812,56 +34941,80 @@ function sessionKeyForCloudSessionId(cloudSessionId) {
 }
 function readLocalAgentSessionFile(cloudSessionId) {
   try {
-    const db = getCliDatabase();
-    const key = sessionKeyForCloudSessionId(cloudSessionId);
-    const row = db.get(
-      "SELECT acp_session_id, backend_agent_type, config_options_json, updated_at FROM agent_session WHERE session_key = ?",
-      [key]
-    );
-    if (!row) return null;
-    let configOptions = null;
-    if (row.config_options_json != null && row.config_options_json !== "") {
-      try {
-        const parsed = JSON.parse(row.config_options_json);
-        configOptions = Array.isArray(parsed) ? parsed : null;
-      } catch {
-        configOptions = null;
+    return withCliSqliteSync((db) => {
+      const key = sessionKeyForCloudSessionId(cloudSessionId);
+      const row = db.get(
+        "SELECT acp_session_id, backend_agent_type, config_options_json, updated_at FROM agent_session WHERE session_key = ?",
+        [key]
+      );
+      if (!row) return null;
+      let configOptions = null;
+      if (row.config_options_json != null && row.config_options_json !== "") {
+        try {
+          const parsed = JSON.parse(row.config_options_json);
+          configOptions = Array.isArray(parsed) ? parsed : null;
+        } catch {
+          configOptions = null;
+        }
       }
-    }
-    return {
-      v: 1,
-      acpSessionId: row.acp_session_id,
-      backendAgentType: row.backend_agent_type,
-      configOptions,
-      updatedAt: row.updated_at
-    };
+      return {
+        v: 1,
+        acpSessionId: row.acp_session_id,
+        backendAgentType: row.backend_agent_type,
+        configOptions,
+        updatedAt: row.updated_at
+      };
+    });
   } catch {
     return null;
   }
 }
 function writeLocalAgentSessionFile(cloudSessionId, patch) {
   try {
-    const db = getCliDatabase();
-    const key = sessionKeyForCloudSessionId(cloudSessionId);
-    const prev = readLocalAgentSessionFile(cloudSessionId);
-    const next = {
-      v: 1,
-      acpSessionId: patch.acpSessionId !== void 0 ? patch.acpSessionId : prev?.acpSessionId ?? null,
-      backendAgentType: patch.backendAgentType !== void 0 ? patch.backendAgentType : prev?.backendAgentType ?? null,
-      configOptions: patch.configOptions !== void 0 ? patch.configOptions : prev?.configOptions ?? null,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    const configJson = next.configOptions != null ? JSON.stringify(next.configOptions) : null;
-    db.run(
-      `INSERT INTO agent_session (session_key, acp_session_id, backend_agent_type, config_options_json, updated_at)
-       VALUES (?, ?, ?, ?, ?)
-       ON CONFLICT(session_key) DO UPDATE SET
-         acp_session_id = excluded.acp_session_id,
-         backend_agent_type = excluded.backend_agent_type,
-         config_options_json = excluded.config_options_json,
-         updated_at = excluded.updated_at`,
-      [key, next.acpSessionId, next.backendAgentType, configJson, next.updatedAt]
-    );
+    withCliSqliteSync((db) => {
+      const key = sessionKeyForCloudSessionId(cloudSessionId);
+      const prevRow = db.get(
+        "SELECT acp_session_id, backend_agent_type, config_options_json, updated_at FROM agent_session WHERE session_key = ?",
+        [key]
+      );
+      let prev = null;
+      if (prevRow) {
+        let configOptions = null;
+        if (prevRow.config_options_json != null && prevRow.config_options_json !== "") {
+          try {
+            const parsed = JSON.parse(prevRow.config_options_json);
+            configOptions = Array.isArray(parsed) ? parsed : null;
+          } catch {
+            configOptions = null;
+          }
+        }
+        prev = {
+          v: 1,
+          acpSessionId: prevRow.acp_session_id,
+          backendAgentType: prevRow.backend_agent_type,
+          configOptions,
+          updatedAt: prevRow.updated_at
+        };
+      }
+      const next = {
+        v: 1,
+        acpSessionId: patch.acpSessionId !== void 0 ? patch.acpSessionId : prev?.acpSessionId ?? null,
+        backendAgentType: patch.backendAgentType !== void 0 ? patch.backendAgentType : prev?.backendAgentType ?? null,
+        configOptions: patch.configOptions !== void 0 ? patch.configOptions : prev?.configOptions ?? null,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const configJson = next.configOptions != null ? JSON.stringify(next.configOptions) : null;
+      db.run(
+        `INSERT INTO agent_session (session_key, acp_session_id, backend_agent_type, config_options_json, updated_at)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(session_key) DO UPDATE SET
+           acp_session_id = excluded.acp_session_id,
+           backend_agent_type = excluded.backend_agent_type,
+           config_options_json = excluded.config_options_json,
+           updated_at = excluded.updated_at`,
+        [key, next.acpSessionId, next.backendAgentType, configJson, next.updatedAt]
+      );
+    });
   } catch {
   }
 }
@@ -36444,41 +36597,45 @@ function getCwdHashForFileIndex(resolvedCwd) {
 // src/files/index/build-file-index.ts
 import path29 from "node:path";
 
-// src/runtime/yield-to-event-loop.ts
-function yieldToEventLoop() {
-  return new Promise((resolve20) => setImmediate(resolve20));
-}
-
 // src/files/index/walk-workspace-tree.ts
 import fs25 from "node:fs";
 import path28 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 = fs25.readdirSync(dir);
+    names = await fs25.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 = path28.join(dir, name);
     let stat3;
     try {
-      stat3 = fs25.statSync(full);
+      stat3 = await fs25.promises.stat(full);
     } catch {
       continue;
     }
     const relative5 = path28.relative(baseDir, full).replace(/\\/g, "/");
     if (stat3.isDirectory()) {
-      walkWorkspaceTreeSync(full, baseDir, onFile);
+      await walkWorkspaceTreeAsync(full, baseDir, onFile, state);
     } else if (stat3.isFile()) {
       onFile(relative5);
     }
   }
 }
+function createWalkYieldState() {
+  return { n: 0 };
+}
 
 // src/files/index/file-index-sqlite-lock.ts
 import fs26 from "node:fs";
@@ -36511,48 +36668,60 @@ function withFileIndexSqliteLock(fn) {
 }
 
 // src/files/index/build-file-index.ts
-var FILE_INDEX_INSERT_BUFFER = 2048;
-function persistFileIndexForResolvedCwd(resolved) {
-  const db = getCliDatabase();
-  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 (?, ?)");
+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);
+    let pathCount = 0;
+    db.run("BEGIN IMMEDIATE");
     try {
-      const flushBuf = () => {
-        for (const rel of buf) {
+      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 {
+        let batch = 0;
+        for (const rel of paths) {
+          if (++batch >= FILE_INDEX_INTERRUPT_CHECK_EVERY) {
+            batch = 0;
+            assertNotShutdown();
+          }
           ins.run([h, rel]);
+          pathCount += 1;
         }
-        pathCount += buf.length;
-        buf.length = 0;
-      };
-      walkWorkspaceTreeSync(resolved, resolved, (rel) => {
-        buf.push(rel);
-        if (buf.length >= FILE_INDEX_INSERT_BUFFER) flushBuf();
-      });
-      flushBuf();
-    } finally {
-      ins.finalize();
-    }
-    db.run("COMMIT");
-  } catch (e) {
-    try {
-      db.run("ROLLBACK");
-    } catch {
+      } finally {
+        ins.finalize();
+      }
+      db.run("COMMIT");
+    } catch (e) {
+      try {
+        db.run("ROLLBACK");
+      } catch {
+      }
+      throw e;
     }
-    throw e;
-  }
-  return pathCount;
+    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 = path29.resolve(cwd);
     await yieldToEventLoop();
-    const pathCount = persistFileIndexForResolvedCwd(resolved);
+    assertNotShutdown();
+    const paths = await collectWorkspacePathsAsync(resolved);
     await yieldToEventLoop();
+    assertNotShutdown();
+    const pathCount = persistFileIndexPaths(resolved, paths);
     return { pathCount };
   });
 }
@@ -36569,23 +36738,20 @@ function sqliteExprBridgeFileIndexDependencyRank() {
 function escapeLikePattern(fragment) {
   return fragment.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
 }
-function bridgeFileIndexIsPopulated(resolvedCwd) {
-  const db = getCliDatabase();
+function bridgeFileIndexIsPopulatedWithDb(resolvedCwd, db) {
   const h = getCwdHashForFileIndex(resolvedCwd);
   const row = db.get("SELECT 1 as ok FROM file_index_path WHERE cwd_hash = ? LIMIT 1", [h]);
   return row != null;
 }
-function bridgeFileIndexPathCount(resolvedCwd) {
-  const db = getCliDatabase();
+function bridgeFileIndexPathCountWithDb(resolvedCwd, db) {
   const h = getCwdHashForFileIndex(resolvedCwd);
   const row = db.get("SELECT COUNT(*) as c FROM file_index_path WHERE cwd_hash = ?", [h]);
   const c = row?.c ?? 0;
   return Number(c);
 }
-function searchBridgeFilePaths(resolvedCwd, query, limit = 100) {
+function searchBridgeFilePathsWithDb(resolvedCwd, query, limit, db) {
   const q = query.trim().toLowerCase();
   if (!q) return [];
-  const db = getCliDatabase();
   const h = getCwdHashForFileIndex(resolvedCwd);
   const pattern = `%${escapeLikePattern(q)}%`;
   const lim = Math.max(0, Math.min(1e4, Math.floor(limit)));
@@ -36596,9 +36762,15 @@ function searchBridgeFilePaths(resolvedCwd, query, limit = 100) {
   );
   return rows.map((r) => String(r.path));
 }
+async function bridgeFileIndexIsPopulated(resolvedCwd) {
+  return withCliSqlite((db) => bridgeFileIndexIsPopulatedWithDb(resolvedCwd, db));
+}
+async function bridgeFileIndexPathCount(resolvedCwd) {
+  return withCliSqlite((db) => bridgeFileIndexPathCountWithDb(resolvedCwd, db));
+}
 async function searchBridgeFilePathsAsync(resolvedCwd, query, limit = 100) {
   await yieldToEventLoop();
-  const out = searchBridgeFilePaths(resolvedCwd, query, limit);
+  const out = await withCliSqlite((db) => searchBridgeFilePathsWithDb(resolvedCwd, query, limit, db));
   if (out.length >= INDEX_WORK_YIELD_EVERY) await yieldToEventLoop();
   return out;
 }
@@ -36606,8 +36778,8 @@ async function searchBridgeFilePathsAsync(resolvedCwd, query, limit = 100) {
 // src/files/index/ensure-file-index.ts
 async function ensureFileIndexAsync(cwd) {
   const resolved = path30.resolve(cwd);
-  if (bridgeFileIndexIsPopulated(resolved)) {
-    return { fromCache: true, pathCount: bridgeFileIndexPathCount(resolved) };
+  if (await bridgeFileIndexIsPopulated(resolved)) {
+    return { fromCache: true, pathCount: await bridgeFileIndexPathCount(resolved) };
   }
   return { ...await buildFileIndexAsync(resolved), fromCache: false };
 }
@@ -36653,11 +36825,13 @@ function createFsWatcher(resolved, schedule) {
 function startFileIndexWatcher(cwd = getBridgeRoot()) {
   const resolved = path31.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);
     });
   };
@@ -37191,9 +37365,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 = {
@@ -37479,22 +37650,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);
@@ -38089,10 +38261,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 {
@@ -38125,6 +38300,7 @@ function createSendLocalSkillsReport(getWs, logFn) {
 }
 function createReportAutoDetectedAgents(getWs, logFn) {
   return async () => {
+    if (isCliImmediateShutdownRequested()) return;
     try {
       const types = await detectLocalAgentTypes();
       const socket = getWs();
@@ -38224,6 +38400,7 @@ var handleBridgeIdentified = (msg, deps) => {
   });
   setImmediate(() => {
     void (async () => {
+      if (isCliImmediateShutdownRequested()) return;
       try {
         await deps.reportAutoDetectedAgents?.();
       } catch (e) {
@@ -38231,6 +38408,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) {
@@ -38241,6 +38419,7 @@ var handleBridgeIdentified = (msg, deps) => {
     })();
   });
   setImmediate(() => {
+    if (isCliImmediateShutdownRequested()) return;
     try {
       deps.sendLocalSkillsReport?.();
     } catch (e) {
@@ -38288,30 +38467,32 @@ var MERGEABLE_SERVER_STATES = /* @__PURE__ */ new Set([
   "stopping",
   "discarded"
 ]);
-function readPersistedQueue(queueKey) {
-  const db = getCliDatabase();
-  const row = db.get("SELECT queue_key, updated_at, turns_json FROM prompt_queue WHERE queue_key = ?", [
-    queueKey
-  ]);
-  if (!row) return null;
-  try {
-    const turns = JSON.parse(row.turns_json);
-    if (!Array.isArray(turns)) return null;
-    return { queueKey: row.queue_key, updatedAt: row.updated_at, turns };
-  } catch {
-    return null;
-  }
+async function readPersistedQueue(queueKey) {
+  return withCliSqlite((db) => {
+    const row = db.get("SELECT queue_key, updated_at, turns_json FROM prompt_queue WHERE queue_key = ?", [
+      queueKey
+    ]);
+    if (!row) return null;
+    try {
+      const turns = JSON.parse(row.turns_json);
+      if (!Array.isArray(turns)) return null;
+      return { queueKey: row.queue_key, updatedAt: row.updated_at, turns };
+    } catch {
+      return null;
+    }
+  });
 }
-function writePersistedQueue(file2) {
-  const db = getCliDatabase();
-  db.run(
-    `INSERT INTO prompt_queue (queue_key, updated_at, turns_json) VALUES (?, ?, ?)
-     ON CONFLICT(queue_key) DO UPDATE SET updated_at = excluded.updated_at, turns_json = excluded.turns_json`,
-    [file2.queueKey, file2.updatedAt, JSON.stringify(file2.turns)]
-  );
+async function writePersistedQueue(file2) {
+  await withCliSqlite((db) => {
+    db.run(
+      `INSERT INTO prompt_queue (queue_key, updated_at, turns_json) VALUES (?, ?, ?)
+       ON CONFLICT(queue_key) DO UPDATE SET updated_at = excluded.updated_at, turns_json = excluded.turns_json`,
+      [file2.queueKey, file2.updatedAt, JSON.stringify(file2.turns)]
+    );
+  });
 }
-function mergeServerQueueSnapshot(queueKey, serverTurns) {
-  const prev = readPersistedQueue(queueKey);
+async function mergeServerQueueSnapshot(queueKey, serverTurns) {
+  const prev = await readPersistedQueue(queueKey);
   const turns = [];
   for (const raw of serverTurns) {
     if (!raw || typeof raw !== "object") continue;
@@ -38408,12 +38589,12 @@ async function applyPromptQueueStateFromServer(msg, deps) {
   const getWs = deps.getWs;
   for (const [queueKey, serverTurns] of Object.entries(raw)) {
     if (!Array.isArray(serverTurns)) continue;
-    const file2 = mergeServerQueueSnapshot(queueKey, serverTurns);
-    writePersistedQueue(file2);
+    const file2 = await mergeServerQueueSnapshot(queueKey, serverTurns);
+    await writePersistedQueue(file2);
   }
   for (const [queueKey, serverTurns] of Object.entries(raw)) {
     if (!Array.isArray(serverTurns)) continue;
-    const file2 = readPersistedQueue(queueKey);
+    const file2 = await readPersistedQueue(queueKey);
     if (!file2) continue;
     for (const running of file2.turns.filter((t) => t.lastClientState === "running")) {
       runIdToQueueKey.set(running.turnId, queueKey);
@@ -38421,7 +38602,7 @@ async function applyPromptQueueStateFromServer(msg, deps) {
   }
   for (const [queueKey, serverTurns] of Object.entries(raw)) {
     if (!Array.isArray(serverTurns)) continue;
-    const file2 = readPersistedQueue(queueKey);
+    const file2 = await readPersistedQueue(queueKey);
     if (!file2) continue;
     const cancelRow = file2.turns.find((t) => t.serverState === "cancel_requested" && t.lastClientState === "running");
     if (cancelRow) {
@@ -38430,7 +38611,7 @@ async function applyPromptQueueStateFromServer(msg, deps) {
         deps.log(
           `[Queue] server cancel_requested for ${cancelRow.turnId.slice(0, 8)}\u2026 but no local agent run is active (e.g. after CLI restart); marking cancelled and notifying bridge.`
         );
-        finalizePromptTurnOnBridge(deps.getWs, cancelRow.turnId, false, { terminalClientState: "cancelled" });
+        await finalizePromptTurnOnBridge(deps.getWs, cancelRow.turnId, false, { terminalClientState: "cancelled" });
         const ws = deps.getWs();
         if (ws && cancelRow.sessionId) {
           sendWsMessage(ws, {
@@ -38449,19 +38630,19 @@ async function applyPromptQueueStateFromServer(msg, deps) {
   const startedThisTick = /* @__PURE__ */ new Set();
   for (const [queueKey, serverTurns] of Object.entries(raw)) {
     if (!Array.isArray(serverTurns)) continue;
-    const file2 = readPersistedQueue(queueKey);
+    const file2 = await readPersistedQueue(queueKey);
     if (!file2) continue;
     if (hasRunningTurn(file2.turns)) continue;
     const next = pickNextRunnableTurn(file2.turns);
     if (!next) continue;
     if (!await runLocalRevertBeforeQueuedPrompt(next, deps)) {
       next.lastClientState = "failed";
-      writePersistedQueue(file2);
+      await writePersistedQueue(file2);
       sendPromptQueueClientReport(getWs(), { [queueKey]: [{ turnId: next.turnId, clientState: "failed" }] });
       continue;
     }
     next.lastClientState = "running";
-    writePersistedQueue(file2);
+    await writePersistedQueue(file2);
     runIdToQueueKey.set(next.turnId, queueKey);
     startedThisTick.add(next.turnId);
     report[queueKey] = [{ turnId: next.turnId, clientState: "running" }];
@@ -38471,7 +38652,7 @@ async function applyPromptQueueStateFromServer(msg, deps) {
   }
   for (const [queueKey, serverTurns] of Object.entries(raw)) {
     if (!Array.isArray(serverTurns)) continue;
-    const file2 = readPersistedQueue(queueKey);
+    const file2 = await readPersistedQueue(queueKey);
     if (!file2) continue;
     const running = file2.turns.find((t) => t.lastClientState === "running");
     if (!running || !startedThisTick.has(running.turnId)) continue;
@@ -38479,17 +38660,17 @@ async function applyPromptQueueStateFromServer(msg, deps) {
     dispatchLocalPrompt(running, deps);
   }
 }
-function finalizePromptTurnOnBridge(getWs, runId, success2, opts) {
+async function finalizePromptTurnOnBridge(getWs, runId, success2, opts) {
   if (!runId) return false;
   const queueKey = runIdToQueueKey.get(runId);
   runIdToQueueKey.delete(runId);
   if (!queueKey) return false;
-  const f = readPersistedQueue(queueKey);
+  const f = await readPersistedQueue(queueKey);
   if (!f) return false;
   const t = f.turns.find((x) => x.turnId === runId);
   if (!t) return false;
   t.lastClientState = opts?.terminalClientState ?? (success2 ? "stopped" : "failed");
-  writePersistedQueue(f);
+  await writePersistedQueue(f);
   sendPromptQueueClientReport(getWs(), { [queueKey]: [{ turnId: runId, clientState: t.lastClientState }] });
   return true;
 }
@@ -38510,12 +38691,13 @@ function createBridgePromptSenders(deps, getWs) {
     if (result.type === "prompt_result") {
       const pr = result;
       const cancelled = pr.stopReason === "cancelled";
-      finalizePromptTurnOnBridge(
+      void finalizePromptTurnOnBridge(
         getWs,
         typeof pr.runId === "string" ? pr.runId : void 0,
         pr.success === true,
         cancelled ? { terminalClientState: "cancelled" } : void 0
-      );
+      ).catch(() => {
+      });
     }
   };
   const sendSessionUpdate = (payload) => {
@@ -38539,12 +38721,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 execFile9 } from "node:child_process";
+import { promisify as promisify9 } from "node:util";
+var execFileAsync8 = promisify9(execFile9);
 async function readGitBranch(cwd) {
   try {
-    const { stdout } = await execFileAsync9("git", ["branch", "--show-current"], { cwd, maxBuffer: 64 * 1024 });
+    const { stdout } = await execFileAsync8("git", ["branch", "--show-current"], { cwd, maxBuffer: 64 * 1024 });
     const b = stdout.trim();
     return b || null;
   } catch {
@@ -39248,7 +39430,7 @@ function handleFileBrowserSearch(msg, socket, e2ee) {
     await yieldToEventLoop();
     const q = typeof msg.q === "string" ? msg.q : "";
     const cwd = path37.resolve(getBridgeRoot());
-    if (!bridgeFileIndexIsPopulated(cwd)) {
+    if (!await bridgeFileIndexIsPopulated(cwd)) {
       const payload2 = {
         type: "file_browser_search_response",
         id: msg.id,
@@ -40009,7 +40191,8 @@ import * as path40 from "node:path";
 // src/agents/capabilities/probe-one-agent-type-for-capabilities.ts
 import * as path39 from "node:path";
 async function probeOneAgentTypeForCapabilities(params) {
-  const { agentType, cwd, workspaceId, log: log2, getDb, reportAgentCapabilities, bridgeReport = true } = 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;
@@ -40020,11 +40203,13 @@ async function probeOneAgentTypeForCapabilities(params) {
     reportedRef.done = true;
     let changed = false;
     try {
-      changed = upsertCliAgentCapabilityCache(getDb(), {
-        workspaceId,
-        agentType,
-        configOptions: co
-      });
+      changed = withCliSqliteSync(
+        (db) => upsertCliAgentCapabilityCache(db, {
+          workspaceId,
+          agentType,
+          configOptions: co
+        })
+      );
     } catch {
     }
     sqliteChanged ||= changed;
@@ -40041,6 +40226,7 @@ async function probeOneAgentTypeForCapabilities(params) {
   }, 28e3);
   killTimer.unref?.();
   try {
+    if (isCliImmediateShutdownRequested()) return false;
     handle = await resolved.createClient({
       command: resolved.command,
       cwd: path39.resolve(cwd),
@@ -40060,7 +40246,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)}`
@@ -40082,19 +40268,19 @@ async function probeAgentCapabilitiesForDetectedTypes(params) {
     cwd,
     workspaceId,
     log: log2,
-    getDb,
     reportAgentCapabilities,
     bridgeReport = true,
     forceAllTypes = false
   } = 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;
     if (!forceAllTypes) {
       try {
-        if (process.env.BUILDAUTOMATON_FORCE_PROBE_ACP_CAPABILITIES !== "1" && hasNonEmptyAgentCapabilityCache(getDb(), workspaceId, agentType)) {
+        if (process.env.BUILDAUTOMATON_FORCE_PROBE_ACP_CAPABILITIES !== "1" && await withCliSqlite((db) => hasNonEmptyAgentCapabilityCache(db, workspaceId, agentType))) {
           continue;
         }
       } catch {
@@ -40105,7 +40291,6 @@ async function probeAgentCapabilitiesForDetectedTypes(params) {
       cwd,
       workspaceId,
       log: log2,
-      getDb,
       reportAgentCapabilities,
       bridgeReport
     });
@@ -40116,60 +40301,64 @@ async function probeAgentCapabilitiesForDetectedTypes(params) {
 
 // src/agents/capabilities/warmup-agent-capabilities-on-connect.ts
 async function warmupAgentCapabilitiesOnConnect(params) {
-  const { workspaceId, log: log2, getDb, getWs } = params;
+  const { workspaceId, log: log2, getWs } = params;
+  if (isCliImmediateShutdownRequested()) return;
   const cwd = path40.resolve(getBridgeRoot());
-  const db = getDb();
-  function sendBatchFromCache() {
+  async function sendBatchFromCache() {
     const socket = getWs();
     if (!socket || socket.readyState !== wrapper_default.OPEN) return;
     try {
-      const rows = listCliAgentCapabilityCacheForWorkspace(db, workspaceId);
+      const rows = await withCliSqlite((db) => listCliAgentCapabilityCacheForWorkspace(db, workspaceId));
       if (rows.length === 0) return;
       sendWsMessage(socket, {
         type: "agent_capabilities_batch",
         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)}`
       );
     }
   }
-  sendBatchFromCache();
+  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,
       cwd,
       workspaceId,
       log: log2,
-      getDb,
       bridgeReport: false,
       forceAllTypes: false
     });
-    if (n > 0) sendBatchFromCache();
+    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,
         workspaceId,
         log: log2,
-        getDb,
         bridgeReport: false,
         forceAllTypes: true
       });
-      if (n > 0) sendBatchFromCache();
+      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)}`);
     }
   })();
@@ -40180,7 +40369,7 @@ async function createBridgeConnection(options) {
   const { apiUrl, workspaceId, justAuthenticated, onAuthInvalid, persistTokens } = options;
   const firehoseServerUrl = options.firehoseServerUrl ?? options.proxyServerUrl;
   const logFn = options.log ?? log;
-  getCliDatabase({ logLegacyMigration: logFn });
+  await ensureCliSqliteInitialized({ logLegacyMigration: logFn });
   const tokens = {
     accessToken: options.authToken,
     refreshToken: options.refreshToken
@@ -40210,12 +40399,15 @@ async function createBridgeConnection(options) {
     if (!Array.isArray(info.configOptions) || info.configOptions.length === 0) return;
     let changed = false;
     try {
-      changed = upsertCliAgentCapabilityCache(getCliDatabase(), {
-        workspaceId,
-        agentType: info.agentType,
-        configOptions: info.configOptions
-      });
-    } catch {
+      changed = withCliSqliteSync(
+        (db) => upsertCliAgentCapabilityCache(db, {
+          workspaceId,
+          agentType: info.agentType,
+          configOptions: info.configOptions
+        })
+      );
+    } catch (e) {
+      if (e instanceof CliSqliteInterrupted) return;
     }
     if (!changed) return;
     const socket = getWs();
@@ -40267,7 +40459,6 @@ async function createBridgeConnection(options) {
       await warmupAgentCapabilitiesOnConnect({
         workspaceId,
         log: logFn,
-        getDb: getCliDatabase,
         getWs
       });
     },
@@ -40299,6 +40490,7 @@ async function createBridgeConnection(options) {
   const stopFileIndexWatcher = startFileIndexWatcher(getBridgeRoot());
   return {
     close: async () => {
+      requestCliImmediateShutdown();
       stopFileIndexWatcher();
       bridgeHeartbeat.stop();
       await closeBridgeConnection(state, acpManager, devServerManager, logFn);
@@ -40372,47 +40564,60 @@ 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();
     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({
@@ -40457,6 +40662,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"
       );