@buildautomaton/cli 0.1.56 → 0.1.57

package/dist/index.js

@@ -4175,8 +4175,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path71, errorMaps, issueData } = params;
-      const fullPath = [...path71, ...issueData.path || []];
+      const { data, path: path73, errorMaps, issueData } = params;
+      const fullPath = [...path73, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -4484,11 +4484,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path71, key) {
+      constructor(parent, value, path73, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path71;
+        this._path = path73;
         this._key = key;
       }
       get path() {
@@ -8103,10 +8103,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path71) {
-  if (!path71)
+function getElementAtPath(obj, path73) {
+  if (!path73)
     return obj;
-  return path71.reduce((acc, key) => acc?.[key], obj);
+  return path73.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -8355,11 +8355,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path71, issues) {
+function prefixIssues(path73, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path71);
+    iss.path.unshift(path73);
     return iss;
   });
 }
@@ -8548,7 +8548,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path71 = []) => {
+  const processError = (error41, path73 = []) => {
     var _a2, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -8558,7 +8558,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path71, ...issue2.path];
+        const fullpath = [...path73, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -8588,9 +8588,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path71) {
+function toDotPath(path73) {
   const segs = [];
-  for (const seg of path71) {
+  for (const seg of path73) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -21596,7 +21596,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path71, checkUnignored, mode) {
+      test(path73, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -21605,7 +21605,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path71);
+          const matched = rule[mode].test(path73);
           if (!matched) {
             return;
           }
@@ -21626,17 +21626,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path71, originalPath, doThrow) => {
-      if (!isString(path71)) {
+    var checkPath = (path73, originalPath, doThrow) => {
+      if (!isString(path73)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path71) {
+      if (!path73) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path71)) {
+      if (checkPath.isNotRelative(path73)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -21645,7 +21645,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path71) => REGEX_TEST_INVALID_PATH.test(path71);
+    var isNotRelative = (path73) => REGEX_TEST_INVALID_PATH.test(path73);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -21675,19 +21675,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache2, checkUnignored, slices) {
-        const path71 = originalPath && checkPath.convert(originalPath);
+        const path73 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path71,
+          path73,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path71, cache2, checkUnignored, slices);
+        return this._t(path73, cache2, checkUnignored, slices);
       }
-      checkIgnore(path71) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path71)) {
-          return this.test(path71);
+      checkIgnore(path73) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path73)) {
+          return this.test(path73);
         }
-        const slices = path71.split(SLASH).filter(Boolean);
+        const slices = path73.split(SLASH).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -21700,18 +21700,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path71, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path73, false, MODE_CHECK_IGNORE);
       }
