@buildautomaton/cli 0.1.63 → 0.1.64

package/dist/cli.js

@@ -973,8 +973,8 @@ var require_command = __commonJS({
   "../../node_modules/.pnpm/commander@12.1.0/node_modules/commander/lib/command.js"(exports) {
     var EventEmitter2 = __require("node:events").EventEmitter;
     var childProcess2 = __require("node:child_process");
-    var path81 = __require("node:path");
-    var fs56 = __require("node:fs");
+    var path84 = __require("node:path");
+    var fs59 = __require("node:fs");
     var process8 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1906,11 +1906,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path81.resolve(baseDir, baseName);
-          if (fs56.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path81.extname(baseName))) return void 0;
+          const localBin = path84.resolve(baseDir, baseName);
+          if (fs59.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path84.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs56.existsSync(`${localBin}${ext}`)
+            (ext) => fs59.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1922,21 +1922,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs56.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs59.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path81.resolve(
-            path81.dirname(resolvedScriptPath),
+          executableDir = path84.resolve(
+            path84.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path81.basename(
+            const legacyName = path84.basename(
               this._scriptPath,
-              path81.extname(this._scriptPath)
+              path84.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1947,7 +1947,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path81.extname(executableFile));
+        launchWithNode = sourceExt.includes(path84.extname(executableFile));
         let proc;
         if (process8.platform !== "win32") {
           if (launchWithNode) {
@@ -2787,7 +2787,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path81.basename(filename, path81.extname(filename));
+        this._name = path84.basename(filename, path84.extname(filename));
         return this;
       }
       /**
@@ -2801,9 +2801,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path82) {
-        if (path82 === void 0) return this._executableDir;
-        this._executableDir = path82;
+      executableDir(path85) {
+        if (path85 === void 0) return this._executableDir;
+        this._executableDir = path85;
         return this;
       }
       /**
@@ -3033,6 +3033,50 @@ var require_commander = __commonJS({
   }
 });
 
+// src/paths/normalize-resolved-path.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+function normalizeResolvedPath(resolved) {
+  const abs = path3.resolve(resolved);
+  try {
+    return fs3.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 initBridgeRoot() {
+  bridgeRootPath = normalizeResolvedPath(process.cwd());
+}
+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/ws@8.19.0/node_modules/ws/lib/constants.js
 var require_constants = __commonJS({
   "../../node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/constants.js"(exports, module) {
@@ -6649,6 +6693,16 @@ var require_websocket_server = __commonJS({
   }
 });
 
+// src/runtime/yield-to-event-loop.ts
+function yieldToEventLoop() {
+  return new Promise((resolve37) => setImmediate(resolve37));
+}
+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) {
@@ -6946,7 +7000,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(path81, checkUnignored, mode) {
+      test(path84, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -6955,7 +7009,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path81);
+          const matched = rule[mode].test(path84);
           if (!matched) {
             return;
           }
@@ -6976,17 +7030,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path81, originalPath, doThrow) => {
-      if (!isString(path81)) {
+    var checkPath = (path84, originalPath, doThrow) => {
+      if (!isString(path84)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path81) {
+      if (!path84) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path81)) {
+      if (checkPath.isNotRelative(path84)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -6995,7 +7049,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path81) => REGEX_TEST_INVALID_PATH.test(path81);
+    var isNotRelative = (path84) => REGEX_TEST_INVALID_PATH.test(path84);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -7025,19 +7079,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache2, checkUnignored, slices) {
-        const path81 = originalPath && checkPath.convert(originalPath);
+        const path84 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path81,
+          path84,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path81, cache2, checkUnignored, slices);
+        return this._t(path84, cache2, checkUnignored, slices);
       }
-      checkIgnore(path81) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path81)) {
-          return this.test(path81);
+      checkIgnore(path84) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path84)) {
+          return this.test(path84);
         }
-        const slices = path81.split(SLASH).filter(Boolean);
+        const slices = path84.split(SLASH).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -7050,18 +7104,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path81, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path84, false, MODE_CHECK_IGNORE);
       }
-      _t(path81, cache2, checkUnignored, slices) {
-        if (path81 in cache2) {
-          return cache2[path81];
+      _t(path84, cache2, checkUnignored, slices) {
+        if (path84 in cache2) {
+          return cache2[path84];
         }
         if (!slices) {
-          slices = path81.split(SLASH).filter(Boolean);
+          slices = path84.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache2[path81] = this._rules.test(path81, checkUnignored, MODE_IGNORE);
+          return cache2[path84] = this._rules.test(path84, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -7069,29 +7123,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache2[path81] = parent.ignored ? parent : this._rules.test(path81, checkUnignored, MODE_IGNORE);
+        return cache2[path84] = parent.ignored ? parent : this._rules.test(path84, checkUnignored, MODE_IGNORE);
       }
-      ignores(path81) {
-        return this._test(path81, this._ignoreCache, false).ignored;
+      ignores(path84) {
+        return this._test(path84, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path81) => !this.ignores(path81);
+        return (path84) => !this.ignores(path84);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path81) {
-        return this._test(path81, this._testCache, true);
+      test(path84) {
+        return this._test(path84, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path81) => checkPath(path81 && checkPath.convert(path81), path81, RETURN_FALSE);
+    var isPathValid = (path84) => checkPath(path84 && checkPath.convert(path84), path84, 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 = (path81) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path81) || isNotRelative(path81);
+      checkPath.isNotRelative = (path84) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path84) || isNotRelative(path84);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -7518,8 +7572,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path81, errorMaps, issueData } = params;
-      const fullPath = [...path81, ...issueData.path || []];
+      const { data, path: path84, errorMaps, issueData } = params;
+      const fullPath = [...path84, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -7827,11 +7881,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path81, key) {
+      constructor(parent, value, path84, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path81;
+        this._path = path84;
         this._key = key;
       }
       get path() {
@@ -11556,10 +11610,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path81) {
-  if (!path81)
+function getElementAtPath(obj, path84) {
+  if (!path84)
     return obj;
-  return path81.reduce((acc, key) => acc?.[key], obj);
+  return path84.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -11808,11 +11862,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path81, issues) {
+function prefixIssues(path84, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path81);
+    iss.path.unshift(path84);
     return iss;
   });
 }
@@ -12001,7 +12055,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path81 = []) => {
+  const processError = (error41, path84 = []) => {
     var _a2, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -12011,7 +12065,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path81, ...issue2.path];
+        const fullpath = [...path84, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -12041,9 +12095,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path81) {
+function toDotPath(path84) {
   const segs = [];
-  for (const seg of path81) {
+  for (const seg of path84) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -25526,10 +25580,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(path81, isFile, isDirectory) {
-      log2(`checking %s`, path81);
+    function check2(path84, isFile, isDirectory) {
+      log2(`checking %s`, path84);
       try {
-        const stat3 = fs_1.statSync(path81);
+        const stat3 = fs_1.statSync(path84);
         if (stat3.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -25549,8 +25603,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path81, type = exports.READABLE) {
-      return check2(path81, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path84, type = exports.READABLE) {
+      return check2(path84, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -25613,6 +25667,112 @@ var require_dist2 = __commonJS({
   }
 });
 
+// src/files/ensure-under-cwd.ts
+import path74 from "node:path";
+function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
+  const normalized = path74.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path74.resolve(cwd, normalized);
+  if (!resolved.startsWith(cwd + path74.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 path75 from "node:path";
+import fs48 from "node:fs";
+async function mapDirEntry(d, relativePath, resolved) {
+  const entryPath = path75.join(relativePath || ".", d.name).replace(/\\/g, "/");
+  const fullPath = path75.join(resolved, d.name);
+  let isDir = d.isDirectory();
+  if (d.isSymbolicLink()) {
+    try {
+      const targetStat = await fs48.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 fs49 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 fs49.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/commander@12.1.0/node_modules/commander/esm.mjs
 var import_index = __toESM(require_commander(), 1);
 var {
@@ -25631,15 +25791,15 @@ var {
 } = import_index.default;
 
 // 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/cli/defaults.ts
 var DEFAULT_API_URL = process.env.BUILDAUTOMATON_API_URL ?? "https://api.buildautomaton.com";
 var DEFAULT_FIREHOSE_URL = "https://buildautomaton-firehose.fly.dev";
 
 // src/cli/run-cli-action.ts
-import * as fs55 from "node:fs";
-import * as path80 from "node:path";
+import * as fs58 from "node:fs";
+import * as path83 from "node:path";
 
 // src/cli-log-level.ts
 var verbosity = "info";
@@ -26084,29 +26244,8 @@ async function loadOrCreateE2eCertificates(directory) {
   };
 }
 
-// src/paths/normalize-resolved-path.ts
-import fs3 from "node:fs";
-import path3 from "node:path";
-function normalizeResolvedPath(resolved) {
-  const abs = path3.resolve(resolved);
-  try {
-    return fs3.realpathSync.native(abs);
-  } catch {
-    return abs;
-  }
-}
-
-// src/files/cwd/bridge-root.ts
-var bridgeRootPath = null;
-function initBridgeRoot() {
-  bridgeRootPath = normalizeResolvedPath(process.cwd());
-}
-function getBridgeRoot() {
-  if (bridgeRootPath == null) {
-    bridgeRootPath = normalizeResolvedPath(process.cwd());
-  }
-  return bridgeRootPath;
-}
+// src/cli/run-cli-action.ts
+init_cwd();
 
 // src/log.ts
 function timestampPrefix() {
@@ -27426,7 +27565,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
@@ -27436,7 +27579,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;
 
@@ -27448,9 +27591,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((resolve37) => setImmediate(resolve37));
+// 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((resolve37) => setTimeout(resolve37, pollMs));
+    }
+  }
+}
+async function yieldForBridgeInteractivePriority() {
+  await yieldToEventLoop();
+  await yieldUntilFileBrowserIdle();
 }
 
 // src/runtime/cli-process-interrupt.ts
@@ -27473,7 +27685,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
@@ -27518,6 +27734,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;
@@ -27679,7 +27896,7 @@ function readMigrationSql(filename, ...searchSubdirs) {
     join2(moduleDir, "..", sub, filename),
     join2(moduleDir, "..", "..", "dist", sub, filename)
   ]);
-  const resolved = candidates.find((path81) => existsSync(path81));
+  const resolved = candidates.find((path84) => existsSync(path84));
   if (!resolved) {
     throw new Error(`Missing SQLite migration SQL: ${filename} (searched ${searchSubdirs.join(", ")})`);
   }
@@ -28068,14 +28285,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.");
   }
 }
@@ -28184,7 +28401,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++;
@@ -28291,7 +28508,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;
 }
@@ -28302,10 +28519,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);
@@ -28317,6 +28534,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, "\\_");
 }
@@ -28373,8 +28591,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 };
 }
@@ -28382,7 +28603,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();
 }
 
@@ -28515,7 +28736,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++;
@@ -28549,6 +28770,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);
 }
@@ -28843,128 +29066,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,
@@ -29114,6 +29220,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(/^\/+/, "");
@@ -29143,6 +29250,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 fs20 from "node:fs";
 import path21 from "node:path";
@@ -29829,6 +30059,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);
@@ -29840,7 +30071,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,
@@ -29850,9 +30085,10 @@ async function parseSourceRoot(filePath, source) {
           parser4.delete();
         }
       };
-    } catch {
+    } catch (err) {
       tree?.delete();
       parser4.delete();
+      if (isSymbolIndexDeferredError(err)) throw err;
       return null;
     }
   });
@@ -29860,9 +30096,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;
 }
 
@@ -29943,7 +30181,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 {
@@ -29959,13 +30197,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;
@@ -30334,6 +30576,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);
@@ -30355,6 +30598,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;
@@ -30363,15 +30607,16 @@ async function extractFileSymbolData(resolved, relPath, workspaceFilesOverride)
       const stat3 = await fs20.promises.stat(absPath);
       if (stat3.isFile() && stat3.size <= MAX_INDEX_FILE_BYTES) {
         source = await fs20.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();
@@ -30382,12 +30627,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,
@@ -30396,7 +30638,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;
@@ -30406,13 +30648,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) => {
@@ -30427,7 +30686,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 });
       }
@@ -30435,18 +30694,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 () => {
@@ -30458,7 +30711,7 @@ async function buildSymbolIndexAsync(parentPath) {
         })
       );
     });
-    if (clearRemaining) await yieldToEventLoop();
+    if (clearRemaining) await yieldForBridgeInteractivePriority();
   }
   const workspaceFiles = /* @__PURE__ */ new Set();
   const walkState = createWalkYieldState();
@@ -30481,10 +30734,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;
@@ -30542,122 +30802,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, "/");
@@ -30667,7 +30990,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);
@@ -30677,7 +31000,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 () => {
@@ -30685,6 +31008,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";
@@ -31185,6 +31512,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);
@@ -31208,6 +31537,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,
@@ -31293,6 +31624,7 @@ function createFileIndexFsWatcher(resolved, schedule) {
 // src/files/index/file-index-incremental-symbol-updates.ts
 import fs21 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);
@@ -31316,6 +31648,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 {
@@ -32371,6 +32704,7 @@ function getAgentModelFromAgentConfig(config2) {
 }
 
 // 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);
@@ -32441,6 +32775,9 @@ async function execProbeShutdownAware(file2, args, timeoutMs) {
   }
 }
 
+// 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;
 function createStderrCapture(child) {
@@ -32829,11 +33166,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((resolve37) => {
-    pending2.set(requestId, { resolve: resolve37, params: paramsRecord });
+    pending.set(requestId, { resolve: resolve37, params: paramsRecord });
     if (onRequest == null) {
-      pending2.delete(requestId);
+      pending.delete(requestId);
       resolve37({ outcome: { outcome: "denied" } });
       return;
     }
@@ -32849,9 +33186,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" } });
   }
 }
@@ -33523,6 +33860,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) {
@@ -33554,8 +33892,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);
     }
@@ -33734,8 +34072,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);
 }
@@ -33872,25 +34210,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 };
@@ -35410,8 +35748,8 @@ async function execGitFile(args, options) {
 }
 
 // src/git/changes/parse/normalize-git-diff-path.ts
-function normalizeGitDiffPath(path81) {
-  return path81.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
+function normalizeGitDiffPath(path84) {
+  return path84.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
 }
 
 // src/git/changes/parse/parse-name-status-entries.ts
@@ -36856,8 +37194,10 @@ async function createBridgeAccessState(options = {}) {
 
 // src/agents/capabilities/warmup-agent-capabilities-on-connect.ts
 import * as path36 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,
@@ -36886,6 +37226,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 as createHash2 } from "node:crypto";
 function hashJsonUtf8Sha256(value) {
@@ -37062,6 +37405,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() {
@@ -37203,6 +37549,7 @@ async function createBridgeAccessAndAcp(options) {
 }
 
 // src/connection/create-bridge-preview-stack.ts
+init_cwd();
 import * as path39 from "node:path";
 
 // src/preview-environments/manager/firehose-messages.ts
@@ -38727,11 +39074,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;
@@ -39093,7 +39440,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) {
@@ -39284,9 +39635,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);
@@ -39418,6 +39769,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();
@@ -39458,6 +39810,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);
@@ -39495,8 +39850,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path81) {
-  return path81 instanceof String && cache.has(path81);
+function isPathSpec(path84) {
+  return path84 instanceof String && cache.has(path84);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -39585,8 +39940,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path81) {
-  return (0, import_file_exists.exists)(path81, import_file_exists.FOLDER);
+function folderExists(path84) {
+  return (0, import_file_exists.exists)(path84, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -39990,8 +40345,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path81) {
-      return /^\.(git)?$/.test(path81.trim());
+    parser(path84) {
+      return /^\.(git)?$/.test(path84.trim());
     }
   };
 }
@@ -40425,11 +40780,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path81, line, preview] = input.split(NULL);
-    paths.add(path81);
-    (results[path81] = results[path81] || []).push({
+    const [path84, line, preview] = input.split(NULL);
+    paths.add(path84);
+    (results[path84] = results[path84] || []).push({
       line: asNumber(line),
-      path: path81,
+      path: path84,
       preview
     });
   });
@@ -41194,14 +41549,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path81, text) {
+function parseInit(bare, path84, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path81, false, result[1]);
+    return new InitSummary(bare, path84, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path81, true, result[1]);
+    return new InitSummary(bare, path84, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -41212,7 +41567,7 @@ function parseInit(bare, path81, text) {
       break;
     }
   }
-  return new InitSummary(bare, path81, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path84, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -41221,9 +41576,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path81, existing, gitDir) {
+      constructor(bare, path84, existing, gitDir) {
         this.bare = bare;
-        this.path = path81;
+        this.path = path84;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -41235,7 +41590,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path81, customArgs) {
+function initTask(bare = false, path84, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -41244,7 +41599,7 @@ function initTask(bare = false, path81, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path81, text);
+      return parseInit(commands.includes("--bare"), path84, text);
     }
   };
 }
@@ -42060,12 +42415,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path81, index, working_dir) {
-        this.path = path81;
+      constructor(path84, index, working_dir) {
+        this.path = path84;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path81) || [null, path81, path81];
+          const detail = fromPathRegex.exec(path84) || [null, path84, path84];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -42096,14 +42451,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path81) {
+  function data(index, workingDir, path84) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path81);
+      handler(result, path84);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path81, index, workingDir));
+      result.files.push(new FileStatusSummary(path84, index, workingDir));
     }
   }
 }
