@buildautomaton/cli 0.1.30 → 0.1.32

package/dist/cli.js

@@ -25064,7 +25064,7 @@ var {
 } = import_index.default;
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.30".length > 0 ? "0.1.30" : "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,17 +26996,29 @@ function migrateCliSqlite(db) {
 
 // src/sqlite/cli-database.ts
 var { Database: SqliteDatabase } = sqliteWasm;
-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();
-  });
+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");
+    db.run("PRAGMA temp_store = FILE");
+  } catch {
+  }
 }
 function safeCloseCliSqliteDatabase(db) {
   if (db == null) return;
@@ -27011,32 +27028,86 @@ 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);
   } catch (e) {
     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) {
@@ -34670,6 +34741,28 @@ function sendGitHeadVsWorkspaceForToolPaths(mergedPaths, sentPaths, send, sessio
   }
 }
 
+// src/agents/acp/hooks/bridge-on-session-update/send-session-info-title-update.ts
+function extractSessionInfoTitle(params) {
+  if (!params || typeof params !== "object") return null;
+  const p = params;
+  const title = typeof p.title === "string" ? p.title.trim() : "";
+  return title ? title : null;
+}
+function sendSessionInfoTitleUpdate(params) {
+  const title = extractSessionInfoTitle(params.payload);
+  if (!title || !params.runId || !params.send) return;
+  try {
+    params.send({
+      type: "session_title_update",
+      ...params.sessionId ? { sessionId: params.sessionId } : {},
+      runId: params.runId,
+      title
+    });
+  } catch (err) {
+    params.log(`[Bridge service] Session title update send failed: ${errorMessage(err)}`);
+  }
+}
+
 // src/agents/acp/hooks/bridge-on-session-update/create-bridge-on-session-update.ts
 function createBridgeOnSessionUpdate(opts) {
   const { routing, getSendSessionUpdate, log: log2, sessionParentPath } = opts;
@@ -34685,6 +34778,10 @@ function createBridgeOnSessionUpdate(opts) {
     if (updateKind === "config_option_update") {
       return;
     }
+    if (updateKind === "session_info_update") {
+      sendSessionInfoTitleUpdate({ payload: params, runId, sessionId, send, log: log2 });
+      return;
+    }
     const isCompletedToolCallUpdate = updateKind === "tool_call_update" && isCompletedToolStatus(p.status);
     const toolName = p.toolCall?.name ?? p.tool_call?.name ?? "";
     const isToolUpdate = updateKind === "tool_call" || updateKind === "tool_call_update" || typeof toolName === "string" && toolName.length > 0;
@@ -34778,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 {
   }
 }
@@ -36410,45 +36531,36 @@ 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";
-async function walkWorkspaceTreeAsync(dir, baseDir, out, state) {
+function shouldSkipWorkspaceWalkEntry(name) {
+  return name.startsWith(".");
+}
+function walkWorkspaceTreeSync(dir, baseDir, onFile) {
   let names;
   try {
-    names = await fs25.promises.readdir(dir);
+    names = fs25.readdirSync(dir);
   } catch {
     return;
   }
   for (const name of names) {
-    if (name.startsWith(".")) continue;
-    if (state.n > 0 && state.n % INDEX_WORK_YIELD_EVERY === 0) {
-      await yieldToEventLoop();
-    }
-    state.n++;
+    if (shouldSkipWorkspaceWalkEntry(name)) continue;
     const full = path28.join(dir, name);
     let stat3;
     try {
-      stat3 = await fs25.promises.stat(full);
+      stat3 = fs25.statSync(full);
     } catch {
       continue;
     }
     const relative5 = path28.relative(baseDir, full).replace(/\\/g, "/");
     if (stat3.isDirectory()) {
-      await walkWorkspaceTreeAsync(full, baseDir, out, state);
+      walkWorkspaceTreeSync(full, baseDir, onFile);
     } else if (stat3.isFile()) {
-      out.push(relative5);
+      onFile(relative5);
     }
   }
 }
-function createWalkYieldState() {
-  return { n: 0 };
-}
 
 // src/files/index/file-index-sqlite-lock.ts
 import fs26 from "node:fs";
@@ -36481,80 +36593,98 @@ function withFileIndexSqliteLock(fn) {
 }
 
 // src/files/index/build-file-index.ts
-function sortPaths(paths) {
-  paths.sort((a, b) => a.localeCompare(b, void 0, { sensitivity: "base" }));
-}
-function persistPathsToSqlite(resolved, paths) {
-  const db = getCliDatabase();
-  const h = getCwdHashForFileIndex(resolved);
-  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_INSERT_BUFFER = 2048;
+function persistFileIndexForResolvedCwd(resolved) {
+  return withCliSqliteSync((db) => {
+    const h = getCwdHashForFileIndex(resolved);
+    const buf = [];
+    let pathCount = 0;
+    db.run("BEGIN IMMEDIATE");
     try {
-      for (const rel of paths) {
-        ins.run([h, rel]);
+      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();
       }
-    } finally {
-      ins.finalize();
-    }
-    db.run("COMMIT");
-  } catch (e) {
-    try {
-      db.run("ROLLBACK");
-    } catch {
+      db.run("COMMIT");
+    } catch (e) {
+      try {
+        db.run("ROLLBACK");
+      } catch {
+      }
+      throw e;
     }
-    throw e;
-  }
+    return pathCount;
+  });
 }
 async function buildFileIndexAsync(cwd) {
   return withFileIndexSqliteLock(async () => {
     const resolved = path29.resolve(cwd);
-    const paths = [];
-    await walkWorkspaceTreeAsync(resolved, resolved, paths, createWalkYieldState());
     await yieldToEventLoop();
-    sortPaths(paths);
-    persistPathsToSqlite(resolved, paths);
-    return { pathCount: paths.length };
+    const pathCount = persistFileIndexForResolvedCwd(resolved);
+    await yieldToEventLoop();
+    return { pathCount };
   });
 }
 
 // src/files/index/ensure-file-index.ts
 import path30 from "node:path";
 
+// src/files/index/file-index-dependency-path.ts
+function sqliteExprBridgeFileIndexDependencyRank() {
+  return `CASE WHEN lower(path) = 'node_modules' OR lower(path) LIKE 'node_modules/%' OR lower(path) LIKE '%/node_modules/%' OR lower(path) = 'bower_components' OR lower(path) LIKE 'bower_components/%' OR lower(path) LIKE '%/bower_components/%' THEN 1 ELSE 0 END`;
+}
+
 // src/files/index/search-file-index.ts
 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)));
