@buildautomaton/cli 0.1.63 → 0.1.64

package/dist/index.js

@@ -3653,6 +3653,47 @@ var require_websocket_server = __commonJS({
   }
 });
 
+// src/paths/normalize-resolved-path.ts
+import fs from "node:fs";
+import path from "node:path";
+function normalizeResolvedPath(resolved) {
+  const abs = path.resolve(resolved);
+  try {
+    return fs.realpathSync.native(abs);
+  } catch {
+    return abs;
+  }
+}
+var init_normalize_resolved_path = __esm({
+  "src/paths/normalize-resolved-path.ts"() {
+    "use strict";
+  }
+});
+
+// src/files/cwd/bridge-root.ts
+function getBridgeRoot() {
+  if (bridgeRootPath == null) {
+    bridgeRootPath = normalizeResolvedPath(process.cwd());
+  }
+  return bridgeRootPath;
+}
+var bridgeRootPath;
+var init_bridge_root = __esm({
+  "src/files/cwd/bridge-root.ts"() {
+    "use strict";
+    init_normalize_resolved_path();
+    bridgeRootPath = null;
+  }
+});
+
+// src/files/cwd/index.ts
+var init_cwd = __esm({
+  "src/files/cwd/index.ts"() {
+    "use strict";
+    init_bridge_root();
+  }
+});
+
 // ../../node_modules/.pnpm/tree-kill@1.2.2/node_modules/tree-kill/index.js
 var require_tree_kill = __commonJS({
   "../../node_modules/.pnpm/tree-kill@1.2.2/node_modules/tree-kill/index.js"(exports, module) {
@@ -4175,8 +4216,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path79, errorMaps, issueData } = params;
-      const fullPath = [...path79, ...issueData.path || []];
+      const { data, path: path82, errorMaps, issueData } = params;
+      const fullPath = [...path82, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -4484,11 +4525,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path79, key) {
+      constructor(parent, value, path82, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path79;
+        this._path = path82;
         this._key = key;
       }
       get path() {
@@ -8103,10 +8144,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path79) {
-  if (!path79)
+function getElementAtPath(obj, path82) {
+  if (!path82)
     return obj;
-  return path79.reduce((acc, key) => acc?.[key], obj);
+  return path82.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -8355,11 +8396,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path79, issues) {
+function prefixIssues(path82, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path79);
+    iss.path.unshift(path82);
     return iss;
   });
 }
@@ -8548,7 +8589,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path79 = []) => {
+  const processError = (error41, path82 = []) => {
     var _a2, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -8558,7 +8599,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path79, ...issue2.path];
+        const fullpath = [...path82, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -8588,9 +8629,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path79) {
+function toDotPath(path82) {
   const segs = [];
-  for (const seg of path79) {
+  for (const seg of path82) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -21299,6 +21340,16 @@ var init_acp = __esm({
   }
 });
 
+// src/runtime/yield-to-event-loop.ts
+function yieldToEventLoop() {
+  return new Promise((resolve35) => setImmediate(resolve35));
+}
+var init_yield_to_event_loop = __esm({
+  "src/runtime/yield-to-event-loop.ts"() {
+    "use strict";
+  }
+});
+
 // ../../node_modules/.pnpm/ignore@7.0.5/node_modules/ignore/index.js
 var require_ignore = __commonJS({
   "../../node_modules/.pnpm/ignore@7.0.5/node_modules/ignore/index.js"(exports, module) {
@@ -21596,7 +21647,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(path79, checkUnignored, mode) {
+      test(path82, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -21605,7 +21656,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path79);
+          const matched = rule[mode].test(path82);
           if (!matched) {
             return;
           }
@@ -21626,17 +21677,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path79, originalPath, doThrow) => {
-      if (!isString(path79)) {
+    var checkPath = (path82, originalPath, doThrow) => {
+      if (!isString(path82)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path79) {
+      if (!path82) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path79)) {
+      if (checkPath.isNotRelative(path82)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -21645,7 +21696,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path79) => REGEX_TEST_INVALID_PATH.test(path79);
+    var isNotRelative = (path82) => REGEX_TEST_INVALID_PATH.test(path82);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -21675,19 +21726,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache2, checkUnignored, slices) {
-        const path79 = originalPath && checkPath.convert(originalPath);
+        const path82 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path79,
+          path82,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path79, cache2, checkUnignored, slices);
+        return this._t(path82, cache2, checkUnignored, slices);
       }
-      checkIgnore(path79) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path79)) {
-          return this.test(path79);
+      checkIgnore(path82) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path82)) {
+          return this.test(path82);
         }
-        const slices = path79.split(SLASH).filter(Boolean);
+        const slices = path82.split(SLASH).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -21700,18 +21751,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path79, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path82, false, MODE_CHECK_IGNORE);
       }
-      _t(path79, cache2, checkUnignored, slices) {
-        if (path79 in cache2) {
-          return cache2[path79];
+      _t(path82, cache2, checkUnignored, slices) {
+        if (path82 in cache2) {
+          return cache2[path82];
         }
         if (!slices) {
-          slices = path79.split(SLASH).filter(Boolean);
+          slices = path82.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache2[path79] = this._rules.test(path79, checkUnignored, MODE_IGNORE);
+          return cache2[path82] = this._rules.test(path82, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -21719,29 +21770,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache2[path79] = parent.ignored ? parent : this._rules.test(path79, checkUnignored, MODE_IGNORE);
+        return cache2[path82] = parent.ignored ? parent : this._rules.test(path82, checkUnignored, MODE_IGNORE);
       }
-      ignores(path79) {
-        return this._test(path79, this._ignoreCache, false).ignored;
+      ignores(path82) {
+        return this._test(path82, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path79) => !this.ignores(path79);
+        return (path82) => !this.ignores(path82);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path79) {
-        return this._test(path79, this._testCache, true);
+      test(path82) {
+        return this._test(path82, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path79) => checkPath(path79 && checkPath.convert(path79), path79, RETURN_FALSE);
+    var isPathValid = (path82) => checkPath(path82 && checkPath.convert(path82), path82, 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 = (path79) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path79) || isNotRelative(path79);
+      checkPath.isNotRelative = (path82) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path82) || isNotRelative(path82);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -22530,10 +22581,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(path79, isFile, isDirectory) {
-      log2(`checking %s`, path79);
+    function check2(path82, isFile, isDirectory) {
+      log2(`checking %s`, path82);
       try {
-        const stat2 = fs_1.statSync(path79);
+        const stat2 = fs_1.statSync(path82);
         if (stat2.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -22553,8 +22604,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path79, type = exports.READABLE) {
-      return check2(path79, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path82, type = exports.READABLE) {
+      return check2(path82, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -22617,6 +22668,112 @@ var require_dist2 = __commonJS({
   }
 });
 
+// src/files/ensure-under-cwd.ts
+import path73 from "node:path";
+function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
+  const normalized = path73.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path73.resolve(cwd, normalized);
+  if (!resolved.startsWith(cwd + path73.sep) && resolved !== cwd) {
+    return null;
+  }
+  return resolved;
+}
+var init_ensure_under_cwd = __esm({
+  "src/files/ensure-under-cwd.ts"() {
+    "use strict";
+    init_cwd();
+  }
+});
+
+// src/files/list-dir/types.ts
+var LIST_DIR_YIELD_EVERY;
+var init_types2 = __esm({
+  "src/files/list-dir/types.ts"() {
+    "use strict";
+    LIST_DIR_YIELD_EVERY = 256;
+  }
+});
+
+// src/files/list-dir/map-dir-entry.ts
+import path74 from "node:path";
+import fs47 from "node:fs";
+async function mapDirEntry(d, relativePath, resolved) {
+  const entryPath = path74.join(relativePath || ".", d.name).replace(/\\/g, "/");
+  const fullPath = path74.join(resolved, d.name);
+  let isDir = d.isDirectory();
+  if (d.isSymbolicLink()) {
+    try {
+      const targetStat = await fs47.promises.stat(fullPath);
+      isDir = targetStat.isDirectory();
+    } catch {
+      isDir = false;
+    }
+  }
+  return {
+    name: d.name,
+    path: entryPath,
+    isDir,
+    isSymlink: d.isSymbolicLink()
+  };
+}
+var init_map_dir_entry = __esm({
+  "src/files/list-dir/map-dir-entry.ts"() {
+    "use strict";
+  }
+});
+
+// src/files/list-dir/sort-entries.ts
+function sortListEntries(entries) {
+  return entries.sort((a, b) => {
+    if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+    return a.name.localeCompare(b.name, void 0, { sensitivity: "base" });
+  });
+}
+var init_sort_entries = __esm({
+  "src/files/list-dir/sort-entries.ts"() {
+    "use strict";
+  }
+});
+
+// src/files/list-dir/index.ts
+var list_dir_exports = {};
+__export(list_dir_exports, {
+  listDirAsync: () => listDirAsync
+});
+import fs48 from "node:fs";
+async function listDirAsync(relativePath, sessionParentPath = getBridgeRoot()) {
+  await yieldToEventLoop();
+  const resolved = ensureUnderCwd(relativePath || ".", sessionParentPath);
+  if (!resolved) {
+    return { error: "Path is outside working directory" };
+  }
+  try {
+    const names = await fs48.promises.readdir(resolved, { withFileTypes: true });
+    const entries = [];
+    for (let i = 0; i < names.length; i++) {
+      if (i > 0 && i % LIST_DIR_YIELD_EVERY === 0) {
+        await yieldToEventLoop();
+      }
+      entries.push(await mapDirEntry(names[i], relativePath, resolved));
+    }
+    return { entries: sortListEntries(entries) };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { error: message };
+  }
+}
+var init_list_dir = __esm({
+  "src/files/list-dir/index.ts"() {
+    "use strict";
+    init_ensure_under_cwd();
+    init_cwd();
+    init_yield_to_event_loop();
+    init_types2();
+    init_map_dir_entry();
+    init_sort_entries();
+  }
+});
+
 // ../../node_modules/.pnpm/ws@8.19.0/node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
 var import_receiver = __toESM(require_receiver(), 1);
@@ -22787,26 +22944,8 @@ function sendWsMessage(ws, payload) {
   }
 }
 
-// src/paths/normalize-resolved-path.ts
-import fs from "node:fs";
-import path from "node:path";
-function normalizeResolvedPath(resolved) {
-  const abs = path.resolve(resolved);
-  try {
-    return fs.realpathSync.native(abs);
-  } catch {
-    return abs;
-  }
-}
-
-// src/files/cwd/bridge-root.ts
-var bridgeRootPath = null;
-function getBridgeRoot() {
-  if (bridgeRootPath == null) {
-    bridgeRootPath = normalizeResolvedPath(process.cwd());
-  }
-  return bridgeRootPath;
-}
+// src/agents/acp/clients/sdk/sdk-stdio-acp-client.ts
+init_cwd();
 
 // src/agents/acp/clients/agent-stderr-capture.ts
 var STDERR_CAPTURE_MAX = 48e3;
@@ -24034,11 +24173,11 @@ function createSdkStdioExtNotificationHandler(options) {
 
 // src/agents/acp/clients/sdk/sdk-stdio-permission-request-handshake.ts
 function awaitSdkStdioPermissionRequestHandshake(params) {
-  const { requestId, paramsRecord, pending: pending2, onRequest } = params;
+  const { requestId, paramsRecord, pending, onRequest } = params;
   return new Promise((resolve35) => {
-    pending2.set(requestId, { resolve: resolve35, params: paramsRecord });
+    pending.set(requestId, { resolve: resolve35, params: paramsRecord });
     if (onRequest == null) {
-      pending2.delete(requestId);
+      pending.delete(requestId);
       resolve35({ outcome: { outcome: "denied" } });
       return;
     }
@@ -24054,9 +24193,9 @@ function awaitSdkStdioPermissionRequestHandshake(params) {
 }
 
 // src/agents/acp/clients/sdk/sdk-stdio-permission-pending.ts
-function resolvePendingSdkStdioPermissionCancellations(pending2) {
-  for (const [id, entry] of [...pending2.entries()]) {
-    pending2.delete(id);
+function resolvePendingSdkStdioPermissionCancellations(pending) {
+  for (const [id, entry] of [...pending.entries()]) {
+    pending.delete(id);
     entry.resolve({ outcome: { outcome: "cancelled" } });
   }
 }
@@ -24938,6 +25077,7 @@ async function proxyToLocalStreaming(request, callbacks) {
 }
 
 // src/skills/preview.ts
+init_cwd();
 import { spawn as spawn2 } from "node:child_process";
 var PREVIEW_API_BASE_PATH = "/__preview";
 var PREVIEW_SECRET_HEADER = "X-Preview-Secret";
@@ -24958,8 +25098,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path79, body) {
-  const url2 = `http://127.0.0.1:${port}${path79}`;
+async function requestPreviewApi(port, secret, method, path82, body) {
+  const url2 = `http://127.0.0.1:${port}${path82}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -24971,7 +25111,7 @@ async function requestPreviewApi(port, secret, method, path79, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path79}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path82}: ${res.status}`);
   }
   return data;
 }
@@ -25186,7 +25326,7 @@ function installBridgeProcessResilience() {
 }
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.63".length > 0 ? "0.1.63" : "0.0.0-dev";
+var CLI_VERSION = "0.1.64".length > 0 ? "0.1.64" : "0.0.0-dev";
 
 // src/connection/heartbeat/constants.ts
 var BRIDGE_APP_HEARTBEAT_INTERVAL_MS = 1e4;
@@ -26301,7 +26441,11 @@ function runPendingAuth(options) {
   };
 }
 
+// src/connection/create-bridge-connection.ts
+init_cwd();
+
 // src/files/watch-file-index.ts
+init_cwd();
 import path25 from "node:path";
 
 // src/files/index/paths.ts
@@ -26311,7 +26455,7 @@ import crypto2 from "node:crypto";
 // src/files/index/constants.ts
 import path5 from "node:path";
 import os3 from "node:os";
-var INDEX_WORK_YIELD_EVERY = 256;
+var INDEX_WORK_YIELD_EVERY = 128;
 var INDEX_DIR = path5.join(os3.homedir(), ".buildautomaton");
 var INDEX_HASH_LEN = 16;
 
@@ -26323,9 +26467,78 @@ function getCwdHashForFileIndex(resolvedCwd) {
 // src/files/index/build-file-index.ts
 import path15 from "node:path";
 
-// src/runtime/yield-to-event-loop.ts
-function yieldToEventLoop() {
-  return new Promise((resolve35) => setImmediate(resolve35));
+// src/files/browser/file-browser-in-flight.ts
+init_yield_to_event_loop();
+
+// src/code-nav/symbol-index/deferred-indexing.ts
+var SymbolIndexDeferredError = class extends Error {
+  constructor() {
+    super("Symbol indexing deferred for file browser");
+    this.name = "SymbolIndexDeferredError";
+  }
+};
+function isSymbolIndexDeferredError(err) {
+  return err instanceof SymbolIndexDeferredError;
+}
+
+// src/files/browser/file-browser-in-flight.ts
+var BROWSE_INDEX_COOLDOWN_MS = 2500;
+var inFlightFileBrowserRequests = 0;
+var lastBrowseActivityAt = 0;
+var activityListeners = /* @__PURE__ */ new Set();
+var requestStartListeners = /* @__PURE__ */ new Set();
+function touchBrowseActivity() {
+  lastBrowseActivityAt = Date.now();
+}
+function registerFileBrowserActivityListener(listener) {
+  activityListeners.add(listener);
+  return () => {
+    activityListeners.delete(listener);
+  };
+}
+function registerFileBrowserRequestStartListener(listener) {
+  requestStartListeners.add(listener);
+  return () => {
+    requestStartListeners.delete(listener);
+  };
+}
+function notifyFileBrowserActivity() {
+  for (const listener of activityListeners) listener();
+}
+function notifyFileBrowserRequestStart() {
+  for (const listener of requestStartListeners) listener();
+}
+function beginFileBrowserRequest() {
+  inFlightFileBrowserRequests += 1;
+  touchBrowseActivity();
+  notifyFileBrowserRequestStart();
+  notifyFileBrowserActivity();
+}
+function endFileBrowserRequest() {
+  inFlightFileBrowserRequests = Math.max(0, inFlightFileBrowserRequests - 1);
+  touchBrowseActivity();
+}
+function fileBrowserRequestInFlight() {
+  return inFlightFileBrowserRequests > 0;
+}
+function isBridgeBrowseInteractiveActive() {
+  if (fileBrowserRequestInFlight()) return true;
+  return Date.now() - lastBrowseActivityAt < BROWSE_INDEX_COOLDOWN_MS;
+}
+function assertBackgroundIndexingAllowed() {
+  if (isBridgeBrowseInteractiveActive()) throw new SymbolIndexDeferredError();
+}
+async function yieldUntilFileBrowserIdle(pollMs = 5) {
+  while (isBridgeBrowseInteractiveActive()) {
+    await yieldToEventLoop();
+    if (isBridgeBrowseInteractiveActive()) {
+      await new Promise((resolve35) => setTimeout(resolve35, pollMs));
+    }
+  }
+}
+async function yieldForBridgeInteractivePriority() {
+  await yieldToEventLoop();
+  await yieldUntilFileBrowserIdle();
 }
 
 // src/runtime/cli-process-interrupt.ts
@@ -26348,7 +26561,11 @@ async function delayMsUnlessShutdownRequested(ms) {
   return !isCliImmediateShutdownRequested();
 }
 
+// src/sqlite/code-nav-cache/code-nav-cache-database.ts
+init_yield_to_event_loop();
+
 // src/sqlite/create-sqlite-database-access.ts
+init_yield_to_event_loop();
 import sqliteWasm from "node-sqlite3-wasm";
 
 // src/sqlite/sqlite-errors.ts
@@ -26393,6 +26610,7 @@ function applySqliteMemoryPragmas(db) {
 }
 
 // src/sqlite/sqlite-lock-retry.ts
+init_yield_to_event_loop();
 var SYNC_RETRY_MAX = 40;
 var ASYNC_RETRY_MAX = 60;
 var ASYNC_BASE_DELAY_MS = 20;
@@ -26554,7 +26772,7 @@ function readMigrationSql(filename, ...searchSubdirs) {
     join(moduleDir, "..", sub, filename),
     join(moduleDir, "..", "..", "dist", sub, filename)
   ]);
-  const resolved = candidates.find((path79) => existsSync(path79));
+  const resolved = candidates.find((path82) => existsSync(path82));
   if (!resolved) {
     throw new Error(`Missing SQLite migration SQL: ${filename} (searched ${searchSubdirs.join(", ")})`);
   }
@@ -26943,14 +27161,14 @@ function legacyCliDiskMigrationIsPending() {
   return false;
 }
 function importCliSqliteLegacyDiskData(db, log2) {
-  const pending2 = legacyCliDiskMigrationIsPending();
-  if (pending2 && log2) {
+  const pending = legacyCliDiskMigrationIsPending();
+  if (pending && log2) {
     log2("Migrating legacy on-disk CLI data to SQLite\u2026");
   }
   archiveLegacyFileIndexJsonFiles();
   importLegacyAgentSessionsFromDisk(db);
   importLegacyPromptQueuesFromDisk(db);
-  if (pending2 && log2) {
+  if (pending && log2) {
     log2("Legacy on-disk CLI data migration finished.");
   }
 }
@@ -27059,7 +27277,7 @@ async function walkWorkspaceTreeAsync(dir, baseDir, onFile, state) {
     if (shouldSkipWorkspaceWalkEntry(name)) continue;
     if (state.n > 0 && state.n % INDEX_WORK_YIELD_EVERY === 0) {
       if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
-      await yieldToEventLoop();
+      await yieldForBridgeInteractivePriority();
       if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
     }
     state.n++;
@@ -27166,7 +27384,7 @@ async function persistFileIndexPathsAsync(resolved, paths) {
     assertFileIndexPersistNotShutdown();
     const batch = paths.slice(offset, offset + FILE_INDEX_INSERT_BUFFER);
     pathCount += await withCodeNavCacheSqlite((db) => insertFileIndexChildPathBatch(db, resolved, batch));
-    await yieldToEventLoop();
+    await yieldForBridgeInteractivePriority();
   }
   return pathCount;
 }
@@ -27177,10 +27395,10 @@ function assertNotShutdown2() {
 }
 async function buildFileIndexAsync(cwd) {
   const resolved = path15.resolve(cwd);
-  await yieldToEventLoop();
+  await yieldForBridgeInteractivePriority();
   assertNotShutdown2();
   const paths = await collectWorkspacePathsAsync(resolved);
-  await yieldToEventLoop();
+  await yieldForBridgeInteractivePriority();
   assertNotShutdown2();
   return await withFileIndexSqliteLock(async () => {
     const pathCount = await persistFileIndexPathsAsync(resolved, paths);
@@ -27192,6 +27410,7 @@ async function buildFileIndexAsync(cwd) {
 import path16 from "node:path";
 
 // src/files/index/search-file-index.ts
+init_yield_to_event_loop();
 function escapeLikePattern(fragment) {
   return fragment.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
 }
@@ -27248,8 +27467,11 @@ async function ensureFileIndexAsync(cwd) {
   return { ...await buildFileIndexAsync(resolved), fromCache: false };
 }
 
+// src/code-nav/symbol-index/build/build-symbol-index.ts
+init_normalize_resolved_path();
+
 // src/code-nav/yield-during-work.ts
-var CODE_NAV_YIELD_EVERY = INDEX_WORK_YIELD_EVERY;
+var CODE_NAV_YIELD_EVERY = 64;
 function createCodeNavYieldState() {
   return { n: 0 };
 }
@@ -27257,7 +27479,7 @@ async function yieldDuringCodeNavWork(state) {
   state.n++;
   if (state.n % CODE_NAV_YIELD_EVERY !== 0) return;
   if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
-  await yieldToEventLoop();
+  await yieldForBridgeInteractivePriority();
   if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
 }
 
@@ -27390,7 +27612,7 @@ async function walkCodeNavFilesInDirectory(dir, baseDir, relDir, filter, onFile,
     if (shouldSkipWorkspaceWalkEntry(name)) continue;
     if (state.n > 0 && state.n % INDEX_WORK_YIELD_EVERY === 0) {
       if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
-      await yieldToEventLoop();
+      await yieldForBridgeInteractivePriority();
       if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
     }
     state.n++;
@@ -27424,6 +27646,8 @@ async function walkCodeNavFilesAsync(rootDir, onFile, state = createWalkYieldSta
 var SYMBOL_INDEX_VERSION = 11;
 
 // src/code-nav/symbol-index/sqlite/parent-path.ts
+init_bridge_root();
+init_normalize_resolved_path();
 function normalizeParentPath(resolved) {
   return normalizeResolvedPath(resolved);
 }
@@ -27718,128 +27942,11 @@ function withSymbolIndexSqliteLock(fn) {
   return withCodeNavCacheSqliteWorkLock(fn);
 }
 
-// src/code-nav/symbol-index/imports/star-reexport-names.ts
-var STAR_LOCAL_NAME = "*";
-function isModuleLevelDef(tag) {
-  return tag.role === "def" && tag.parentScopeStartLine == null && tag.parentScopeStartColumn == null;
-}
-function collectExportableNamesFromTags(tags) {
-  const names = /* @__PURE__ */ new Map();
-  for (const tag of tags) {
-    if (!isModuleLevelDef(tag)) continue;
-    if (!names.has(tag.name)) names.set(tag.name, tag.name);
-  }
-  return names;
-}
-function existingLocalNames(imports) {
-  return new Set(imports.map((binding) => binding.localName));
-}
-function resolveExportableNames(filePath, entriesByPath, visited) {
-  if (visited.has(filePath)) return /* @__PURE__ */ new Map();
-  visited.add(filePath);
-  const entry = entriesByPath.get(filePath);
-  if (!entry) return /* @__PURE__ */ new Map();
-  const out = collectExportableNamesFromTags(entry.tags);
-  const resolved = /* @__PURE__ */ new Map();
-  for (const [name, sourceName] of out) {
-    resolved.set(name, { sourceName, sourceFilePath: filePath });
-  }
-  for (const binding of entry.imports) {
-    if (binding.importKind !== "star" || !binding.sourceFilePath) continue;
-    const upstream = resolveExportableNames(binding.sourceFilePath, entriesByPath, visited);
-    for (const [name, info] of upstream) {
-      if (!resolved.has(name)) resolved.set(name, info);
-    }
-  }
-  for (const binding of entry.imports) {
-    if (binding.importKind !== "reexport" && binding.importKind !== "type") continue;
-    if (!binding.sourceFilePath) continue;
-    if (!resolved.has(binding.localName)) {
-      resolved.set(binding.localName, {
-        sourceName: binding.sourceName,
-        sourceFilePath: binding.sourceFilePath
-      });
-    }
-  }
-  return resolved;
-}
-
-// src/code-nav/symbol-index/imports/star-reexport-upstream.ts
-function collectUpstreamEntries(entry, resolveEntry) {
-  const entriesByPath = /* @__PURE__ */ new Map();
-  entriesByPath.set(entry.relPath, entry);
-  const visit = (filePath, visited) => {
-    if (visited.has(filePath)) return;
-    visited.add(filePath);
-    const resolved = resolveEntry(filePath);
-    if (resolved == null) return;
-    entriesByPath.set(filePath, resolved);
-    for (const binding of resolved.imports) {
-      if (binding.sourceFilePath) visit(binding.sourceFilePath, visited);
-    }
-  };
-  for (const star of entry.imports) {
-    if (star.importKind !== "star" || !star.sourceFilePath) continue;
-    visit(star.sourceFilePath, /* @__PURE__ */ new Set());
-  }
-  return [...entriesByPath.values()];
-}
-
-// src/code-nav/symbol-index/imports/expand-star-reexports.ts
-function expandStarReexportForFile(entry, resolveEntry) {
-  const collected = collectUpstreamEntries(entry, resolveEntry);
-  return expandStarReexportBindings(collected).find((row) => row.relPath === entry.relPath) ?? entry;
-}
-function expandStarReexportBindings(collected) {
-  const entriesByPath = new Map(collected.map((entry) => [entry.relPath, entry]));
-  return collected.map((entry) => {
-    const stars = entry.imports.filter((binding) => binding.importKind === "star");
-    if (stars.length === 0) return entry;
-    const localNames = existingLocalNames(entry.imports);
-    const materialized = [];
-    for (const star of stars) {
-      if (!star.sourceFilePath) continue;
-      const exportable = resolveExportableNames(star.sourceFilePath, entriesByPath, /* @__PURE__ */ new Set());
-      for (const [localName, info] of exportable) {
-        if (localName === STAR_LOCAL_NAME || localNames.has(localName)) continue;
-        localNames.add(localName);
-        materialized.push({
-          localName,
-          sourceName: info.sourceName,
-          moduleSpecifier: star.moduleSpecifier,
-          sourceFilePath: info.sourceFilePath,
-          importKind: star.importKind === "type" ? "type" : "reexport",
-          startLine: star.startLine,
-          startColumn: star.startColumn
-        });
-      }
-    }
-    if (materialized.length === 0) return entry;
-    return { ...entry, imports: [...entry.imports, ...materialized] };
-  });
-}
+// src/code-nav/symbol-index/build/ensure-symbol-index-file.ts
+init_normalize_resolved_path();
 
-// src/code-nav/symbol-index/persistence/persist-single-file.ts
-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);
-    });
-  });
-}
-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);
-    });
-  });
-}
+// src/code-nav/symbol-index/query/list-direct-import-targets.ts
+init_normalize_resolved_path();
 
 // 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,
@@ -27989,6 +28096,7 @@ async function listDirectImportTargetsForFileAsync(parentPath, filePath) {
 }
 
 // src/code-nav/symbol-index/lifecycle/symbol-index-file-ready.ts
+init_normalize_resolved_path();
 function symbolIndexFileIsReadyWithDb(db, parentPath, filePath) {
   const normalizedParent = normalizeResolvedPath(parentPath);
   const normalizedFile = filePath.replace(/\\/g, "/").replace(/^\/+/, "");
@@ -28018,6 +28126,129 @@ async function loadSymbolIndexReadyFileSet(parentPath) {
   return new Set(paths);
 }
 
+// src/code-nav/symbol-index/imports/star-reexport-names.ts
+var STAR_LOCAL_NAME = "*";
+function isModuleLevelDef(tag) {
+  return tag.role === "def" && tag.parentScopeStartLine == null && tag.parentScopeStartColumn == null;
+}
+function collectExportableNamesFromTags(tags) {
+  const names = /* @__PURE__ */ new Map();
+  for (const tag of tags) {
+    if (!isModuleLevelDef(tag)) continue;
+    if (!names.has(tag.name)) names.set(tag.name, tag.name);
+  }
+  return names;
+}
+function existingLocalNames(imports) {
+  return new Set(imports.map((binding) => binding.localName));
+}
+function resolveExportableNames(filePath, entriesByPath, visited) {
+  if (visited.has(filePath)) return /* @__PURE__ */ new Map();
+  visited.add(filePath);
+  const entry = entriesByPath.get(filePath);
+  if (!entry) return /* @__PURE__ */ new Map();
+  const out = collectExportableNamesFromTags(entry.tags);
+  const resolved = /* @__PURE__ */ new Map();
+  for (const [name, sourceName] of out) {
+    resolved.set(name, { sourceName, sourceFilePath: filePath });
+  }
+  for (const binding of entry.imports) {
+    if (binding.importKind !== "star" || !binding.sourceFilePath) continue;
+    const upstream = resolveExportableNames(binding.sourceFilePath, entriesByPath, visited);
+    for (const [name, info] of upstream) {
+      if (!resolved.has(name)) resolved.set(name, info);
+    }
+  }
+  for (const binding of entry.imports) {
+    if (binding.importKind !== "reexport" && binding.importKind !== "type") continue;
+    if (!binding.sourceFilePath) continue;
+    if (!resolved.has(binding.localName)) {
+      resolved.set(binding.localName, {
+        sourceName: binding.sourceName,
+        sourceFilePath: binding.sourceFilePath
+      });
+    }
+  }
+  return resolved;
+}
+
+// src/code-nav/symbol-index/imports/star-reexport-upstream.ts
+function collectUpstreamEntries(entry, resolveEntry) {
+  const entriesByPath = /* @__PURE__ */ new Map();
+  entriesByPath.set(entry.relPath, entry);
+  const visit = (filePath, visited) => {
+    if (visited.has(filePath)) return;
+    visited.add(filePath);
+    const resolved = resolveEntry(filePath);
+    if (resolved == null) return;
+    entriesByPath.set(filePath, resolved);
+    for (const binding of resolved.imports) {
+      if (binding.sourceFilePath) visit(binding.sourceFilePath, visited);
+    }
+  };
+  for (const star of entry.imports) {
+    if (star.importKind !== "star" || !star.sourceFilePath) continue;
+    visit(star.sourceFilePath, /* @__PURE__ */ new Set());
+  }
+  return [...entriesByPath.values()];
+}
+
+// src/code-nav/symbol-index/imports/expand-star-reexports.ts
+function expandStarReexportForFile(entry, resolveEntry) {
+  const collected = collectUpstreamEntries(entry, resolveEntry);
+  return expandStarReexportBindings(collected).find((row) => row.relPath === entry.relPath) ?? entry;
+}
+function expandStarReexportBindings(collected) {
+  const entriesByPath = new Map(collected.map((entry) => [entry.relPath, entry]));
+  return collected.map((entry) => {
+    const stars = entry.imports.filter((binding) => binding.importKind === "star");
+    if (stars.length === 0) return entry;
+    const localNames = existingLocalNames(entry.imports);
+    const materialized = [];
+    for (const star of stars) {
+      if (!star.sourceFilePath) continue;
+      const exportable = resolveExportableNames(star.sourceFilePath, entriesByPath, /* @__PURE__ */ new Set());
+      for (const [localName, info] of exportable) {
+        if (localName === STAR_LOCAL_NAME || localNames.has(localName)) continue;
+        localNames.add(localName);
+        materialized.push({
+          localName,
+          sourceName: info.sourceName,
+          moduleSpecifier: star.moduleSpecifier,
+          sourceFilePath: info.sourceFilePath,
+          importKind: star.importKind === "type" ? "type" : "reexport",
+          startLine: star.startLine,
+          startColumn: star.startColumn
+        });
+      }
+    }
+    if (materialized.length === 0) return entry;
+    return { ...entry, imports: [...entry.imports, ...materialized] };
+  });
+}
+
+// src/code-nav/symbol-index/persistence/persist-single-file.ts
+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);
+    });
+  });
+}
+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);
+    });
+  });
+}
+
 // src/code-nav/symbol-index/build/extract-file-symbol-data.ts
 import fs19 from "node:fs";
 import path21 from "node:path";
@@ -28704,6 +28935,7 @@ async function parseSourceRoot(filePath, source) {
   const languageKey = getLanguageKeyForFilePath(filePath);
   if (!languageKey) return null;
   return withTreeSitterRuntimeLock(async () => {
+    await yieldForBridgeInteractivePriority();
     let loaded;
     try {
       loaded = await loadLanguage(languageKey);
@@ -28715,7 +28947,11 @@ async function parseSourceRoot(filePath, source) {
     parser4.setLanguage(loaded.language);
     let tree = null;
     try {
+      await yieldForBridgeInteractivePriority();
+      assertBackgroundIndexingAllowed();
       tree = parser4.parse(source);
+      assertBackgroundIndexingAllowed();
+      await yieldForBridgeInteractivePriority();
       if (!tree) return null;
       return {
         root: tree.rootNode,
@@ -28725,9 +28961,10 @@ async function parseSourceRoot(filePath, source) {
           parser4.delete();
         }
       };
-    } catch {
+    } catch (err) {
       tree?.delete();
       parser4.delete();
+      if (isSymbolIndexDeferredError(err)) throw err;
       return null;
     }
   });
@@ -28735,9 +28972,11 @@ async function parseSourceRoot(filePath, source) {
 
 // src/code-nav/parser/run-tags-query.ts
 async function runTagsQuery(loaded, root) {
-  await yieldToEventLoop();
+  await yieldForBridgeInteractivePriority();
+  assertBackgroundIndexingAllowed();
   const matches = loaded.query.matches(root);
-  await yieldToEventLoop();
+  assertBackgroundIndexingAllowed();
+  await yieldForBridgeInteractivePriority();
   return matches;
 }
 
@@ -28818,7 +29057,7 @@ async function tagsFromMatchesAsync(matches, state) {
 // src/code-nav/parser/extract-tags.ts
 async function extractTagsFromSource(filePath, source) {
   const languageKey = getLanguageKeyForFilePath(filePath);
-  await yieldToEventLoop();
+  await yieldForBridgeInteractivePriority();
   const parsed = await parseSourceRoot(filePath, source);
   if (!parsed) return [];
   try {
@@ -28834,13 +29073,17 @@ async function extractTagsFromSource(filePath, source) {
     const withReceivers = await augmentMemberReceiverTags(withFunctionTypeParamRefs, nameNodes, parsed.root, languageKey);
     await yieldDuringCodeNavWork(yieldState);
     return await enrichTagsWithEnclosingScope(withReceivers, nameNodes);
-  } catch {
+  } catch (err) {
+    if (isSymbolIndexDeferredError(err)) throw err;
     return [];
   } finally {
     parsed.cleanup();
   }
 }
 
+// src/code-nav/symbol-index/imports/index.ts
+init_yield_to_event_loop();
+
 // src/code-nav/symbol-index/imports/shared.ts
 function pushBinding(out, filePath, workspaceFiles, moduleSpecifier, localName, sourceName, importKind, nameNode) {
   if (!localName) return;
@@ -29209,6 +29452,7 @@ async function extractImportBindingsFromSource(filePath, source, workspaceFiles)
 var MAX_INDEX_FILE_BYTES = 512 * 1024;
 
 // src/code-nav/symbol-index/build/workspace-files.ts
+init_normalize_resolved_path();
 function listWorkspaceFiles(db, workspacePath, includePath) {
   const files = /* @__PURE__ */ new Set([includePath.replace(/\\/g, "/")]);
   const normalizedWorkspace = normalizeResolvedPath(workspacePath);
@@ -29230,6 +29474,7 @@ function listWorkspaceFiles(db, workspacePath, includePath) {
 
 // src/code-nav/symbol-index/build/extract-file-symbol-data.ts
 async function extractFileSymbolData(resolved, relPath, workspaceFilesOverride) {
+  await yieldForBridgeInteractivePriority();
   const absPath = path21.join(resolved, relPath);
   let tags = [];
   let source = null;
@@ -29238,15 +29483,16 @@ async function extractFileSymbolData(resolved, relPath, workspaceFilesOverride)
       const stat2 = await fs19.promises.stat(absPath);
       if (stat2.isFile() && stat2.size <= MAX_INDEX_FILE_BYTES) {
         source = await fs19.promises.readFile(absPath, "utf8");
-        await yieldToEventLoop();
+        await yieldForBridgeInteractivePriority();
         tags = await extractTagsFromSource(relPath, source);
       }
-    } catch {
+    } catch (err) {
+      if (isSymbolIndexDeferredError(err)) throw err;
       tags = [];
       source = null;
     }
   }
-  await yieldToEventLoop();
+  await yieldForBridgeInteractivePriority();
   const workspaceFiles = workspaceFilesOverride ?? await withCodeNavCacheSqlite((db) => listWorkspaceFiles(db, resolved, relPath));
   const imports = source != null ? await extractImportBindingsFromSource(relPath, source, workspaceFiles) : [];
   const yieldState = createCodeNavYieldState();
@@ -29257,12 +29503,9 @@ async function extractFileSymbolData(resolved, relPath, workspaceFilesOverride)
   };
 }
 
-// src/code-nav/symbol-index/build/ensure-symbol-index-file.ts
-var MAX_IMPORT_PREFETCH_COUNT = 8;
-function normalizeRelPath3(filePath) {
-  return filePath.replace(/\\/g, "/").replace(/^\/+/, "");
-}
+// src/code-nav/symbol-index/build/index-one-symbol-file-for-build.ts
 async function indexOneSymbolFileForBuild(resolved, relPath, workspaceFiles) {
+  await yieldForBridgeInteractivePriority();
   const data = await extractFileSymbolData(resolved, relPath, workspaceFiles);
   let entry = {
     relPath,
@@ -29271,7 +29514,7 @@ async function indexOneSymbolFileForBuild(resolved, relPath, workspaceFiles) {
     imports: data.imports
   };
   if (data.imports.some((binding) => binding.importKind === "star")) {
-    await yieldToEventLoop();
+    await yieldForBridgeInteractivePriority();
     entry = await withCodeNavCacheSqlite((db) => {
       const ctx = getSymbolIndexParentContext(db, resolved);
       if (ctx == null) return entry;
@@ -29281,13 +29524,30 @@ async function indexOneSymbolFileForBuild(resolved, relPath, workspaceFiles) {
     entry.source = data.source;
   }
   await withSymbolIndexSqliteLock(async () => {
-    await yieldToEventLoop();
+    await yieldForBridgeInteractivePriority();
     await persistSymbolIndexFileAsync(resolved, relPath, entry.source, entry.tags, entry.imports);
   });
 }
+
+// src/code-nav/symbol-index/build/normalize-symbol-index-rel-path.ts
+function normalizeSymbolIndexRelPath(filePath) {
+  return filePath.replace(/\\/g, "/").replace(/^\/+/, "");
+}
+
+// src/code-nav/symbol-index/build/register-symbol-index-parent.ts
+init_normalize_resolved_path();
+async function registerSymbolIndexParentAsync(parentPath) {
+  const resolved = normalizeResolvedPath(parentPath);
+  await withCodeNavCacheSqlite((db) => {
+    upsertSymbolIndexParentPath(db, resolved);
+  });
+}
+
+// src/code-nav/symbol-index/build/ensure-symbol-index-file.ts
+var MAX_IMPORT_PREFETCH_COUNT = 8;
 async function ensureSymbolIndexFileAsync(parentPath, filePath, opts) {
   const resolved = normalizeResolvedPath(parentPath);
-  const relPath = normalizeRelPath3(filePath);
+  const relPath = normalizeSymbolIndexRelPath(filePath);
   if (!relPath) return false;
   const importDepth = opts?.importDepth ?? 0;
   await withCodeNavCacheSqlite((db) => {
@@ -29302,7 +29562,7 @@ async function ensureSymbolIndexFileAsync(parentPath, filePath, opts) {
       MAX_IMPORT_PREFETCH_COUNT
     );
     for (const target of targets) {
-      await yieldToEventLoop();
+      await yieldForBridgeInteractivePriority();
       if (!await symbolIndexFileIsReadyAsync(resolved, target)) {
         await ensureSymbolIndexFileAsync(resolved, target, { importDepth: importDepth - 1 });
       }
@@ -29310,18 +29570,12 @@ async function ensureSymbolIndexFileAsync(parentPath, filePath, opts) {
   }
   return await symbolIndexFileIsReadyAsync(resolved, relPath);
 }
-async function registerSymbolIndexParentAsync(parentPath) {
-  const resolved = normalizeResolvedPath(parentPath);
-  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 yieldForBridgeInteractivePriority();
   let clearRemaining = true;
   while (clearRemaining) {
     await withSymbolIndexSqliteLock(async () => {
@@ -29333,7 +29587,7 @@ async function buildSymbolIndexAsync(parentPath) {
         })
       );
     });
-    if (clearRemaining) await yieldToEventLoop();
+    if (clearRemaining) await yieldForBridgeInteractivePriority();
   }
   const workspaceFiles = /* @__PURE__ */ new Set();
   const walkState = createWalkYieldState();
@@ -29356,10 +29610,17 @@ async function buildSymbolIndexAsync(parentPath) {
     },
     walkState
   );
-  await yieldToEventLoop();
+  await yieldForBridgeInteractivePriority();
   return { fileCount, tagCount: 0 };
 }
 
+// src/code-nav/symbol-index/build/ensure-symbol-index.ts
+init_bridge_root();
+init_normalize_resolved_path();
+
+// src/code-nav/symbol-index/scheduler/task-queue-enqueue.ts
+init_normalize_resolved_path();
+
 // src/code-nav/symbol-index/scheduler/task-priority-heap.ts
 function higherPriority(a, b) {
   return a.priority > b.priority;
@@ -29417,122 +29678,185 @@ 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();
+// src/code-nav/symbol-index/scheduler/task-queue-store.ts
+var pendingSymbolIndexTasks = /* @__PURE__ */ new Map();
+var symbolIndexTaskHeap = new SymbolIndexTaskPriorityHeap();
 var latestActiveSequenceByParent = /* @__PURE__ */ new Map();
-var workerRunning = false;
+var symbolIndexWorkerRunning = false;
+function setSymbolIndexWorkerRunning(running) {
+  symbolIndexWorkerRunning = running;
+}
+function deferBackgroundSymbolIndexTasks() {
+  if (pendingSymbolIndexTasks.size === 0) return;
+  pendingSymbolIndexTasks.clear();
+  symbolIndexTaskHeap.clear();
+}
+registerFileBrowserRequestStartListener(() => {
+  deferBackgroundSymbolIndexTasks();
+});
 function taskMatchesCurrentPending(task) {
-  const current = pending.get(symbolIndexTaskKey(task.parentPath, task.filePath));
+  const current = pendingSymbolIndexTasks.get(symbolIndexTaskKey(task.parentPath, task.filePath));
   return current === task;
 }
-function pickNextTask() {
-  while (heap.size > 0) {
-    const task = heap.pop();
+function pickNextSymbolIndexTask() {
+  while (symbolIndexTaskHeap.size > 0) {
+    const task = symbolIndexTaskHeap.pop();
     if (task == null || !taskMatchesCurrentPending(task)) continue;
     return task;
   }
   return void 0;
 }
+function addPendingSymbolIndexTask(task) {
+  const key = symbolIndexTaskKey(task.parentPath, task.filePath);
+  const existing = pendingSymbolIndexTasks.get(key);
+  if (existing != null && existing.priority >= task.priority) return false;
+  pendingSymbolIndexTasks.set(key, task);
+  symbolIndexTaskHeap.push(task);
+  return true;
+}
+function clearSymbolIndexHeapIfEmpty() {
+  if (pendingSymbolIndexTasks.size === 0) symbolIndexTaskHeap.clear();
+}
+
+// src/code-nav/symbol-index/scheduler/task-queue-worker.ts
 async function runWorker() {
-  if (workerRunning) return;
-  workerRunning = true;
+  if (symbolIndexWorkerRunning) return;
+  setSymbolIndexWorkerRunning(true);
   try {
     const yieldState = createCodeNavYieldState();
-    while (pending.size > 0) {
-      const task = pickNextTask();
+    while (pendingSymbolIndexTasks.size > 0) {
+      await yieldForBridgeInteractivePriority();
+      const task = pickNextSymbolIndexTask();
       if (task == null) break;
-      pending.delete(symbolIndexTaskKey(task.parentPath, task.filePath));
+      pendingSymbolIndexTasks.delete(symbolIndexTaskKey(task.parentPath, task.filePath));
       await yieldDuringCodeNavWork(yieldState);
       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);
+        try {
+          await ensureSymbolIndexFileAsync(task.parentPath, task.filePath);
+        } catch (err) {
+          if (isSymbolIndexDeferredError(err)) {
+            if (addPendingSymbolIndexTask(task)) void runWorker();
+            continue;
+          }
+          throw err;
+        }
       }
-      await yieldToEventLoop();
+      await yieldForBridgeInteractivePriority();
     }
   } finally {
-    if (pending.size === 0) heap.clear();
-    workerRunning = false;
-    if (pending.size > 0) void runWorker();
+    clearSymbolIndexHeapIfEmpty();
+    setSymbolIndexWorkerRunning(false);
+    if (pendingSymbolIndexTasks.size > 0) void runWorker();
   }
 }
+function kickSymbolIndexWorker() {
+  void runWorker();
+}
+
+// src/code-nav/symbol-index/scheduler/task-queue-enqueue.ts
 function enqueueSymbolIndexTask(parentPath, filePath, priority, sequence) {
   const normalizedParent = normalizeResolvedPath(parentPath);
   const normalizedFile = filePath.replace(/\\/g, "/").replace(/^\/+/, "");
   if (!normalizedFile) return;
-  const key = symbolIndexTaskKey(normalizedParent, normalizedFile);
-  const existing = pending.get(key);
-  if (existing != null && existing.priority >= priority) return;
-  const task = { parentPath: normalizedParent, filePath: normalizedFile, priority, sequence };
-  pending.set(key, task);
-  heap.push(task);
-  void runWorker();
+  const added = addPendingSymbolIndexTask({
+    parentPath: normalizedParent,
+    filePath: normalizedFile,
+    priority,
+    sequence
+  });
+  if (added) kickSymbolIndexWorker();
 }
 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) {
+  for (const [key, task] of pendingSymbolIndexTasks) {
     if (task.parentPath === normalizedParent && task.sequence != null && task.sequence < sequence) {
-      pending.delete(key);
+      pendingSymbolIndexTasks.delete(key);
     }
   }
-  if (pending.size === 0) heap.clear();
+  if (pendingSymbolIndexTasks.size === 0) symbolIndexTaskHeap.clear();
 }
 
-// src/code-nav/symbol-index/scheduler/symbol-index-scheduler.ts
+// src/code-nav/symbol-index/scheduler/symbol-index-warmup.ts
+init_normalize_resolved_path();
 var requestSeq = 0;
 var warmupSeq = 0;
-var warmupScheduled = /* @__PURE__ */ new Set();
 var warmupCompleted = /* @__PURE__ */ new Set();
+var pendingWarmupParents = /* @__PURE__ */ new Set();
+var warmupWalkInProgress = /* @__PURE__ */ new Set();
+var WARMUP_IDLE_MS = 3e3;
+var warmupIdleTimer = null;
+function scheduleWarmupWhenIdle() {
+  if (warmupIdleTimer != null) clearTimeout(warmupIdleTimer);
+  warmupIdleTimer = setTimeout(() => {
+    warmupIdleTimer = null;
+    if (fileBrowserRequestInFlight()) {
+      scheduleWarmupWhenIdle();
+      return;
+    }
+    for (const parentPath of [...pendingWarmupParents]) {
+      void runWarmupWalk(parentPath);
+    }
+  }, WARMUP_IDLE_MS);
+}
+registerFileBrowserActivityListener(() => {
+  if (pendingWarmupParents.size > 0) scheduleWarmupWhenIdle();
+});
+async function runWarmupWalk(resolved) {
+  if (warmupCompleted.has(resolved) || warmupWalkInProgress.has(resolved)) {
+    pendingWarmupParents.delete(resolved);
+    return;
+  }
+  warmupWalkInProgress.add(resolved);
+  pendingWarmupParents.delete(resolved);
+  try {
+    const readyFiles = await loadSymbolIndexReadyFileSet(resolved);
+    const walkState = createWalkYieldState();
+    const yieldState = createCodeNavYieldState();
+    await walkCodeNavFilesAsync(
+      resolved,
+      async (relPath) => {
+        await yieldDuringCodeNavWork(yieldState);
+        if (!readyFiles.has(relPath)) {
+          enqueueSymbolIndexTask(resolved, relPath, ++warmupSeq, requestSeq);
+        }
+      },
+      walkState
+    );
+    warmupCompleted.add(resolved);
+  } finally {
+    warmupWalkInProgress.delete(resolved);
+  }
+}
+
+// src/code-nav/symbol-index/scheduler/symbol-index-scheduler.ts
+var requestSeq2 = 0;
 function scheduleSymbolIndexFile(parentPath, filePath) {
-  const sequence = ++requestSeq;
+  const sequence = ++requestSeq2;
   markLatestActiveSymbolIndexTask(parentPath, sequence);
   enqueueSymbolIndexTask(parentPath, filePath, 1e6 + sequence, sequence);
 }
 function scheduleSymbolIndexImportNeighbors(parentPath, filePaths) {
-  let priority = 5e5 + requestSeq;
+  let priority = 5e5 + requestSeq2;
   for (const filePath of filePaths) {
-    enqueueSymbolIndexTask(parentPath, filePath, priority, requestSeq);
+    enqueueSymbolIndexTask(parentPath, filePath, priority, requestSeq2);
     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 (!readyFiles.has(relPath)) {
-              enqueueSymbolIndexTask(resolved, relPath, ++warmupSeq, requestSeq);
-            }
-          },
-          walkState
-        );
-        warmupCompleted.add(resolved);
-      } finally {
-        warmupScheduled.delete(resolved);
-      }
-    })();
-  });
-}
+
+// src/code-nav/symbol-index/build/update-symbol-index-file.ts
+init_normalize_resolved_path();
+init_yield_to_event_loop();
 
 // src/code-nav/symbol-index/lifecycle/normalize-symbol-index-path.ts
 import path22 from "node:path";
-function normalizeSymbolIndexRelPath(parentPath, changedPath) {
+function normalizeSymbolIndexRelPath2(parentPath, changedPath) {
   const resolvedParent = path22.resolve(parentPath);
   const abs = path22.isAbsolute(changedPath) ? path22.resolve(changedPath) : path22.resolve(resolvedParent, changedPath);
   const rel = path22.relative(resolvedParent, abs).replace(/\\/g, "/");
@@ -29542,7 +29866,7 @@ function normalizeSymbolIndexRelPath(parentPath, changedPath) {
 
 // src/code-nav/symbol-index/build/update-symbol-index-file.ts
 async function updateSymbolIndexForFile(parentPath, changedPath) {
-  const relPath = normalizeSymbolIndexRelPath(parentPath, changedPath);
+  const relPath = normalizeSymbolIndexRelPath2(parentPath, changedPath);
   if (relPath == null) return;
   const resolved = normalizeResolvedPath(parentPath);
   const { source, tags, imports } = await extractFileSymbolData(resolved, relPath);
@@ -29552,7 +29876,7 @@ async function updateSymbolIndexForFile(parentPath, changedPath) {
   });
 }
 async function removeSymbolIndexForFile(parentPath, changedPath) {
-  const relPath = normalizeSymbolIndexRelPath(parentPath, changedPath);
+  const relPath = normalizeSymbolIndexRelPath2(parentPath, changedPath);
   if (relPath == null) return;
   const resolved = normalizeResolvedPath(parentPath);
   await withSymbolIndexSqliteLock(async () => {
@@ -29560,6 +29884,10 @@ async function removeSymbolIndexForFile(parentPath, changedPath) {
   });
 }
 
+// src/code-nav/symbol-index/query/query-definitions.ts
+init_normalize_resolved_path();
+init_yield_to_event_loop();
+
 // src/code-nav/symbol-index/sqlite/symbol-index-import-sqlite.ts
 function prefersTypeImport(refKind) {
   return refKind === "type";
@@ -30060,6 +30388,8 @@ async function queryDefinitionAt(parentPath, filePath, line, column) {
 }
 
 // src/code-nav/symbol-index/query/query-references.ts
+init_normalize_resolved_path();
+init_yield_to_event_loop();
 async function queryReferencesAt(parentPath, filePath, line, column) {
   await yieldToEventLoop();
   const resolved = normalizeResolvedPath(parentPath);
@@ -30083,6 +30413,8 @@ async function queryReferencesAt(parentPath, filePath, line, column) {
 }
 
 // src/code-nav/symbol-index/query/query-symbols-in-file.ts
+init_normalize_resolved_path();
+init_yield_to_event_loop();
 function rowToSymbolSpan(row, clickable) {
   return {
     name: row.name,
@@ -30168,6 +30500,7 @@ function createFileIndexFsWatcher(resolved, schedule) {
 // src/files/index/file-index-incremental-symbol-updates.ts
 import fs20 from "node:fs";
 import path23 from "node:path";
+init_yield_to_event_loop();
 async function applyIncrementalSymbolIndexUpdates(resolved, relPaths) {
   for (const rel of relPaths) {
     const absPath = path23.join(resolved, rel);
@@ -30191,6 +30524,7 @@ async function applyIncrementalSymbolIndexUpdates(resolved, relPaths) {
 
 // src/files/index/file-index-initial-builds.ts
 import path24 from "node:path";
+init_cwd();
 async function runInitialIndexBuilds(cwd = getBridgeRoot()) {
   const resolved = path24.resolve(cwd);
   try {
@@ -30408,6 +30742,7 @@ import * as fs21 from "node:fs";
 import * as path29 from "node:path";
 
 // src/paths/session-layout-paths.ts
+init_cwd();
 import * as path26 from "node:path";
 function resolveIsolatedSessionParentPathFromCheckouts(worktreePaths) {
   const resolved = worktreePaths.map((p) => path26.resolve(p)).filter(Boolean);
@@ -30539,6 +30874,7 @@ __export(cursor_acp_client_exports, {
   createCursorAcpClient: () => createCursorAcpClient,
   detectLocalAgentPresence: () => detectLocalAgentPresence3
 });
+init_cwd();
 
 // src/agents/acp/clients/cursor/cursor-spawn-command.ts
 function buildCursorAcpSpawnCommand(base, sessionMode) {
@@ -30570,8 +30906,8 @@ function createCursorAcpSessionContext(options) {
 
 // src/agents/acp/clients/cursor/cancel-pending-cursor-permission-requests.ts
 function cancelPendingCursorPermissionRequests(pendingRequests, respond) {
-  for (const [reqId, pending2] of [...pendingRequests.entries()]) {
-    if (pending2.method === "session/request_permission") {
+  for (const [reqId, pending] of [...pendingRequests.entries()]) {
+    if (pending.method === "session/request_permission") {
       respond(reqId, { outcome: { outcome: "cancelled" } });
       pendingRequests.delete(reqId);
     }
@@ -30750,8 +31086,8 @@ function handleCursorIncomingPermissionRequest(id, method, msg, deps) {
 
 // src/agents/acp/clients/cursor/cursor-incoming-resolve-request.ts
 function resolveCursorIncomingRequest(pendingRequests, respond, requestId, result) {
-  const pending2 = pendingRequests.get(requestId);
-  const payload = pending2?.method === "session/request_permission" ? enrichAcpPermissionRpcResultFromRequestParams(result, pending2.params) : result;
+  const pending = pendingRequests.get(requestId);
+  const payload = pending?.method === "session/request_permission" ? enrichAcpPermissionRpcResultFromRequestParams(result, pending.params) : result;
   respond(requestId, payload);
   pendingRequests.delete(requestId);
 }
@@ -30888,25 +31224,25 @@ function createCursorJsonRpcInboundRespond(stdin) {
 
 // src/agents/acp/clients/cursor/cursor-json-rpc-outbound.ts
 function createCursorJsonRpcOutboundPending() {
-  const pending2 = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
   let nextId = 1;
   function allocateId() {
     return nextId++;
   }
   function register(id, waiter) {
-    pending2.set(id, waiter);
+    pending.set(id, waiter);
   }
   function settleResponse(id, msg) {
-    const waiter = pending2.get(id);
+    const waiter = pending.get(id);
     if (!waiter) return false;
-    pending2.delete(id);
+    pending.delete(id);
     if (msg.error) waiter.reject(msg.error);
     else waiter.resolve(msg.result);
     return true;
   }
   function rejectOnWriteError(id, err) {
-    const waiter = pending2.get(id);
-    pending2.delete(id);
+    const waiter = pending.get(id);
+    pending.delete(id);
     waiter?.reject(err);
   }
   return { allocateId, register, settleResponse, rejectOnWriteError };
@@ -32426,8 +32762,8 @@ async function execGitFile(args, options) {
 }
 
 // src/git/changes/parse/normalize-git-diff-path.ts
-function normalizeGitDiffPath(path79) {
-  return path79.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
+function normalizeGitDiffPath(path82) {
+  return path82.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
 }
 
 // src/git/changes/parse/parse-name-status-entries.ts
@@ -34043,8 +34379,10 @@ async function createBridgeAccessState(options = {}) {
 
 // src/agents/capabilities/warmup-agent-capabilities-on-connect.ts
 import * as path35 from "node:path";
+init_cwd();
 
 // src/agents/detect-local-agent-types.ts
+init_yield_to_event_loop();
 var LOCAL_AGENT_ACP_MODULES = [
   cursor_acp_client_exports,
   codex_acp_client_exports,
@@ -34073,6 +34411,9 @@ async function detectLocalAgentTypes() {
   }
 }
 
+// src/agents/capabilities/probe-agent-capabilities-for-types.ts
+init_yield_to_event_loop();
+
 // src/sqlite/hash-json-sha256.ts
 import { createHash } from "node:crypto";
 function hashJsonUtf8Sha256(value) {
@@ -34249,6 +34590,9 @@ async function probeAgentCapabilitiesForDetectedTypes(params) {
   return changedCount;
 }
 
+// src/agents/capabilities/warmup-agent-capabilities-on-connect.ts
+init_yield_to_event_loop();
+
 // src/agents/capabilities/agent-capability-warmup-run.ts
 var warmupEpoch = 0;
 function cancelInFlightAgentCapabilityWarmup() {
@@ -34390,6 +34734,7 @@ async function createBridgeAccessAndAcp(options) {
 }
 
 // src/connection/create-bridge-preview-stack.ts
+init_cwd();
 import * as path38 from "node:path";
 
 // src/preview-environments/manager/firehose-messages.ts
@@ -35678,11 +36023,11 @@ function tryConsumeBinaryProxyBody(raw, deps) {
   if (!PROXY_ID_RE.test(id)) return false;
   const body = raw.slice(PROXY_ID_BYTES);
   const bodyBytes = body.length > 0 ? new Uint8Array(body) : new Uint8Array(0);
-  const pending2 = deps.pendingProxyBody.get(id);
-  if (pending2) {
+  const pending = deps.pendingProxyBody.get(id);
+  if (pending) {
     deps.pendingProxyBody.delete(id);
     deps.startStreamingProxy({
-      ...pending2.pr,
+      ...pending.pr,
       body: bodyBytes.length > 0 ? bodyBytes : void 0
     });
     return true;
@@ -36044,7 +36389,11 @@ function createBridgeMessageDeps(params) {
   };
 }
 
+// src/connection/create-bridge-local-reports.ts
+init_cwd();
+
 // src/skills/discovery/skill-discovery-roots.ts
+init_yield_to_event_loop();
 var SKILL_DISCOVERY_ROOTS = [".agents/skills", ".claude/skills", ".cursor/skills", "skills"];
 async function yieldSkillDiscoveryWork(entryCount) {
   if (entryCount > 0 && entryCount % INDEX_WORK_YIELD_EVERY === 0) {
@@ -36235,9 +36584,9 @@ function createBridgeHeartbeatController(params) {
       if (awaitingSeq === null) return;
       if (!Number.isFinite(seq)) return;
       const ack = Math.trunc(seq);
-      const pending2 = awaitingSeq;
-      if (ack < pending2) return;
-      if (ack === pending2) {
+      const pending = awaitingSeq;
+      if (ack < pending) return;
+      if (ack === pending) {
         const rtt = Date.now() - sentAtMs;
         if (Number.isFinite(rtt) && rtt >= 0 && rtt < 6e5) {
           rttSamples.push(rtt);
@@ -36369,6 +36718,7 @@ function allocateDirNameForLauncherCwd(layout, bridgeRootPath2) {
 }
 
 // src/worktrees/manager/session-worktree-cache.ts
+init_normalize_resolved_path();
 var SessionWorktreeCache = class {
   sessionRepoCheckoutPaths = /* @__PURE__ */ new Map();
   sessionParentPathBySession = /* @__PURE__ */ new Map();
@@ -36409,6 +36759,9 @@ function createSessionWorktreeManagerContext(options) {
   };
 }
 
+// src/worktrees/manager/git/commit-session-worktree.ts
+init_cwd();
+
 // ../../node_modules/.pnpm/simple-git@3.32.3/node_modules/simple-git/dist/esm/index.js
 var import_file_exists = __toESM(require_dist(), 1);
 var import_debug = __toESM(require_src(), 1);
@@ -36446,8 +36799,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path79) {
-  return path79 instanceof String && cache.has(path79);
+function isPathSpec(path82) {
+  return path82 instanceof String && cache.has(path82);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -36536,8 +36889,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path79) {
-  return (0, import_file_exists.exists)(path79, import_file_exists.FOLDER);
+function folderExists(path82) {
+  return (0, import_file_exists.exists)(path82, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -36941,8 +37294,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path79) {
-      return /^\.(git)?$/.test(path79.trim());
+    parser(path82) {
+      return /^\.(git)?$/.test(path82.trim());
     }
   };
 }
@@ -37376,11 +37729,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path79, line, preview] = input.split(NULL);
-    paths.add(path79);
-    (results[path79] = results[path79] || []).push({
+    const [path82, line, preview] = input.split(NULL);
+    paths.add(path82);
+    (results[path82] = results[path82] || []).push({
       line: asNumber(line),
-      path: path79,
+      path: path82,
       preview
     });
   });
@@ -38145,14 +38498,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path79, text) {
+function parseInit(bare, path82, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path79, false, result[1]);
+    return new InitSummary(bare, path82, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path79, true, result[1]);
+    return new InitSummary(bare, path82, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -38163,7 +38516,7 @@ function parseInit(bare, path79, text) {
       break;
     }
   }
-  return new InitSummary(bare, path79, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path82, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -38172,9 +38525,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path79, existing, gitDir) {
+      constructor(bare, path82, existing, gitDir) {
         this.bare = bare;
-        this.path = path79;
+        this.path = path82;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -38186,7 +38539,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path79, customArgs) {
+function initTask(bare = false, path82, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -38195,7 +38548,7 @@ function initTask(bare = false, path79, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path79, text);
+      return parseInit(commands.includes("--bare"), path82, text);
     }
   };
 }
@@ -39011,12 +39364,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path79, index, working_dir) {
-        this.path = path79;
+      constructor(path82, index, working_dir) {
+        this.path = path82;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path79) || [null, path79, path79];
+          const detail = fromPathRegex.exec(path82) || [null, path82, path82];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -39047,14 +39400,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path79) {
+  function data(index, workingDir, path82) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path79);
+      handler(result, path82);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path79, index, workingDir));
+      result.files.push(new FileStatusSummary(path82, index, workingDir));
     }
   }
 }
@@ -39363,9 +39716,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path79, write) {
+      hashObject(path82, write) {
         return this._runTask(
-          hashObjectTask(path79, write === true),
+          hashObjectTask(path82, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -39718,8 +40071,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path79 = input.trim().replace(/^["']|["']$/g, "");
-  return path79 && normalize3(path79);
+  const path82 = input.trim().replace(/^["']|["']$/g, "");
+  return path82 && normalize3(path82);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -40033,8 +40386,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path79) {
-  return subModuleTask(["add", repo, path79]);
+function addSubModuleTask(repo, path82) {
+  return subModuleTask(["add", repo, path82]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -40367,8 +40720,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path79, then) {
-      return this._runTask(addSubModuleTask2(repo, path79), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path82, then) {
+      return this._runTask(addSubModuleTask2(repo, path82), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -41104,8 +41457,8 @@ function parseNumstatEntries(lines) {
 }
 function parseNumstat(lines) {
   const m = /* @__PURE__ */ new Map();
-  for (const [path79, entry] of parseNumstatEntries(lines)) {
-    m.set(path79, { additions: entry.additions, deletions: entry.deletions });
+  for (const [path82, entry] of parseNumstatEntries(lines)) {
+    m.set(path82, { additions: entry.additions, deletions: entry.deletions });
   }
   return m;
 }
@@ -41303,6 +41656,7 @@ async function pushAheadOfUpstreamForPaths(paths) {
 }
 
 // src/worktrees/manager/resolve-commit-targets.ts
+init_cwd();
 function bridgeRootBinding(bridgeRoot) {
   return {
     sessionParentPath: bridgeRoot,
@@ -41388,6 +41742,7 @@ function formatRemoteDisplayLabel(remoteUrl) {
 }
 
 // src/git/changes/repo/get-working-tree-change-repo-details.ts
+init_cwd();
 import * as path51 from "node:path";
 
 // src/git/changes/repo/build-working-tree-change-repo-detail.ts
@@ -41637,6 +41992,7 @@ function createHydrateSourceLines(options) {
 }
 
 // src/git/changes/patch/hydrate/create-hydrate-yield.ts
+init_yield_to_event_loop();
 function createHydrateYield() {
   let processedLines = 0;
   return async () => {
@@ -42400,6 +42756,7 @@ function parseWorkingTreeChangeKind(value) {
 }
 
 // src/worktrees/manager/git/get-session-working-tree-change-file-patch.ts
+init_cwd();
 import * as path53 from "node:path";
 async function getSessionWorkingTreeChangeFilePatch(cache2, sessionId, discover, opts) {
   const targets = await resolveCommitTargetsAsync(sessionId, cache2, discover);
@@ -42450,6 +42807,8 @@ import * as fs35 from "node:fs";
 import * as fs34 from "node:fs";
 
 // src/worktrees/is-removable-session-worktree-checkout-path.ts
+init_cwd();
+init_normalize_resolved_path();
 import path54 from "node:path";
 function isBridgeRootCheckoutPath(checkoutPath) {
   return normalizeResolvedPath(checkoutPath) === normalizeResolvedPath(getBridgeRoot());
@@ -42550,9 +42909,13 @@ async function renameSessionWorktreeBranch(cache2, sessionId, newBranch, log2) {
   await renameSessionWorktreeBranches(paths, newBranch, log2);
 }
 
+// src/worktrees/manager/discover-session-binding.ts
+init_cwd();
+
 // src/worktrees/discovery/discover-session-worktree-on-disk.ts
 import * as fs39 from "node:fs";
 import * as path60 from "node:path";
+init_yield_to_event_loop();
 
 // src/worktrees/discovery/collect-worktree-paths.ts
 import * as fs37 from "node:fs";
@@ -42586,6 +42949,7 @@ function shouldSkipDiskWalkEntry(name) {
 // src/worktrees/discovery/disk-walk-utils.ts
 import * as fs36 from "node:fs";
 import * as path56 from "node:path";
+init_yield_to_event_loop();
 async function yieldDuringDiskWalk(state) {
   state.entries++;
   if (state.entries % DISK_WALK_YIELD_EVERY !== 0) return true;
@@ -42775,6 +43139,7 @@ import * as path62 from "node:path";
 
 // src/worktrees/discovery/discover-legacy-binding-ascending-from-checkout.ts
 import * as path61 from "node:path";
+init_yield_to_event_loop();
 async function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
   const sid = sessionId.trim();
   if (!sid) return null;
@@ -42892,11 +43257,16 @@ function parseSessionParent(v) {
   return null;
 }
 
+// src/worktrees/manager/prepare-and-remember-session-worktrees.ts
+init_cwd();
+
 // src/worktrees/prepare-new-isolated-worktrees.ts
 import * as fs42 from "node:fs";
 import * as path64 from "node:path";
 
 // src/git/discover-repos.ts
+init_cwd();
+init_yield_to_event_loop();
 import * as fs41 from "node:fs";
 import * as path63 from "node:path";
 var GIT_DISCOVER_YIELD_EVERY = 32;
@@ -43124,6 +43494,7 @@ async function resolveExistingSessionParentPath(sessionId, cache2, discover) {
 
 // src/worktrees/manager/resolve-explicit-session-parent-path.ts
 import * as path65 from "node:path";
+init_yield_to_event_loop();
 async function resolveExplicitSessionParentPath(params) {
   const resolved = path65.resolve(params.parentPathRaw);
   if (parseSessionParent(params.sessionParent) !== "worktrees_root") {
@@ -43289,7 +43660,12 @@ var SessionWorktreeManager = class {
   }
 };
 
+// src/worktrees/manager/preview-worktree-manager.ts
+init_cwd();
+
 // src/worktrees/discovery/discover-preview-worktree-on-disk.ts
+init_cwd();
+init_yield_to_event_loop();
 import * as fs43 from "node:fs";
 import * as path66 from "node:path";
 async function discoverPreviewWorktreeOnDisk(options) {
@@ -43340,6 +43716,7 @@ async function discoverPreviewWorktreeForBridge(options) {
 }
 
 // src/worktrees/manager/preview-worktree-cache.ts
+init_normalize_resolved_path();
 var PreviewWorktreeCache = class {
   repoCheckoutPaths = /* @__PURE__ */ new Map();
   parentPathByEnvironment = /* @__PURE__ */ new Map();
@@ -43452,6 +43829,7 @@ var PreviewWorktreeManager = class {
 };
 
 // src/worktrees/deploy/deploy-session-to-preview-environment.ts
+init_cwd();
 import * as path70 from "node:path";
 
 // src/git/worktrees/reset-worktree-to-branch.ts
@@ -44149,6 +44527,7 @@ async function applyPreTurnSnapshot(filePath, log2) {
 }
 
 // src/prompt-turn-queue/runner/run-local-revert-before-queued-prompt.ts
+init_cwd();
 async function runLocalRevertBeforeQueuedPrompt(next, deps) {
   if (next.bridgeServerState !== "requeued_with_revert") return true;
   const sid = next.sessionId;
@@ -44338,6 +44717,7 @@ function parseWorktreeBaseBranches(msg) {
 }
 
 // src/agents/acp/from-bridge/bridge-prompt-preamble.ts
+init_cwd();
 import { execFile as execFile8 } from "node:child_process";
 import { promisify as promisify9 } from "node:util";
 var execFileAsync7 = promisify9(execFile8);
@@ -44569,6 +44949,8 @@ var handleSkillCallMessage = (msg, { getWs, log: log2 }) => {
 };
 
 // src/files/resolve-file-browser-session-parent.ts
+init_normalize_resolved_path();
+init_cwd();
 async function resolveFileBrowserSessionParent(sessionWorktreeManager, sessionId) {
   const sid = sessionId?.trim();
   if (sid) {
@@ -44579,301 +44961,18 @@ async function resolveFileBrowserSessionParent(sessionWorktreeManager, sessionId
   return getBridgeRoot();
 }
 
-// src/files/list-dir/index.ts
-import fs48 from "node:fs";
-
-// src/files/ensure-under-cwd.ts
-import path73 from "node:path";
-function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
-  const normalized = path73.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path73.resolve(cwd, normalized);
-  if (!resolved.startsWith(cwd + path73.sep) && resolved !== cwd) {
-    return null;
-  }
-  return resolved;
-}
-
-// src/files/list-dir/types.ts
-var LIST_DIR_YIELD_EVERY = 256;
-
-// src/files/list-dir/map-dir-entry.ts
-import path74 from "node:path";
-import fs47 from "node:fs";
-async function mapDirEntry(d, relativePath, resolved) {
-  const entryPath = path74.join(relativePath || ".", d.name).replace(/\\/g, "/");
-  const fullPath = path74.join(resolved, d.name);
-  let isDir = d.isDirectory();
-  if (d.isSymbolicLink()) {
-    try {
-      const targetStat = await fs47.promises.stat(fullPath);
-      isDir = targetStat.isDirectory();
-    } catch {
-      isDir = false;
-    }
-  }
-  return {
-    name: d.name,
-    path: entryPath,
-    isDir,
-    isSymlink: d.isSymbolicLink()
-  };
-}
-
-// src/files/list-dir/sort-entries.ts
-function sortListEntries(entries) {
-  return entries.sort((a, b) => {
-    if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
-    return a.name.localeCompare(b.name, void 0, { sensitivity: "base" });
-  });
-}
-
-// src/files/list-dir/index.ts
-async function listDirAsync(relativePath, sessionParentPath = getBridgeRoot()) {
-  await yieldToEventLoop();
-  const resolved = ensureUnderCwd(relativePath || ".", sessionParentPath);
-  if (!resolved) {
-    return { error: "Path is outside working directory" };
-  }
-  try {
-    const names = await fs48.promises.readdir(resolved, { withFileTypes: true });
-    const entries = [];
-    for (let i = 0; i < names.length; i++) {
-      if (i > 0 && i % LIST_DIR_YIELD_EVERY === 0) {
-        await yieldToEventLoop();
-      }
-      entries.push(await mapDirEntry(names[i], relativePath, resolved));
-    }
-    return { entries: sortListEntries(entries) };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return { error: message };
-  }
-}
-
-// src/files/handle-file-browser-search.ts
-import path75 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 = path75.resolve(
-      sessionWorktreeManager != null ? await resolveFileBrowserSessionParent(sessionWorktreeManager, msg.sessionId) : getBridgeRoot()
-    );
-    if (!await bridgeFileIndexIsPopulated(sessionParentPath)) {
-      const payload2 = {
-        type: "file_browser_search_response",
-        id: msg.id,
-        paths: [],
-        indexReady: false
-      };
-      sendWsMessage(socket, e2ee ? e2ee.encryptFields(payload2, ["paths"]) : payload2);
-      return;
-    }
-    const results = await searchBridgeFilePathsAsync(sessionParentPath, q, SEARCH_LIMIT);
-    const payload = {
-      type: "file_browser_search_response",
-      id: msg.id,
-      paths: results,
-      indexReady: true
-    };
-    sendWsMessage(socket, e2ee ? e2ee.encryptFields(payload, ["paths"]) : payload);
-  })();
-}
-function triggerFileIndexBuild(sessionParentPath = getBridgeRoot()) {
-  setImmediate(() => {
-    void ensureFileIndexAsync(sessionParentPath).catch((e) => {
-      console.error("[file-index] Background build failed:", e);
-    });
-  });
-}
-
-// src/code-nav/handlers/send-code-nav-response.ts
-var ENCRYPTED_FIELDS = ["definition", "definitions", "references", "symbols", "confidentTarget"];
-function sendCodeNavResponse(socket, e2ee, payload) {
-  const fieldsToEncrypt = ENCRYPTED_FIELDS.filter((field) => field in payload && payload[field] !== void 0);
-  sendWsMessage(
-    socket,
-    e2ee && fieldsToEncrypt.length > 0 ? e2ee.encryptFields(payload, [...fieldsToEncrypt]) : payload
-  );
-}
-
-// src/code-nav/handlers/handle-definition-op.ts
-async function handleDefinitionOp(ctx) {
-  const definition = await queryDefinitionAt(ctx.sessionParentPath, ctx.reqPath, ctx.line, ctx.column);
-  sendCodeNavResponse(ctx.socket, ctx.e2ee, {
-    type: "code_nav_response",
-    id: ctx.msg.id,
-    indexReady: true,
-    definition
-  });
-}
-
-// src/code-nav/handlers/handle-definitions-op.ts
-async function handleDefinitionsOp(ctx) {
-  const { definitions, confidentTarget } = await queryDefinitionsNavigation(
-    ctx.sessionParentPath,
-    ctx.reqPath,
-    ctx.line,
-    ctx.column
-  );
-  sendCodeNavResponse(ctx.socket, ctx.e2ee, {
-    type: "code_nav_response",
-    id: ctx.msg.id,
-    indexReady: true,
-    definitions,
-    confidentTarget
-  });
-}
-
-// src/code-nav/handlers/handle-references-op.ts
-async function handleReferencesOp(ctx) {
-  const references = await queryReferencesAt(ctx.sessionParentPath, ctx.reqPath, ctx.line, ctx.column);
-  sendCodeNavResponse(ctx.socket, ctx.e2ee, {
-    type: "code_nav_response",
-    id: ctx.msg.id,
-    indexReady: true,
-    references
-  });
-}
-
-// src/code-nav/handlers/handle-symbols-op.ts
-async function handleSymbolsOp(ctx) {
-  const symbols = await querySymbolsInFile(ctx.sessionParentPath, ctx.reqPath);
-  sendCodeNavResponse(ctx.socket, ctx.e2ee, {
-    type: "code_nav_response",
-    id: ctx.msg.id,
-    indexReady: true,
-    symbols
-  });
-}
-
-// src/code-nav/handlers/code-nav-op-context.ts
-function normalizeCodeNavOp(op) {
-  if (op === "references" || op === "symbols" || op === "definitions") return op;
-  return "definition";
-}
-
-// src/code-nav/handlers/resolve-code-nav-parent.ts
-async function resolveCodeNavParentPath(sessionWorktreeManager, sessionId) {
-  const parent = sessionWorktreeManager != null ? await resolveFileBrowserSessionParent(sessionWorktreeManager, sessionId) : getBridgeRoot();
-  return normalizeResolvedPath(parent);
-}
-
-// 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((resolve35) => setTimeout(resolve35, 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(/^\/+/, "") || "";
-  if (!reqPath) {
-    sendCodeNavResponse(socket, e2ee, {
-      type: "code_nav_response",
-      id: msg.id,
-      error: "Path required"
-    });
-    return null;
-  }
-  const sessionParentPath = await resolveCodeNavParentPath(sessionWorktreeManager, msg.sessionId);
-  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();
-  return {
-    socket,
-    e2ee,
-    msg,
-    reqPath,
-    sessionParentPath,
-    line: typeof msg.line === "number" ? msg.line : 1,
-    column: typeof msg.column === "number" ? msg.column : 0,
-    indexReady
-  };
-}
-function sendIndexNotReadyResponse(ctx) {
-  sendCodeNavResponse(ctx.socket, ctx.e2ee, {
-    type: "code_nav_response",
-    id: ctx.msg.id,
-    indexReady: false,
-    definition: null,
-    definitions: [],
-    references: [],
-    symbols: []
-  });
-}
-function preparedOpContext(ctx) {
-  return {
-    socket: ctx.socket,
-    e2ee: ctx.e2ee,
-    msg: { ...ctx.msg, op: normalizeCodeNavOp(ctx.msg.op) },
-    reqPath: ctx.reqPath,
-    sessionParentPath: ctx.sessionParentPath,
-    line: ctx.line,
-    column: ctx.column
-  };
-}
-
-// src/code-nav/handlers/handle-code-nav-request.ts
-function handleCodeNavRequest(msg, socket, e2ee, sessionWorktreeManager) {
-  void (async () => {
-    const prepared = await prepareCodeNavRequest(msg, socket, e2ee, sessionWorktreeManager);
-    if (prepared == null) return;
-    if (!prepared.indexReady) {
-      sendIndexNotReadyResponse(prepared);
-      return;
-    }
-    const ctx = preparedOpContext(prepared);
-    switch (ctx.msg.op) {
-      case "symbols":
-        await handleSymbolsOp(ctx);
-        return;
-      case "references":
-        await handleReferencesOp(ctx);
-        return;
-      case "definitions":
-        await handleDefinitionsOp(ctx);
-        return;
-      default:
-        await handleDefinitionOp(ctx);
-    }
-  })();
-}
-
-// src/code-nav/handlers/trigger-symbol-index-build.ts
-function triggerSymbolIndexBuild(parentPath) {
-  setImmediate(() => {
-    void (async () => {
-      const resolved = normalizeResolvedPath(parentPath);
-      await registerSymbolIndexParentAsync(resolved);
-      scheduleSymbolIndexWarmup(resolved);
-    })();
-  });
-}
+// src/files/browser/handle-file-browser-list.ts
+init_list_dir();
 
 // src/git/tree/resolve-repo-abs-path.ts
-import * as path76 from "node:path";
+init_cwd();
+import * as path75 from "node:path";
 function resolveRepoAbsPathFromBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path76.resolve(bridgeRoot);
+  const bridgeResolved = path75.resolve(bridgeRoot);
   const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
-  const repoPath = rel === "" ? bridgeResolved : path76.join(bridgeResolved, rel);
-  const resolved = path76.resolve(repoPath);
-  if (!resolved.startsWith(bridgeResolved + path76.sep) && resolved !== bridgeResolved) {
+  const repoPath = rel === "" ? bridgeResolved : path75.join(bridgeResolved, rel);
+  const resolved = path75.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path75.sep) && resolved !== bridgeResolved) {
     return null;
   }
   return resolved;
@@ -44891,6 +44990,9 @@ async function resolveBranchCommit(repoAbsPath, branch) {
 }
 
 // src/git/tree/list-git-tree-dir.ts
+init_yield_to_event_loop();
+init_types2();
+init_sort_entries();
 function parseLsTreeLine(line) {
   const tab = line.indexOf("	");
   if (tab < 0) return null;
@@ -44953,6 +45055,9 @@ async function listGitTreeDirAsync(repoAbsPath, branch, relativePath) {
   }
 }
 
+// src/git/tree/file/index.ts
+init_yield_to_event_loop();
+
 // src/files/read-file/types.ts
 var LINE_CHUNK_SIZE = 64 * 1024;
 var READ_RANGE_YIELD_EVERY_BYTES = 256 * 1024;
@@ -44989,6 +45094,7 @@ function guessMimeType(filePath) {
 }
 
 // src/git/tree/file/git-blob-ref.ts
+init_yield_to_event_loop();
 async function gitBlobRef(repoAbsPath, branch, relativePath) {
   const commit = await resolveBranchCommit(repoAbsPath, branch);
   await yieldToEventLoop();
@@ -45008,6 +45114,7 @@ function isBinaryBuffer(buf) {
 }
 
 // src/git/tree/file/read-git-blob-text-async.ts
+init_yield_to_event_loop();
 import { StringDecoder } from "node:string_decoder";
 async function countGitBlobLinesAsync(buf) {
   if (buf.length === 0) return 1;
@@ -45256,6 +45363,145 @@ function sendFileBrowserMessage(socket, e2ee, payload) {
   sendWsMessage(socket, e2ee ? e2ee.encryptFields(payload, ["entries", "content", "totalLines", "size", "lineOffset"]) : payload);
 }
 
+// src/files/read-file/resolve-file-cache-warmup.ts
+init_yield_to_event_loop();
+import path77 from "node:path";
+
+// src/files/read-file/resolve-file-cache.ts
+import fs49 from "node:fs";
+import path76 from "node:path";
+var RESOLVE_CACHE_MAX = 4096;
+var resolveCache = /* @__PURE__ */ new Map();
+var warmedDirectories = /* @__PURE__ */ new Set();
+function resolveCacheKey(sessionParentPath, relativePath) {
+  return `${sessionParentPath}\0${relativePath}`;
+}
+function warmedDirectoryKey(sessionParentPath, directoryRelativePath) {
+  const dir = directoryRelativePath.replace(/^\/+/, "") || ".";
+  return `${path76.resolve(sessionParentPath)}\0${dir}`;
+}
+function pathStaysUnderParent(filePath, sessionParentPath) {
+  const parent = path76.resolve(sessionParentPath);
+  const resolved = path76.resolve(filePath);
+  return resolved === parent || resolved.startsWith(`${parent}${path76.sep}`);
+}
+async function statMatchesCache(entry) {
+  try {
+    const stat2 = await fs49.promises.stat(entry.path);
+    return stat2.isFile() && stat2.mtimeMs === entry.mtimeMs && stat2.size === entry.size;
+  } catch {
+    return false;
+  }
+}
+function getResolveCacheEntry(cacheKey) {
+  return resolveCache.get(cacheKey);
+}
+function deleteResolveCacheEntry(cacheKey) {
+  resolveCache.delete(cacheKey);
+}
+function storeResolveCacheEntry(cacheKey, entry) {
+  if (resolveCache.size >= RESOLVE_CACHE_MAX) resolveCache.clear();
+  resolveCache.set(cacheKey, entry);
+  return entry;
+}
+function hasResolveCacheEntry(cacheKey) {
+  return resolveCache.has(cacheKey);
+}
+function markDirectoryWarmed(dirKey) {
+  if (warmedDirectories.has(dirKey)) return false;
+  warmedDirectories.add(dirKey);
+  return true;
+}
+function unmarkDirectoryWarmed(dirKey) {
+  warmedDirectories.delete(dirKey);
+}
+
+// src/files/read-file/resolve-file-path.ts
+init_ensure_under_cwd();
+init_cwd();
+import fs50 from "node:fs";
+async function resolveFileForReadAsync(relativePath, sessionParentPath = getBridgeRoot()) {
+  const cacheKey = resolveCacheKey(sessionParentPath, relativePath);
+  const cached2 = getResolveCacheEntry(cacheKey);
+  if (cached2 != null && await statMatchesCache(cached2)) {
+    return { path: cached2.path, size: cached2.size };
+  }
+  if (cached2 != null) deleteResolveCacheEntry(cacheKey);
+  const resolved = ensureUnderCwd(relativePath, sessionParentPath);
+  if (!resolved) return { error: "Path is outside working directory" };
+  let real;
+  let size;
+  let mtimeMs;
+  try {
+    const lstat = await fs50.promises.lstat(resolved);
+    if (lstat.isSymbolicLink()) {
+      real = await fs50.promises.realpath(resolved);
+      if (!pathStaysUnderParent(real, sessionParentPath)) {
+        return { error: "Path is outside working directory" };
+      }
+      const stat2 = await fs50.promises.stat(real);
+      if (!stat2.isFile()) return { error: "Not a file" };
+      size = stat2.size;
+      mtimeMs = stat2.mtimeMs;
+    } else if (lstat.isFile()) {
+      real = resolved;
+      size = lstat.size;
+      mtimeMs = lstat.mtimeMs;
+    } else {
+      return { error: "Not a file" };
+    }
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+  const entry = storeResolveCacheEntry(cacheKey, { path: real, size, mtimeMs });
+  return { path: entry.path, size: entry.size };
+}
+async function resolveFilePathAsync(relativePath, sessionParentPath = getBridgeRoot()) {
+  const result = await resolveFileForReadAsync(relativePath, sessionParentPath);
+  if ("error" in result) return result;
+  return result.path;
+}
+
+// src/files/read-file/resolve-file-cache-warmup.ts
+var WARMED_DIRECTORY_TTL_MS = 6e4;
+async function warmDirectoryResolveCache(sessionParentPath, directoryRelativePath) {
+  const { listDirAsync: listDirAsync2 } = await Promise.resolve().then(() => (init_list_dir(), list_dir_exports));
+  const result = await listDirAsync2(directoryRelativePath, sessionParentPath);
+  if ("error" in result) return;
+  for (const entry of result.entries) {
+    if (entry.isDir) continue;
+    if (fileBrowserRequestInFlight()) return;
+    const cacheKey = resolveCacheKey(sessionParentPath, entry.path);
+    if (hasResolveCacheEntry(cacheKey)) continue;
+    await resolveFileForReadAsync(entry.path, sessionParentPath).catch(() => void 0);
+    await yieldToEventLoop();
+  }
+}
+function scheduleDirectoryResolveCacheWarmup(sessionParentPath, directoryRelativePath) {
+  const parent = path77.resolve(sessionParentPath);
+  const dirKey = warmedDirectoryKey(parent, directoryRelativePath);
+  if (!markDirectoryWarmed(dirKey)) return;
+  setTimeout(() => unmarkDirectoryWarmed(dirKey), WARMED_DIRECTORY_TTL_MS);
+  setImmediate(() => {
+    void warmDirectoryResolveCache(parent, directoryRelativePath.replace(/^\/+/, "") || ".");
+  });
+}
+function scheduleResolveCacheWarmupForListedEntries(sessionParentPath, listRelativePath, entries) {
+  scheduleDirectoryResolveCacheWarmup(sessionParentPath, listRelativePath);
+  setImmediate(() => {
+    void (async () => {
+      for (const entry of entries) {
+        if (entry.isDir) continue;
+        if (fileBrowserRequestInFlight()) return;
+        const cacheKey = resolveCacheKey(sessionParentPath, entry.path);
+        if (hasResolveCacheEntry(cacheKey)) continue;
+        await resolveFileForReadAsync(entry.path, sessionParentPath).catch(() => void 0);
+        await yieldToEventLoop();
+      }
+    })();
+  });
+}
+
 // src/files/browser/handle-file-browser-list.ts
 async function handleFileBrowserList(socket, e2ee, id, reqPath, sessionParentPath, gitScope) {
   const result = gitScope ? await listGitTreeDirAsync(gitScope.repoAbsPath, gitScope.branch, reqPath) : await listDirAsync(reqPath, sessionParentPath);
@@ -45264,38 +45510,138 @@ async function handleFileBrowserList(socket, e2ee, id, reqPath, sessionParentPat
     return;
   }
   sendFileBrowserMessage(socket, e2ee, { type: "file_browser_response", id, entries: result.entries });
-  if (!gitScope && (reqPath === "." || reqPath === "")) {
-    triggerFileIndexBuild(sessionParentPath);
-    if (sessionParentPath) triggerSymbolIndexBuild(sessionParentPath);
+  if (!gitScope && sessionParentPath) {
+    scheduleResolveCacheWarmupForListedEntries(sessionParentPath, reqPath, result.entries);
   }
 }
 
-// src/files/read-file/resolve-file-path.ts
-import fs49 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 fs49.promises.realpath(resolved);
-  } catch {
-    real = resolved;
+// src/files/browser/handle-file-browser-read.ts
+import path78 from "node:path";
+init_cwd();
+
+// src/files/read-file/index.ts
+init_cwd();
+init_yield_to_event_loop();
+import fs54 from "node:fs";
+
+// src/files/read-file/read-file-range-async.ts
+init_yield_to_event_loop();
+import fs51 from "node:fs";
+import { StringDecoder as StringDecoder2 } from "node:string_decoder";
+
+// src/files/read-file/read-file-range-line-zero.ts
+function createLineZeroStreamState(lineOffsetIn) {
+  return {
+    line0Accum: "",
+    skipLine0Chars: typeof lineOffsetIn === "number" ? lineOffsetIn : 0,
+    line0CharsReturned: 0
+  };
+}
+function shouldTrackLineZero(startLine, lineOffsetIn) {
+  return startLine === 0 || lineOffsetIn !== void 0;
+}
+function stripCarriageReturn(lineContent) {
+  return lineContent.endsWith("\r") ? lineContent.slice(0, -1) : lineContent;
+}
+function lineContentBeforeNewline(text, lineStart, newlineIndex) {
+  let lineEnd = newlineIndex;
+  if (lineEnd > lineStart && text[lineEnd - 1] === "\r") lineEnd--;
+  return text.slice(lineStart, lineEnd);
+}
+function buildLineZeroChunkResult(resultLines, fileSize, lineOffset, totalLines = 1) {
+  return {
+    content: resultLines.join("\n"),
+    size: fileSize,
+    lineOffset,
+    totalLines
+  };
+}
+function tryFinishLineZeroOnCompleteLine(state, lineContent, resultLines, fileSize, lineChunkSize, lineOffsetIn, endLine, currentLine) {
+  state.line0Accum += lineContent;
+  const totalLine0 = state.line0Accum.length;
+  if (state.skipLine0Chars > 0) {
+    if (totalLine0 <= state.skipLine0Chars) {
+      state.skipLine0Chars -= totalLine0;
+      state.line0Accum = "";
+      return currentLine + 1 > endLine ? "done" : "continue";
+    }
+    const from = state.skipLine0Chars;
+    const take = Math.min(lineChunkSize, totalLine0 - from);
+    resultLines.push(state.line0Accum.slice(from, from + take));
+    state.line0CharsReturned += take;
+    if (from + take < totalLine0) {
+      return buildLineZeroChunkResult(
+        resultLines,
+        fileSize,
+        (lineOffsetIn ?? 0) + state.line0CharsReturned
+      );
+    }
+    state.line0Accum = "";
+    state.skipLine0Chars = 0;
+    state.line0CharsReturned = 0;
+    return "continue";
+  }
+  if (totalLine0 > lineChunkSize) {
+    resultLines.push(state.line0Accum.slice(0, lineChunkSize));
+    return buildLineZeroChunkResult(resultLines, fileSize, lineChunkSize);
+  }
+  resultLines.push(state.line0Accum);
+  state.line0Accum = "";
+  return "continue";
+}
+function tryFinishLineZeroPartial(state, partialLine, resultLines, fileSize, lineChunkSize, lineOffsetIn) {
+  state.line0Accum += partialLine;
+  const totalLine0 = state.line0Accum.length;
+  if (state.skipLine0Chars > 0) {
+    if (totalLine0 <= state.skipLine0Chars) {
+      state.skipLine0Chars -= totalLine0;
+      state.line0Accum = "";
+      return null;
+    }
+    const from = state.skipLine0Chars;
+    const take = Math.min(lineChunkSize, totalLine0 - from);
+    resultLines.push(state.line0Accum.slice(from, from + take));
+    return buildLineZeroChunkResult(resultLines, fileSize, (lineOffsetIn ?? 0) + take);
   }
-  try {
-    const stat2 = await fs49.promises.stat(real);
-    if (!stat2.isFile()) return { error: "Not a file" };
-    return real;
-  } catch (err) {
-    return { error: err instanceof Error ? err.message : String(err) };
+  if (totalLine0 > lineChunkSize) {
+    resultLines.push(state.line0Accum.slice(0, lineChunkSize));
+    return buildLineZeroChunkResult(resultLines, fileSize, lineChunkSize);
   }
+  return null;
+}
+function finishLineZeroTail(state, tail, resultLines, fileSize, lineChunkSize, lineOffsetIn) {
+  if (tail.length === 0) return null;
+  state.line0Accum += stripCarriageReturn(tail);
+  const totalLine0 = state.line0Accum.length;
+  if (state.skipLine0Chars > 0) {
+    if (totalLine0 <= state.skipLine0Chars) {
+      return { content: resultLines.join("\n"), size: fileSize };
+    }
+    const from = state.skipLine0Chars;
+    const take = Math.min(lineChunkSize, totalLine0 - from);
+    resultLines.push(state.line0Accum.slice(from, from + take));
+    state.line0CharsReturned += take;
+    if (from + take < totalLine0) {
+      return buildLineZeroChunkResult(
+        resultLines,
+        fileSize,
+        (lineOffsetIn ?? 0) + state.line0CharsReturned
+      );
+    }
+    return null;
+  }
+  if (totalLine0 > lineChunkSize) {
+    resultLines.push(state.line0Accum.slice(0, lineChunkSize));
+    return buildLineZeroChunkResult(resultLines, fileSize, lineChunkSize);
+  }
+  resultLines.push(state.line0Accum);
+  return null;
 }
 
 // src/files/read-file/read-file-range-async.ts
-import fs50 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 fs50.promises.stat(filePath)).size;
-  const fd = await fs50.promises.open(filePath, "r");
+async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE, fileSizeIn) {
+  const fileSize = fileSizeIn ?? (await fs51.promises.stat(filePath)).size;
+  const fd = await fs51.promises.open(filePath, "r");
   const bufSize = 64 * 1024;
   const buf = Buffer.alloc(bufSize);
   const decoder = new StringDecoder2("utf8");
@@ -45303,9 +45649,8 @@ async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, li
   const resultLines = [];
   let partial2 = "";
   let done = false;
-  let skipLine0Chars = typeof lineOffsetIn === "number" ? lineOffsetIn : 0;
-  let line0CharsReturned = 0;
-  let line0Accum = "";
+  const trackLineZero = shouldTrackLineZero(startLine, lineOffsetIn);
+  const lineZeroState = createLineZeroStreamState(lineOffsetIn);
   let bytesSinceYield = 0;
   try {
     let position = 0;
@@ -45322,130 +45667,70 @@ async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, li
       partial2 = "";
       let lineStart = 0;
       for (let i = 0; i < text.length; i++) {
-        if (text[i] === "\n") {
-          const lineContent = (() => {
-            let lineEnd = i;
-            if (lineEnd > lineStart && text[lineEnd - 1] === "\r") lineEnd--;
-            return text.slice(lineStart, lineEnd);
-          })();
-          if (currentLine === 0 && (startLine === 0 || lineOffsetIn !== void 0)) {
-            line0Accum += lineContent;
-            const totalLine0 = line0Accum.length;
-            if (skipLine0Chars > 0) {
-              if (totalLine0 <= skipLine0Chars) {
-                skipLine0Chars -= totalLine0;
-                line0Accum = "";
-                currentLine++;
-                lineStart = i + 1;
-                if (currentLine > endLine) {
-                  done = true;
-                  break;
-                }
-                continue;
-              }
-              const from = skipLine0Chars;
-              const take = Math.min(lineChunkSize, totalLine0 - from);
-              resultLines.push(line0Accum.slice(from, from + take));
-              line0CharsReturned += take;
-              if (from + take < totalLine0) {
-                return {
-                  content: resultLines.join("\n"),
-                  size: fileSize,
-                  lineOffset: lineOffsetIn + line0CharsReturned,
-                  totalLines: 1
-                };
-              }
-              line0Accum = "";
-              skipLine0Chars = 0;
-              line0CharsReturned = 0;
-            } else if (totalLine0 > lineChunkSize) {
-              resultLines.push(line0Accum.slice(0, lineChunkSize));
-              return {
-                content: resultLines.join("\n"),
-                size: fileSize,
-                lineOffset: lineChunkSize,
-                totalLines: 1
-              };
-            } else {
-              resultLines.push(line0Accum);
-              line0Accum = "";
-            }
-          } else if (currentLine >= startLine && currentLine <= endLine) {
-            resultLines.push(lineContent);
+        if (text[i] !== "\n") continue;
+        const lineContent2 = lineContentBeforeNewline(text, lineStart, i);
+        if (currentLine === 0 && trackLineZero) {
+          const lineZeroResult = tryFinishLineZeroOnCompleteLine(
+            lineZeroState,
+            lineContent2,
+            resultLines,
+            fileSize,
+            lineChunkSize,
+            lineOffsetIn,
+            endLine,
+            currentLine
+          );
+          if (lineZeroResult === "done") {
+            done = true;
+            break;
           }
+          if (lineZeroResult !== "continue") return lineZeroResult;
           currentLine++;
           lineStart = i + 1;
           if (currentLine > endLine) {
             done = true;
             break;
           }
+          continue;
         }
-      }
-      if (!done) {
-        const lineContent = text.slice(lineStart);
-        if (currentLine === 0 && (startLine === 0 || lineOffsetIn !== void 0)) {
-          line0Accum += lineContent;
-          const totalLine0 = line0Accum.length;
-          if (skipLine0Chars > 0) {
-            if (totalLine0 <= skipLine0Chars) {
-              skipLine0Chars -= totalLine0;
-              line0Accum = "";
-            } else {
-              const from = skipLine0Chars;
-              const take = Math.min(lineChunkSize, totalLine0 - from);
-              resultLines.push(line0Accum.slice(from, from + take));
-              return {
-                content: resultLines.join("\n"),
-                size: fileSize,
-                lineOffset: (lineOffsetIn ?? 0) + take,
-                totalLines: 1
-              };
-            }
-          } else if (totalLine0 > lineChunkSize) {
-            resultLines.push(line0Accum.slice(0, lineChunkSize));
-            return {
-              content: resultLines.join("\n"),
-              size: fileSize,
-              lineOffset: lineChunkSize,
-              totalLines: 1
-            };
-          }
+        if (currentLine >= startLine && currentLine <= endLine) {
+          resultLines.push(lineContent2);
+        }
+        currentLine++;
+        lineStart = i + 1;
+        if (currentLine > endLine) {
+          done = true;
+          break;
         }
-        partial2 = text.slice(lineStart);
+      }
+      if (done) continue;
+      const lineContent = text.slice(lineStart);
+      if (currentLine === 0 && trackLineZero) {
+        const partialResult = tryFinishLineZeroPartial(
+          lineZeroState,
+          lineContent,
+          resultLines,
+          fileSize,
+          lineChunkSize,
+          lineOffsetIn
+        );
+        if (partialResult != null) return partialResult;
+      } else {
+        partial2 = lineContent;
       }
     }
     if (!done) {
       const tail = partial2 + decoder.end();
-      if (currentLine === 0 && (startLine === 0 || lineOffsetIn !== void 0) && tail.length > 0) {
-        line0Accum += tail.endsWith("\r") ? tail.slice(0, -1) : tail;
-        const totalLine0 = line0Accum.length;
-        if (skipLine0Chars > 0) {
-          if (totalLine0 <= skipLine0Chars) {
-            return { content: resultLines.join("\n"), size: fileSize };
-          }
-          const from = skipLine0Chars;
-          const take = Math.min(lineChunkSize, totalLine0 - from);
-          resultLines.push(line0Accum.slice(from, from + take));
-          line0CharsReturned += take;
-          if (from + take < totalLine0) {
-            return {
-              content: resultLines.join("\n"),
-              size: fileSize,
-              lineOffset: (lineOffsetIn ?? 0) + line0CharsReturned,
-              totalLines: 1
-            };
-          }
-        } else if (totalLine0 > lineChunkSize) {
-          resultLines.push(line0Accum.slice(0, lineChunkSize));
-          return {
-            content: resultLines.join("\n"),
-            size: fileSize,
-            lineOffset: lineChunkSize,
-            totalLines: 1
-          };
-        } else {
-          resultLines.push(line0Accum);
-        }
+      if (currentLine === 0 && trackLineZero) {
+        const tailResult = finishLineZeroTail(
+          lineZeroState,
+          tail,
+          resultLines,
+          fileSize,
+          lineChunkSize,
+          lineOffsetIn
+        );
+        if (tailResult != null) return tailResult;
       } else if (tail.length > 0 && currentLine >= startLine && currentLine <= endLine) {
         resultLines.push(tail.endsWith("\r") ? tail.slice(0, -1) : tail);
       }
@@ -45456,12 +45741,48 @@ async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, li
   }
 }
 
+// src/files/read-file/read-small-file-range-async.ts
+import fs52 from "node:fs";
+var SMALL_FILE_RANGE_MAX_BYTES = 512 * 1024;
+function sliceLineRange(lines, startLine, endLine, lineOffsetIn, lineChunkSize, fileSize) {
+  if (startLine === 0 && lineOffsetIn == null && lines[0] != null && lines[0].length > lineChunkSize) {
+    return {
+      content: lines[0].slice(0, lineChunkSize),
+      size: fileSize,
+      lineOffset: lineChunkSize,
+      totalLines: lines.length
+    };
+  }
+  if (startLine === 0 && typeof lineOffsetIn === "number") {
+    const line0 = lines[0] ?? "";
+    const from = lineOffsetIn;
+    const take = Math.min(lineChunkSize, Math.max(0, line0.length - from));
+    return {
+      content: line0.slice(from, from + take),
+      size: fileSize,
+      ...from + take < line0.length ? { lineOffset: from + take, totalLines: lines.length } : { totalLines: lines.length }
+    };
+  }
+  const slice = lines.slice(startLine, endLine + 1);
+  return {
+    content: slice.join("\n"),
+    size: fileSize,
+    totalLines: lines.length
+  };
+}
+async function readSmallFileRangeAsync(filePath, fileSize, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
+  const raw = await fs52.promises.readFile(filePath, "utf8");
+  const lines = raw.split(/\r?\n/);
+  return sliceLineRange(lines, startLine, endLine, lineOffsetIn, lineChunkSize, fileSize);
+}
+
 // src/files/read-file/read-file-buffer-full-async.ts
-import fs51 from "node:fs";
+init_yield_to_event_loop();
+import fs53 from "node:fs";
 var READ_CHUNK_BYTES = 256 * 1024;
 async function readFileBufferFullAsync(filePath) {
-  const stat2 = await fs51.promises.stat(filePath);
-  const fd = await fs51.promises.open(filePath, "r");
+  const stat2 = await fs53.promises.stat(filePath);
+  const fd = await fs53.promises.open(filePath, "r");
   const chunks = [];
   let position = 0;
   let bytesSinceYield = 0;
@@ -45503,12 +45824,23 @@ async function readFileBinaryFullAsync(filePath) {
 }
 
 // src/files/read-file/index.ts
-async function readFileAsync(relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE, sessionParentPath = getBridgeRoot(), encoding = "utf8") {
-  await yieldToEventLoop();
+async function readFileAsync(relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE, sessionParentPath = getBridgeRoot(), encoding = "utf8", options) {
+  if (!options?.skipInitialYield) {
+    await yieldToEventLoop();
+  }
   try {
-    const result = await resolveFilePathAsync(relativePath, sessionParentPath);
-    if (typeof result === "object") return result;
-    const resolvedPath = result;
+    let resolvedPath;
+    let fileSize;
+    if (options?.useResolvedSize) {
+      const resolved = await resolveFileForReadAsync(relativePath, sessionParentPath);
+      if ("error" in resolved) return resolved;
+      resolvedPath = resolved.path;
+      fileSize = resolved.size;
+    } else {
+      const result = await resolveFilePathAsync(relativePath, sessionParentPath);
+      if (typeof result === "object") return result;
+      resolvedPath = result;
+    }
     const hasRange = typeof startLine === "number" && typeof endLine === "number";
     if (encoding === "base64") {
       if (hasRange) return { error: "base64 encoding requires a full file read (no line range)" };
@@ -45516,7 +45848,26 @@ async function readFileAsync(relativePath, startLine, endLine, lineOffset, lineC
       return { ...read2, resolvedPath };
     }
     if (hasRange) {
-      return readFileRangeAsync(resolvedPath, startLine, endLine, lineOffset, lineChunkSize);
+      if (fileSize == null) {
+        const stat2 = await fs54.promises.stat(resolvedPath);
+        fileSize = stat2.size;
+      }
+      const read2 = fileSize <= SMALL_FILE_RANGE_MAX_BYTES ? await readSmallFileRangeAsync(
+        resolvedPath,
+        fileSize,
+        startLine,
+        endLine,
+        lineOffset,
+        lineChunkSize
+      ) : await readFileRangeAsync(
+        resolvedPath,
+        startLine,
+        endLine,
+        lineOffset,
+        lineChunkSize,
+        fileSize
+      );
+      return read2;
     }
     const read = await readFileFullAsync(resolvedPath);
     return { ...read, resolvedPath };
@@ -45525,6 +45876,17 @@ async function readFileAsync(relativePath, startLine, endLine, lineOffset, lineC
   }
 }
 
+// src/files/browser/file-browser-read-queue.ts
+var readChain = Promise.resolve();
+function withFileBrowserReadQueue(fn) {
+  const next = readChain.then(() => fn());
+  readChain = next.then(
+    () => void 0,
+    () => void 0
+  );
+  return next;
+}
+
 // src/files/browser/handle-file-browser-read.ts
 async function handleFileBrowserRead(socket, e2ee, msg, reqPath, sessionParentPath, gitScope) {
   const startLine = typeof msg.startLine === "number" ? msg.startLine : void 0;
@@ -45541,14 +45903,17 @@ async function handleFileBrowserRead(socket, e2ee, msg, reqPath, sessionParentPa
     lineOffset,
     lineChunkSize,
     encoding
-  ) : await readFileAsync(
-    reqPath,
-    startLine,
-    endLine,
-    lineOffset,
-    lineChunkSize,
-    sessionParentPath,
-    encoding
+  ) : await withFileBrowserReadQueue(
+    () => readFileAsync(
+      reqPath,
+      startLine,
+      endLine,
+      lineOffset,
+      lineChunkSize,
+      sessionParentPath,
+      encoding,
+      { skipInitialYield: true, useResolvedSize: true }
+    )
   );
   if ("error" in result) {
     sendWsMessage(socket, { type: "file_browser_response", id: msg.id, error: result.error });
@@ -45565,6 +45930,10 @@ async function handleFileBrowserRead(socket, e2ee, msg, reqPath, sessionParentPa
   if (result.mimeType != null) payload.mimeType = result.mimeType;
   if (result.resolvedPath != null) payload.resolvedPath = result.resolvedPath;
   sendFileBrowserMessage(socket, e2ee, payload);
+  if (!gitScope) {
+    const parentDir = path78.dirname(reqPath.replace(/^\/+/, "") || ".");
+    scheduleDirectoryResolveCacheWarmup(sessionParentPath ?? getBridgeRoot(), parentDir === "" ? "." : parentDir);
+  }
 }
 
 // src/files/browser/resolve-git-branch-scope.ts
@@ -45578,22 +45947,67 @@ function resolveGitBranchScope(msg) {
 
 // src/files/browser/index.ts
 function handleFileBrowserRequest(msg, socket, e2ee, sessionWorktreeManager) {
+  beginFileBrowserRequest();
   void (async () => {
-    const reqPath = msg.path.replace(/^\/+/, "") || ".";
-    const op = msg.op === "read" ? "read" : "list";
-    const sessionParentPath = sessionWorktreeManager != null ? await resolveFileBrowserSessionParent(sessionWorktreeManager, msg.sessionId) : void 0;
-    const gitScope = resolveGitBranchScope(msg);
-    if (msg.source === "git_branch" && typeof msg.repoRelPath === "string" && typeof msg.branch === "string" && msg.branch.trim().length > 0 && !gitScope) {
-      sendWsMessage(socket, { type: "file_browser_response", id: msg.id, error: "Invalid repository path" });
-      return;
+    try {
+      const reqPath = msg.path.replace(/^\/+/, "") || ".";
+      const sessionParentPath = sessionWorktreeManager != null ? await resolveFileBrowserSessionParent(sessionWorktreeManager, msg.sessionId) : void 0;
+      const gitScope = resolveGitBranchScope(msg);
+      if (msg.source === "git_branch" && typeof msg.repoRelPath === "string" && typeof msg.branch === "string" && msg.branch.trim().length > 0 && !gitScope) {
+        sendWsMessage(socket, { type: "file_browser_response", id: msg.id, error: "Invalid repository path" });
+        return;
+      }
+      if (msg.op === "read") {
+        await handleFileBrowserRead(socket, e2ee, msg, reqPath, sessionParentPath, gitScope);
+      } else {
+        await handleFileBrowserList(socket, e2ee, msg.id, reqPath, sessionParentPath, gitScope);
+      }
+    } finally {
+      endFileBrowserRequest();
     }
-    if (op === "list") {
-      await handleFileBrowserList(socket, e2ee, msg.id, reqPath, sessionParentPath, gitScope);
-    } else {
-      await handleFileBrowserRead(socket, e2ee, msg, reqPath, sessionParentPath, gitScope);
+  })();
+}
+
+// src/files/handle-file-browser-search.ts
+init_cwd();
+init_yield_to_event_loop();
+import path79 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 = path79.resolve(
+      sessionWorktreeManager != null ? await resolveFileBrowserSessionParent(sessionWorktreeManager, msg.sessionId) : getBridgeRoot()
+    );
+    if (!await bridgeFileIndexIsPopulated(sessionParentPath)) {
+      triggerFileIndexBuild(sessionParentPath);
+      const payload2 = {
+        type: "file_browser_search_response",
+        id: msg.id,
+        paths: [],
+        indexReady: false
+      };
+      sendWsMessage(socket, e2ee ? e2ee.encryptFields(payload2, ["paths"]) : payload2);
+      return;
     }
+    const results = await searchBridgeFilePathsAsync(sessionParentPath, q, SEARCH_LIMIT);
+    const payload = {
+      type: "file_browser_search_response",
+      id: msg.id,
+      paths: results,
+      indexReady: true
+    };
+    sendWsMessage(socket, e2ee ? e2ee.encryptFields(payload, ["paths"]) : payload);
   })();
 }
+function triggerFileIndexBuild(sessionParentPath = getBridgeRoot()) {
+  setImmediate(() => {
+    void ensureFileIndexAsync(sessionParentPath).catch((e) => {
+      console.error("[file-index] Background build failed:", e);
+    });
+  });
+}
 
 // src/routing/handlers/file-browser-messages.ts
 function handleFileBrowserRequestMessage(msg, { getWs, e2ee, sessionWorktreeManager }) {
@@ -45614,6 +46028,235 @@ function handleFileBrowserSearchMessage(msg, { getWs, e2ee, sessionWorktreeManag
   );
 }
 
+// src/code-nav/handlers/send-code-nav-response.ts
+var ENCRYPTED_FIELDS = ["definition", "definitions", "references", "symbols", "confidentTarget"];
+function sendCodeNavResponse(socket, e2ee, payload) {
+  const fieldsToEncrypt = ENCRYPTED_FIELDS.filter((field) => field in payload && payload[field] !== void 0);
+  sendWsMessage(
+    socket,
+    e2ee && fieldsToEncrypt.length > 0 ? e2ee.encryptFields(payload, [...fieldsToEncrypt]) : payload
+  );
+}
+
+// src/code-nav/handlers/handle-definition-op.ts
+async function handleDefinitionOp(ctx) {
+  const definition = await queryDefinitionAt(ctx.sessionParentPath, ctx.reqPath, ctx.line, ctx.column);
+  sendCodeNavResponse(ctx.socket, ctx.e2ee, {
+    type: "code_nav_response",
+    id: ctx.msg.id,
+    indexReady: true,
+    definition
+  });
+}
+
+// src/code-nav/handlers/handle-definitions-op.ts
+async function handleDefinitionsOp(ctx) {
+  const { definitions, confidentTarget } = await queryDefinitionsNavigation(
+    ctx.sessionParentPath,
+    ctx.reqPath,
+    ctx.line,
+    ctx.column
+  );
+  sendCodeNavResponse(ctx.socket, ctx.e2ee, {
+    type: "code_nav_response",
+    id: ctx.msg.id,
+    indexReady: true,
+    definitions,
+    confidentTarget
+  });
+}
+
+// src/code-nav/handlers/handle-references-op.ts
+async function handleReferencesOp(ctx) {
+  const references = await queryReferencesAt(ctx.sessionParentPath, ctx.reqPath, ctx.line, ctx.column);
+  sendCodeNavResponse(ctx.socket, ctx.e2ee, {
+    type: "code_nav_response",
+    id: ctx.msg.id,
+    indexReady: true,
+    references
+  });
+}
+
+// src/code-nav/handlers/handle-symbols-op.ts
+async function handleSymbolsOp(ctx) {
+  const symbols = await querySymbolsInFile(ctx.sessionParentPath, ctx.reqPath);
+  sendCodeNavResponse(ctx.socket, ctx.e2ee, {
+    type: "code_nav_response",
+    id: ctx.msg.id,
+    indexReady: true,
+    symbols
+  });
+}
+
+// src/code-nav/handlers/prepare-code-nav-request.ts
+init_yield_to_event_loop();
+
+// src/code-nav/handlers/deferred-code-nav-index.ts
+var latestSeqBySession = /* @__PURE__ */ new Map();
+var pendingBySession = /* @__PURE__ */ new Map();
+var flushPromise = null;
+function scheduleDeferredCodeNavIndex(sessionKey, sessionParentPath, reqPath) {
+  const seq = (latestSeqBySession.get(sessionKey) ?? 0) + 1;
+  latestSeqBySession.set(sessionKey, seq);
+  pendingBySession.set(sessionKey, { sessionParentPath, reqPath, seq });
+  scheduleFlushWhenIdle();
+}
+function scheduleFlushWhenIdle() {
+  if (flushPromise != null) return;
+  flushPromise = runFlushWhenIdle().finally(() => {
+    flushPromise = null;
+    if (pendingBySession.size > 0) scheduleFlushWhenIdle();
+  });
+}
+async function runFlushWhenIdle() {
+  await yieldUntilFileBrowserIdle();
+  const entries = [];
+  for (const [sessionKey, entry] of pendingBySession) {
+    pendingBySession.delete(sessionKey);
+    if (entry.seq === latestSeqBySession.get(sessionKey)) entries.push(entry);
+  }
+  for (const entry of entries) {
+    scheduleSymbolIndexFile(entry.sessionParentPath, entry.reqPath);
+  }
+}
+registerFileBrowserActivityListener(() => {
+  if (pendingBySession.size > 0 && !isBridgeBrowseInteractiveActive()) {
+    scheduleFlushWhenIdle();
+  }
+});
+
+// src/code-nav/handlers/code-nav-session-key.ts
+function codeNavSessionKey(sessionId, sessionParentPath) {
+  const trimmed2 = sessionId?.trim();
+  return trimmed2 ? trimmed2 : sessionParentPath;
+}
+
+// src/code-nav/handlers/wait-for-symbol-index-ready.ts
+var CODE_NAV_INDEX_READY_WAIT_MS = 75;
+var CODE_NAV_INDEX_READY_POLL_MS = 15;
+function delay2(ms) {
+  return new Promise((resolve35) => setTimeout(resolve35, ms));
+}
+async function waitForSymbolIndexReady(sessionParentPath, reqPath, maxWaitMs = CODE_NAV_INDEX_READY_WAIT_MS) {
+  const deadline = Date.now() + maxWaitMs;
+  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);
+}
+
+// src/code-nav/handlers/prepare-code-nav-base-context.ts
+function buildPreparedCodeNavBaseContext(msg, socket, e2ee, reqPath, sessionParentPath) {
+  return {
+    socket,
+    e2ee,
+    msg,
+    reqPath,
+    sessionParentPath,
+    line: typeof msg.line === "number" ? msg.line : 1,
+    column: typeof msg.column === "number" ? msg.column : 0
+  };
+}
+
+// src/code-nav/handlers/code-nav-op-context.ts
+function normalizeCodeNavOp(op) {
+  if (op === "references" || op === "symbols" || op === "definitions") return op;
+  return "definition";
+}
+
+// src/code-nav/handlers/resolve-code-nav-parent.ts
+init_cwd();
+init_normalize_resolved_path();
+async function resolveCodeNavParentPath(sessionWorktreeManager, sessionId) {
+  const parent = sessionWorktreeManager != null ? await resolveFileBrowserSessionParent(sessionWorktreeManager, sessionId) : getBridgeRoot();
+  return normalizeResolvedPath(parent);
+}
+
+// src/code-nav/handlers/prepare-code-nav-request.ts
+async function prepareCodeNavRequest(msg, socket, e2ee, sessionWorktreeManager) {
+  await yieldToEventLoop();
+  const reqPath = msg.path.replace(/^\/+/, "") || "";
+  if (!reqPath) {
+    sendCodeNavResponse(socket, e2ee, {
+      type: "code_nav_response",
+      id: msg.id,
+      error: "Path required"
+    });
+    return null;
+  }
+  const sessionParentPath = await resolveCodeNavParentPath(sessionWorktreeManager, msg.sessionId);
+  await registerSymbolIndexParentAsync(sessionParentPath);
+  const sessionKey = codeNavSessionKey(msg.sessionId, sessionParentPath);
+  const baseContext = buildPreparedCodeNavBaseContext(msg, socket, e2ee, reqPath, sessionParentPath);
+  if (isBridgeBrowseInteractiveActive()) {
+    scheduleDeferredCodeNavIndex(sessionKey, sessionParentPath, reqPath);
+    return { ...baseContext, indexReady: false };
+  }
+  scheduleSymbolIndexFile(sessionParentPath, reqPath);
+  const indexReady = await waitForSymbolIndexReady(sessionParentPath, reqPath);
+  if (indexReady) {
+    const importTargets = await listDirectImportTargetsForFileAsync(sessionParentPath, reqPath);
+    scheduleSymbolIndexImportNeighbors(sessionParentPath, importTargets);
+  }
+  await yieldToEventLoop();
+  return {
+    ...baseContext,
+    indexReady
+  };
+}
+function sendIndexNotReadyResponse(ctx) {
+  sendCodeNavResponse(ctx.socket, ctx.e2ee, {
+    type: "code_nav_response",
+    id: ctx.msg.id,
+    indexReady: false,
+    definition: null,
+    definitions: [],
+    references: [],
+    symbols: []
+  });
+}
+function preparedOpContext(ctx) {
+  return {
+    socket: ctx.socket,
+    e2ee: ctx.e2ee,
+    msg: { ...ctx.msg, op: normalizeCodeNavOp(ctx.msg.op) },
+    reqPath: ctx.reqPath,
+    sessionParentPath: ctx.sessionParentPath,
+    line: ctx.line,
+    column: ctx.column
+  };
+}
+
+// src/code-nav/handlers/handle-code-nav-request.ts
+function handleCodeNavRequest(msg, socket, e2ee, sessionWorktreeManager) {
+  void (async () => {
+    const prepared = await prepareCodeNavRequest(msg, socket, e2ee, sessionWorktreeManager);
+    if (prepared == null) return;
+    if (!prepared.indexReady) {
+      sendIndexNotReadyResponse(prepared);
+      return;
+    }
+    const ctx = preparedOpContext(prepared);
+    switch (ctx.msg.op) {
+      case "symbols":
+        await handleSymbolsOp(ctx);
+        return;
+      case "references":
+        await handleReferencesOp(ctx);
+        return;
+      case "definitions":
+        await handleDefinitionsOp(ctx);
+        return;
+      default:
+        await handleDefinitionOp(ctx);
+    }
+  })();
+}
+
+// src/code-nav/handlers/trigger-symbol-index-build.ts
+init_normalize_resolved_path();
+
 // src/routing/handlers/code-nav-messages.ts
 function handleFileBrowserCodeNavMessage(msg, { getWs, e2ee, sessionWorktreeManager }) {
   if (typeof msg.id !== "string" || typeof msg.path !== "string") return;
@@ -45636,6 +46279,7 @@ function handleFileBrowserCodeNavMessage(msg, { getWs, e2ee, sessionWorktreeMana
 }
 
 // src/routing/handlers/skill-layout-request.ts
+init_cwd();
 function handleSkillLayoutRequest(msg, deps) {
   const id = typeof msg.id === "string" ? msg.id : "";
   void (async () => {
@@ -45647,6 +46291,9 @@ function handleSkillLayoutRequest(msg, deps) {
   })();
 }
 
+// src/routing/handlers/install-skills.ts
+init_cwd();
+
 // src/skills/install/is-valid-install-item.ts
 function isValidRemoteSkillInstallItem(item) {
   if (item === null || typeof item !== "object") return false;
@@ -45655,8 +46302,9 @@ function isValidRemoteSkillInstallItem(item) {
 }
 
 // src/skills/install/install-remote-skills-async.ts
-import fs52 from "node:fs";
-import path77 from "node:path";
+init_yield_to_event_loop();
+import fs55 from "node:fs";
+import path80 from "node:path";
 
 // src/skills/install/constants.ts
 var INSTALL_SKILLS_YIELD_EVERY = 16;
@@ -45667,12 +46315,12 @@ async function writeInstallFileAsync(skillDir, f, filesWritten) {
   if (++filesWritten.count % INSTALL_SKILLS_YIELD_EVERY === 0) {
     await yieldToEventLoop();
   }
-  const dest = path77.join(skillDir, f.path);
-  await fs52.promises.mkdir(path77.dirname(dest), { recursive: true });
+  const dest = path80.join(skillDir, f.path);
+  await fs55.promises.mkdir(path80.dirname(dest), { recursive: true });
   if (f.text !== void 0) {
-    await fs52.promises.writeFile(dest, f.text, "utf8");
+    await fs55.promises.writeFile(dest, f.text, "utf8");
   } else if (f.base64) {
-    await fs52.promises.writeFile(dest, Buffer.from(f.base64, "base64"));
+    await fs55.promises.writeFile(dest, Buffer.from(f.base64, "base64"));
   }
 }
 async function installRemoteSkillsAsync(cwd, targetDir, items) {
@@ -45684,7 +46332,7 @@ async function installRemoteSkillsAsync(cwd, targetDir, items) {
   try {
     for (const item of items) {
       if (!isValidRemoteSkillInstallItem(item)) continue;
-      const skillDir = path77.join(cwd, targetDir, item.skillName);
+      const skillDir = path80.join(cwd, targetDir, item.skillName);
       for (const f of item.files) {
         await writeInstallFileAsync(skillDir, f, filesWritten);
       }
@@ -45966,7 +46614,8 @@ var handleSessionDiscardedMessage = (msg, deps) => {
 };
 
 // src/routing/handlers/revert-turn-snapshot.ts
-import * as fs53 from "node:fs";
+init_cwd();
+import * as fs56 from "node:fs";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
@@ -45979,7 +46628,7 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
     const agentBase = sessionWorktreeManager.getSessionWorktreeRootForSession(sessionId) ?? getBridgeRoot();
     const file2 = snapshotFilePath(agentBase, turnId);
     try {
-      await fs53.promises.access(file2, fs53.constants.F_OK);
+      await fs56.promises.access(file2, fs56.constants.F_OK);
     } catch {
       sendWsMessage(s, {
         type: "revert_turn_snapshot_result",
@@ -46064,7 +46713,9 @@ var handleDeploySessionToPreviewMessage = (msg, deps) => {
 };
 
 // src/git/bridge-git-context.ts
-import * as path78 from "node:path";
+init_cwd();
+init_yield_to_event_loop();
+import * as path81 from "node:path";
 
 // src/git/branches/get-current-branch.ts
 async function getCurrentBranch(repoPath) {
@@ -46114,12 +46765,12 @@ async function listRepoBranchRefs(repoPath) {
 // src/git/bridge-git-context.ts
 function folderNameForRelPath(relPath, bridgeRoot) {
   if (relPath === "." || relPath === "") {
-    return path78.basename(path78.resolve(bridgeRoot)) || "repo";
+    return path81.basename(path81.resolve(bridgeRoot)) || "repo";
   }
-  return path78.basename(relPath) || relPath;
+  return path81.basename(relPath) || relPath;
 }
 async function discoverGitReposForBridgeContext(bridgeRoot) {
-  const root = path78.resolve(bridgeRoot);
+  const root = path81.resolve(bridgeRoot);
   if (await isGitRepoDirectory(root)) {
     const remoteUrl = await getRemoteOriginUrl(root);
     return [{ absolutePath: root, remoteUrl }];
@@ -46127,19 +46778,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(path78.resolve(repo.absolutePath), repo);
+    byPath.set(path81.resolve(repo.absolutePath), repo);
   }
   return [...byPath.values()];
 }
 async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path78.resolve(bridgeRoot);
+  const bridgeResolved = path81.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 = path78.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path78.isAbsolute(rel)) continue;
+    let rel = path81.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path81.isAbsolute(rel)) continue;
     const relPath = rel === "" ? "." : rel.replace(/\\/g, "/");
     const currentBranch = await getCurrentBranch(repo.absolutePath);
     const remoteUrl = repo.remoteUrl.trim() || null;
@@ -46154,11 +46805,11 @@ async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
   return rows;
 }
 async function listRepoBranchesForBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path78.resolve(bridgeRoot);
+  const bridgeResolved = path81.resolve(bridgeRoot);
   const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
-  const repoPath = rel === "" ? bridgeResolved : path78.join(bridgeResolved, rel);
-  const resolved = path78.resolve(repoPath);
-  if (!resolved.startsWith(bridgeResolved + path78.sep) && resolved !== bridgeResolved) {
+  const repoPath = rel === "" ? bridgeResolved : path81.join(bridgeResolved, rel);
+  const resolved = path81.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path81.sep) && resolved !== bridgeResolved) {
     return [];
   }
   return listRepoBranchRefs(resolved);