@@ -42412,9 +42767,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path81, write) {
+      hashObject(path84, write) {
         return this._runTask(
-          hashObjectTask(path81, write === true),
+          hashObjectTask(path84, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -42767,8 +43122,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path81 = input.trim().replace(/^["']|["']$/g, "");
-  return path81 && normalize3(path81);
+  const path84 = input.trim().replace(/^["']|["']$/g, "");
+  return path84 && normalize3(path84);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -43082,8 +43437,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path81) {
-  return subModuleTask(["add", repo, path81]);
+function addSubModuleTask(repo, path84) {
+  return subModuleTask(["add", repo, path84]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -43416,8 +43771,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path81, then) {
-      return this._runTask(addSubModuleTask2(repo, path81), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path84, then) {
+      return this._runTask(addSubModuleTask2(repo, path84), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -44153,8 +44508,8 @@ function parseNumstatEntries(lines) {
 }
 function parseNumstat(lines) {
   const m = /* @__PURE__ */ new Map();
-  for (const [path81, entry] of parseNumstatEntries(lines)) {
-    m.set(path81, { additions: entry.additions, deletions: entry.deletions });
+  for (const [path84, entry] of parseNumstatEntries(lines)) {
+    m.set(path84, { additions: entry.additions, deletions: entry.deletions });
   }
   return m;
 }
@@ -44352,6 +44707,7 @@ async function pushAheadOfUpstreamForPaths(paths) {
 }
 
 // src/worktrees/manager/resolve-commit-targets.ts
+init_cwd();
 function bridgeRootBinding(bridgeRoot) {
   return {
     sessionParentPath: bridgeRoot,
@@ -44437,6 +44793,7 @@ function formatRemoteDisplayLabel(remoteUrl) {
 }
 
 // src/git/changes/repo/get-working-tree-change-repo-details.ts
+init_cwd();
 import * as path52 from "node:path";
 
 // src/git/changes/repo/build-working-tree-change-repo-detail.ts
@@ -44686,6 +45043,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 () => {
@@ -45449,6 +45807,7 @@ function parseWorkingTreeChangeKind(value) {
 }
 
 // src/worktrees/manager/git/get-session-working-tree-change-file-patch.ts
+init_cwd();
 import * as path54 from "node:path";
 async function getSessionWorkingTreeChangeFilePatch(cache2, sessionId, discover, opts) {
   const targets = await resolveCommitTargetsAsync(sessionId, cache2, discover);
@@ -45499,6 +45858,8 @@ import * as fs36 from "node:fs";
 import * as fs35 from "node:fs";
 
 // src/worktrees/is-removable-session-worktree-checkout-path.ts
+init_cwd();
+init_normalize_resolved_path();
 import path55 from "node:path";
 function isBridgeRootCheckoutPath(checkoutPath) {
   return normalizeResolvedPath(checkoutPath) === normalizeResolvedPath(getBridgeRoot());
@@ -45599,9 +45960,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 fs40 from "node:fs";
 import * as path61 from "node:path";
+init_yield_to_event_loop();
 
 // src/worktrees/discovery/collect-worktree-paths.ts
 import * as fs38 from "node:fs";
@@ -45635,6 +46000,7 @@ function shouldSkipDiskWalkEntry(name) {
 // src/worktrees/discovery/disk-walk-utils.ts
 import * as fs37 from "node:fs";
 import * as path57 from "node:path";
+init_yield_to_event_loop();
 async function yieldDuringDiskWalk(state) {
   state.entries++;
   if (state.entries % DISK_WALK_YIELD_EVERY !== 0) return true;
@@ -45824,6 +46190,7 @@ import * as path63 from "node:path";
 
 // src/worktrees/discovery/discover-legacy-binding-ascending-from-checkout.ts
 import * as path62 from "node:path";
+init_yield_to_event_loop();
 async function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
   const sid = sessionId.trim();
   if (!sid) return null;
@@ -45941,11 +46308,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 fs43 from "node:fs";
 import * as path65 from "node:path";
 
 // src/git/discover-repos.ts
+init_cwd();
+init_yield_to_event_loop();
 import * as fs42 from "node:fs";
 import * as path64 from "node:path";
 var GIT_DISCOVER_YIELD_EVERY = 32;
@@ -46173,6 +46545,7 @@ async function resolveExistingSessionParentPath(sessionId, cache2, discover) {
 
 // src/worktrees/manager/resolve-explicit-session-parent-path.ts
 import * as path66 from "node:path";
+init_yield_to_event_loop();
 async function resolveExplicitSessionParentPath(params) {
   const resolved = path66.resolve(params.parentPathRaw);
   if (parseSessionParent(params.sessionParent) !== "worktrees_root") {
@@ -46338,7 +46711,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 fs44 from "node:fs";
 import * as path67 from "node:path";
 async function discoverPreviewWorktreeOnDisk(options) {
@@ -46389,6 +46767,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();
@@ -46501,6 +46880,7 @@ var PreviewWorktreeManager = class {
 };
 
 // src/worktrees/deploy/deploy-session-to-preview-environment.ts
+init_cwd();
 import * as path71 from "node:path";
 
 // src/git/worktrees/reset-worktree-to-branch.ts
@@ -47198,6 +47578,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;
@@ -47387,6 +47768,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);
@@ -47594,6 +47976,7 @@ var handleSessionRequestResponseMessage = (msg, deps) => {
 };
 
 // src/skills/preview.ts
+init_cwd();
 import { spawn as spawn10 } from "node:child_process";
 var PREVIEW_API_BASE_PATH = "/__preview";
 var PREVIEW_SECRET_HEADER = "X-Preview-Secret";
@@ -47614,8 +47997,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path81, body) {
-  const url2 = `http://127.0.0.1:${port}${path81}`;
+async function requestPreviewApi(port, secret, method, path84, body) {
+  const url2 = `http://127.0.0.1:${port}${path84}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -47627,7 +48010,7 @@ async function requestPreviewApi(port, secret, method, path81, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path81}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path84}: ${res.status}`);
   }
   return data;
 }
@@ -47792,6 +48175,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) {
@@ -47802,301 +48187,18 @@ async function resolveFileBrowserSessionParent(sessionWorktreeManager, sessionId
   return getBridgeRoot();
 }
 
-// src/files/list-dir/index.ts
-import fs49 from "node:fs";
-
-// src/files/ensure-under-cwd.ts
-import path74 from "node:path";
-function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
-  const normalized = path74.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path74.resolve(cwd, normalized);
-  if (!resolved.startsWith(cwd + path74.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 path75 from "node:path";
-import fs48 from "node:fs";
-async function mapDirEntry(d, relativePath, resolved) {
-  const entryPath = path75.join(relativePath || ".", d.name).replace(/\\/g, "/");
-  const fullPath = path75.join(resolved, d.name);
-  let isDir = d.isDirectory();
-  if (d.isSymbolicLink()) {
-    try {
-      const targetStat = await fs48.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 fs49.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 path76 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 = path76.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((resolve37) => setTimeout(resolve37, 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 path77 from "node:path";
+init_cwd();
+import * as path76 from "node:path";
 function resolveRepoAbsPathFromBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path77.resolve(bridgeRoot);
+  const bridgeResolved = path76.resolve(bridgeRoot);
   const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
-  const repoPath = rel === "" ? bridgeResolved : path77.join(bridgeResolved, rel);
-  const resolved = path77.resolve(repoPath);
-  if (!resolved.startsWith(bridgeResolved + path77.sep) && resolved !== bridgeResolved) {
+  const repoPath = rel === "" ? bridgeResolved : path76.join(bridgeResolved, rel);
+  const resolved = path76.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path76.sep) && resolved !== bridgeResolved) {
     return null;
   }
   return resolved;
@@ -48114,6 +48216,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;
@@ -48176,6 +48281,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;
@@ -48212,6 +48320,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();
@@ -48231,6 +48340,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;
@@ -48479,6 +48589,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 path78 from "node:path";
+
+// src/files/read-file/resolve-file-cache.ts
+import fs50 from "node:fs";
+import path77 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 `${path77.resolve(sessionParentPath)}\0${dir}`;
+}
+function pathStaysUnderParent(filePath, sessionParentPath) {
+  const parent = path77.resolve(sessionParentPath);
+  const resolved = path77.resolve(filePath);
+  return resolved === parent || resolved.startsWith(`${parent}${path77.sep}`);
+}
+async function statMatchesCache(entry) {
+  try {
+    const stat3 = await fs50.promises.stat(entry.path);
+    return stat3.isFile() && stat3.mtimeMs === entry.mtimeMs && stat3.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 fs51 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 fs51.promises.lstat(resolved);
+    if (lstat.isSymbolicLink()) {
+      real = await fs51.promises.realpath(resolved);
+      if (!pathStaysUnderParent(real, sessionParentPath)) {
+        return { error: "Path is outside working directory" };
+      }
+      const stat3 = await fs51.promises.stat(real);
+      if (!stat3.isFile()) return { error: "Not a file" };
+      size = stat3.size;
+      mtimeMs = stat3.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 = path78.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);
@@ -48487,38 +48736,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 fs50 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 fs50.promises.realpath(resolved);
-  } catch {
-    real = resolved;
+// src/files/browser/handle-file-browser-read.ts
+import path79 from "node:path";
+init_cwd();
+
+// src/files/read-file/index.ts
+init_cwd();
+init_yield_to_event_loop();
+import fs55 from "node:fs";
+
+// src/files/read-file/read-file-range-async.ts
+init_yield_to_event_loop();
+import fs52 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 stat3 = await fs50.promises.stat(real);
-    if (!stat3.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 fs51 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 fs51.promises.stat(filePath)).size;
-  const fd = await fs51.promises.open(filePath, "r");
+async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE, fileSizeIn) {
+  const fileSize = fileSizeIn ?? (await fs52.promises.stat(filePath)).size;
+  const fd = await fs52.promises.open(filePath, "r");
   const bufSize = 64 * 1024;
   const buf = Buffer.alloc(bufSize);
   const decoder = new StringDecoder2("utf8");
@@ -48526,9 +48875,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;
@@ -48545,130 +48893,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);
       }
@@ -48679,12 +48967,48 @@ async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, li
   }
 }
 
+// src/files/read-file/read-small-file-range-async.ts
+import fs53 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 fs53.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 fs52 from "node:fs";
+init_yield_to_event_loop();
+import fs54 from "node:fs";
 var READ_CHUNK_BYTES = 256 * 1024;
 async function readFileBufferFullAsync(filePath) {
-  const stat3 = await fs52.promises.stat(filePath);
-  const fd = await fs52.promises.open(filePath, "r");
+  const stat3 = await fs54.promises.stat(filePath);
+  const fd = await fs54.promises.open(filePath, "r");
   const chunks = [];
   let position = 0;
   let bytesSinceYield = 0;
@@ -48726,12 +49050,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)" };
@@ -48739,7 +49074,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 stat3 = await fs55.promises.stat(resolvedPath);
+        fileSize = stat3.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 };
@@ -48748,6 +49102,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;
@@ -48764,14 +49129,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 });
@@ -48788,6 +49156,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 = path79.dirname(reqPath.replace(/^\/+/, "") || ".");
+    scheduleDirectoryResolveCacheWarmup(sessionParentPath ?? getBridgeRoot(), parentDir === "" ? "." : parentDir);
+  }
 }
 
 // src/files/browser/resolve-git-branch-scope.ts
@@ -48801,22 +49173,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 path80 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 = path80.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 }) {
@@ -48837,6 +49254,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((resolve37) => setTimeout(resolve37, 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;
@@ -48859,6 +49505,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 () => {
@@ -48870,6 +49517,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;
@@ -48878,8 +49528,9 @@ function isValidRemoteSkillInstallItem(item) {
 }
 
 // src/skills/install/install-remote-skills-async.ts
-import fs53 from "node:fs";
-import path78 from "node:path";
+init_yield_to_event_loop();
+import fs56 from "node:fs";
+import path81 from "node:path";
 
 // src/skills/install/constants.ts
 var INSTALL_SKILLS_YIELD_EVERY = 16;
@@ -48890,12 +49541,12 @@ async function writeInstallFileAsync(skillDir, f, filesWritten) {
   if (++filesWritten.count % INSTALL_SKILLS_YIELD_EVERY === 0) {
     await yieldToEventLoop();
   }
-  const dest = path78.join(skillDir, f.path);
-  await fs53.promises.mkdir(path78.dirname(dest), { recursive: true });
+  const dest = path81.join(skillDir, f.path);
+  await fs56.promises.mkdir(path81.dirname(dest), { recursive: true });
   if (f.text !== void 0) {
-    await fs53.promises.writeFile(dest, f.text, "utf8");
+    await fs56.promises.writeFile(dest, f.text, "utf8");
   } else if (f.base64) {
-    await fs53.promises.writeFile(dest, Buffer.from(f.base64, "base64"));
+    await fs56.promises.writeFile(dest, Buffer.from(f.base64, "base64"));
   }
 }
 async function installRemoteSkillsAsync(cwd, targetDir, items) {
@@ -48907,7 +49558,7 @@ async function installRemoteSkillsAsync(cwd, targetDir, items) {
   try {
     for (const item of items) {
       if (!isValidRemoteSkillInstallItem(item)) continue;
-      const skillDir = path78.join(cwd, targetDir, item.skillName);
+      const skillDir = path81.join(cwd, targetDir, item.skillName);
       for (const f of item.files) {
         await writeInstallFileAsync(skillDir, f, filesWritten);
       }
@@ -49189,7 +49840,8 @@ var handleSessionDiscardedMessage = (msg, deps) => {
 };
 
 // src/routing/handlers/revert-turn-snapshot.ts
-import * as fs54 from "node:fs";
+init_cwd();
+import * as fs57 from "node:fs";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
@@ -49202,7 +49854,7 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
     const agentBase = sessionWorktreeManager.getSessionWorktreeRootForSession(sessionId) ?? getBridgeRoot();
     const file2 = snapshotFilePath(agentBase, turnId);
     try {
-      await fs54.promises.access(file2, fs54.constants.F_OK);
+      await fs57.promises.access(file2, fs57.constants.F_OK);
     } catch {
       sendWsMessage(s, {
         type: "revert_turn_snapshot_result",
@@ -49287,7 +49939,9 @@ var handleDeploySessionToPreviewMessage = (msg, deps) => {
 };
 
 // src/git/bridge-git-context.ts
-import * as path79 from "node:path";
+init_cwd();
+init_yield_to_event_loop();
+import * as path82 from "node:path";
 
 // src/git/branches/get-current-branch.ts
 async function getCurrentBranch(repoPath) {
@@ -49337,12 +49991,12 @@ async function listRepoBranchRefs(repoPath) {
 // src/git/bridge-git-context.ts
 function folderNameForRelPath(relPath, bridgeRoot) {
   if (relPath === "." || relPath === "") {
-    return path79.basename(path79.resolve(bridgeRoot)) || "repo";
+    return path82.basename(path82.resolve(bridgeRoot)) || "repo";
   }
-  return path79.basename(relPath) || relPath;
+  return path82.basename(relPath) || relPath;
 }
 async function discoverGitReposForBridgeContext(bridgeRoot) {
-  const root = path79.resolve(bridgeRoot);
+  const root = path82.resolve(bridgeRoot);
   if (await isGitRepoDirectory(root)) {
     const remoteUrl = await getRemoteOriginUrl(root);
     return [{ absolutePath: root, remoteUrl }];
@@ -49350,19 +50004,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(path79.resolve(repo.absolutePath), repo);
+    byPath.set(path82.resolve(repo.absolutePath), repo);
   }
   return [...byPath.values()];
 }
 async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path79.resolve(bridgeRoot);
+  const bridgeResolved = path82.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 = path79.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path79.isAbsolute(rel)) continue;
+    let rel = path82.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path82.isAbsolute(rel)) continue;
     const relPath = rel === "" ? "." : rel.replace(/\\/g, "/");
     const currentBranch = await getCurrentBranch(repo.absolutePath);
     const remoteUrl = repo.remoteUrl.trim() || null;
@@ -49377,11 +50031,11 @@ async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
   return rows;
 }
 async function listRepoBranchesForBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path79.resolve(bridgeRoot);
+  const bridgeResolved = path82.resolve(bridgeRoot);
   const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
-  const repoPath = rel === "" ? bridgeResolved : path79.join(bridgeResolved, rel);
-  const resolved = path79.resolve(repoPath);
-  if (!resolved.startsWith(bridgeResolved + path79.sep) && resolved !== bridgeResolved) {
+  const repoPath = rel === "" ? bridgeResolved : path82.join(bridgeResolved, rel);
+  const resolved = path82.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path82.sep) && resolved !== bridgeResolved) {
     return [];
   }
   return listRepoBranchRefs(resolved);
@@ -50057,9 +50711,9 @@ async function runCliAction(program2, opts) {
   const firehoseServerUrl = opts.firehoseUrl ?? opts.proxyUrl ?? process.env.BUILDAUTOMATON_FIREHOSE_URL ?? process.env.BUILDAUTOMATON_PROXY_URL ?? DEFAULT_FIREHOSE_URL;
   const bridgeRootOpt = (opts.bridgeRoot && typeof opts.bridgeRoot === "string" && opts.bridgeRoot.trim() ? opts.bridgeRoot.trim() : null) ?? (opts.cwd && typeof opts.cwd === "string" && opts.cwd.trim() ? opts.cwd.trim() : null);
   if (bridgeRootOpt) {
-    const resolvedBridgeRoot = path80.resolve(process.cwd(), bridgeRootOpt);
+    const resolvedBridgeRoot = path83.resolve(process.cwd(), bridgeRootOpt);
     try {
-      const st = fs55.statSync(resolvedBridgeRoot);
+      const st = fs58.statSync(resolvedBridgeRoot);
       if (!st.isDirectory()) {
         console.error(`Bridge root is not a directory: ${resolvedBridgeRoot}`);
         process.exit(1);
@@ -50079,7 +50733,7 @@ async function runCliAction(program2, opts) {
   );
   let worktreesRootPath;
   if (opts.worktreesRoot && opts.worktreesRoot.trim()) {
-    worktreesRootPath = path80.resolve(opts.worktreesRoot.trim());
+    worktreesRootPath = path83.resolve(opts.worktreesRoot.trim());
   }
   const e2eCertificates = opts.e2eeCertificatesDir?.trim() ? await loadOrCreateE2eCertificates(opts.e2eeCertificatesDir.trim()) : void 0;
   if (e2eCertificates) {