@buildautomaton/cli 0.1.31 → 0.1.32

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.32".length > 0 ? "0.1.32" : "0.0.0-dev";
 
 // src/cli/defaults.ts
 var DEFAULT_API_URL = process.env.BUILDAUTOMATON_API_URL ?? "https://api.buildautomaton.com";
@@ -26699,6 +26699,11 @@ function runPendingAuth(options) {
 // 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 +26996,23 @@ 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;
+function applyCliSqliteConcurrencyPragmas(db) {
+  try {
+    db.exec("PRAGMA journal_mode = WAL");
+  } catch {
+  }
+  try {
+    db.run("PRAGMA synchronous = NORMAL");
+  } catch {
+  }
+  try {
+    db.run("PRAGMA busy_timeout = 8000");
+  } catch {
+  }
+}
 function applyCliSqliteMemoryPragmas(db) {
   try {
     db.run("PRAGMA cache_size = -8192");
@@ -26998,18 +27020,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 +27028,33 @@ function safeCloseCliSqliteDatabase(db) {
   }
 }
 function closeAllCliSqliteConnections() {
-  for (const db of openDatabases.values()) {
-    safeCloseCliSqliteDatabase(db);
+}
+function isCliSqliteLockError(e) {
+  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) {
+    }
   }
-  openDatabases.clear();
 }
-function getCliDatabase(options) {
+function asyncDelayMs(ms) {
+  return new Promise((resolve20) => setTimeout(resolve20, ms));
+}
+function openCliSqliteConnection(options) {
   const sqlitePath = getCliSqlitePath();
-  const existing = openDatabases.get(sqlitePath);
-  if (existing?.isOpen) return existing;
-  if (existing && !existing.isOpen) {
-    safeCloseCliSqliteDatabase(existing);
-    openDatabases.delete(sqlitePath);
-  }
   ensureCliSqliteParentDir(sqlitePath);
   const db = new SqliteDatabase(sqlitePath);
   try {
+    applyCliSqliteConcurrencyPragmas(db);
     applyCliSqliteMemoryPragmas(db);
     migrateCliSqlite(db);
     importCliSqliteLegacyDiskData(db, options?.logLegacyMigration);
@@ -27041,10 +27062,52 @@ 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++) {
+    let db;
+    try {
+      db = openCliSqliteConnection(options);
+      try {
+        return fn(db);
+      } finally {
+        safeCloseCliSqliteDatabase(db);
+      }
+    } catch (e) {
+      safeCloseCliSqliteDatabase(db);
+      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++) {
+    let db;
+    try {
+      db = openCliSqliteConnection(options);
+      try {
+        return await Promise.resolve(fn(db));
+      } finally {
+        safeCloseCliSqliteDatabase(db);
+      }
+    } catch (e) {
+      lastError = e;
+      safeCloseCliSqliteDatabase(db);
+      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 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) {
@@ -34812,56 +34875,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,11 +36531,6 @@ 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";
@@ -36513,39 +36595,40 @@ 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 (?, ?)");
+  return withCliSqliteSync((db) => {
+    const h = getCwdHashForFileIndex(resolved);
+    const buf = [];
+    let pathCount = 0;
+    db.run("BEGIN IMMEDIATE");
     try {
-      const flushBuf = () => {
-        for (const rel of buf) {
-          ins.run([h, rel]);
-        }
-        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 {
+      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]);
+          }
+          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 {
+      }
+      throw e;
     }
-    throw e;
-  }
-  return pathCount;
+    return pathCount;
+  });
 }
 async function buildFileIndexAsync(cwd) {
   return withFileIndexSqliteLock(async () => {
@@ -36569,23 +36652,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 +36676,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 +36692,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 };
 }
@@ -38288,30 +38374,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 +38496,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 +38509,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 +38518,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 +38537,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 +38559,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 +38567,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 +38598,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) => {
@@ -39248,7 +39337,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 +40098,7 @@ 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;
   const resolved = resolveAgentCommand(agentType);
   if (!resolved) return false;
   let sqliteChanged = false;
@@ -40020,11 +40109,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;
@@ -40082,7 +40173,6 @@ async function probeAgentCapabilitiesForDetectedTypes(params) {
     cwd,
     workspaceId,
     log: log2,
-    getDb,
     reportAgentCapabilities,
     bridgeReport = true,
     forceAllTypes = false
@@ -40094,7 +40184,7 @@ async function probeAgentCapabilitiesForDetectedTypes(params) {
     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 +40195,6 @@ async function probeAgentCapabilitiesForDetectedTypes(params) {
       cwd,
       workspaceId,
       log: log2,
-      getDb,
       reportAgentCapabilities,
       bridgeReport
     });
@@ -40116,14 +40205,13 @@ 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;
   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",
@@ -40135,7 +40223,7 @@ async function warmupAgentCapabilitiesOnConnect(params) {
       );
     }
   }
-  sendBatchFromCache();
+  await sendBatchFromCache();
   let types = [];
   try {
     types = [...await detectLocalAgentTypes()];
@@ -40148,11 +40236,10 @@ async function warmupAgentCapabilitiesOnConnect(params) {
       cwd,
       workspaceId,
       log: log2,
-      getDb,
       bridgeReport: false,
       forceAllTypes: false
     });
-    if (n > 0) sendBatchFromCache();
+    if (n > 0) await sendBatchFromCache();
   } catch (e) {
     log2(`[Bridge service] Agent capability probe (missing cache) failed: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -40164,11 +40251,10 @@ async function warmupAgentCapabilitiesOnConnect(params) {
         cwd,
         workspaceId,
         log: log2,
-        getDb,
         bridgeReport: false,
         forceAllTypes: true
       });
-      if (n > 0) sendBatchFromCache();
+      if (n > 0) await sendBatchFromCache();
     } catch (e) {
       log2(`[Bridge service] Agent capability lazy refresh failed: ${e instanceof Error ? e.message : String(e)}`);
     }
@@ -40180,7 +40266,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,11 +40296,13 @@ 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
-      });
+      changed = withCliSqliteSync(
+        (db) => upsertCliAgentCapabilityCache(db, {
+          workspaceId,
+          agentType: info.agentType,
+          configOptions: info.configOptions
+        })
+      );
     } catch {
     }
     if (!changed) return;
@@ -40267,7 +40355,6 @@ async function createBridgeConnection(options) {
       await warmupAgentCapabilitiesOnConnect({
         workspaceId,
         log: logFn,
-        getDb: getCliDatabase,
         getWs
       });
     },