-      _t(path71, cache2, checkUnignored, slices) {
-        if (path71 in cache2) {
-          return cache2[path71];
+      _t(path73, cache2, checkUnignored, slices) {
+        if (path73 in cache2) {
+          return cache2[path73];
         }
         if (!slices) {
-          slices = path71.split(SLASH).filter(Boolean);
+          slices = path73.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache2[path71] = this._rules.test(path71, checkUnignored, MODE_IGNORE);
+          return cache2[path73] = this._rules.test(path73, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -21719,29 +21719,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache2[path71] = parent.ignored ? parent : this._rules.test(path71, checkUnignored, MODE_IGNORE);
+        return cache2[path73] = parent.ignored ? parent : this._rules.test(path73, checkUnignored, MODE_IGNORE);
       }
-      ignores(path71) {
-        return this._test(path71, this._ignoreCache, false).ignored;
+      ignores(path73) {
+        return this._test(path73, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path71) => !this.ignores(path71);
+        return (path73) => !this.ignores(path73);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path71) {
-        return this._test(path71, this._testCache, true);
+      test(path73) {
+        return this._test(path73, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path71) => checkPath(path71 && checkPath.convert(path71), path71, RETURN_FALSE);
+    var isPathValid = (path73) => checkPath(path73 && checkPath.convert(path73), path73, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path71) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path71) || isNotRelative(path71);
+      checkPath.isNotRelative = (path73) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path73) || isNotRelative(path73);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -22530,10 +22530,10 @@ var require_src2 = __commonJS({
     var fs_1 = __require("fs");
     var debug_1 = __importDefault(require_src());
     var log2 = debug_1.default("@kwsites/file-exists");
-    function check2(path71, isFile, isDirectory) {
-      log2(`checking %s`, path71);
+    function check2(path73, isFile, isDirectory) {
+      log2(`checking %s`, path73);
       try {
-        const stat2 = fs_1.statSync(path71);
+        const stat2 = fs_1.statSync(path73);
         if (stat2.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -22553,8 +22553,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path71, type = exports.READABLE) {
-      return check2(path71, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path73, type = exports.READABLE) {
+      return check2(path73, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -23640,9 +23640,9 @@ function parseChangeSummaryJson(raw, allowedPaths, options) {
     const rawPath = typeof o.path === "string" ? o.path.trim() : "";
     const summary = typeof o.summary === "string" ? o.summary.trim() : "";
     if (!rawPath || !summary) continue;
-    const path71 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
-    if (!path71) continue;
-    rows.push({ path: path71, summary: clampSummaryToAtMostTwoLines(summary) });
+    const path73 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
+    if (!path73) continue;
+    rows.push({ path: path73, summary: clampSummaryToAtMostTwoLines(summary) });
   }
   return rows;
 }
@@ -24956,8 +24956,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path71, body) {
-  const url2 = `http://127.0.0.1:${port}${path71}`;
+async function requestPreviewApi(port, secret, method, path73, body) {
+  const url2 = `http://127.0.0.1:${port}${path73}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -24969,7 +24969,7 @@ async function requestPreviewApi(port, secret, method, path71, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path71}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path73}: ${res.status}`);
   }
   return data;
 }
@@ -25184,7 +25184,7 @@ function installBridgeProcessResilience() {
 }
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.56".length > 0 ? "0.1.56" : "0.0.0-dev";
+var CLI_VERSION = "0.1.57".length > 0 ? "0.1.57" : "0.0.0-dev";
 
 // src/connection/heartbeat/constants.ts
 var BRIDGE_APP_HEARTBEAT_INTERVAL_MS = 1e4;
@@ -26043,7 +26043,7 @@ function clearMainBridgeReconnectQuietOnOpen(state, log2) {
 function scheduleMainBridgeReconnect(state, connect, log2, closeMeta) {
   if (state.closedByUser || state.currentWs != null) return;
   const meta = closeMeta ?? state.lastReconnectCloseMeta ?? void 0;
-  const delay2 = applyTieredReconnectPlanAndLog(
+  const delay3 = applyTieredReconnectPlanAndLog(
     state.mainOutage,
     log2,
     BRIDGE_SERVICE_LABEL,
@@ -26052,7 +26052,7 @@ function scheduleMainBridgeReconnect(state, connect, log2, closeMeta) {
     meta?.reason
   );
   armReconnectDelayTimer({
-    delayMs: delay2,
+    delayMs: delay3,
     bumpAttempt: () => {
       state.reconnectAttempt += 1;
     },
@@ -26254,10 +26254,10 @@ function runPendingAuth(options) {
         }
         if (resolved) return;
         beginDeferredPendingCloseLog(code, reason);
-        const delay2 = pendingAuthReconnectDelayMs(reconnectAttempt);
+        const delay3 = pendingAuthReconnectDelayMs(reconnectAttempt);
         reconnectAttempt += 1;
         if (signInQuiet.verboseLogs) {
-          const delayLabel = formatReconnectDelayForLog(delay2);
+          const delayLabel = formatReconnectDelayForLog(delay3);
           logFn(
             `[Bridge service] Next sign-in connection attempt in ${delayLabel} (attempt ${reconnectAttempt}).`
           );
@@ -26265,7 +26265,7 @@ function runPendingAuth(options) {
         reconnectTimeout = setTimeout(() => {
           reconnectTimeout = null;
           connect();
-        }, delay2);
+        }, delay3);
       },
       onError: (err) => logCliWebSocketError(logFn, "[Bridge service]", err, "while waiting for sign-in"),
       onMessage: (data) => {
@@ -26359,11 +26359,7 @@ function isCliSqliteLockError(e) {
   return lower.includes("database is locked") || lower.includes("sqlite_busy") || lower.includes("sqlite3_busy") || lower.includes("database") && lower.includes("locked");
 }
 
-// src/sqlite/create-sqlite-database-access.ts
-var { Database: SqliteDatabase } = sqliteWasm;
-var SYNC_RETRY_MAX = 40;
-var ASYNC_RETRY_MAX = 60;
-var ASYNC_BASE_DELAY_MS = 20;
+// src/sqlite/sqlite-pragmas.ts
 function applySqliteConcurrencyPragmas(db) {
   try {
     db.run("PRAGMA foreign_keys = ON");
@@ -26389,12 +26385,17 @@ function applySqliteMemoryPragmas(db) {
   } catch {
   }
 }
+
+// src/sqlite/sqlite-lock-retry.ts
+var SYNC_RETRY_MAX = 40;
+var ASYNC_RETRY_MAX = 60;
+var ASYNC_BASE_DELAY_MS = 20;
 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());
+    const chunk = Math.min(10, deadline - Date.now());
     if (chunk <= 0) break;
     try {
       const sab = new SharedArrayBuffer(4);
@@ -26418,7 +26419,22 @@ async function asyncDelayMsInterruptible(ms) {
     await yieldToEventLoop();
   }
 }
+
+// src/sqlite/create-sqlite-database-access.ts
+var { Database: SqliteDatabase } = sqliteWasm;
 function createSqliteDatabaseAccess(config2) {
+  let migrateDoneForPath = null;
+  function shouldSkipMigrate(sqlitePath, db) {
+    if (migrateDoneForPath !== sqlitePath) return false;
+    try {
+      const row = db.get(
+        "SELECT 1 as ok FROM sqlite_master WHERE type='table' AND name='__migrations' LIMIT 1"
+      );
+      return row != null;
+    } catch {
+      return false;
+    }
+  }
   function safeClose(db) {
     if (db == null) return;
     try {
@@ -26434,7 +26450,11 @@ function createSqliteDatabaseAccess(config2) {
     try {
       applySqliteConcurrencyPragmas(db);
       applySqliteMemoryPragmas(db);
-      config2.migrate(db);
+      const sqlitePath2 = config2.getPath();
+      if (!shouldSkipMigrate(sqlitePath2, db)) {
+        config2.migrate(db);
+        migrateDoneForPath = sqlitePath2;
+      }
       config2.afterOpen?.(db, options);
     } catch (e) {
       safeClose(db);
@@ -26490,14 +26510,16 @@ function createSqliteDatabaseAccess(config2) {
   async function ensureInitialized(options) {
     await withAsync(() => void 0, options);
   }
+  function closeAllConnections() {
+    migrateDoneForPath = null;
+  }
   return {
     safeClose,
     openConnection,
     withSync,
     withAsync,
     ensureInitialized,
-    closeAllConnections: () => {
-    }
+    closeAllConnections
   };
 }
 
@@ -26697,7 +26719,7 @@ function readMigrationSql(filename, ...searchSubdirs) {
     join(moduleDir, "..", sub, filename),
     join(moduleDir, "..", "..", "dist", sub, filename)
   ]);
-  const resolved = candidates.find((path71) => existsSync(path71));
+  const resolved = candidates.find((path73) => existsSync(path73));
   if (!resolved) {
     throw new Error(`Missing SQLite migration SQL: ${filename} (searched ${searchSubdirs.join(", ")})`);
   }
@@ -26829,6 +26851,161 @@ var withCliSqliteSync = cliSqlite.withSync;
 var withCliSqlite = cliSqlite.withAsync;
 var ensureCliSqliteInitialized = cliSqlite.ensureInitialized;
 
+// src/sqlite/code-nav-cache/code-nav-cache-paths.ts
+import fs14 from "node:fs";
+import path12 from "node:path";
+import os7 from "node:os";
+function getCodeNavCacheSqlitePath() {
+  const override = process.env.BUILDAMATON_CODE_NAV_CACHE_SQLITE_PATH?.trim();
+  if (override) return path12.resolve(override);
+  return path12.join(os7.homedir(), ".buildautomaton", "code-nav-cache.sqlite");
+}
+function ensureCodeNavCacheSqliteParentDir(sqlitePath) {
+  const dir = path12.dirname(sqlitePath);
+  if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
+}
+
+// src/sqlite/code-nav-cache/migrate-code-nav-cache-sqlite.ts
+var CHECKPOINT_V12 = "001_code_nav_cache_checkpoint_v1";
+var CHECKPOINT_V1_SQL2 = readCodeNavCacheMigrationSql("001_code_nav_cache_checkpoint_v1.sql");
+var MIGRATION_002 = "002_content_hash_symbol_index";
+var MIGRATION_002_SQL = readCodeNavCacheMigrationSql("002_content_hash_symbol_index.sql");
+var MIGRATION_003 = "003_content_hash_tag_rows";
+var MIGRATION_003_SQL = readCodeNavCacheMigrationSql("003_content_hash_tag_rows.sql");
+var CODE_NAV_CACHE_SQLITE_MIGRATIONS = [
+  {
+    name: CHECKPOINT_V12,
+    checkpoint: true,
+    migrate: (db) => {
+      db.exec(CHECKPOINT_V1_SQL2);
+    },
+    alreadyApplied: (db) => {
+      const row = db.get(
+        `SELECT 1 as ok FROM sqlite_master WHERE type='table' AND name='file_index_parent_path' LIMIT 1`
+      );
+      return row != null;
+    }
+  },
+  {
+    name: MIGRATION_002,
+    migrate: (db) => {
+      db.exec(MIGRATION_002_SQL);
+    },
+    alreadyApplied: (db) => {
+      const row = db.get(
+        `SELECT 1 as ok FROM sqlite_master WHERE type='table' AND name='symbol_file_blob' LIMIT 1`
+      );
+      return row != null;
+    }
+  },
+  {
+    name: MIGRATION_003,
+    migrate: (db) => {
+      db.exec(MIGRATION_003_SQL);
+    },
+    alreadyApplied: (db) => {
+      const row = db.get(
+        `SELECT 1 as ok FROM sqlite_master WHERE type='table' AND name='symbol_index_tag' LIMIT 1`
+      );
+      if (row == null) return false;
+      const blob = db.get(
+        `SELECT 1 as ok FROM sqlite_master WHERE type='table' AND name='symbol_file_blob' LIMIT 1`
+      );
+      return blob == null;
+    }
+  }
+];
+function migrateCodeNavCacheSqlite(db) {
+  runSqliteMigrations(
+    db,
+    CODE_NAV_CACHE_SQLITE_MIGRATIONS,
+    readCodeNavCacheMigrationSql("000_bootstrap_migrations_table.sql"),
+    "code-nav-cache"
+  );
+}
+
+// src/sqlite/code-nav-cache/code-nav-cache-sqlite-work-lock.ts
+import fs15 from "node:fs";
+function isSqliteCorruptError(e) {
+  const msg = e instanceof Error ? e.message : String(e);
+  return msg.includes("malformed") || msg.includes("database disk image is malformed") || msg.includes("corrupt");
+}
+var chain = Promise.resolve();
+var workLockDepth = 0;
+function resetCodeNavCacheSqliteWorkLock() {
+  chain = Promise.resolve();
+  workLockDepth = 0;
+}
+function withCodeNavCacheSqliteWorkLock(fn) {
+  if (workLockDepth > 0) {
+    return Promise.resolve(fn());
+  }
+  const run = async () => {
+    workLockDepth += 1;
+    try {
+      return await Promise.resolve(fn());
+    } finally {
+      workLockDepth = Math.max(0, workLockDepth - 1);
+    }
+  };
+  const runWithCorruptRecovery = async () => {
+    try {
+      return await run();
+    } catch (e) {
+      if (!isSqliteCorruptError(e)) throw e;
+      try {
+        fs15.unlinkSync(getCodeNavCacheSqlitePath());
+      } catch {
+      }
+      chain = Promise.resolve();
+      return await run();
+    }
+  };
+  const next = chain.then(runWithCorruptRecovery);
+  chain = next.then(
+    () => void 0,
+    () => void 0
+  );
+  return next;
+}
+
+// src/sqlite/code-nav-cache/code-nav-cache-database.ts
+var codeNavCacheSqlite = createSqliteDatabaseAccess({
+  getPath: getCodeNavCacheSqlitePath,
+  ensureParentDir: ensureCodeNavCacheSqliteParentDir,
+  migrate: migrateCodeNavCacheSqlite
+});
+var codeNavCacheAccessDepth = 0;
+async function waitForOuterCodeNavCacheAccessAsync() {
+  while (codeNavCacheAccessDepth > 0) {
+    if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+    await new Promise((resolve32) => setTimeout(resolve32, 5));
+    await yieldToEventLoop();
+  }
+}
+var safeCloseCodeNavCacheSqliteDatabase = codeNavCacheSqlite.safeClose;
+function closeAllCodeNavCacheSqliteConnections() {
+  codeNavCacheSqlite.closeAllConnections();
+  resetCodeNavCacheSqliteWorkLock();
+  codeNavCacheAccessDepth = 0;
+}
+var openCodeNavCacheSqliteConnection = codeNavCacheSqlite.openConnection;
+async function withCodeNavCacheSqlite(fn) {
+  return withCodeNavCacheSqliteWorkLock(async () => {
+    const nested = codeNavCacheAccessDepth > 0;
+    if (!nested) await waitForOuterCodeNavCacheAccessAsync();
+    codeNavCacheAccessDepth += 1;
+    try {
+      return await codeNavCacheSqlite.withAsync(fn);
+    } finally {
+      codeNavCacheAccessDepth = Math.max(0, codeNavCacheAccessDepth - 1);
+    }
+  });
+}
+async function ensureCodeNavCacheSqliteInitialized() {
+  await withCodeNavCacheSqlite(() => void 0);
+}
+
 // src/connection/close-bridge-connection.ts
 async function closeBridgeConnection(state, acpManager, devServerManager, log2) {
   requestCliImmediateShutdown();
@@ -26874,6 +27051,7 @@ async function closeBridgeConnection(state, acpManager, devServerManager, log2)
   }
   try {
     closeAllCliSqliteConnections();
+    closeAllCodeNavCacheSqliteConnections();
   } catch {
   }
   say("Shutdown complete.");
@@ -26960,16 +27138,16 @@ import * as fs20 from "node:fs";
 import * as path24 from "node:path";
 
 // src/paths/session-layout-paths.ts
-import * as path12 from "node:path";
+import * as path13 from "node:path";
 function resolveIsolatedSessionParentPathFromCheckouts(worktreePaths) {
-  const resolved = worktreePaths.map((p) => path12.resolve(p)).filter(Boolean);
+  const resolved = worktreePaths.map((p) => path13.resolve(p)).filter(Boolean);
   if (resolved.length === 0) return null;
   resolved.sort();
   return resolved[0];
 }
 function resolveSessionParentPathForAgentProcess(resolvedSessionParentPath) {
   if (resolvedSessionParentPath != null && String(resolvedSessionParentPath).trim() !== "") {
-    return path12.resolve(String(resolvedSessionParentPath).trim());
+    return path13.resolve(String(resolvedSessionParentPath).trim());
   }
   return getBridgeRoot();
 }
@@ -27710,16 +27888,16 @@ import { existsSync as existsSync2, statSync } from "node:fs";
 
 // src/git/get-git-repo-root-sync.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 function getGitRepoRootSync(startDir) {
   try {
     const out = execFileSync2("git", ["rev-parse", "--show-toplevel"], {
-      cwd: path13.resolve(startDir),
+      cwd: path14.resolve(startDir),
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       maxBuffer: 1024 * 1024
     }).trim();
-    return out ? path13.resolve(out) : null;
+    return out ? path14.resolve(out) : null;
   } catch {
     return null;
   }
@@ -27728,25 +27906,25 @@ function getGitRepoRootSync(startDir) {
 // src/agents/acp/workspace-files.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { readFileSync as readFileSync3 } from "node:fs";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 function resolveWorkspaceFilePath(sessionParentPath, rawPath) {
   const trimmed2 = rawPath.trim();
   if (!trimmed2) return null;
-  const normalizedSessionParent = path14.resolve(sessionParentPath);
+  const normalizedSessionParent = path15.resolve(sessionParentPath);
   let resolvedPath = resolveSafePathUnderCwd(sessionParentPath, trimmed2);
   if (!resolvedPath) {
-    const candidate = path14.isAbsolute(trimmed2) ? path14.normalize(trimmed2) : path14.normalize(path14.resolve(normalizedSessionParent, trimmed2));
+    const candidate = path15.isAbsolute(trimmed2) ? path15.normalize(trimmed2) : path15.normalize(path15.resolve(normalizedSessionParent, trimmed2));
     const gitRoot2 = getGitRepoRootSync(sessionParentPath);
     if (!gitRoot2) return null;
-    const rel = path14.relative(gitRoot2, candidate);
-    if (rel.startsWith("..") || path14.isAbsolute(rel)) return null;
+    const rel = path15.relative(gitRoot2, candidate);
+    if (rel.startsWith("..") || path15.isAbsolute(rel)) return null;
     resolvedPath = candidate;
   }
   const gitRoot = getGitRepoRootSync(sessionParentPath);
   if (gitRoot) {
-    const relFromRoot = path14.relative(gitRoot, resolvedPath);
-    if (!relFromRoot.startsWith("..") && !path14.isAbsolute(relFromRoot)) {
-      return { resolvedPath, display: relFromRoot.split(path14.sep).join("/") };
+    const relFromRoot = path15.relative(gitRoot, resolvedPath);
+    if (!relFromRoot.startsWith("..") && !path15.isAbsolute(relFromRoot)) {
+      return { resolvedPath, display: relFromRoot.split(path15.sep).join("/") };
     }
   }
   return { resolvedPath, display: toDisplayPathRelativeToCwd(sessionParentPath, resolvedPath) };
@@ -27755,9 +27933,9 @@ function readUtf8WorkspaceFile(sessionParentPath, displayPath) {
   if (!displayPath || displayPath.includes("..")) return "";
   const gitRoot = getGitRepoRootSync(sessionParentPath);
   if (gitRoot) {
-    const resolvedPath2 = path14.resolve(gitRoot, displayPath);
-    const rel = path14.relative(gitRoot, resolvedPath2);
-    if (!rel.startsWith("..") && !path14.isAbsolute(rel)) {
+    const resolvedPath2 = path15.resolve(gitRoot, displayPath);
+    const rel = path15.relative(gitRoot, resolvedPath2);
+    if (!rel.startsWith("..") && !path15.isAbsolute(rel)) {
       try {
         return readFileSync3(resolvedPath2, "utf8");
       } catch {
@@ -27776,9 +27954,9 @@ function tryWorkspaceDisplayToPath(sessionParentPath, displayPath) {
   if (!displayPath || displayPath.includes("..")) return null;
   const gitRoot = getGitRepoRootSync(sessionParentPath);
   if (gitRoot) {
-    const resolvedPath = path14.resolve(gitRoot, displayPath);
-    const rel = path14.relative(gitRoot, resolvedPath);
-    if (!rel.startsWith("..") && !path14.isAbsolute(rel)) return resolvedPath;
+    const resolvedPath = path15.resolve(gitRoot, displayPath);
+    const rel = path15.relative(gitRoot, resolvedPath);
+    if (!rel.startsWith("..") && !path15.isAbsolute(rel)) return resolvedPath;
   }
   return resolveSafePathUnderCwd(sessionParentPath, displayPath);
 }
@@ -27829,92 +28007,22 @@ function getSessionFileChangeDirectoryFlags(sessionParentPath, displayPath) {
   return { isDirectory: false, directoryRemoved: false };
 }
 
-// src/sqlite/code-nav-cache/code-nav-cache-paths.ts
-import fs14 from "node:fs";
-import path15 from "node:path";
-import os7 from "node:os";
-function getCodeNavCacheSqlitePath() {
-  const override = process.env.BUILDAMATON_CODE_NAV_CACHE_SQLITE_PATH?.trim();
-  if (override) return path15.resolve(override);
-  return path15.join(os7.homedir(), ".buildautomaton", "code-nav-cache.sqlite");
-}
-function ensureCodeNavCacheSqliteParentDir(sqlitePath) {
-  const dir = path15.dirname(sqlitePath);
-  if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
-}
-
-// src/sqlite/code-nav-cache/migrate-code-nav-cache-sqlite.ts
-var CHECKPOINT_V12 = "001_code_nav_cache_checkpoint_v1";
-var CHECKPOINT_V1_SQL2 = readCodeNavCacheMigrationSql("001_code_nav_cache_checkpoint_v1.sql");
-var MIGRATION_002 = "002_content_hash_symbol_index";
-var MIGRATION_002_SQL = readCodeNavCacheMigrationSql("002_content_hash_symbol_index.sql");
-var MIGRATION_003 = "003_content_hash_tag_rows";
-var MIGRATION_003_SQL = readCodeNavCacheMigrationSql("003_content_hash_tag_rows.sql");
-var CODE_NAV_CACHE_SQLITE_MIGRATIONS = [
-  {
-    name: CHECKPOINT_V12,
-    checkpoint: true,
-    migrate: (db) => {
-      db.exec(CHECKPOINT_V1_SQL2);
-    },
-    alreadyApplied: (db) => {
-      const row = db.get(
-        `SELECT 1 as ok FROM sqlite_master WHERE type='table' AND name='file_index_parent_path' LIMIT 1`
-      );
-      return row != null;
-    }
-  },
-  {
-    name: MIGRATION_002,
-    migrate: (db) => {
-      db.exec(MIGRATION_002_SQL);
-    },
-    alreadyApplied: (db) => {
-      const row = db.get(
-        `SELECT 1 as ok FROM sqlite_master WHERE type='table' AND name='symbol_file_blob' LIMIT 1`
-      );
-      return row != null;
-    }
-  },
-  {
-    name: MIGRATION_003,
-    migrate: (db) => {
-      db.exec(MIGRATION_003_SQL);
-    },
-    alreadyApplied: (db) => {
-      const row = db.get(
-        `SELECT 1 as ok FROM sqlite_master WHERE type='table' AND name='symbol_index_tag' LIMIT 1`
-      );
-      if (row == null) return false;
-      const blob = db.get(
-        `SELECT 1 as ok FROM sqlite_master WHERE type='table' AND name='symbol_file_blob' LIMIT 1`
-      );
-      return blob == null;
+// src/sqlite/code-nav-cache/code-nav-cache-sqlite-transaction.ts
+function runCodeNavCacheWriteTransaction(db, fn) {
+  db.run("BEGIN IMMEDIATE");
+  try {
+    const result = fn();
+    db.run("COMMIT");
+    return result;
+  } catch (e) {
+    try {
+      db.run("ROLLBACK");
+    } catch {
     }
+    throw e;
   }
-];
-function migrateCodeNavCacheSqlite(db) {
-  runSqliteMigrations(
-    db,
-    CODE_NAV_CACHE_SQLITE_MIGRATIONS,
-    readCodeNavCacheMigrationSql("000_bootstrap_migrations_table.sql"),
-    "code-nav-cache"
-  );
 }
 
-// src/sqlite/code-nav-cache/code-nav-cache-database.ts
-var codeNavCacheSqlite = createSqliteDatabaseAccess({
-  getPath: getCodeNavCacheSqlitePath,
-  ensureParentDir: ensureCodeNavCacheSqliteParentDir,
-  migrate: migrateCodeNavCacheSqlite
-});
-var safeCloseCodeNavCacheSqliteDatabase = codeNavCacheSqlite.safeClose;
-var closeAllCodeNavCacheSqliteConnections = codeNavCacheSqlite.closeAllConnections;
-var openCodeNavCacheSqliteConnection = codeNavCacheSqlite.openConnection;
-var withCodeNavCacheSqliteSync = codeNavCacheSqlite.withSync;
-var withCodeNavCacheSqlite = codeNavCacheSqlite.withAsync;
-var ensureCodeNavCacheSqliteInitialized = codeNavCacheSqlite.ensureInitialized;
-
 // src/code-nav/yield-during-work.ts
 var CODE_NAV_YIELD_EVERY = INDEX_WORK_YIELD_EVERY;
 function createCodeNavYieldState() {
@@ -27929,11 +28037,11 @@ async function yieldDuringCodeNavWork(state) {
 }
 
 // src/code-nav/walk-code-nav-files.ts
-import fs17 from "node:fs";
+import fs18 from "node:fs";
 import path19 from "node:path";
 
 // src/files/index/walk-workspace-tree.ts
-import fs15 from "node:fs";
+import fs16 from "node:fs";
 import path16 from "node:path";
 var DEPENDENCY_INSTALL_DIR_NAMES = /* @__PURE__ */ new Set([
   "node_modules",
@@ -27951,7 +28059,7 @@ function shouldSkipWorkspaceWalkEntry(name) {
 async function walkWorkspaceTreeAsync(dir, baseDir, onFile, state) {
   let names;
   try {
-    names = await fs15.promises.readdir(dir);
+    names = await fs16.promises.readdir(dir);
   } catch {
     return;
   }
@@ -27966,7 +28074,7 @@ async function walkWorkspaceTreeAsync(dir, baseDir, onFile, state) {
     const full = path16.join(dir, name);
     let stat2;
     try {
-      stat2 = await fs15.promises.stat(full);
+      stat2 = await fs16.promises.stat(full);
     } catch {
       continue;
     }
@@ -27984,7 +28092,7 @@ function createWalkYieldState() {
 
 // src/code-nav/gitignore-filter.ts
 var import_ignore = __toESM(require_ignore(), 1);
-import fs16 from "node:fs";
+import fs17 from "node:fs";
 import path17 from "node:path";
 var DEFAULT_IGNORED = [".git", ".git/**"];
 function normalizeRelPath(relPath) {
@@ -27995,7 +28103,7 @@ var GitignoreFilter = class {
   /** Load `.gitignore` in `absDir` and push a layer when the file exists. */
   async enterDirectory(absDir, dirRel) {
     try {
-      const content = await fs16.promises.readFile(path17.join(absDir, ".gitignore"), "utf8");
+      const content = await fs17.promises.readFile(path17.join(absDir, ".gitignore"), "utf8");
       this.layers.push({ dirRel, ig: (0, import_ignore.default)().add(content) });
     } catch {
     }
@@ -28098,7 +28206,7 @@ async function walkCodeNavFilesInDirectory(dir, baseDir, relDir, filter, onFile,
   await filter.enterDirectory(dir, relDir);
   let names;
   try {
-    names = await fs17.promises.readdir(dir);
+    names = await fs18.promises.readdir(dir);
   } catch {
     filter.leaveDirectory(relDir);
     return;
@@ -28115,7 +28223,7 @@ async function walkCodeNavFilesInDirectory(dir, baseDir, relDir, filter, onFile,
     const full = path19.join(dir, name);
     let stat2;
     try {
-      stat2 = await fs17.promises.stat(full);
+      stat2 = await fs18.promises.stat(full);
     } catch {
       continue;
     }
@@ -28322,12 +28430,27 @@ function removeParentFileMapEntry(db, parentId, filePath) {
   db.run("DELETE FROM symbol_parent_file_map WHERE parent_id = ? AND file_path = ?", [parentId, filePath]);
   return previous === void 0 ? null : previous;
 }
-function clearParentFileMap(db, parentId) {
-  const rows = db.all("SELECT content_hash FROM symbol_parent_file_map WHERE parent_id = ? AND content_hash IS NOT NULL", [
-    parentId
-  ]);
-  db.run("DELETE FROM symbol_parent_file_map WHERE parent_id = ?", [parentId]);
-  return rows.map((row) => row.content_hash);
+function clearParentFileMapBatch(db, parentId, limit) {
+  const rows = db.all(
+    `SELECT file_path, content_hash
+     FROM symbol_parent_file_map
+     WHERE parent_id = ?
+     LIMIT ?`,
+    [parentId, limit]
+  );
+  if (rows.length === 0) return { released: [], remaining: false };
+  const del = db.prepare("DELETE FROM symbol_parent_file_map WHERE parent_id = ? AND file_path = ?");
+  try {
+    for (const row of rows) {
+      del.run([parentId, row.file_path]);
+    }
+  } finally {
+    del.finalize();
+  }
+  return {
+    released: rows.flatMap((row) => row.content_hash == null ? [] : [row.content_hash]),
+    remaining: rows.length >= limit
+  };
 }
 
 // src/code-nav/symbol-index/storage/symbol-content-index.ts
@@ -28416,139 +28539,15 @@ function removeSymbolIndexFileData(db, ctx, filePath) {
   const released = removeParentFileMapEntry(db, ctx.parentId, filePath);
   gcReleasedHashes(db, [released]);
 }
-function clearSymbolIndexParentData(db, ctx) {
-  const released = clearParentFileMap(db, ctx.parentId);
+function clearSymbolIndexParentDataBatch(db, ctx, limit) {
+  const { released, remaining } = clearParentFileMapBatch(db, ctx.parentId, limit);
   gcReleasedHashes(db, released);
-}
-
-// src/code-nav/symbol-index/query/tag-query-shared.ts
-var TAG_SELECT = `file_path, name, role, kind, start_line, start_column, end_line, end_column,
-  scope_start_line, scope_start_column, parent_scope_start_line, parent_scope_start_column, nav_target_path, scope_chain`;
-function rowToLocation(row) {
-  return {
-    path: row.file_path,
-    line: row.start_line + 1,
-    column: row.start_column,
-    kind: row.kind,
-    role: row.role === "def" ? "definition" : "reference"
-  };
-}
-function modulePathLocation(row) {
-  return {
-    path: row.nav_target_path,
-    line: 1,
-    column: 0,
-    kind: "module",
-    role: "reference"
-  };
-}
-function emptyRefRow(filePath) {
-  return {
-    file_path: filePath,
-    name: "",
-    role: "ref",
-    kind: "",
-    start_line: 0,
-    start_column: 0,
-    end_line: 0,
-    end_column: 0,
-    scope_start_line: null,
-    scope_start_column: null,
-    parent_scope_start_line: null,
-    parent_scope_start_column: null,
-    nav_target_path: null,
-    scope_chain: null
-  };
-}
-
-// src/code-nav/symbol-index/storage/file-content-load.ts
-function loadFileTags(db, ctx, filePath) {
-  const contentHash = getEffectiveContentHash(db, ctx, filePath);
-  if (contentHash == null) return [];
-  return db.all(
-    `SELECT ${TAG_SELECT}
-     FROM symbol_index_tag
-     WHERE content_hash = ? AND file_path = ?
-     ORDER BY start_line, start_column`,
-    [contentHash, filePath]
-  );
-}
-function loadFileImports(db, ctx, filePath) {
-  const contentHash = getEffectiveContentHash(db, ctx, filePath);
-  if (contentHash == null) return [];
-  return db.all(
-    `SELECT file_path, local_name, source_name, module_specifier, source_file_path, import_kind, start_line, start_column
-     FROM symbol_index_import
-     WHERE content_hash = ? AND file_path = ?
-     ORDER BY start_line, start_column`,
-    [contentHash, filePath]
-  );
-}
-function findTagsByName(db, ctx, name) {
-  const filePaths = listEffectiveIndexedFilePaths(db, ctx);
-  const rows = [];
-  for (const filePath of filePaths) {
-    const contentHash = getEffectiveContentHash(db, ctx, filePath);
-    if (contentHash == null) continue;
-    const matches = db.all(
-      `SELECT ${TAG_SELECT}
-       FROM symbol_index_tag
-       WHERE content_hash = ? AND file_path = ? AND name = ?
-       ORDER BY start_line, start_column`,
-      [contentHash, filePath, name]
-    );
-    rows.push(...matches);
-  }
-  rows.sort(
-    (a, b) => a.file_path.localeCompare(b.file_path) || a.start_line - b.start_line || a.start_column - b.start_column
-  );
-  return rows;
-}
-
-// src/code-nav/symbol-index/lifecycle/symbol-index-file-ready.ts
-function symbolIndexFileIsReady(parentPath, filePath) {
-  const normalizedParent = normalizeResolvedPath(parentPath);
-  const normalizedFile = filePath.replace(/\\/g, "/").replace(/^\/+/, "");
-  if (!normalizedFile) return false;
-  return withCodeNavCacheSqliteSync((db) => {
-    const ctx = getSymbolIndexParentContext(db, normalizedParent);
-    if (ctx == null) return false;
-    const versionRow = db.get("SELECT index_version FROM symbol_index_parent_path WHERE id = ?", [
-      ctx.parentId
-    ]);
-    if (versionRow == null || versionRow.index_version < SYMBOL_INDEX_VERSION) return false;
-    return getEffectiveContentHash(db, ctx, normalizedFile) != null;
-  });
+  return remaining;
 }
 
 // src/code-nav/symbol-index/sqlite/symbol-index-sqlite-lock.ts
-import fs18 from "node:fs";
-function isSqliteCorruptError(e) {
-  const msg = e instanceof Error ? e.message : String(e);
-  return msg.includes("malformed") || msg.includes("database disk image is malformed") || msg.includes("corrupt");
-}
-var chain = Promise.resolve();
 function withSymbolIndexSqliteLock(fn) {
-  const run = async () => {
-    try {
-      return await Promise.resolve(fn());
-    } catch (e) {
-      if (!isSqliteCorruptError(e)) throw e;
-      closeAllCodeNavCacheSqliteConnections();
-      try {
-        fs18.unlinkSync(getCodeNavCacheSqlitePath());
-      } catch {
-      }
-      chain = Promise.resolve();
-      return await Promise.resolve(fn());
-    }
-  };
-  const next = chain.then(run);
-  chain = next.then(
-    () => void 0,
-    () => void 0
-  );
-  return next;
+  return withCodeNavCacheSqliteWorkLock(fn);
 }
 
 // src/code-nav/symbol-index/imports/star-reexport-names.ts
@@ -28653,43 +28652,111 @@ function expandStarReexportBindings(collected) {
 }
 
 // src/code-nav/symbol-index/persistence/persist-single-file.ts
-function persistSymbolIndexFile(resolved, relPath, source, tags, imports) {
-  withCodeNavCacheSqliteSync((db) => {
-    db.run("BEGIN IMMEDIATE");
-    try {
+async function persistSymbolIndexFileAsync(resolved, relPath, source, tags, imports) {
+  await withCodeNavCacheSqlite(async (db) => {
+    runCodeNavCacheWriteTransaction(db, () => {
       upsertSymbolIndexParentPath(db, resolved);
       const ctx = getSymbolIndexParentContext(db, resolved);
       if (ctx == null) throw new Error(`Failed to resolve symbol index parent: ${resolved}`);
       persistSymbolIndexFileData(db, ctx, relPath, source, tags, imports);
-      db.run("COMMIT");
-    } catch (e) {
-      try {
-        db.run("ROLLBACK");
-      } catch {
-      }
-      throw e;
-    }
+    });
   });
 }
-function removeSymbolIndexFile(resolved, relPath) {
-  withCodeNavCacheSqliteSync((db) => {
-    db.run("BEGIN IMMEDIATE");
-    try {
+async function removeSymbolIndexFileAsync(resolved, relPath) {
+  await withCodeNavCacheSqlite(async (db) => {
+    runCodeNavCacheWriteTransaction(db, () => {
       upsertSymbolIndexParentPath(db, resolved);
       const ctx = getSymbolIndexParentContext(db, resolved);
       if (ctx == null) throw new Error(`Failed to resolve symbol index parent: ${resolved}`);
       removeSymbolIndexFileData(db, ctx, relPath);
-      db.run("COMMIT");
-    } catch (e) {
-      try {
-        db.run("ROLLBACK");
-      } catch {
-      }
-      throw e;
-    }
+    });
   });
 }
 
+// src/code-nav/symbol-index/query/tag-query-shared.ts
+var TAG_SELECT = `file_path, name, role, kind, start_line, start_column, end_line, end_column,
+  scope_start_line, scope_start_column, parent_scope_start_line, parent_scope_start_column, nav_target_path, scope_chain`;
+function rowToLocation(row) {
+  return {
+    path: row.file_path,
+    line: row.start_line + 1,
+    column: row.start_column,
+    kind: row.kind,
+    role: row.role === "def" ? "definition" : "reference"
+  };
+}
+function modulePathLocation(row) {
+  return {
+    path: row.nav_target_path,
+    line: 1,
+    column: 0,
+    kind: "module",
+    role: "reference"
+  };
+}
+function emptyRefRow(filePath) {
+  return {
+    file_path: filePath,
+    name: "",
+    role: "ref",
+    kind: "",
+    start_line: 0,
+    start_column: 0,
+    end_line: 0,
+    end_column: 0,
+    scope_start_line: null,
+    scope_start_column: null,
+    parent_scope_start_line: null,
+    parent_scope_start_column: null,
+    nav_target_path: null,
+    scope_chain: null
+  };
+}
+
+// src/code-nav/symbol-index/storage/file-content-load.ts
+function loadFileTags(db, ctx, filePath) {
+  const contentHash = getEffectiveContentHash(db, ctx, filePath);
+  if (contentHash == null) return [];
+  return db.all(
+    `SELECT ${TAG_SELECT}
+     FROM symbol_index_tag
+     WHERE content_hash = ? AND file_path = ?
+     ORDER BY start_line, start_column`,
+    [contentHash, filePath]
+  );
+}
+function loadFileImports(db, ctx, filePath) {
+  const contentHash = getEffectiveContentHash(db, ctx, filePath);
+  if (contentHash == null) return [];
+  return db.all(
+    `SELECT file_path, local_name, source_name, module_specifier, source_file_path, import_kind, start_line, start_column
+     FROM symbol_index_import
+     WHERE content_hash = ? AND file_path = ?
+     ORDER BY start_line, start_column`,
+    [contentHash, filePath]
+  );
+}
+function findTagsByName(db, ctx, name) {
+  const filePaths = listEffectiveIndexedFilePaths(db, ctx);
+  const rows = [];
+  for (const filePath of filePaths) {
+    const contentHash = getEffectiveContentHash(db, ctx, filePath);
+    if (contentHash == null) continue;
+    const matches = db.all(
+      `SELECT ${TAG_SELECT}
+       FROM symbol_index_tag
+       WHERE content_hash = ? AND file_path = ? AND name = ?
+       ORDER BY start_line, start_column`,
+      [contentHash, filePath, name]
+    );
+    rows.push(...matches);
+  }
+  rows.sort(
+    (a, b) => a.file_path.localeCompare(b.file_path) || a.start_line - b.start_line || a.start_column - b.start_column
+  );
+  return rows;
+}
+
 // src/code-nav/symbol-index/build/load-indexed-file-entry.ts
 function dbTagToSymbolTag(row) {
   return {
@@ -28735,21 +28802,52 @@ function loadIndexedFileEntry(db, ctx, relPath) {
 function normalizeRelPath2(filePath) {
   return filePath.replace(/\\/g, "/").replace(/^\/+/, "");
 }
-function listDirectImportTargetsForFile(parentPath, filePath) {
+function listDirectImportTargetsWithDb(db, resolved, relPath) {
+  const ctx = getSymbolIndexParentContext(db, resolved);
+  if (ctx == null) return [];
+  const entry = loadIndexedFileEntry(db, ctx, relPath);
+  if (entry == null) return [];
+  const paths = /* @__PURE__ */ new Set();
+  for (const binding of entry.imports) {
+    if (binding.sourceFilePath) paths.add(binding.sourceFilePath);
+  }
+  return Array.from(paths);
+}
+async function listDirectImportTargetsForFileAsync(parentPath, filePath) {
   const resolved = normalizeResolvedPath(parentPath);
   const relPath = normalizeRelPath2(filePath);
   if (!relPath) return [];
-  return withCodeNavCacheSqliteSync((db) => {
-    const ctx = getSymbolIndexParentContext(db, resolved);
+  return withCodeNavCacheSqlite((db) => listDirectImportTargetsWithDb(db, resolved, relPath));
+}
+
+// src/code-nav/symbol-index/lifecycle/symbol-index-file-ready.ts
+function symbolIndexFileIsReadyWithDb(db, parentPath, filePath) {
+  const normalizedParent = normalizeResolvedPath(parentPath);
+  const normalizedFile = filePath.replace(/\\/g, "/").replace(/^\/+/, "");
+  if (!normalizedFile) return false;
+  const ctx = getSymbolIndexParentContext(db, normalizedParent);
+  if (ctx == null) return false;
+  const versionRow = db.get("SELECT index_version FROM symbol_index_parent_path WHERE id = ?", [
+    ctx.parentId
+  ]);
+  if (versionRow == null || versionRow.index_version < SYMBOL_INDEX_VERSION) return false;
+  return getEffectiveContentHash(db, ctx, normalizedFile) != null;
+}
+async function symbolIndexFileIsReadyAsync(parentPath, filePath) {
+  return withCodeNavCacheSqlite((db) => symbolIndexFileIsReadyWithDb(db, parentPath, filePath));
+}
+async function loadSymbolIndexReadyFileSet(parentPath) {
+  const normalizedParent = normalizeResolvedPath(parentPath);
+  const paths = await withCodeNavCacheSqlite((db) => {
+    const ctx = getSymbolIndexParentContext(db, normalizedParent);
     if (ctx == null) return [];
-    const entry = loadIndexedFileEntry(db, ctx, relPath);
-    if (entry == null) return [];
-    const paths = /* @__PURE__ */ new Set();
-    for (const binding of entry.imports) {
-      if (binding.sourceFilePath) paths.add(binding.sourceFilePath);
-    }
-    return [...paths];
+    const versionRow = db.get("SELECT index_version FROM symbol_index_parent_path WHERE id = ?", [
+      ctx.parentId
+    ]);
+    if (versionRow == null || versionRow.index_version < SYMBOL_INDEX_VERSION) return [];
+    return listEffectiveIndexedFilePaths(db, ctx);
   });
+  return new Set(paths);
 }
 
 // src/code-nav/symbol-index/build/extract-file-symbol-data.ts
@@ -29059,9 +29157,9 @@ async function augmentTypeReferenceTags(tags, nameNodes, root) {
 }
 
 // src/code-nav/scope-chain.ts
-function serializeScopeChain(chain3) {
-  if (chain3.length === 0) return null;
-  return chain3.map((anchor) => `${anchor.startLine}:${anchor.startColumn}`).join(",");
+function serializeScopeChain(chain2) {
+  if (chain2.length === 0) return null;
+  return chain2.map((anchor) => `${anchor.startLine}:${anchor.startColumn}`).join(",");
 }
 function parseScopeChain(raw) {
   if (!raw) return [];
@@ -29077,9 +29175,9 @@ function parseScopeChain(raw) {
   }
   return out;
 }
-function anchorInScopeChain(line, column, chain3) {
-  if (line == null || column == null) return chain3.length === 0;
-  return chain3.some((anchor) => anchor.startLine === line && anchor.startColumn === column);
+function anchorInScopeChain(line, column, chain2) {
+  if (line == null || column == null) return chain2.length === 0;
+  return chain2.some((anchor) => anchor.startLine === line && anchor.startColumn === column);
 }
 
 // src/code-nav/enrich-tag-scope.ts
@@ -29116,15 +29214,15 @@ function scopeAnchorFromNode(node) {
   };
 }
 function findEnclosingScopeChain(nameNode) {
-  const chain3 = [];
+  const chain2 = [];
   let current = nameNode.parent;
   while (current) {
     if (SCOPE_CONTAINER_TYPES.has(current.type)) {
-      chain3.push(scopeAnchorFromNode(current));
+      chain2.push(scopeAnchorFromNode(current));
     }
     current = current.parent;
   }
-  return chain3;
+  return chain2;
 }
 function findEnclosingScopes(nameNode) {
   const scopeChain = findEnclosingScopeChain(nameNode);
@@ -29981,7 +30079,7 @@ async function extractFileSymbolData(resolved, relPath, workspaceFilesOverride)
     }
   }
   await yieldToEventLoop();
-  const workspaceFiles = workspaceFilesOverride ?? withCodeNavCacheSqliteSync((db) => listWorkspaceFiles(db, resolved, relPath));
+  const workspaceFiles = workspaceFilesOverride ?? await withCodeNavCacheSqlite((db) => listWorkspaceFiles(db, resolved, relPath));
   const imports = source != null ? await extractImportBindingsFromSource(relPath, source, workspaceFiles) : [];
   const yieldState = createCodeNavYieldState();
   return {
@@ -30006,7 +30104,7 @@ async function indexOneSymbolFileForBuild(resolved, relPath, workspaceFiles) {
   };
   if (data.imports.some((binding) => binding.importKind === "star")) {
     await yieldToEventLoop();
-    entry = withCodeNavCacheSqliteSync((db) => {
+    entry = await withCodeNavCacheSqlite((db) => {
       const ctx = getSymbolIndexParentContext(db, resolved);
       if (ctx == null) return entry;
       const resolveEntry = (filePath) => loadIndexedFileEntry(db, ctx, filePath);
@@ -30016,7 +30114,7 @@ async function indexOneSymbolFileForBuild(resolved, relPath, workspaceFiles) {
   }
   await withSymbolIndexSqliteLock(async () => {
     await yieldToEventLoop();
-    persistSymbolIndexFile(resolved, relPath, entry.source, entry.tags, entry.imports);
+    await persistSymbolIndexFileAsync(resolved, relPath, entry.source, entry.tags, entry.imports);
   });
 }
 async function ensureSymbolIndexFileAsync(parentPath, filePath, opts) {
@@ -30024,41 +30122,51 @@ async function ensureSymbolIndexFileAsync(parentPath, filePath, opts) {
   const relPath = normalizeRelPath3(filePath);
   if (!relPath) return false;
   const importDepth = opts?.importDepth ?? 0;
-  withCodeNavCacheSqliteSync((db) => {
+  await withCodeNavCacheSqlite((db) => {
     upsertSymbolIndexParentPath(db, resolved);
   });
-  if (!symbolIndexFileIsReady(resolved, relPath)) {
+  if (!await symbolIndexFileIsReadyAsync(resolved, relPath)) {
     await indexOneSymbolFileForBuild(resolved, relPath, void 0);
   }
-  if (importDepth > 0 && symbolIndexFileIsReady(resolved, relPath)) {
-    const targets = listDirectImportTargetsForFile(resolved, relPath).slice(0, MAX_IMPORT_PREFETCH_COUNT);
+  if (importDepth > 0 && await symbolIndexFileIsReadyAsync(resolved, relPath)) {
+    const targets = (await listDirectImportTargetsForFileAsync(resolved, relPath)).slice(
+      0,
+      MAX_IMPORT_PREFETCH_COUNT
+    );
     for (const target of targets) {
       await yieldToEventLoop();
-      if (!symbolIndexFileIsReady(resolved, target)) {
+      if (!await symbolIndexFileIsReadyAsync(resolved, target)) {
         await ensureSymbolIndexFileAsync(resolved, target, { importDepth: importDepth - 1 });
       }
     }
   }
-  return symbolIndexFileIsReady(resolved, relPath);
+  return await symbolIndexFileIsReadyAsync(resolved, relPath);
 }
-function registerSymbolIndexParent(parentPath) {
+async function registerSymbolIndexParentAsync(parentPath) {
   const resolved = normalizeResolvedPath(parentPath);
-  withCodeNavCacheSqliteSync((db) => {
+  await withCodeNavCacheSqlite((db) => {
     upsertSymbolIndexParentPath(db, resolved);
   });
 }
 
 // src/code-nav/symbol-index/build/build-symbol-index.ts
+var SYMBOL_PARENT_CLEAR_BATCH_SIZE = 256;
 async function buildSymbolIndexAsync(parentPath) {
   const resolved = normalizeResolvedPath(parentPath);
   await yieldToEventLoop();
-  await withSymbolIndexSqliteLock(() => {
-    withCodeNavCacheSqliteSync((db) => {
-      upsertSymbolIndexParentPath(db, resolved);
-      const ctx = getSymbolIndexParentContext(db, resolved);
-      if (ctx != null) clearSymbolIndexParentData(db, ctx);
+  let clearRemaining = true;
+  while (clearRemaining) {
+    await withSymbolIndexSqliteLock(async () => {
+      clearRemaining = await withCodeNavCacheSqlite(
+        (db) => runCodeNavCacheWriteTransaction(db, () => {
+          upsertSymbolIndexParentPath(db, resolved);
+          const ctx = getSymbolIndexParentContext(db, resolved);
+          return ctx == null ? false : clearSymbolIndexParentDataBatch(db, ctx, SYMBOL_PARENT_CLEAR_BATCH_SIZE);
+        })
+      );
     });
-  });
+    if (clearRemaining) await yieldToEventLoop();
+  }
   const workspaceFiles = /* @__PURE__ */ new Set();
   const walkState = createWalkYieldState();
   const yieldState = createCodeNavYieldState();
@@ -30075,9 +30183,7 @@ async function buildSymbolIndexAsync(parentPath) {
     resolved,
     async (relPath) => {
       await yieldDuringCodeNavWork(yieldState);
-      if (!symbolIndexFileIsReady(resolved, relPath)) {
-        await indexOneSymbolFileForBuild(resolved, relPath, workspaceFiles);
-      }
+      await indexOneSymbolFileForBuild(resolved, relPath, workspaceFiles);
       fileCount += 1;
     },
     walkState
@@ -30086,18 +30192,79 @@ async function buildSymbolIndexAsync(parentPath) {
   return { fileCount, tagCount: 0 };
 }
 
+// src/code-nav/symbol-index/scheduler/task-priority-heap.ts
+function higherPriority(a, b) {
+  return a.priority > b.priority;
+}
+var SymbolIndexTaskPriorityHeap = class {
+  heap = [];
+  clear() {
+    this.heap.length = 0;
+  }
+  push(task) {
+    this.heap.push(task);
+    let i = this.heap.length - 1;
+    while (i > 0) {
+      const parent = Math.floor((i - 1) / 2);
+      if (!higherPriority(this.heap[i], this.heap[parent])) break;
+      this.swap(i, parent);
+      i = parent;
+    }
+  }
+  pop() {
+    if (this.heap.length === 0) return void 0;
+    const top = this.heap[0];
+    const last2 = this.heap.pop();
+    if (this.heap.length > 0) {
+      this.heap[0] = last2;
+      this.sink(0);
+    }
+    return top;
+  }
+  get size() {
+    return this.heap.length;
+  }
+  sink(start) {
+    let i = start;
+    while (true) {
+      const left = i * 2 + 1;
+      const right = left + 1;
+      let best = i;
+      if (left < this.heap.length && higherPriority(this.heap[left], this.heap[best])) best = left;
+      if (right < this.heap.length && higherPriority(this.heap[right], this.heap[best])) best = right;
+      if (best === i) break;
+      this.swap(i, best);
+      i = best;
+    }
+  }
+  swap(i, j) {
+    const tmp = this.heap[i];
+    this.heap[i] = this.heap[j];
+    this.heap[j] = tmp;
+  }
+};
+
+// src/code-nav/symbol-index/scheduler/task-queue-types.ts
+function symbolIndexTaskKey(parentPath, filePath) {
+  return `${parentPath}\0${filePath}`;
+}
+
 // src/code-nav/symbol-index/scheduler/task-queue.ts
 var pending = /* @__PURE__ */ new Map();
+var heap = new SymbolIndexTaskPriorityHeap();
+var latestActiveSequenceByParent = /* @__PURE__ */ new Map();
 var workerRunning = false;
-function taskKey(parentPath, filePath) {
-  return `${parentPath}\0${filePath}`;
+function taskMatchesCurrentPending(task) {
+  const current = pending.get(symbolIndexTaskKey(task.parentPath, task.filePath));
+  return current === task;
 }
 function pickNextTask() {
-  let best;
-  for (const task of pending.values()) {
-    if (best == null || task.priority > best.priority) best = task;
+  while (heap.size > 0) {
+    const task = heap.pop();
+    if (task == null || !taskMatchesCurrentPending(task)) continue;
+    return task;
   }
-  return best;
+  return void 0;
 }
 async function runWorker() {
   if (workerRunning) return;
@@ -30107,74 +30274,93 @@ async function runWorker() {
     while (pending.size > 0) {
       const task = pickNextTask();
       if (task == null) break;
-      pending.delete(taskKey(task.parentPath, task.filePath));
+      pending.delete(symbolIndexTaskKey(task.parentPath, task.filePath));
       await yieldDuringCodeNavWork(yieldState);
-      if (!symbolIndexFileIsReady(task.parentPath, task.filePath)) {
+      const latestActiveSequence = latestActiveSequenceByParent.get(task.parentPath);
+      if (latestActiveSequence != null && task.sequence != null && task.sequence < latestActiveSequence) {
+        continue;
+      }
+      if (!await symbolIndexFileIsReadyAsync(task.parentPath, task.filePath)) {
         await ensureSymbolIndexFileAsync(task.parentPath, task.filePath);
       }
       await yieldToEventLoop();
     }
   } finally {
+    if (pending.size === 0) heap.clear();
     workerRunning = false;
     if (pending.size > 0) void runWorker();
   }
 }
-function enqueueSymbolIndexTask(parentPath, filePath, priority) {
+function enqueueSymbolIndexTask(parentPath, filePath, priority, sequence) {
   const normalizedParent = normalizeResolvedPath(parentPath);
   const normalizedFile = filePath.replace(/\\/g, "/").replace(/^\/+/, "");
   if (!normalizedFile) return;
-  if (symbolIndexFileIsReady(normalizedParent, normalizedFile)) return;
-  const key = taskKey(normalizedParent, normalizedFile);
+  const key = symbolIndexTaskKey(normalizedParent, normalizedFile);
   const existing = pending.get(key);
   if (existing != null && existing.priority >= priority) return;
-  pending.set(key, { parentPath: normalizedParent, filePath: normalizedFile, priority });
+  const task = { parentPath: normalizedParent, filePath: normalizedFile, priority, sequence };
+  pending.set(key, task);
+  heap.push(task);
   void runWorker();
 }
+function markLatestActiveSymbolIndexTask(parentPath, sequence) {
+  const normalizedParent = normalizeResolvedPath(parentPath);
+  const existing = latestActiveSequenceByParent.get(normalizedParent);
+  if (existing != null && existing >= sequence) return;
+  latestActiveSequenceByParent.set(normalizedParent, sequence);
+  for (const [key, task] of pending) {
+    if (task.parentPath === normalizedParent && task.sequence != null && task.sequence < sequence) {
+      pending.delete(key);
+    }
+  }
+  if (pending.size === 0) heap.clear();
+}
 
 // src/code-nav/symbol-index/scheduler/symbol-index-scheduler.ts
 var requestSeq = 0;
 var warmupSeq = 0;
 var warmupScheduled = /* @__PURE__ */ new Set();
+var warmupCompleted = /* @__PURE__ */ new Set();
 function scheduleSymbolIndexFile(parentPath, filePath) {
-  enqueueSymbolIndexTask(parentPath, filePath, 1e6 + ++requestSeq);
+  const sequence = ++requestSeq;
+  markLatestActiveSymbolIndexTask(parentPath, sequence);
+  enqueueSymbolIndexTask(parentPath, filePath, 1e6 + sequence, sequence);
 }
 function scheduleSymbolIndexImportNeighbors(parentPath, filePaths) {
   let priority = 5e5 + requestSeq;
   for (const filePath of filePaths) {
-    enqueueSymbolIndexTask(parentPath, filePath, priority);
+    enqueueSymbolIndexTask(parentPath, filePath, priority, requestSeq);
     priority -= 1;
   }
 }
 function scheduleSymbolIndexWarmup(parentPath) {
   const resolved = normalizeResolvedPath(parentPath);
+  if (warmupCompleted.has(resolved)) return;
   if (warmupScheduled.has(resolved)) return;
   warmupScheduled.add(resolved);
   setImmediate(() => {
     void (async () => {
       try {
+        const readyFiles = await loadSymbolIndexReadyFileSet(resolved);
         const walkState = createWalkYieldState();
         const yieldState = createCodeNavYieldState();
         await walkCodeNavFilesAsync(
           resolved,
           async (relPath) => {
             await yieldDuringCodeNavWork(yieldState);
-            if (!symbolIndexFileIsReady(resolved, relPath)) {
-              enqueueSymbolIndexTask(resolved, relPath, ++warmupSeq);
+            if (!readyFiles.has(relPath)) {
+              enqueueSymbolIndexTask(resolved, relPath, ++warmupSeq, requestSeq);
             }
           },
           walkState
         );
+        warmupCompleted.add(resolved);
       } finally {
         warmupScheduled.delete(resolved);
       }
     })();
   });
 }
-function scheduleSymbolIndexForRequest(parentPath, reqPath, importTargets) {
-  scheduleSymbolIndexFile(parentPath, reqPath);
-  scheduleSymbolIndexImportNeighbors(parentPath, importTargets);
-  scheduleSymbolIndexWarmup(parentPath);
-}
 
 // src/code-nav/symbol-index/lifecycle/normalize-symbol-index-path.ts
 import path23 from "node:path";
@@ -30190,27 +30376,23 @@ function normalizeSymbolIndexRelPath(parentPath, changedPath) {
 async function updateSymbolIndexForFile(parentPath, changedPath) {
   const relPath = normalizeSymbolIndexRelPath(parentPath, changedPath);
   if (relPath == null) return;
+  const resolved = normalizeResolvedPath(parentPath);
+  const { source, tags, imports } = await extractFileSymbolData(resolved, relPath);
+  await yieldToEventLoop();
   await withSymbolIndexSqliteLock(async () => {
-    const resolved = normalizeResolvedPath(parentPath);
-    const { source, tags, imports } = await extractFileSymbolData(resolved, relPath);
-    await yieldToEventLoop();
-    persistSymbolIndexFile(resolved, relPath, source, tags, imports);
+    await persistSymbolIndexFileAsync(resolved, relPath, source, tags, imports);
   });
 }
 async function removeSymbolIndexForFile(parentPath, changedPath) {
   const relPath = normalizeSymbolIndexRelPath(parentPath, changedPath);
   if (relPath == null) return;
+  const resolved = normalizeResolvedPath(parentPath);
   await withSymbolIndexSqliteLock(async () => {
-    removeSymbolIndexFile(normalizeResolvedPath(parentPath), relPath);
+    await removeSymbolIndexFileAsync(resolved, relPath);
   });
 }
 
 // src/code-nav/symbol-index/sqlite/symbol-index-import-sqlite.ts
-function listImportsForFile(db, parentId, filePath) {
-  const ctx = getSymbolIndexParentContextById(db, parentId);
-  if (ctx == null) return [];
-  return loadFileImports(db, ctx, filePath);
-}
 function prefersTypeImport(refKind) {
   return refKind === "type";
 }
@@ -30236,7 +30418,7 @@ function findImportBindingForLocalName(imports, localName, ref) {
 function defsByFileNameKey(filePath, name) {
   return `${filePath}\0${name}`;
 }
-function createNavigationLookups(db, parentId) {
+function createSnapshotNavigationLookups(db, parentId) {
   const ctx = getSymbolIndexParentContextById(db, parentId);
   if (ctx == null) {
     return {
@@ -30248,29 +30430,24 @@ function createNavigationLookups(db, parentId) {
   const fileDefsCache = /* @__PURE__ */ new Map();
   const defsByFileNameCache = /* @__PURE__ */ new Map();
   const importsCache = /* @__PURE__ */ new Map();
-  return {
-    loadFileDefs(filePath) {
-      let cached2 = fileDefsCache.get(filePath);
-      if (cached2) return cached2;
-      cached2 = loadFileTags(db, ctx, filePath).filter((row) => row.role === "def");
-      fileDefsCache.set(filePath, cached2);
-      return cached2;
-    },
-    lookupDefsInFileNamed(filePath, name) {
-      const key = defsByFileNameKey(filePath, name);
-      let cached2 = defsByFileNameCache.get(key);
-      if (cached2) return cached2;
-      cached2 = loadFileTags(db, ctx, filePath).filter((row) => row.role === "def" && row.name === name);
-      defsByFileNameCache.set(key, cached2);
-      return cached2;
-    },
-    lookupImportsForFile(filePath) {
-      let cached2 = importsCache.get(filePath);
-      if (cached2) return cached2;
-      cached2 = listImportsForFile(db, parentId, filePath);
-      importsCache.set(filePath, cached2);
-      return cached2;
+  for (const filePath of listEffectiveIndexedFilePaths(db, ctx)) {
+    const defs = loadFileTags(db, ctx, filePath).filter((row) => row.role === "def");
+    fileDefsCache.set(filePath, defs);
+    for (const def of defs) {
+      const key = defsByFileNameKey(filePath, def.name);
+      const existing = defsByFileNameCache.get(key);
+      if (existing) {
+        existing.push(def);
+      } else {
+        defsByFileNameCache.set(key, [def]);
+      }
     }
+    importsCache.set(filePath, loadFileImports(db, ctx, filePath));
+  }
+  return {
+    loadFileDefs: (filePath) => fileDefsCache.get(filePath) ?? [],
+    lookupDefsInFileNamed: (filePath, name) => defsByFileNameCache.get(defsByFileNameKey(filePath, name)) ?? [],
+    lookupImportsForFile: (filePath) => importsCache.get(filePath) ?? []
   };
 }
 
@@ -30279,11 +30456,11 @@ function refScopeChain(ref) {
   const parsed = parseScopeChain(ref.scope_chain);
   if (parsed.length > 0) return parsed;
   if (ref.scope_start_line != null && ref.scope_start_column != null) {
-    const chain3 = [{ startLine: ref.scope_start_line, startColumn: ref.scope_start_column }];
+    const chain2 = [{ startLine: ref.scope_start_line, startColumn: ref.scope_start_column }];
     if (ref.parent_scope_start_line != null && ref.parent_scope_start_column != null) {
-      chain3.push({ startLine: ref.parent_scope_start_line, startColumn: ref.parent_scope_start_column });
+      chain2.push({ startLine: ref.parent_scope_start_line, startColumn: ref.parent_scope_start_column });
     }
-    return chain3;
+    return chain2;
   }
   return [];
 }
@@ -30294,17 +30471,17 @@ function defAtScopeAnchor(def, anchor) {
   return scopesMatch(def.scope_start_line, def.scope_start_column, anchor.startLine, anchor.startColumn) || scopesMatch(def.start_line, def.start_column, anchor.startLine, anchor.startColumn);
 }
 function defVisibleInRefScopeChain(def, ref) {
-  const chain3 = refScopeChain(ref);
-  if (chain3.length === 0) return isModuleLevelDef2(def);
-  return anchorInScopeChain(def.scope_start_line, def.scope_start_column, chain3) || anchorInScopeChain(def.start_line, def.start_column, chain3.slice(1));
+  const chain2 = refScopeChain(ref);
+  if (chain2.length === 0) return isModuleLevelDef2(def);
+  return anchorInScopeChain(def.scope_start_line, def.scope_start_column, chain2) || anchorInScopeChain(def.start_line, def.start_column, chain2.slice(1));
 }
 function scopeDepthInChain(def, ref) {
-  const chain3 = refScopeChain(ref);
-  for (let index = 0; index < chain3.length; index++) {
-    const anchor = chain3[index];
+  const chain2 = refScopeChain(ref);
+  for (let index = 0; index < chain2.length; index++) {
+    const anchor = chain2[index];
     if (defAtScopeAnchor(def, anchor)) return index;
   }
-  return chain3.length;
+  return chain2.length;
 }
 
 // src/code-nav/resolution/navigation/confidence.ts
@@ -30470,9 +30647,9 @@ function resolveScopeLevelCandidates(defs) {
 function resolveLocalDefinitions(ref, fileDefs) {
   const named = fileDefs.filter((def) => def.name === ref.name && declaredBeforeRef(def, ref));
   if (named.length === 0) return [];
-  const chain3 = refScopeChain(ref);
-  if (chain3.length > 0) {
-    for (const anchor of chain3) {
+  const chain2 = refScopeChain(ref);
+  if (chain2.length > 0) {
+    for (const anchor of chain2) {
       const atLevel = named.filter((def) => defAtScopeAnchor(def, anchor));
       if (atLevel.length > 0) return resolveScopeLevelCandidates(atLevel);
     }
@@ -30487,10 +30664,10 @@ function resolveLocalDefinitions(ref, fileDefs) {
 function resolveLocalDefinitionCandidates(ref, fileDefs) {
   const named = fileDefs.filter((def) => def.name === ref.name && declaredBeforeRef(def, ref));
   if (named.length === 0) return [];
-  const chain3 = refScopeChain(ref);
-  if (chain3.length === 0) return resolveScopeLevelCandidates(named.filter((def) => isModuleLevelDef2(def)));
+  const chain2 = refScopeChain(ref);
+  if (chain2.length === 0) return resolveScopeLevelCandidates(named.filter((def) => isModuleLevelDef2(def)));
   const visible = named.filter((def) => {
-    if (chain3.some((anchor) => defAtScopeAnchor(def, anchor))) return true;
+    if (chain2.some((anchor) => defAtScopeAnchor(def, anchor))) return true;
     if (defVisibleInRefScopeChain(def, ref)) return true;
     return isModuleLevelDef2(def);
   });
@@ -30671,32 +30848,41 @@ function pickPrimaryTagAtPosition(rows, filePath, line, column) {
 async function queryDefinitionsNavigation(parentPath, filePath, line, column) {
   await yieldToEventLoop();
   const resolved = normalizeResolvedPath(parentPath);
-  const result = withCodeNavCacheSqliteSync((db) => {
+  const snapshot = await withCodeNavCacheSqlite((db) => {
     const ctx = getSymbolIndexParentContext(db, resolved);
     if (ctx == null) return null;
     const fileRows = loadFileTags(db, ctx, filePath);
     const primary = pickPrimaryTagAtPosition(fileRows, filePath, line, column);
     if (!primary) return null;
     const atPos = findTagsAtPosition(fileRows, filePath, line, column);
-    if (primary.kind === "module" && primary.nav_target_path) {
-      return { definitions: [modulePathLocation(primary)], confidentTarget: true };
-    }
-    const onDefinition = atPos.some((row) => row.role === "def");
-    if (onDefinition) {
-      const defs = atPos.filter((row) => row.role === "def").map(rowToLocation);
-      return { definitions: defs, confidentTarget: defs.length === 1 };
-    }
-    const lookups = createNavigationLookups(db, ctx.parentId);
+    const lookups = createSnapshotNavigationLookups(db, ctx.parentId);
     const workspaceFiles = listWorkspaceFiles(db, resolved, filePath);
-    const navCtx = buildNavigationContext(filePath, primary, lookups, workspaceFiles);
-    const navigation = resolveNavigation(navCtx);
-    return {
-      definitions: navigation.definitions.map(rowToLocation),
-      confidentTarget: navigation.confidentTarget
-    };
+    return { primary, atPos, lookups, workspaceFiles };
   });
+  if (snapshot == null) {
+    await yieldToEventLoop();
+    return { definitions: [], confidentTarget: false };
+  }
+  const result = resolveDefinitionsFromSnapshot(filePath, snapshot);
   await yieldToEventLoop();
-  return result ?? { definitions: [], confidentTarget: false };
+  return result;
+}
+function resolveDefinitionsFromSnapshot(filePath, snapshot) {
+  const { primary, atPos, lookups, workspaceFiles } = snapshot;
+  if (primary.kind === "module" && primary.nav_target_path) {
+    return { definitions: [modulePathLocation(primary)], confidentTarget: true };
+  }
+  const onDefinition = atPos.some((row) => row.role === "def");
+  if (onDefinition) {
+    const defs = atPos.filter((row) => row.role === "def").map(rowToLocation);
+    return { definitions: defs, confidentTarget: defs.length === 1 };
+  }
+  const navCtx = buildNavigationContext(filePath, primary, lookups, workspaceFiles);
+  const navigation = resolveNavigation(navCtx);
+  return {
+    definitions: navigation.definitions.map(rowToLocation),
+    confidentTarget: navigation.confidentTarget
+  };
 }
 async function queryDefinitionsAt(parentPath, filePath, line, column) {
   return (await queryDefinitionsNavigation(parentPath, filePath, line, column)).definitions;
@@ -30709,7 +30895,7 @@ async function queryDefinitionAt(parentPath, filePath, line, column) {
 async function queryReferencesAt(parentPath, filePath, line, column) {
   await yieldToEventLoop();
   const resolved = normalizeResolvedPath(parentPath);
-  const rows = withCodeNavCacheSqliteSync((db) => {
+  const rows = await withCodeNavCacheSqlite((db) => {
     const ctx = getSymbolIndexParentContext(db, resolved);
     if (ctx == null) return null;
     const fileRows = loadFileTags(db, ctx, filePath);
@@ -30744,23 +30930,28 @@ function rowToSymbolSpan(row, clickable) {
 async function querySymbolsInFile(parentPath, filePath) {
   await yieldToEventLoop();
   const resolved = normalizeResolvedPath(parentPath);
-  const spans = withCodeNavCacheSqliteSync((db) => {
+  const snapshot = await withCodeNavCacheSqlite((db) => {
     const ctx = getSymbolIndexParentContext(db, resolved);
-    if (ctx == null) return [];
+    if (ctx == null) return null;
     const rows = loadFileTags(db, ctx, filePath);
-    if (rows.length === 0) return [];
-    const lookups = createNavigationLookups(db, ctx.parentId);
+    if (rows.length === 0) return null;
+    const lookups = createSnapshotNavigationLookups(db, ctx.parentId);
     const workspaceFiles = listWorkspaceFiles(db, resolved, filePath);
-    const baseCtx = buildNavigationContext(
-      filePath,
-      rows[0] ?? emptyRefRow(filePath),
-      lookups,
-      workspaceFiles
-    );
-    return rows.map((row) => {
-      const navCtx = { ...baseCtx, ref: row };
-      return rowToSymbolSpan(row, refHasResolvableDefinitions(navCtx));
-    });
+    return { rows, lookups, workspaceFiles };
+  });
+  if (snapshot == null) {
+    await yieldToEventLoop();
+    return [];
+  }
+  const baseCtx = buildNavigationContext(
+    filePath,
+    snapshot.rows[0] ?? emptyRefRow(filePath),
+    snapshot.lookups,
+    snapshot.workspaceFiles
+  );
+  const spans = snapshot.rows.map((row) => {
+    const navCtx = { ...baseCtx, ref: row };
+    return rowToSymbolSpan(row, refHasResolvableDefinitions(navCtx));
   });
   await yieldToEventLoop();
   return spans;
@@ -31763,8 +31954,8 @@ async function execGitFile(args, options) {
 }
 
 // src/git/changes/parse/normalize-git-diff-path.ts
-function normalizeGitDiffPath(path71) {
-  return path71.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
+function normalizeGitDiffPath(path73) {
+  return path73.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
 }
 
 // src/git/changes/parse/parse-name-status-entries.ts
@@ -32051,9 +32242,9 @@ async function collectTurnGitDiffFromPreTurnSnapshot(options) {
 // src/agents/acp/put-summarize-change-summaries.ts
 async function putEncryptedChangeSummaryRows(params) {
   const base = params.apiBaseUrl.replace(/\/+$/, "");
-  const entries = params.rows.map(({ path: path71, summary }) => {
+  const entries = params.rows.map(({ path: path73, summary }) => {
     const enc = params.e2ee.encryptFields({ summary }, ["summary"]);
-    return { path: path71, summary: JSON.stringify(enc) };
+    return { path: path73, summary: JSON.stringify(enc) };
   });
   const res = await fetch(
     `${base}/internal/sessions/${encodeURIComponent(params.sessionId)}/follow-ups/summarize-changes`,
@@ -32980,8 +33171,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path71) {
-  return path71 instanceof String && cache.has(path71);
+function isPathSpec(path73) {
+  return path73 instanceof String && cache.has(path73);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -33070,8 +33261,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path71) {
-  return (0, import_file_exists.exists)(path71, import_file_exists.FOLDER);
+function folderExists(path73) {
+  return (0, import_file_exists.exists)(path73, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -33475,8 +33666,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path71) {
-      return /^\.(git)?$/.test(path71.trim());
+    parser(path73) {
+      return /^\.(git)?$/.test(path73.trim());
     }
   };
 }
@@ -33910,11 +34101,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path71, line, preview] = input.split(NULL);
-    paths.add(path71);
-    (results[path71] = results[path71] || []).push({
+    const [path73, line, preview] = input.split(NULL);
+    paths.add(path73);
+    (results[path73] = results[path73] || []).push({
       line: asNumber(line),
-      path: path71,
+      path: path73,
       preview
     });
   });
@@ -34679,14 +34870,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path71, text) {
+function parseInit(bare, path73, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path71, false, result[1]);
+    return new InitSummary(bare, path73, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path71, true, result[1]);
+    return new InitSummary(bare, path73, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -34697,7 +34888,7 @@ function parseInit(bare, path71, text) {
       break;
     }
   }
-  return new InitSummary(bare, path71, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path73, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -34706,9 +34897,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path71, existing, gitDir) {
+      constructor(bare, path73, existing, gitDir) {
         this.bare = bare;
-        this.path = path71;
+        this.path = path73;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -34720,7 +34911,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path71, customArgs) {
+function initTask(bare = false, path73, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -34729,7 +34920,7 @@ function initTask(bare = false, path71, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path71, text);
+      return parseInit(commands.includes("--bare"), path73, text);
     }
   };
 }
@@ -35545,12 +35736,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path71, index, working_dir) {
-        this.path = path71;
+      constructor(path73, index, working_dir) {
+        this.path = path73;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path71) || [null, path71, path71];
+          const detail = fromPathRegex.exec(path73) || [null, path73, path73];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -35581,14 +35772,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path71) {
+  function data(index, workingDir, path73) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path71);
+      handler(result, path73);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path71, index, workingDir));
+      result.files.push(new FileStatusSummary(path73, index, workingDir));
     }
   }
 }
@@ -35861,15 +36052,15 @@ var init_simple_git_api = __esm2({
         this._executor = _executor;
       }
       _runTask(task, then) {
-        const chain3 = this._executor.chain();
-        const promise2 = chain3.push(task);
+        const chain2 = this._executor.chain();
+        const promise2 = chain2.push(task);
         if (then) {
           taskCallback(task, promise2, then);
         }
         return Object.create(this, {
           then: { value: promise2.then.bind(promise2) },
           catch: { value: promise2.catch.bind(promise2) },
-          _executor: { value: chain3 }
+          _executor: { value: chain2 }
         });
       }
       add(files) {
@@ -35897,9 +36088,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path71, write) {
+      hashObject(path73, write) {
         return this._runTask(
-          hashObjectTask(path71, write === true),
+          hashObjectTask(path73, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -36252,8 +36443,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path71 = input.trim().replace(/^["']|["']$/g, "");
-  return path71 && normalize3(path71);
+  const path73 = input.trim().replace(/^["']|["']$/g, "");
+  return path73 && normalize3(path73);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -36567,8 +36758,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path71) {
-  return subModuleTask(["add", repo, path71]);
+function addSubModuleTask(repo, path73) {
+  return subModuleTask(["add", repo, path73]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -36901,8 +37092,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path71, then) {
-      return this._runTask(addSubModuleTask2(repo, path71), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path73, then) {
+      return this._runTask(addSubModuleTask2(repo, path73), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -37638,8 +37829,8 @@ function parseNumstatEntries(lines) {
 }
 function parseNumstat(lines) {
   const m = /* @__PURE__ */ new Map();
-  for (const [path71, entry] of parseNumstatEntries(lines)) {
-    m.set(path71, { additions: entry.additions, deletions: entry.deletions });
+  for (const [path73, entry] of parseNumstatEntries(lines)) {
+    m.set(path73, { additions: entry.additions, deletions: entry.deletions });
   }
   return m;
 }
@@ -39683,37 +39874,16 @@ function defaultWorktreesRootPath() {
 }
 
 // src/files/watch-file-index.ts
-import fs36 from "node:fs";
-import { watch } from "node:fs";
-import path56 from "node:path";
+import path58 from "node:path";
 
 // src/files/index/build-file-index.ts
 import path54 from "node:path";
 
 // src/files/index/file-index-sqlite-lock.ts
-import fs35 from "node:fs";
-function isSqliteCorruptError2(e) {
-  const msg = e instanceof Error ? e.message : String(e);
-  return msg.includes("malformed") || msg.includes("database disk image is malformed") || msg.includes("corrupt");
-}
-var chain2 = Promise.resolve();
+var fileIndexChain = Promise.resolve();
 function withFileIndexSqliteLock(fn) {
-  const run = async () => {
-    try {
-      return await Promise.resolve(fn());
-    } catch (e) {
-      if (!isSqliteCorruptError2(e)) throw e;
-      closeAllCodeNavCacheSqliteConnections();
-      try {
-        fs35.unlinkSync(getCodeNavCacheSqlitePath());
-      } catch {
-      }
-      chain2 = Promise.resolve();
-      return await Promise.resolve(fn());
-    }
-  };
-  const next = chain2.then(run);
-  chain2 = next.then(
+  const next = fileIndexChain.then(() => Promise.resolve(fn()));
+  fileIndexChain = next.then(
     () => void 0,
     () => void 0
   );
@@ -39734,6 +39904,14 @@ async function collectWorkspacePathsAsync(resolved) {
   return paths;
 }
 
+// src/files/index/file-index-persist-constants.ts
+var FILE_INDEX_INSERT_BUFFER = 2048;
+
+// src/files/index/file-index-persist-shutdown.ts
+function assertFileIndexPersistNotShutdown() {
+  if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+}
+
 // src/files/index/file-index-parent-path.ts
 function upsertFileIndexParentPath(db, resolved) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -39748,57 +39926,56 @@ function upsertFileIndexParentPath(db, resolved) {
   return Number(row.id);
 }
 
-// src/files/index/persist-file-index.ts
-var FILE_INDEX_INTERRUPT_CHECK_EVERY = 256;
-function assertNotShutdown2() {
-  if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
+// src/files/index/file-index-persist-transaction.ts
+function clearFileIndexChildPaths(db, resolved) {
+  runCodeNavCacheWriteTransaction(db, () => {
+    const parentId = upsertFileIndexParentPath(db, resolved);
+    db.run("DELETE FROM file_index_child_path WHERE parent_id = ?", [parentId]);
+  });
 }
-function persistFileIndexPaths(resolved, paths) {
-  return withCodeNavCacheSqliteSync((db) => {
-    let pathCount = 0;
-    db.run("BEGIN IMMEDIATE");
+function insertFileIndexChildPathBatch(db, resolved, paths) {
+  return runCodeNavCacheWriteTransaction(db, () => {
+    const parentId = upsertFileIndexParentPath(db, resolved);
+    const ins = db.prepare(
+      "INSERT INTO file_index_child_path (parent_id, path) VALUES (?, ?)"
+    );
     try {
-      const parentId = upsertFileIndexParentPath(db, resolved);
-      db.run("DELETE FROM file_index_child_path WHERE parent_id = ?", [parentId]);
-      const ins = db.prepare("INSERT INTO file_index_child_path (parent_id, path) VALUES (?, ?)");
-      try {
-        let batch = 0;
-        for (const rel of paths) {
-          if (++batch >= FILE_INDEX_INTERRUPT_CHECK_EVERY) {
-            batch = 0;
-            assertNotShutdown2();
-          }
-          ins.run([parentId, rel]);
-          pathCount += 1;
-        }
-      } finally {
-        ins.finalize();
+      for (const rel of paths) {
+        ins.run([parentId, rel]);
       }
-      db.run("COMMIT");
-    } catch (e) {
-      try {
-        db.run("ROLLBACK");
-      } catch {
-      }
-      throw e;
+      return paths.length;
+    } finally {
+      ins.finalize();
     }
-    return pathCount;
   });
 }
 
+// src/files/index/persist-file-index-paths.ts
+async function persistFileIndexPathsAsync(resolved, paths) {
+  await withCodeNavCacheSqlite((db) => clearFileIndexChildPaths(db, resolved));
+  let pathCount = 0;
+  for (let offset = 0; offset < paths.length; offset += FILE_INDEX_INSERT_BUFFER) {
+    assertFileIndexPersistNotShutdown();
+    const batch = paths.slice(offset, offset + FILE_INDEX_INSERT_BUFFER);
+    pathCount += await withCodeNavCacheSqlite((db) => insertFileIndexChildPathBatch(db, resolved, batch));
+    await yieldToEventLoop();
+  }
+  return pathCount;
+}
+
 // src/files/index/build-file-index.ts
-function assertNotShutdown3() {
+function assertNotShutdown2() {
   if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
 }
 async function buildFileIndexAsync(cwd) {
-  return withFileIndexSqliteLock(async () => {
-    const resolved = path54.resolve(cwd);
-    await yieldToEventLoop();
-    assertNotShutdown3();
-    const paths = await collectWorkspacePathsAsync(resolved);
-    await yieldToEventLoop();
-    assertNotShutdown3();
-    const pathCount = persistFileIndexPaths(resolved, paths);
+  const resolved = path54.resolve(cwd);
+  await yieldToEventLoop();
+  assertNotShutdown2();
+  const paths = await collectWorkspacePathsAsync(resolved);
+  await yieldToEventLoop();
+  assertNotShutdown2();
+  return await withFileIndexSqliteLock(async () => {
+    const pathCount = await persistFileIndexPathsAsync(resolved, paths);
     return { pathCount };
   });
 }
@@ -39863,8 +40040,9 @@ async function ensureFileIndexAsync(cwd) {
   return { ...await buildFileIndexAsync(resolved), fromCache: false };
 }
 
-// src/files/watch-file-index.ts
-var DEBOUNCE_MS = 900;
+// src/files/index/file-index-fs-watcher.ts
+import { watch } from "node:fs";
+var FILE_INDEX_WATCH_DEBOUNCE_MS = 900;
 function shouldIgnoreRelative(rel) {
   const n = rel.replace(/\\/g, "/");
   return n.split("/").some((segment) => shouldSkipWorkspaceWalkEntry(segment));
@@ -39874,7 +40052,7 @@ function attachWatchErrorLog(w) {
     console.error("[file-index] File watcher error:", err);
   });
 }
-function createFsWatcher(resolved, schedule) {
+function createFileIndexFsWatcher(resolved, schedule) {
   const onEvent = (_event, filename) => {
     if (filename != null) {
       const rel = typeof filename === "string" ? filename.replace(/\\/g, "/") : filename.toString("utf8").replace(/\\/g, "/");
@@ -39901,11 +40079,15 @@ function createFsWatcher(resolved, schedule) {
     throw e;
   }
 }
+
+// src/files/index/file-index-incremental-symbol-updates.ts
+import fs35 from "node:fs";
+import path56 from "node:path";
 async function applyIncrementalSymbolIndexUpdates(resolved, relPaths) {
   for (const rel of relPaths) {
     const absPath = path56.join(resolved, rel);
     try {
-      const stat2 = await fs36.promises.stat(absPath);
+      const stat2 = await fs35.promises.stat(absPath);
       if (stat2.isFile()) {
         await updateSymbolIndexForFile(resolved, absPath);
       } else {
@@ -39921,54 +40103,80 @@ async function applyIncrementalSymbolIndexUpdates(resolved, relPaths) {
     await yieldToEventLoop();
   }
 }
-function startFileIndexWatcher(cwd = getBridgeRoot()) {
-  const resolved = path56.resolve(cwd);
-  void buildFileIndexAsync(resolved).catch((e) => {
+
+// src/files/index/file-index-initial-builds.ts
+import path57 from "node:path";
+async function runInitialIndexBuilds(cwd = getBridgeRoot()) {
+  const resolved = path57.resolve(cwd);
+  try {
+    await buildFileIndexAsync(resolved);
+    await buildSymbolIndexAsync(resolved);
+  } catch (e) {
     if (e instanceof CliSqliteInterrupted) return;
     console.error("[file-index] Initial index build failed:", e);
+  }
+}
+function scheduleInitialIndexBuilds(cwd = getBridgeRoot()) {
+  setImmediate(() => {
+    void runInitialIndexBuilds(cwd);
   });
-  void buildSymbolIndexAsync(resolved).catch((e) => {
-    if (e instanceof CliSqliteInterrupted) return;
-    console.error("[code-nav] Initial symbol index build failed:", e);
-  });
+}
+
+// src/files/watch-file-index.ts
+var MAX_INCREMENTAL_SYMBOL_UPDATES = 512;
+function startFileIndexWatcher(cwd = getBridgeRoot()) {
+  const resolved = path58.resolve(cwd);
   let timer = null;
   const pendingSymbolUpdates = /* @__PURE__ */ new Set();
   let needsFullSymbolRebuild = false;
+  let rebuildRunning = false;
+  let rebuildQueued = false;
   const runRebuild = () => {
-    void buildFileIndexAsync(resolved).catch((e) => {
-      if (e instanceof CliSqliteInterrupted) return;
-      console.error("[file-index] Watch rebuild failed:", e);
-    });
-    if (needsFullSymbolRebuild) {
-      needsFullSymbolRebuild = false;
-      pendingSymbolUpdates.clear();
-      void buildSymbolIndexAsync(resolved).catch((e) => {
-        if (e instanceof CliSqliteInterrupted) return;
-        console.error("[code-nav] Watch rebuild failed:", e);
-      });
+    if (rebuildRunning) {
+      rebuildQueued = true;
       return;
     }
-    const relPaths = [...pendingSymbolUpdates];
+    rebuildRunning = true;
+    const fullSymbol = needsFullSymbolRebuild;
+    needsFullSymbolRebuild = false;
+    const relPaths = fullSymbol ? [] : [...pendingSymbolUpdates];
     pendingSymbolUpdates.clear();
-    if (relPaths.length === 0) return;
-    void applyIncrementalSymbolIndexUpdates(resolved, relPaths).catch((e) => {
+    void buildFileIndexAsync(resolved).then(async () => {
+      if (fullSymbol) {
+        await buildSymbolIndexAsync(resolved);
+        return;
+      }
+      if (relPaths.length === 0) return;
+      await applyIncrementalSymbolIndexUpdates(resolved, relPaths);
+    }).catch((e) => {
       if (e instanceof CliSqliteInterrupted) return;
-      console.error("[code-nav] Incremental watch update failed:", e);
+      console.error("[file-index] Watch rebuild failed:", e);
+    }).finally(() => {
+      rebuildRunning = false;
+      if (rebuildQueued || needsFullSymbolRebuild || pendingSymbolUpdates.size > 0) {
+        rebuildQueued = false;
+        setImmediate(runRebuild);
+      }
     });
   };
   const schedule = (relPath) => {
-    if (relPath != null) {
+    if (relPath != null && !needsFullSymbolRebuild) {
       pendingSymbolUpdates.add(relPath);
+      if (pendingSymbolUpdates.size > MAX_INCREMENTAL_SYMBOL_UPDATES) {
+        pendingSymbolUpdates.clear();
+        needsFullSymbolRebuild = true;
+      }
     } else {
+      pendingSymbolUpdates.clear();
       needsFullSymbolRebuild = true;
     }
     if (timer) clearTimeout(timer);
     timer = setTimeout(() => {
       timer = null;
       runRebuild();
-    }, DEBOUNCE_MS);
+    }, FILE_INDEX_WATCH_DEBOUNCE_MS);
   };
-  const watcher = createFsWatcher(resolved, schedule);
+  const watcher = createFileIndexFsWatcher(resolved, schedule);
   return () => {
     if (timer) {
       clearTimeout(timer);
@@ -39979,7 +40187,7 @@ function startFileIndexWatcher(cwd = getBridgeRoot()) {
 }
 
 // src/connection/create-bridge-connection.ts
-import * as path70 from "node:path";
+import * as path72 from "node:path";
 
 // src/dev-servers/manager/dev-server-manager.ts
 import { rm as rm2 } from "node:fs/promises";
@@ -40023,7 +40231,7 @@ function forceKillChild(proc, log2, shortId, graceMs) {
 }
 
 // src/dev-servers/process/wire-dev-server-child-process.ts
-import fs37 from "node:fs";
+import fs36 from "node:fs";
 
 // src/dev-servers/manager/forward-pipe.ts
 function forwardChildPipe(childReadable, terminal, onData) {
@@ -40059,7 +40267,7 @@ function wireDevServerChildProcess(d) {
         d.setPollInterval(void 0);
         return;
       }
-      fs37.readFile(d.mergedLogPath, (err, buf) => {
+      fs36.readFile(d.mergedLogPath, (err, buf) => {
         if (err || (d.getSpawnGeneration() ?? 0) !== d.scheduledGen) return;
         if (buf.length <= d.mergedReadPos.value) return;
         const chunk = Buffer.from(buf.subarray(d.mergedReadPos.value));
@@ -40097,7 +40305,7 @@ ${errTail}` : ""}`);
       d.sendStatus(code === 0 || code == null ? "stopped" : "error", detail, tails);
     };
     if (mergedPath) {
-      fs37.readFile(mergedPath, (err, buf) => {
+      fs36.readFile(mergedPath, (err, buf) => {
         if (!err && buf.length > d.mergedReadPos.value) {
           const chunk = Buffer.from(buf.subarray(d.mergedReadPos.value));
           if (chunk.length > 0) {
@@ -40199,13 +40407,13 @@ function parseDevServerDefs(servers) {
 }
 
 // src/dev-servers/manager/shell-spawn/utils.ts
-import fs38 from "node:fs";
+import fs37 from "node:fs";
 function isSpawnEbadf(e) {
   return typeof e === "object" && e !== null && "code" in e && e.code === "EBADF";
 }
 function rmDirQuiet(dir) {
   try {
-    fs38.rmSync(dir, { recursive: true, force: true });
+    fs37.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -40213,7 +40421,7 @@ var cachedDevNullReadFd;
 function devNullReadFd() {
   if (cachedDevNullReadFd === void 0) {
     const devPath = process.platform === "win32" ? "nul" : "/dev/null";
-    cachedDevNullReadFd = fs38.openSync(devPath, "r");
+    cachedDevNullReadFd = fs37.openSync(devPath, "r");
   }
   return cachedDevNullReadFd;
 }
@@ -40287,15 +40495,15 @@ function trySpawnShellTruePiped(command, env, cwd, devNullFd, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-merged-log-file.ts
 import { spawn as spawn8 } from "node:child_process";
-import fs39 from "node:fs";
+import fs38 from "node:fs";
 import { tmpdir } from "node:os";
-import path57 from "node:path";
+import path59 from "node:path";
 function trySpawnMergedLogFile(command, env, cwd, signal) {
-  const tmpRoot = fs39.mkdtempSync(path57.join(tmpdir(), "ba-devsrv-log-"));
-  const logPath = path57.join(tmpRoot, "combined.log");
+  const tmpRoot = fs38.mkdtempSync(path59.join(tmpdir(), "ba-devsrv-log-"));
+  const logPath = path59.join(tmpRoot, "combined.log");
   let logFd;
   try {
-    logFd = fs39.openSync(logPath, "a");
+    logFd = fs38.openSync(logPath, "a");
   } catch {
     rmDirQuiet(tmpRoot);
     return null;
@@ -40314,7 +40522,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     } else {
       proc = spawn8("/bin/sh", ["-c", command], { env, cwd, stdio, ...signal ? { signal } : {} });
     }
-    fs39.closeSync(logFd);
+    fs38.closeSync(logFd);
     return {
       proc,
       pipedStdoutStderr: true,
@@ -40323,7 +40531,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     };
   } catch (e) {
     try {
-      fs39.closeSync(logFd);
+      fs38.closeSync(logFd);
     } catch {
     }
     rmDirQuiet(tmpRoot);
@@ -40334,22 +40542,22 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-shell-script-log-redirect.ts
 import { spawn as spawn9 } from "node:child_process";
-import fs40 from "node:fs";
+import fs39 from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path58 from "node:path";
+import path60 from "node:path";
 function shSingleQuote(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 function trySpawnShellScriptLogRedirectUnix(command, env, cwd, signal) {
-  const tmpRoot = fs40.mkdtempSync(path58.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path58.join(tmpRoot, "combined.log");
-  const innerPath = path58.join(tmpRoot, "_cmd.sh");
-  const runnerPath = path58.join(tmpRoot, "_run.sh");
+  const tmpRoot = fs39.mkdtempSync(path60.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path60.join(tmpRoot, "combined.log");
+  const innerPath = path60.join(tmpRoot, "_cmd.sh");
+  const runnerPath = path60.join(tmpRoot, "_run.sh");
   try {
-    fs40.writeFileSync(innerPath, `#!/bin/sh
+    fs39.writeFileSync(innerPath, `#!/bin/sh
 ${command}
 `);
-    fs40.writeFileSync(
+    fs39.writeFileSync(
       runnerPath,
       `#!/bin/sh
 cd ${shSingleQuote(cwd)}
@@ -40375,13 +40583,13 @@ cd ${shSingleQuote(cwd)}
   }
 }
 function trySpawnShellScriptLogRedirectWin(command, env, cwd, signal) {
-  const tmpRoot = fs40.mkdtempSync(path58.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path58.join(tmpRoot, "combined.log");
-  const runnerPath = path58.join(tmpRoot, "_run.bat");
+  const tmpRoot = fs39.mkdtempSync(path60.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path60.join(tmpRoot, "combined.log");
+  const runnerPath = path60.join(tmpRoot, "_run.bat");
   const q = (p) => `"${p.replace(/"/g, '""')}"`;
   const com = process.env.ComSpec || "cmd.exe";
   try {
-    fs40.writeFileSync(
+    fs39.writeFileSync(
       runnerPath,
       `@ECHO OFF\r
 CD /D ${q(cwd)}\r
@@ -41038,7 +41246,7 @@ function attachFirehoseAfterIdentified(ctx, params) {
   function scheduleFirehoseRetryAfterDrop(closeMeta) {
     if (state.closedByUser) return;
     const meta = closeMeta ?? state.lastFirehoseReconnectCloseMeta ?? void 0;
-    const delay2 = applyTieredReconnectPlanAndLog(
+    const delay3 = applyTieredReconnectPlanAndLog(
       state.firehoseOutage,
       logFn,
       PREVIEW_TUNNEL_SERVICE_LABEL,
@@ -41047,7 +41255,7 @@ function attachFirehoseAfterIdentified(ctx, params) {
       meta?.reason
     );
     armReconnectDelayTimer({
-      delayMs: delay2,
+      delayMs: delay3,
       bumpAttempt: () => {
         state.firehoseReconnectAttempt += 1;
       },
@@ -41158,17 +41366,17 @@ async function yieldSkillDiscoveryWork(entryCount) {
 }
 
 // src/skills/discovery/discover-local-skills.ts
-import fs41 from "node:fs";
-import path59 from "node:path";
+import fs40 from "node:fs";
+import path61 from "node:path";
 function collectSkillFromDir(rel, base, name, seenKeys, out) {
-  const dir = path59.join(base, name);
+  const dir = path61.join(base, name);
   try {
-    if (!fs41.statSync(dir).isDirectory()) return;
+    if (!fs40.statSync(dir).isDirectory()) return;
   } catch {
     return;
   }
-  const skillMd = path59.join(dir, "SKILL.md");
-  if (!fs41.existsSync(skillMd)) return;
+  const skillMd = path61.join(dir, "SKILL.md");
+  if (!fs40.existsSync(skillMd)) return;
   const key = `${rel}/${name}`;
   if (seenKeys.has(key)) return;
   seenKeys.add(key);
@@ -41180,11 +41388,11 @@ async function discoverLocalSkillsAsync(cwd) {
   let work = 0;
   for (const rel of SKILL_DISCOVERY_ROOTS) {
     await yieldSkillDiscoveryWork(++work);
-    const base = path59.join(cwd, rel);
-    if (!fs41.existsSync(base) || !fs41.statSync(base).isDirectory()) continue;
+    const base = path61.join(cwd, rel);
+    if (!fs40.existsSync(base) || !fs40.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs41.readdirSync(base);
+      entries = fs40.readdirSync(base);
     } catch {
       continue;
     }
@@ -41197,16 +41405,16 @@ async function discoverLocalSkillsAsync(cwd) {
 }
 
 // src/skills/discovery/discover-skill-layout-roots.ts
-import fs42 from "node:fs";
-import path60 from "node:path";
+import fs41 from "node:fs";
+import path62 from "node:path";
 function collectLayoutSkill(rel, base, name, skills2) {
-  const dir = path60.join(base, name);
+  const dir = path62.join(base, name);
   try {
-    if (!fs42.statSync(dir).isDirectory()) return;
+    if (!fs41.statSync(dir).isDirectory()) return;
   } catch {
     return;
   }
-  if (!fs42.existsSync(path60.join(dir, "SKILL.md"))) return;
+  if (!fs41.existsSync(path62.join(dir, "SKILL.md"))) return;
   const relPath = `${rel}/${name}`.replace(/\\/g, "/");
   skills2.push({ name, relPath });
 }
@@ -41215,11 +41423,11 @@ async function discoverSkillLayoutRootsAsync(cwd) {
   let work = 0;
   for (const rel of SKILL_DISCOVERY_ROOTS) {
     await yieldSkillDiscoveryWork(++work);
-    const base = path60.join(cwd, rel);
-    if (!fs42.existsSync(base) || !fs42.statSync(base).isDirectory()) continue;
+    const base = path62.join(cwd, rel);
+    if (!fs41.existsSync(base) || !fs41.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs42.readdirSync(base);
+      entries = fs41.readdirSync(base);
     } catch {
       continue;
     }
@@ -41307,27 +41515,6 @@ function buildBridgeUrl(apiUrl, workspaceId, authToken) {
   return `${base}/ws/bridge?${params.toString()}`;
 }
 
-// src/connection/report-git-repos.ts
-function reportGitRepos(getWs, log2) {
-  setImmediate(() => {
-    discoverGitRepos().then((repos) => {
-      if (repos.length > 0) {
-        const socket = getWs();
-        if (socket) {
-          sendWsMessage(socket, {
-            type: "git_repos",
-            repos: repos.map((r) => ({ absolutePath: r.absolutePath, remoteUrl: r.remoteUrl }))
-          });
-        }
-      }
-    }).catch((err) => {
-      log2(
-        `[Bridge service] Git repository discovery failed: ${err instanceof Error ? err.message : String(err)}`
-      );
-    });
-  });
-}
-
 // src/types/api-to-bridge-messages.ts
 var API_TO_BRIDGE_MESSAGE_TYPES = [
   "auth_token",
@@ -41584,11 +41771,11 @@ function syncRunningTurnQueueKeys(turns, queueKey) {
 }
 
 // src/prompt-turn-queue/runner/run-local-revert-before-queued-prompt.ts
-import fs44 from "node:fs";
+import fs43 from "node:fs";
 
 // src/git/snapshot/capture.ts
-import * as fs43 from "node:fs";
-import * as path61 from "node:path";
+import * as fs42 from "node:fs";
+import * as path63 from "node:path";
 
 // src/git/snapshot/git.ts
 async function gitStashCreate(repoRoot, log2) {
@@ -41628,7 +41815,7 @@ async function gitRun(repoRoot, args, log2, label) {
 async function resolveSnapshotRepoRoots(options) {
   const { worktreePaths, fallbackCwd, sessionId, log: log2 } = options;
   if (worktreePaths?.length) {
-    const uniq = [...new Set(worktreePaths.map((p) => path61.resolve(p)))];
+    const uniq = [...new Set(worktreePaths.map((p) => path63.resolve(p)))];
     return uniq;
   }
   try {
@@ -41636,7 +41823,7 @@ async function resolveSnapshotRepoRoots(options) {
     const mapped = repos.map((r) => r.absolutePath);
     const sid = sessionId?.trim();
     if (sid) {
-      const filtered = mapped.filter((root) => path61.basename(root) === sid);
+      const filtered = mapped.filter((root) => path63.basename(root) === sid);
       if (filtered.length > 0) return filtered;
     }
     return mapped;
@@ -41658,7 +41845,7 @@ async function capturePreTurnSnapshot(options) {
   });
   const dir = snapshotsDirForCwd(agentCwd);
   try {
-    fs43.mkdirSync(dir, { recursive: true });
+    fs42.mkdirSync(dir, { recursive: true });
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
   }
@@ -41667,9 +41854,9 @@ async function capturePreTurnSnapshot(options) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     repos
   };
-  const filePath = path61.join(dir, `${runId}.json`);
+  const filePath = path63.join(dir, `${runId}.json`);
   try {
-    fs43.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
+    fs42.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
   }
@@ -41682,7 +41869,7 @@ async function capturePreTurnSnapshot(options) {
 async function applyPreTurnSnapshot(filePath, log2) {
   let data;
   try {
-    const raw = fs43.readFileSync(filePath, "utf8");
+    const raw = fs42.readFileSync(filePath, "utf8");
     data = JSON.parse(raw);
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
@@ -41722,7 +41909,7 @@ async function runLocalRevertBeforeQueuedPrompt(next, deps) {
   const agentBase = deps.sessionWorktreeManager.getSessionWorktreeRootForSession(sid) ?? getBridgeRoot();
   const file2 = snapshotFilePath(agentBase, tid);
   try {
-    await fs44.promises.access(file2, fs44.constants.F_OK);
+    await fs43.promises.access(file2, fs43.constants.F_OK);
   } catch {
     deps.log(
       `[Queue] requeued_with_revert: no pre-turn snapshot for ${tid.slice(0, 8)}\u2026; continuing without revert.`
@@ -42010,9 +42197,9 @@ function parseChangeSummarySnapshots(raw) {
   for (const item of raw) {
     if (!item || typeof item !== "object") continue;
     const o = item;
-    const path71 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
-    if (!path71) continue;
-    const row = { path: path71 };
+    const path73 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
+    if (!path73) continue;
+    const row = { path: path73 };
     if (typeof o.patchContent === "string") row.patchContent = o.patchContent;
     if (typeof o.oldText === "string") row.oldText = o.oldText;
     if (typeof o.newText === "string") row.newText = o.newText;
@@ -42237,14 +42424,14 @@ async function resolveFileBrowserSessionParent(sessionWorktreeManager, sessionId
 }
 
 // src/files/list-dir/index.ts
-import fs46 from "node:fs";
+import fs45 from "node:fs";
 
 // src/files/ensure-under-cwd.ts
-import path62 from "node:path";
+import path64 from "node:path";
 function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
-  const normalized = path62.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path62.resolve(cwd, normalized);
-  if (!resolved.startsWith(cwd + path62.sep) && resolved !== cwd) {
+  const normalized = path64.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path64.resolve(cwd, normalized);
+  if (!resolved.startsWith(cwd + path64.sep) && resolved !== cwd) {
     return null;
   }
   return resolved;
@@ -42254,15 +42441,15 @@ function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
 var LIST_DIR_YIELD_EVERY = 256;
 
 // src/files/list-dir/map-dir-entry.ts
-import path63 from "node:path";
-import fs45 from "node:fs";
+import path65 from "node:path";
+import fs44 from "node:fs";
 async function mapDirEntry(d, relativePath, resolved) {
-  const entryPath = path63.join(relativePath || ".", d.name).replace(/\\/g, "/");
-  const fullPath = path63.join(resolved, d.name);
+  const entryPath = path65.join(relativePath || ".", d.name).replace(/\\/g, "/");
+  const fullPath = path65.join(resolved, d.name);
   let isDir = d.isDirectory();
   if (d.isSymbolicLink()) {
     try {
-      const targetStat = await fs45.promises.stat(fullPath);
+      const targetStat = await fs44.promises.stat(fullPath);
       isDir = targetStat.isDirectory();
     } catch {
       isDir = false;
@@ -42292,7 +42479,7 @@ async function listDirAsync(relativePath, sessionParentPath = getBridgeRoot()) {
     return { error: "Path is outside working directory" };
   }
   try {
-    const names = await fs46.promises.readdir(resolved, { withFileTypes: true });
+    const names = await fs45.promises.readdir(resolved, { withFileTypes: true });
     const entries = [];
     for (let i = 0; i < names.length; i++) {
       if (i > 0 && i % LIST_DIR_YIELD_EVERY === 0) {
@@ -42308,13 +42495,13 @@ async function listDirAsync(relativePath, sessionParentPath = getBridgeRoot()) {
 }
 
 // src/files/handle-file-browser-search.ts
-import path64 from "node:path";
+import path66 from "node:path";
 var SEARCH_LIMIT = 100;
 function handleFileBrowserSearch(msg, socket, e2ee, sessionWorktreeManager) {
   void (async () => {
     await yieldToEventLoop();
     const q = typeof msg.q === "string" ? msg.q : "";
-    const sessionParentPath = path64.resolve(
+    const sessionParentPath = path66.resolve(
       sessionWorktreeManager != null ? await resolveFileBrowserSessionParent(sessionWorktreeManager, msg.sessionId) : getBridgeRoot()
     );
     if (!await bridgeFileIndexIsPopulated(sessionParentPath)) {
@@ -42418,6 +42605,19 @@ async function resolveCodeNavParentPath(sessionWorktreeManager, sessionId) {
 }
 
 // src/code-nav/handlers/prepare-code-nav-request.ts
+var CODE_NAV_INDEX_READY_WAIT_MS = 75;
+var CODE_NAV_INDEX_READY_POLL_MS = 15;
+function delay2(ms) {
+  return new Promise((resolve32) => setTimeout(resolve32, ms));
+}
+async function waitForSymbolIndexReady(sessionParentPath, reqPath) {
+  const deadline = Date.now() + CODE_NAV_INDEX_READY_WAIT_MS;
+  do {
+    if (await symbolIndexFileIsReadyAsync(sessionParentPath, reqPath)) return true;
+    await delay2(CODE_NAV_INDEX_READY_POLL_MS);
+  } while (Date.now() < deadline);
+  return await symbolIndexFileIsReadyAsync(sessionParentPath, reqPath);
+}
 async function prepareCodeNavRequest(msg, socket, e2ee, sessionWorktreeManager) {
   await yieldToEventLoop();
   const reqPath = msg.path.replace(/^\/+/, "") || "";
@@ -42430,12 +42630,15 @@ async function prepareCodeNavRequest(msg, socket, e2ee, sessionWorktreeManager)
     return null;
   }
   const sessionParentPath = await resolveCodeNavParentPath(sessionWorktreeManager, msg.sessionId);
-  registerSymbolIndexParent(sessionParentPath);
-  await ensureSymbolIndexFileAsync(sessionParentPath, reqPath, { importDepth: 1 });
+  await registerSymbolIndexParentAsync(sessionParentPath);
+  scheduleSymbolIndexFile(sessionParentPath, reqPath);
+  const indexReady = await waitForSymbolIndexReady(sessionParentPath, reqPath);
+  if (indexReady) {
+    const importTargets = await listDirectImportTargetsForFileAsync(sessionParentPath, reqPath);
+    scheduleSymbolIndexImportNeighbors(sessionParentPath, importTargets);
+  }
+  scheduleSymbolIndexWarmup(sessionParentPath);
   await yieldToEventLoop();
-  const importTargets = listDirectImportTargetsForFile(sessionParentPath, reqPath);
-  scheduleSymbolIndexForRequest(sessionParentPath, reqPath, importTargets);
-  const indexReady = symbolIndexFileIsReady(sessionParentPath, reqPath);
   return {
     socket,
     e2ee,
@@ -42499,20 +42702,22 @@ function handleCodeNavRequest(msg, socket, e2ee, sessionWorktreeManager) {
 // src/code-nav/handlers/trigger-symbol-index-build.ts
 function triggerSymbolIndexBuild(parentPath) {
   setImmediate(() => {
-    const resolved = normalizeResolvedPath(parentPath);
-    registerSymbolIndexParent(resolved);
-    scheduleSymbolIndexWarmup(resolved);
+    void (async () => {
+      const resolved = normalizeResolvedPath(parentPath);
+      await registerSymbolIndexParentAsync(resolved);
+      scheduleSymbolIndexWarmup(resolved);
+    })();
   });
 }
 
 // src/git/tree/resolve-repo-abs-path.ts
-import * as path65 from "node:path";
+import * as path67 from "node:path";
 function resolveRepoAbsPathFromBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path65.resolve(bridgeRoot);
+  const bridgeResolved = path67.resolve(bridgeRoot);
   const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
-  const repoPath = rel === "" ? bridgeResolved : path65.join(bridgeResolved, rel);
-  const resolved = path65.resolve(repoPath);
-  if (!resolved.startsWith(bridgeResolved + path65.sep) && resolved !== bridgeResolved) {
+  const repoPath = rel === "" ? bridgeResolved : path67.join(bridgeResolved, rel);
+  const resolved = path67.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path67.sep) && resolved !== bridgeResolved) {
     return null;
   }
   return resolved;
@@ -42910,18 +43115,18 @@ async function handleFileBrowserList(socket, e2ee, id, reqPath, sessionParentPat
 }
 
 // src/files/read-file/resolve-file-path.ts
-import fs47 from "node:fs";
+import fs46 from "node:fs";
 async function resolveFilePathAsync(relativePath, sessionParentPath = getBridgeRoot()) {
   const resolved = ensureUnderCwd(relativePath, sessionParentPath);
   if (!resolved) return { error: "Path is outside working directory" };
   let real;
   try {
-    real = await fs47.promises.realpath(resolved);
+    real = await fs46.promises.realpath(resolved);
   } catch {
     real = resolved;
   }
   try {
-    const stat2 = await fs47.promises.stat(real);
+    const stat2 = await fs46.promises.stat(real);
     if (!stat2.isFile()) return { error: "Not a file" };
     return real;
   } catch (err) {
@@ -42930,11 +43135,11 @@ async function resolveFilePathAsync(relativePath, sessionParentPath = getBridgeR
 }
 
 // src/files/read-file/read-file-range-async.ts
-import fs48 from "node:fs";
+import fs47 from "node:fs";
 import { StringDecoder as StringDecoder2 } from "node:string_decoder";
 async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
-  const fileSize = (await fs48.promises.stat(filePath)).size;
-  const fd = await fs48.promises.open(filePath, "r");
+  const fileSize = (await fs47.promises.stat(filePath)).size;
+  const fd = await fs47.promises.open(filePath, "r");
   const bufSize = 64 * 1024;
   const buf = Buffer.alloc(bufSize);
   const decoder = new StringDecoder2("utf8");
@@ -43096,11 +43301,11 @@ async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, li
 }
 
 // src/files/read-file/read-file-buffer-full-async.ts
-import fs49 from "node:fs";
+import fs48 from "node:fs";
 var READ_CHUNK_BYTES = 256 * 1024;
 async function readFileBufferFullAsync(filePath) {
-  const stat2 = await fs49.promises.stat(filePath);
-  const fd = await fs49.promises.open(filePath, "r");
+  const stat2 = await fs48.promises.stat(filePath);
+  const fd = await fs48.promises.open(filePath, "r");
   const chunks = [];
   let position = 0;
   let bytesSinceYield = 0;
@@ -43294,8 +43499,8 @@ function isValidRemoteSkillInstallItem(item) {
 }
 
 // src/skills/install/install-remote-skills-async.ts
-import fs50 from "node:fs";
-import path66 from "node:path";
+import fs49 from "node:fs";
+import path68 from "node:path";
 
 // src/skills/install/constants.ts
 var INSTALL_SKILLS_YIELD_EVERY = 16;
@@ -43306,12 +43511,12 @@ async function writeInstallFileAsync(skillDir, f, filesWritten) {
   if (++filesWritten.count % INSTALL_SKILLS_YIELD_EVERY === 0) {
     await yieldToEventLoop();
   }
-  const dest = path66.join(skillDir, f.path);
-  await fs50.promises.mkdir(path66.dirname(dest), { recursive: true });
+  const dest = path68.join(skillDir, f.path);
+  await fs49.promises.mkdir(path68.dirname(dest), { recursive: true });
   if (f.text !== void 0) {
-    await fs50.promises.writeFile(dest, f.text, "utf8");
+    await fs49.promises.writeFile(dest, f.text, "utf8");
   } else if (f.base64) {
-    await fs50.promises.writeFile(dest, Buffer.from(f.base64, "base64"));
+    await fs49.promises.writeFile(dest, Buffer.from(f.base64, "base64"));
   }
 }
 async function installRemoteSkillsAsync(cwd, targetDir, items) {
@@ -43323,7 +43528,7 @@ async function installRemoteSkillsAsync(cwd, targetDir, items) {
   try {
     for (const item of items) {
       if (!isValidRemoteSkillInstallItem(item)) continue;
-      const skillDir = path66.join(cwd, targetDir, item.skillName);
+      const skillDir = path68.join(cwd, targetDir, item.skillName);
       for (const f of item.files) {
         await writeInstallFileAsync(skillDir, f, filesWritten);
       }
@@ -43605,7 +43810,7 @@ var handleSessionDiscardedMessage = (msg, deps) => {
 };
 
 // src/routing/handlers/revert-turn-snapshot.ts
-import * as fs51 from "node:fs";
+import * as fs50 from "node:fs";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
@@ -43618,7 +43823,7 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
     const agentBase = sessionWorktreeManager.getSessionWorktreeRootForSession(sessionId) ?? getBridgeRoot();
     const file2 = snapshotFilePath(agentBase, turnId);
     try {
-      await fs51.promises.access(file2, fs51.constants.F_OK);
+      await fs50.promises.access(file2, fs50.constants.F_OK);
     } catch {
       sendWsMessage(s, {
         type: "revert_turn_snapshot_result",
@@ -43662,7 +43867,7 @@ var handleDevServersConfig = (msg, deps) => {
 };
 
 // src/git/bridge-git-context.ts
-import * as path67 from "node:path";
+import * as path69 from "node:path";
 
 // src/git/branches/get-current-branch.ts
 async function getCurrentBranch(repoPath) {
@@ -43712,12 +43917,12 @@ async function listRepoBranchRefs(repoPath) {
 // src/git/bridge-git-context.ts
 function folderNameForRelPath(relPath, bridgeRoot) {
   if (relPath === "." || relPath === "") {
-    return path67.basename(path67.resolve(bridgeRoot)) || "repo";
+    return path69.basename(path69.resolve(bridgeRoot)) || "repo";
   }
-  return path67.basename(relPath) || relPath;
+  return path69.basename(relPath) || relPath;
 }
 async function discoverGitReposForBridgeContext(bridgeRoot) {
-  const root = path67.resolve(bridgeRoot);
+  const root = path69.resolve(bridgeRoot);
   if (await isGitRepoDirectory(root)) {
     const remoteUrl = await getRemoteOriginUrl(root);
     return [{ absolutePath: root, remoteUrl }];
@@ -43725,19 +43930,19 @@ async function discoverGitReposForBridgeContext(bridgeRoot) {
   const [deep, shallow] = await Promise.all([discoverGitReposUnderRoot(root), discoverGitRepos(root)]);
   const byPath = /* @__PURE__ */ new Map();
   for (const repo of [...deep, ...shallow]) {
-    byPath.set(path67.resolve(repo.absolutePath), repo);
+    byPath.set(path69.resolve(repo.absolutePath), repo);
   }
   return [...byPath.values()];
 }
 async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path67.resolve(bridgeRoot);
+  const bridgeResolved = path69.resolve(bridgeRoot);
   const repos = await discoverGitReposForBridgeContext(bridgeResolved);
   const rows = [];
   for (let i = 0; i < repos.length; i++) {
     if (i > 0) await yieldToEventLoop();
     const repo = repos[i];
-    let rel = path67.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path67.isAbsolute(rel)) continue;
+    let rel = path69.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path69.isAbsolute(rel)) continue;
     const relPath = rel === "" ? "." : rel.replace(/\\/g, "/");
     const currentBranch = await getCurrentBranch(repo.absolutePath);
     const remoteUrl = repo.remoteUrl.trim() || null;
@@ -43752,11 +43957,11 @@ async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
   return rows;
 }
 async function listRepoBranchesForBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path67.resolve(bridgeRoot);
+  const bridgeResolved = path69.resolve(bridgeRoot);
   const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
-  const repoPath = rel === "" ? bridgeResolved : path67.join(bridgeResolved, rel);
-  const resolved = path67.resolve(repoPath);
-  if (!resolved.startsWith(bridgeResolved + path67.sep) && resolved !== bridgeResolved) {
+  const repoPath = rel === "" ? bridgeResolved : path69.join(bridgeResolved, rel);
+  const resolved = path69.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path69.sep) && resolved !== bridgeResolved) {
     return [];
   }
   return listRepoBranchRefs(resolved);
@@ -43925,25 +44130,127 @@ async function refreshBridgeTokens(params) {
   }
 }
 
-// src/connection/main-bridge-ws-lifecycle.ts
-function createMainBridgeWebSocketLifecycle(params) {
+// src/connection/main-bridge-auth-refresh-handler.ts
+function resetAfterAuthInvalid(params) {
+  const { state } = params;
+  state.reconnectAttempt = 0;
+  resetReconnectOutageTracker(state.mainOutage);
+  state.lastReconnectCloseMeta = null;
+}
+function createMainBridgeAuthRefreshHandler(params, connect) {
+  const { apiUrl, workspaceId, logFn, tokens, persistTokens, onAuthInvalid } = params;
+  let authRefreshInFlight = false;
+  return () => {
+    if (authRefreshInFlight) return;
+    void (async () => {
+      authRefreshInFlight = true;
+      try {
+        if (tokens.refreshToken) {
+          const next = await refreshBridgeTokens({
+            apiUrl,
+            workspaceId,
+            refreshToken: tokens.refreshToken
+          });
+          if (next?.token && next.refreshToken) {
+            tokens.accessToken = next.token;
+            tokens.refreshToken = next.refreshToken;
+            persistTokens?.({ token: tokens.accessToken, refreshToken: tokens.refreshToken });
+            try {
+              logFn("[Bridge service] Access token refreshed; reconnecting\u2026");
+            } catch {
+            }
+            resetAfterAuthInvalid(params);
+            params.state.logBridgeOpenAsReconnect = true;
+            authRefreshInFlight = false;
+            connect();
+            return;
+          }
+        }
+        authRefreshInFlight = false;
+        resetAfterAuthInvalid(params);
+        onAuthInvalid();
+      } catch {
+        authRefreshInFlight = false;
+        resetAfterAuthInvalid(params);
+        onAuthInvalid();
+      }
+    })();
+  };
+}
+
+// src/connection/main-bridge-ws-close-handler.ts
+function createMainBridgeCloseHandler(params, connect) {
+  const { state, logFn, bridgeHeartbeat } = params;
+  return (code, reason) => {
+    bridgeHeartbeat?.stop();
+    try {
+      const was = state.currentWs;
+      state.currentWs = null;
+      if (was) was.removeAllListeners();
+      const willReconnect = !state.closedByUser;
+      if (willReconnect) {
+        const duplicateResult = evaluateDuplicateBridgeDisconnect(
+          state.duplicateBridgeFlap,
+          Date.now(),
+          code,
+          reason
+        );
+        logDuplicateBridgeWarning(logFn, duplicateResult);
+      }
+      beginMainBridgeDeferredDisconnect(state, code, reason, logFn, willReconnect);
+      if (willReconnect) {
+        state.lastReconnectCloseMeta = { code, reason };
+        try {
+          scheduleMainBridgeReconnect(state, connect, logFn, { code, reason });
+        } catch {
+        }
+      }
+    } catch {
+      if (!state.closedByUser) {
+        try {
+          scheduleMainBridgeReconnect(state, connect, logFn);
+        } catch {
+        }
+      }
+    }
+  };
+}
+
+// src/connection/report-git-repos.ts
+function reportGitRepos(getWs, log2) {
+  setImmediate(() => {
+    discoverGitRepos().then((repos) => {
+      if (repos.length > 0) {
+        const socket = getWs();
+        if (socket) {
+          sendWsMessage(socket, {
+            type: "git_repos",
+            repos: repos.map((r) => ({ absolutePath: r.absolutePath, remoteUrl: r.remoteUrl }))
+          });
+        }
+      }
+    }).catch((err) => {
+      log2(
+        `[Bridge service] Git repository discovery failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    });
+  });
+}
+
+// src/connection/main-bridge-ws-open-handler.ts
+function createMainBridgeOpenHandler(params) {
   const {
     state,
     getWs,
-    apiUrl,
     workspaceId,
     justAuthenticated,
     logFn,
-    messageDeps,
     tokens,
-    persistTokens,
-    onAuthInvalid,
     e2ee,
     identifyReportedPaths,
-    bridgeHeartbeat
+    onBridgeSocketOpen
   } = params;
-  let authRefreshInFlight = false;
-  function handleOpen() {
+  return () => {
     recordBridgeSessionOpened(state.duplicateBridgeFlap, Date.now());
     const logOpenAsPostRefreshReconnect = state.logBridgeOpenAsReconnect;
     clearMainBridgeReconnectQuietOnOpen(state, logFn);
@@ -43963,6 +44270,10 @@ function createMainBridgeWebSocketLifecycle(params) {
         ...e2ee ? { e: e2ee.handshake } : {}
       });
       reportGitRepos(getWs, logFn);
+      try {
+        onBridgeSocketOpen?.();
+      } catch {
+      }
     }
     if (justAuthenticated && socket) {
       logFn(
@@ -43971,41 +44282,25 @@ function createMainBridgeWebSocketLifecycle(params) {
       logFn(`  export BUILDAUTOMATON_AUTH_TOKEN="${tokens.accessToken}"`);
       logFn(`  export BUILDAUTOMATON_WORKSPACE_ID="${workspaceId}"`);
     }
-  }
-  function handleClose(code, reason) {
-    bridgeHeartbeat?.stop();
-    try {
-      const was = state.currentWs;
-      state.currentWs = null;
-      if (was) was.removeAllListeners();
-      const willReconnect = !state.closedByUser;
-      if (willReconnect) {
-        const duplicateResult = evaluateDuplicateBridgeDisconnect(
-          state.duplicateBridgeFlap,
-          Date.now(),
-          code,
-          reason
-        );
-        logDuplicateBridgeWarning(logFn, duplicateResult);
-      }
-      beginMainBridgeDeferredDisconnect(state, code, reason, logFn, willReconnect);
-      if (willReconnect) {
-        state.lastReconnectCloseMeta = { code, reason };
-        try {
-          scheduleMainBridgeReconnect(state, connect, logFn, { code, reason });
-        } catch {
-        }
-      }
-    } catch {
-      if (!state.closedByUser) {
-        try {
-          scheduleMainBridgeReconnect(state, connect, logFn);
-        } catch {
-        }
-      }
-    }
-  }
-  function connect() {
+  };
+}
+
+// src/connection/main-bridge-ws-lifecycle.ts
+function createMainBridgeWebSocketLifecycle(params) {
+  const {
+    state,
+    apiUrl,
+    workspaceId,
+    logFn,
+    messageDeps,
+    tokens,
+    bridgeHeartbeat
+  } = params;
+  let connect;
+  const handleOpen = createMainBridgeOpenHandler(params);
+  const handleClose = createMainBridgeCloseHandler(params, () => connect());
+  const handleAuthInvalid = createMainBridgeAuthRefreshHandler(params, () => connect());
+  connect = () => {
     if (state.closedByUser) return;
     if (state.reconnectTimeout != null) {
       clearTimeout(state.reconnectTimeout);
@@ -44041,48 +44336,7 @@ function createMainBridgeWebSocketLifecycle(params) {
         onCompactHeartbeatAck: (seq) => {
           messageDeps.onBridgeHeartbeatAck?.(seq);
         },
-        onAuthInvalid: () => {
-          if (authRefreshInFlight) return;
-          void (async () => {
-            authRefreshInFlight = true;
-            try {
-              if (tokens.refreshToken) {
-                const next = await refreshBridgeTokens({
-                  apiUrl,
-                  workspaceId,
-                  refreshToken: tokens.refreshToken
-                });
-                if (next?.token && next.refreshToken) {
-                  tokens.accessToken = next.token;
-                  tokens.refreshToken = next.refreshToken;
-                  persistTokens?.({ token: tokens.accessToken, refreshToken: tokens.refreshToken });
-                  try {
-                    logFn("[Bridge service] Access token refreshed; reconnecting\u2026");
-                  } catch {
-                  }
-                  state.reconnectAttempt = 0;
-                  resetReconnectOutageTracker(state.mainOutage);
-                  state.lastReconnectCloseMeta = null;
-                  state.logBridgeOpenAsReconnect = true;
-                  authRefreshInFlight = false;
-                  connect();
-                  return;
-                }
-              }
-              authRefreshInFlight = false;
-              state.reconnectAttempt = 0;
-              resetReconnectOutageTracker(state.mainOutage);
-              state.lastReconnectCloseMeta = null;
-              onAuthInvalid();
-            } catch {
-              authRefreshInFlight = false;
-              state.reconnectAttempt = 0;
-              resetReconnectOutageTracker(state.mainOutage);
-              state.lastReconnectCloseMeta = null;
-              onAuthInvalid();
-            }
-          })();
-        },
+        onAuthInvalid: handleAuthInvalid,
         onOpen: handleOpen,
         onClose: handleClose,
         onError: (err) => {
@@ -44109,7 +44363,7 @@ function createMainBridgeWebSocketLifecycle(params) {
         }
       }
     }
-  }
+  };
   return { connect };
 }
 
@@ -44278,256 +44532,6 @@ function createBridgeHeartbeatController(params) {
   };
 }
 
-// src/sqlite/hash-json-sha256.ts
-import { createHash } from "node:crypto";
-function hashJsonUtf8Sha256(value) {
-  return createHash("sha256").update(JSON.stringify(value), "utf8").digest("hex");
-}
-
-// src/sqlite/agent-capability-cache.ts
-function hasNonEmptyAgentCapabilityCache(db, workspaceId, agentType) {
-  const t = agentType.trim();
-  if (!t) return false;
-  try {
-    const row = db.get(
-      `SELECT config_options_json FROM agent_capabilities WHERE workspace_id = ? AND agent_type = ?`,
-      [workspaceId, t]
-    );
-    if (row?.config_options_json == null || row.config_options_json === "") return false;
-    const parsed = JSON.parse(row.config_options_json);
-    return Array.isArray(parsed) && parsed.length > 0;
-  } catch {
-    return false;
-  }
-}
-function upsertCliAgentCapabilityCache(db, row) {
-  const t = row.agentType.trim();
-  if (!t) return false;
-  const hash = hashJsonUtf8Sha256(row.configOptions);
-  try {
-    const prev = db.get(
-      `SELECT content_hash FROM agent_capabilities WHERE workspace_id = ? AND agent_type = ?`,
-      [row.workspaceId, t]
-    );
-    if (prev?.content_hash === hash) return false;
-  } catch {
-  }
-  const json2 = JSON.stringify(row.configOptions);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.run(
-    `INSERT INTO agent_capabilities (workspace_id, agent_type, config_options_json, content_hash, updated_at)
-     VALUES (?, ?, ?, ?, ?)
-     ON CONFLICT(workspace_id, agent_type) DO UPDATE SET
-       config_options_json = excluded.config_options_json,
-       content_hash = excluded.content_hash,
-       updated_at = excluded.updated_at`,
-    [row.workspaceId, t, json2, hash, now]
-  );
-  return true;
-}
-function listCliAgentCapabilityCacheForWorkspace(db, workspaceId) {
-  const rows = db.all(
-    `SELECT agent_type, config_options_json FROM agent_capabilities WHERE workspace_id = ?`,
-    [workspaceId]
-  );
-  const out = [];
-  for (const r of rows) {
-    try {
-      const parsed = JSON.parse(r.config_options_json);
-      if (!Array.isArray(parsed) || parsed.length === 0) continue;
-      out.push({ agentType: r.agent_type, configOptions: parsed });
-    } catch {
-    }
-  }
-  return out;
-}
-
-// src/agents/capabilities/warmup-agent-capabilities-on-connect.ts
-import * as path69 from "node:path";
-
-// src/agents/capabilities/probe-one-agent-type-for-capabilities.ts
-import * as path68 from "node:path";
-async function probeOneAgentTypeForCapabilities(params) {
-  const { agentType, cwd, workspaceId, log: log2, reportAgentCapabilities, bridgeReport = true, shouldContinue } = params;
-  const canContinue = () => shouldContinue?.() !== false;
-  if (!canContinue()) return false;
-  const resolved = resolveAgentCommand(agentType);
-  if (!resolved) return false;
-  let sqliteChanged = false;
-  const reportedRef = { done: false };
-  const tryReport = (co) => {
-    if (reportedRef.done) return;
-    if (!Array.isArray(co) || co.length === 0) return;
-    reportedRef.done = true;
-    let changed = false;
-    try {
-      changed = withCliSqliteSync(
-        (db) => upsertCliAgentCapabilityCache(db, {
-          workspaceId,
-          agentType,
-          configOptions: co
-        })
-      );
-    } catch {
-    }
-    sqliteChanged ||= changed;
-    if (bridgeReport && changed) {
-      reportAgentCapabilities?.({ agentType, configOptions: co });
-    }
-  };
-  let handle = null;
-  const killTimer = setTimeout(() => {
-    void handle?.disconnectGracefully();
-  }, 28e3);
-  killTimer.unref?.();
-  try {
-    if (!canContinue()) return false;
-    handle = await resolved.createClient({
-      command: resolved.command,
-      cwd: path68.resolve(cwd),
-      backendAgentType: agentType,
-      sessionMode: "agent",
-      persistedAcpSessionId: null,
-      agentConfig: null,
-      getActiveConfigOptions: () => null,
-      onAcpSessionEstablished: (info) => {
-        tryReport(info.configOptions ?? null);
-      },
-      onAcpConfigOptionsUpdated: (co) => {
-        tryReport(co);
-      },
-      onAgentSubprocessExit: () => {
-      },
-      onSessionUpdate: () => {
-      }
-    });
-    if (!await delayMsUnlessShutdownRequested(1200) || !canContinue()) return false;
-  } catch (e) {
-    log2(
-      `[Bridge service] Agent capability probe (${agentType}): ${e instanceof Error ? e.message : String(e)}`
-    );
-  } finally {
-    clearTimeout(killTimer);
-    try {
-      await handle?.disconnectGracefully();
-    } catch {
-    }
-  }
-  return sqliteChanged;
-}
-
-// src/agents/capabilities/probe-agent-capabilities-for-types.ts
-async function probeAgentCapabilitiesForDetectedTypes(params) {
-  const {
-    agentTypes,
-    cwd,
-    workspaceId,
-    log: log2,
-    reportAgentCapabilities,
-    bridgeReport = true,
-    forceAllTypes = false,
-    shouldContinue
-  } = params;
-  const canContinue = () => !isCliImmediateShutdownRequested() && shouldContinue?.() !== false;
-  let changedCount = 0;
-  for (let i = 0; i < agentTypes.length; i++) {
-    if (!canContinue()) 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" && await withCliSqlite((db) => hasNonEmptyAgentCapabilityCache(db, workspaceId, agentType))) {
-          continue;
-        }
-      } catch {
-      }
-    }
-    const changed = await probeOneAgentTypeForCapabilities({
-      agentType,
-      cwd,
-      workspaceId,
-      log: log2,
-      reportAgentCapabilities,
-      bridgeReport,
-      shouldContinue: canContinue
-    });
-    if (changed) changedCount += 1;
-  }
-  return changedCount;
-}
-
-// src/agents/capabilities/warmup-agent-capabilities-on-connect.ts
-async function warmupAgentCapabilitiesOnConnect(params) {
-  const { workspaceId, log: log2, getWs } = params;
-  const isCurrent = beginAgentCapabilityWarmupRun();
-  if (!isCurrent()) return;
-  const cwd = path69.resolve(getBridgeRoot());
-  async function sendBatchFromCache() {
-    if (!isCurrent()) return;
-    const socket = getWs();
-    if (!socket || socket.readyState !== wrapper_default.OPEN) return;
-    try {
-      const rows = await withCliSqlite((db) => listCliAgentCapabilityCacheForWorkspace(db, workspaceId));
-      if (!isCurrent()) return;
-      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)}`
-      );
-    }
-  }
-  await sendBatchFromCache();
-  if (!isCurrent()) return;
-  let types = [];
-  try {
-    types = [...await detectLocalAgentTypes()];
-  } catch (e) {
-    log2(`[Bridge service] detectLocalAgentTypes failed: ${e instanceof Error ? e.message : String(e)}`);
-  }
-  if (!isCurrent()) return;
-  try {
-    const n = await probeAgentCapabilitiesForDetectedTypes({
-      agentTypes: types,
-      cwd,
-      workspaceId,
-      log: log2,
-      bridgeReport: false,
-      forceAllTypes: false,
-      shouldContinue: isCurrent
-    });
-    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)}`);
-  }
-  if (!isCurrent()) return;
-  void (async () => {
-    try {
-      await yieldToEventLoop();
-      if (!isCurrent()) return;
-      const n = await probeAgentCapabilitiesForDetectedTypes({
-        agentTypes: types,
-        cwd,
-        workspaceId,
-        log: log2,
-        bridgeReport: false,
-        forceAllTypes: true,
-        shouldContinue: isCurrent
-      });
-      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)}`);
-    }
-  })();
-}
-
 // src/mcp/tools/session-history/fork/mcp-text-result.ts
 function mcpTextResult(text, isError = false) {
   return { content: [{ type: "text", text }], ...isError ? { isError: true } : {} };
@@ -44912,6 +44916,327 @@ async function createBridgeAccessState(options = {}) {
   };
 }
 
+// src/agents/capabilities/warmup-agent-capabilities-on-connect.ts
+import * as path71 from "node:path";
+
+// src/sqlite/hash-json-sha256.ts
+import { createHash } from "node:crypto";
+function hashJsonUtf8Sha256(value) {
+  return createHash("sha256").update(JSON.stringify(value), "utf8").digest("hex");
+}
+
+// src/sqlite/agent-capability-cache.ts
+function hasNonEmptyAgentCapabilityCache(db, workspaceId, agentType) {
+  const t = agentType.trim();
+  if (!t) return false;
+  try {
+    const row = db.get(
+      `SELECT config_options_json FROM agent_capabilities WHERE workspace_id = ? AND agent_type = ?`,
+      [workspaceId, t]
+    );
+    if (row?.config_options_json == null || row.config_options_json === "") return false;
+    const parsed = JSON.parse(row.config_options_json);
+    return Array.isArray(parsed) && parsed.length > 0;
+  } catch {
+    return false;
+  }
+}
+function upsertCliAgentCapabilityCache(db, row) {
+  const t = row.agentType.trim();
+  if (!t) return false;
+  const hash = hashJsonUtf8Sha256(row.configOptions);
+  try {
+    const prev = db.get(
+      `SELECT content_hash FROM agent_capabilities WHERE workspace_id = ? AND agent_type = ?`,
+      [row.workspaceId, t]
+    );
+    if (prev?.content_hash === hash) return false;
+  } catch {
+  }
+  const json2 = JSON.stringify(row.configOptions);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.run(
+    `INSERT INTO agent_capabilities (workspace_id, agent_type, config_options_json, content_hash, updated_at)
+     VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(workspace_id, agent_type) DO UPDATE SET
+       config_options_json = excluded.config_options_json,
+       content_hash = excluded.content_hash,
+       updated_at = excluded.updated_at`,
+    [row.workspaceId, t, json2, hash, now]
+  );
+  return true;
+}
+function listCliAgentCapabilityCacheForWorkspace(db, workspaceId) {
+  const rows = db.all(
+    `SELECT agent_type, config_options_json FROM agent_capabilities WHERE workspace_id = ?`,
+    [workspaceId]
+  );
+  const out = [];
+  for (const r of rows) {
+    try {
+      const parsed = JSON.parse(r.config_options_json);
+      if (!Array.isArray(parsed) || parsed.length === 0) continue;
+      out.push({ agentType: r.agent_type, configOptions: parsed });
+    } catch {
+    }
+  }
+  return out;
+}
+
+// src/agents/capabilities/probe-one-agent-type-for-capabilities.ts
+import * as path70 from "node:path";
+async function probeOneAgentTypeForCapabilities(params) {
+  const { agentType, cwd, workspaceId, log: log2, reportAgentCapabilities, bridgeReport = true, shouldContinue } = params;
+  const canContinue = () => shouldContinue?.() !== false;
+  if (!canContinue()) return false;
+  const resolved = resolveAgentCommand(agentType);
+  if (!resolved) return false;
+  let sqliteChanged = false;
+  const reportedRef = { done: false };
+  const tryReport = (co) => {
+    if (reportedRef.done) return;
+    if (!Array.isArray(co) || co.length === 0) return;
+    reportedRef.done = true;
+    let changed = false;
+    try {
+      changed = withCliSqliteSync(
+        (db) => upsertCliAgentCapabilityCache(db, {
+          workspaceId,
+          agentType,
+          configOptions: co
+        })
+      );
+    } catch {
+    }
+    sqliteChanged ||= changed;
+    if (bridgeReport && changed) {
+      reportAgentCapabilities?.({ agentType, configOptions: co });
+    }
+  };
+  let handle = null;
+  const killTimer = setTimeout(() => {
+    void handle?.disconnectGracefully();
+  }, 28e3);
+  killTimer.unref?.();
+  try {
+    if (!canContinue()) return false;
+    handle = await resolved.createClient({
+      command: resolved.command,
+      cwd: path70.resolve(cwd),
+      backendAgentType: agentType,
+      sessionMode: "agent",
+      persistedAcpSessionId: null,
+      agentConfig: null,
+      getActiveConfigOptions: () => null,
+      onAcpSessionEstablished: (info) => {
+        tryReport(info.configOptions ?? null);
+      },
+      onAcpConfigOptionsUpdated: (co) => {
+        tryReport(co);
+      },
+      onAgentSubprocessExit: () => {
+      },
+      onSessionUpdate: () => {
+      }
+    });
+    if (!await delayMsUnlessShutdownRequested(1200) || !canContinue()) return false;
+  } catch (e) {
+    log2(
+      `[Bridge service] Agent capability probe (${agentType}): ${e instanceof Error ? e.message : String(e)}`
+    );
+  } finally {
+    clearTimeout(killTimer);
+    try {
+      await handle?.disconnectGracefully();
+    } catch {
+    }
+  }
+  return sqliteChanged;
+}
+
+// src/agents/capabilities/probe-agent-capabilities-for-types.ts
+async function probeAgentCapabilitiesForDetectedTypes(params) {
+  const {
+    agentTypes,
+    cwd,
+    workspaceId,
+    log: log2,
+    reportAgentCapabilities,
+    bridgeReport = true,
+    forceAllTypes = false,
+    shouldContinue
+  } = params;
+  const canContinue = () => !isCliImmediateShutdownRequested() && shouldContinue?.() !== false;
+  let changedCount = 0;
+  for (let i = 0; i < agentTypes.length; i++) {
+    if (!canContinue()) 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" && await withCliSqlite((db) => hasNonEmptyAgentCapabilityCache(db, workspaceId, agentType))) {
+          continue;
+        }
+      } catch {
+      }
+    }
+    const changed = await probeOneAgentTypeForCapabilities({
+      agentType,
+      cwd,
+      workspaceId,
+      log: log2,
+      reportAgentCapabilities,
+      bridgeReport,
+      shouldContinue: canContinue
+    });
+    if (changed) changedCount += 1;
+  }
+  return changedCount;
+}
+
+// src/agents/capabilities/warmup-agent-capabilities-on-connect.ts
+async function warmupAgentCapabilitiesOnConnect(params) {
+  const { workspaceId, log: log2, getWs } = params;
+  const isCurrent = beginAgentCapabilityWarmupRun();
+  if (!isCurrent()) return;
+  const cwd = path71.resolve(getBridgeRoot());
+  async function sendBatchFromCache() {
+    if (!isCurrent()) return;
+    const socket = getWs();
+    if (!socket || socket.readyState !== wrapper_default.OPEN) return;
+    try {
+      const rows = await withCliSqlite((db) => listCliAgentCapabilityCacheForWorkspace(db, workspaceId));
+      if (!isCurrent()) return;
+      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)}`
+      );
+    }
+  }
+  await sendBatchFromCache();
+  if (!isCurrent()) return;
+  let types = [];
+  try {
+    types = [...await detectLocalAgentTypes()];
+  } catch (e) {
+    log2(`[Bridge service] detectLocalAgentTypes failed: ${e instanceof Error ? e.message : String(e)}`);
+  }
+  if (!isCurrent()) return;
+  try {
+    const n = await probeAgentCapabilitiesForDetectedTypes({
+      agentTypes: types,
+      cwd,
+      workspaceId,
+      log: log2,
+      bridgeReport: false,
+      forceAllTypes: false,
+      shouldContinue: isCurrent
+    });
+    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)}`);
+  }
+  if (!isCurrent()) return;
+  void (async () => {
+    try {
+      await yieldToEventLoop();
+      if (!isCurrent()) return;
+      const n = await probeAgentCapabilitiesForDetectedTypes({
+        agentTypes: types,
+        cwd,
+        workspaceId,
+        log: log2,
+        bridgeReport: false,
+        forceAllTypes: true,
+        shouldContinue: isCurrent
+      });
+      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)}`);
+    }
+  })();
+}
+
+// src/connection/create-bridge-agent-capabilities-reporter.ts
+function createAgentCapabilitiesReporter(params) {
+  const { workspaceId, getWs } = params;
+  return (info) => {
+    if (!Array.isArray(info.configOptions) || info.configOptions.length === 0) return;
+    setImmediate(() => {
+      let changed = false;
+      try {
+        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();
+      if (!socket || socket.readyState !== wrapper_default.OPEN) return;
+      sendWsMessage(socket, {
+        type: "agent_capabilities",
+        agentType: info.agentType,
+        configOptions: info.configOptions
+      });
+    });
+  };
+}
+function createWarmupAgentCapabilitiesOnConnect(params) {
+  return async () => {
+    await warmupAgentCapabilitiesOnConnect(params);
+  };
+}
+
+// src/connection/create-bridge-message-deps.ts
+function createBridgeMessageDeps(params) {
+  const {
+    getWs,
+    log: log2,
+    acpManager,
+    sessionWorktreeManager,
+    onBridgeIdentified,
+    bridgeHeartbeat,
+    sendLocalSkillsReport,
+    reportAutoDetectedAgents,
+    warmupAgentCapabilitiesOnConnect: warmupAgentCapabilitiesOnConnect2,
+    devServerManager,
+    e2ee,
+    cloudApiBaseUrl,
+    getCloudAccessToken
+  } = params;
+  return {
+    getWs,
+    log: log2,
+    acpManager,
+    sessionWorktreeManager,
+    onBridgeIdentified,
+    onBridgeHeartbeatAck: (seq) => {
+      bridgeHeartbeat.onAck(seq);
+    },
+    sendLocalSkillsReport,
+    reportAutoDetectedAgents,
+    warmupAgentCapabilitiesOnConnect: warmupAgentCapabilitiesOnConnect2,
+    devServerManager,
+    e2ee,
+    cloudApiBaseUrl,
+    getCloudAccessToken
+  };
+}
+
 // src/connection/create-bridge-connection.ts
 async function createBridgeConnection(options) {
   const { apiUrl, workspaceId, justAuthenticated, onAuthInvalid, persistTokens } = options;
@@ -44945,48 +45270,36 @@ async function createBridgeConnection(options) {
   function getWs() {
     return state.currentWs;
   }
-  function sendAgentCapabilitiesToBridge(info) {
-    if (!Array.isArray(info.configOptions) || info.configOptions.length === 0) return;
-    setImmediate(() => {
-      let changed = false;
-      try {
-        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();
-      if (!socket || socket.readyState !== wrapper_default.OPEN) return;
-      sendWsMessage(socket, {
-        type: "agent_capabilities",
-        agentType: info.agentType,
-        configOptions: info.configOptions
-      });
-    });
-  }
+  const sendAgentCapabilitiesToBridge = createAgentCapabilitiesReporter({ workspaceId, getWs });
   const worktreesRootPath = options.worktreesRootPath ?? defaultWorktreesRootPath();
   const sessionWorktreeManager = new SessionWorktreeManager({
     worktreesRootPath,
     log: logFn
   });
   const e2ee = options.e2eCertificate ? createCliE2eeRuntime(options.e2eCertificate) : void 0;
-  const bridgeAccess = await createBridgeAccessState({
+  const bridgeAccessRef = {
+    current: null
+  };
+  const bridgeAccessPromise = createBridgeAccessState({
     cloudApiBaseUrl: apiUrl,
     getCloudAccessToken: () => tokens.accessToken,
     e2ee
+  }).then((bridgeAccess2) => {
+    bridgeAccessRef.current = bridgeAccess2;
+    return bridgeAccess2;
   });
   const acpManager = await createAcpManager({
     log: logFn,
-    getBridgeAccessPort: () => bridgeAccess.getPort(),
+    getBridgeAccessPort: () => bridgeAccessRef.current?.getPort() ?? 0,
     reportAgentCapabilities: sendAgentCapabilitiesToBridge
   });
   logFn("CLI running. Press Ctrl+C to exit.");
+  let initialIndexBuildsScheduled = false;
+  const scheduleInitialIndexBuildsOnce = () => {
+    if (initialIndexBuildsScheduled) return;
+    initialIndexBuildsScheduled = true;
+    scheduleInitialIndexBuilds(getBridgeRoot());
+  };
   const devServerManager = new DevServerManager({ getWs, log: logFn, getBridgeRoot, e2ee });
   const bridgeHeartbeat = createBridgeHeartbeatController({ getWs, log: logFn });
   const baseOnBridgeIdentified = createOnBridgeIdentified({
@@ -45002,32 +45315,28 @@ async function createBridgeConnection(options) {
   };
   const sendLocalSkillsReport = createSendLocalSkillsReport(getWs, logFn);
   const reportAutoDetectedAgents = createReportAutoDetectedAgents(getWs, logFn);
-  const messageDeps = {
+  const messageDeps = createBridgeMessageDeps({
     getWs,
     log: logFn,
     acpManager,
     sessionWorktreeManager,
     onBridgeIdentified,
-    onBridgeHeartbeatAck: (seq) => {
-      bridgeHeartbeat.onAck(seq);
-    },
+    bridgeHeartbeat,
     sendLocalSkillsReport,
     reportAutoDetectedAgents,
-    warmupAgentCapabilitiesOnConnect: async () => {
-      await warmupAgentCapabilitiesOnConnect({
-        workspaceId,
-        log: logFn,
-        getWs
-      });
-    },
+    warmupAgentCapabilitiesOnConnect: createWarmupAgentCapabilitiesOnConnect({
+      workspaceId,
+      log: logFn,
+      getWs
+    }),
     devServerManager,
     e2ee,
     cloudApiBaseUrl: apiUrl,
     getCloudAccessToken: () => tokens.accessToken
-  };
+  });
   const identifyReportedPaths = {
-    bridgeRootPath: path70.resolve(getBridgeRoot()),
-    worktreesRootPath: path70.resolve(worktreesRootPath)
+    bridgeRootPath: path72.resolve(getBridgeRoot()),
+    worktreesRootPath: path72.resolve(worktreesRootPath)
   };
   const { connect } = createMainBridgeWebSocketLifecycle({
     state,
@@ -45042,10 +45351,12 @@ async function createBridgeConnection(options) {
     onAuthInvalid,
     e2ee,
     identifyReportedPaths,
-    bridgeHeartbeat
+    bridgeHeartbeat,
+    onBridgeSocketOpen: scheduleInitialIndexBuildsOnce
   });
   connect();
   const stopFileIndexWatcher = startFileIndexWatcher(getBridgeRoot());
+  const bridgeAccess = await bridgeAccessPromise;
   return {
     close: async () => {
       requestCliImmediateShutdown();