+  const depRank = sqliteExprBridgeFileIndexDependencyRank();
   const rows = db.all(
-    `SELECT path FROM file_index_path WHERE cwd_hash = ? AND lower(path) LIKE ? ESCAPE '\\' LIMIT ?`,
+    `SELECT path FROM file_index_path WHERE cwd_hash = ? AND lower(path) LIKE ? ESCAPE '\\' ORDER BY ${depRank}, path LIMIT ?`,
     [h, pattern, lim]
   );
   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;
 }
@@ -36562,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 };
 }
@@ -36572,7 +36702,6 @@ async function ensureFileIndexAsync(cwd) {
 var DEBOUNCE_MS = 900;
 function shouldIgnoreRelative(rel) {
   const n = rel.replace(/\\/g, "/");
-  if (n.includes("/node_modules/") || n.startsWith("node_modules/")) return true;
   if (n.includes("/.git/") || n === ".git" || n.startsWith(".git/")) return true;
   if (n.includes("/.buildautomaton/") || n.startsWith(".buildautomaton/")) return true;
   return false;
@@ -38245,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;
@@ -38365,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);
@@ -38378,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) {
@@ -38387,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, {
@@ -38406,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" }];
@@ -38428,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;
@@ -38436,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;
 }
@@ -38467,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) => {
@@ -39205,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,
@@ -39966,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;
@@ -39977,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;
@@ -40039,7 +40173,6 @@ async function probeAgentCapabilitiesForDetectedTypes(params) {
     cwd,
     workspaceId,
     log: log2,
-    getDb,
     reportAgentCapabilities,
     bridgeReport = true,
     forceAllTypes = false
@@ -40051,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 {
@@ -40062,7 +40195,6 @@ async function probeAgentCapabilitiesForDetectedTypes(params) {
       cwd,
       workspaceId,
       log: log2,
-      getDb,
       reportAgentCapabilities,
       bridgeReport
     });
@@ -40073,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",
@@ -40092,7 +40223,7 @@ async function warmupAgentCapabilitiesOnConnect(params) {
       );
     }
   }
-  sendBatchFromCache();
+  await sendBatchFromCache();
   let types = [];
   try {
     types = [...await detectLocalAgentTypes()];
@@ -40105,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)}`);
   }
@@ -40121,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)}`);
     }
@@ -40137,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
@@ -40167,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;
@@ -40224,7 +40355,6 @@ async function createBridgeConnection(options) {
       await warmupAgentCapabilitiesOnConnect({
         workspaceId,
         log: logFn,
-        getDb: getCliDatabase,
         getWs
       });
     },