@buildautomaton/cli 0.1.51 → 0.1.52

package/dist/cli.js

@@ -973,7 +973,7 @@ 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 path62 = __require("node:path");
+    var path63 = __require("node:path");
     var fs47 = __require("node:fs");
     var process8 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
@@ -1906,9 +1906,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path62.resolve(baseDir, baseName);
+          const localBin = path63.resolve(baseDir, baseName);
           if (fs47.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path62.extname(baseName))) return void 0;
+          if (sourceExt.includes(path63.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
             (ext) => fs47.existsSync(`${localBin}${ext}`)
           );
@@ -1926,17 +1926,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path62.resolve(
-            path62.dirname(resolvedScriptPath),
+          executableDir = path63.resolve(
+            path63.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path62.basename(
+            const legacyName = path63.basename(
               this._scriptPath,
-              path62.extname(this._scriptPath)
+              path63.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1947,7 +1947,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path62.extname(executableFile));
+        launchWithNode = sourceExt.includes(path63.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 = path62.basename(filename, path62.extname(filename));
+        this._name = path63.basename(filename, path63.extname(filename));
         return this;
       }
       /**
@@ -2801,9 +2801,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path63) {
-        if (path63 === void 0) return this._executableDir;
-        this._executableDir = path63;
+      executableDir(path64) {
+        if (path64 === void 0) return this._executableDir;
+        this._executableDir = path64;
         return this;
       }
       /**
@@ -7061,8 +7061,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path62, errorMaps, issueData } = params;
-      const fullPath = [...path62, ...issueData.path || []];
+      const { data, path: path63, errorMaps, issueData } = params;
+      const fullPath = [...path63, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -7370,11 +7370,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path62, key) {
+      constructor(parent, value, path63, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path62;
+        this._path = path63;
         this._key = key;
       }
       get path() {
@@ -11099,10 +11099,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path62) {
-  if (!path62)
+function getElementAtPath(obj, path63) {
+  if (!path63)
     return obj;
-  return path62.reduce((acc, key) => acc?.[key], obj);
+  return path63.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -11351,11 +11351,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path62, issues) {
+function prefixIssues(path63, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path62);
+    iss.path.unshift(path63);
     return iss;
   });
 }
@@ -11544,7 +11544,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path62 = []) => {
+  const processError = (error41, path63 = []) => {
     var _a2, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -11554,7 +11554,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path62, ...issue2.path];
+        const fullpath = [...path63, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -11584,9 +11584,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path62) {
+function toDotPath(path63) {
   const segs = [];
-  for (const seg of path62) {
+  for (const seg of path63) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -24049,8 +24049,8 @@ var init_acp = __esm({
         this.#requestHandler = requestHandler;
         this.#notificationHandler = notificationHandler;
         this.#stream = stream;
-        this.#closedPromise = new Promise((resolve34) => {
-          this.#abortController.signal.addEventListener("abort", () => resolve34());
+        this.#closedPromise = new Promise((resolve35) => {
+          this.#abortController.signal.addEventListener("abort", () => resolve35());
         });
         this.#receive();
       }
@@ -24199,8 +24199,8 @@ var init_acp = __esm({
       }
       async sendRequest(method, params) {
         const id = this.#nextRequestId++;
-        const responsePromise = new Promise((resolve34, reject) => {
-          this.#pendingResponses.set(id, { resolve: resolve34, reject });
+        const responsePromise = new Promise((resolve35, reject) => {
+          this.#pendingResponses.set(id, { resolve: resolve35, reject });
         });
         await this.#sendMessage({ jsonrpc: "2.0", id, method, params });
         return responsePromise;
@@ -25069,10 +25069,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(path62, isFile, isDirectory) {
-      log2(`checking %s`, path62);
+    function check2(path63, isFile, isDirectory) {
+      log2(`checking %s`, path63);
       try {
-        const stat3 = fs_1.statSync(path62);
+        const stat3 = fs_1.statSync(path63);
         if (stat3.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -25092,8 +25092,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path62, type = exports.READABLE) {
-      return check2(path62, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path63, type = exports.READABLE) {
+      return check2(path63, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -25174,7 +25174,7 @@ var {
 } = import_index.default;
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.51".length > 0 ? "0.1.51" : "0.0.0-dev";
+var CLI_VERSION = "0.1.52".length > 0 ? "0.1.52" : "0.0.0-dev";
 
 // src/cli/defaults.ts
 var DEFAULT_API_URL = process.env.BUILDAUTOMATON_API_URL ?? "https://api.buildautomaton.com";
@@ -25182,7 +25182,7 @@ var DEFAULT_FIREHOSE_URL = "https://buildautomaton-firehose.fly.dev";
 
 // src/cli/run-cli-action.ts
 import * as fs46 from "node:fs";
-import * as path61 from "node:path";
+import * as path62 from "node:path";
 
 // src/cli-log-level.ts
 var verbosity = "info";
@@ -26297,14 +26297,14 @@ var baseOpen = async (options) => {
   }
   const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve34, reject) => {
+    return new Promise((resolve35, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode > 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve34(subprocess);
+        resolve35(subprocess);
       });
     });
   }
@@ -26848,8 +26848,8 @@ function runPendingAuth(options) {
   let hasOpenedBrowser = false;
   let resolved = false;
   let resolveAuth;
-  const authPromise = new Promise((resolve34) => {
-    resolveAuth = resolve34;
+  const authPromise = new Promise((resolve35) => {
+    resolveAuth = resolve35;
   });
   let reconnectAttempt = 0;
   const signInQuiet = createEmptyReconnectQuietSlot();
@@ -27000,7 +27000,7 @@ import sqliteWasm from "node-sqlite3-wasm";
 
 // src/runtime/yield-to-event-loop.ts
 function yieldToEventLoop() {
-  return new Promise((resolve34) => setImmediate(resolve34));
+  return new Promise((resolve35) => setImmediate(resolve35));
 }
 
 // src/sqlite/cli-sqlite-paths.ts
@@ -28117,9 +28117,9 @@ function parseChangeSummaryJson(raw, allowedPaths, options) {
     const rawPath = typeof o.path === "string" ? o.path.trim() : "";
     const summary = typeof o.summary === "string" ? o.summary.trim() : "";
     if (!rawPath || !summary) continue;
-    const path62 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
-    if (!path62) continue;
-    rows.push({ path: path62, summary: clampSummaryToAtMostTwoLines(summary) });
+    const path63 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
+    if (!path63) continue;
+    rows.push({ path: path63, summary: clampSummaryToAtMostTwoLines(summary) });
   }
   return rows;
 }
@@ -28631,10 +28631,10 @@ async function killChildProcessTreeGracefully(child, graceMs = ACP_PROCESS_TREE_
   }
   await killProcessTree(pid, "SIGTERM");
   if (graceMs <= 0) return;
-  const exited = new Promise((resolve34) => {
-    child.once("exit", () => resolve34());
+  const exited = new Promise((resolve35) => {
+    child.once("exit", () => resolve35());
   });
-  await Promise.race([exited, new Promise((resolve34) => setTimeout(resolve34, graceMs))]);
+  await Promise.race([exited, new Promise((resolve35) => setTimeout(resolve35, graceMs))]);
   if (child.exitCode == null && child.signalCode == null) {
     await killProcessTree(pid, "SIGKILL");
   }
@@ -28651,8 +28651,8 @@ async function gracefulAcpSubprocessDisconnect(params) {
       await transport.closeSession?.(sessionId);
     } catch {
     }
-    await new Promise((resolve34) => {
-      const timer = setTimeout(resolve34, ACP_GRACEFUL_SESSION_CLOSE_WAIT_MS);
+    await new Promise((resolve35) => {
+      const timer = setTimeout(resolve35, ACP_GRACEFUL_SESSION_CLOSE_WAIT_MS);
       timer.unref?.();
     });
   }
@@ -28927,11 +28927,11 @@ function createSdkStdioExtNotificationHandler(options) {
 // src/agents/acp/clients/sdk/sdk-stdio-permission-request-handshake.ts
 function awaitSdkStdioPermissionRequestHandshake(params) {
   const { requestId, paramsRecord, pending, onRequest } = params;
-  return new Promise((resolve34) => {
-    pending.set(requestId, { resolve: resolve34, params: paramsRecord });
+  return new Promise((resolve35) => {
+    pending.set(requestId, { resolve: resolve35, params: paramsRecord });
     if (onRequest == null) {
       pending.delete(requestId);
-      resolve34({ outcome: { outcome: "denied" } });
+      resolve35({ outcome: { outcome: "denied" } });
       return;
     }
     try {
@@ -29441,10 +29441,10 @@ function createSdkStdioInitSettle(child) {
       forceAcpSubprocessDisconnect(child);
       reject(err);
     },
-    settleResolve(resolve34, handle) {
+    settleResolve(resolve35, handle) {
       if (initSettled) return;
       initSettled = true;
-      resolve34(handle);
+      resolve35(handle);
     }
   };
 }
@@ -29513,7 +29513,7 @@ async function createSdkStdioAcpClient(options) {
     onFileChange,
     stderrCapture
   });
-  return new Promise((resolve34, reject) => {
+  return new Promise((resolve35, reject) => {
     const init = createSdkStdioInitSettle(child);
     child.on("error", (err) => {
       init.settleReject(reject, new Error(formatSpawnError(err, command[0])));
@@ -29538,7 +29538,7 @@ async function createSdkStdioAcpClient(options) {
           protocolVersion: PROTOCOL_VERSION2
         });
         init.settleResolve(
-          resolve34,
+          resolve35,
           createSdkStdioHandle({
             child,
             sessionId: established.sessionId,
@@ -30071,7 +30071,7 @@ async function createCursorAcpClient(options) {
     onFileChange,
     stderrCapture
   });
-  return new Promise((resolve34, reject) => {
+  return new Promise((resolve35, reject) => {
     child.on("error", (err) => {
       killChildProcessTree(child, "SIGKILL");
       reject(new Error(formatSpawnError(err, command[0])));
@@ -30083,7 +30083,7 @@ async function createCursorAcpClient(options) {
           sessionCtx,
           incomingDeps: { dbgFs, sessionCtx, onSessionUpdate, onRequest }
         });
-        resolve34(
+        resolve35(
           createCursorAcpHandle({
             child,
             sessionId: established.sessionId,
@@ -31289,8 +31289,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path62) {
-  return path62 instanceof String && cache.has(path62);
+function isPathSpec(path63) {
+  return path63 instanceof String && cache.has(path63);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -31379,8 +31379,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path62) {
-  return (0, import_file_exists.exists)(path62, import_file_exists.FOLDER);
+function folderExists(path63) {
+  return (0, import_file_exists.exists)(path63, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -31784,8 +31784,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path62) {
-      return /^\.(git)?$/.test(path62.trim());
+    parser(path63) {
+      return /^\.(git)?$/.test(path63.trim());
     }
   };
 }
@@ -32219,11 +32219,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path62, line, preview] = input.split(NULL);
-    paths.add(path62);
-    (results[path62] = results[path62] || []).push({
+    const [path63, line, preview] = input.split(NULL);
+    paths.add(path63);
+    (results[path63] = results[path63] || []).push({
       line: asNumber(line),
-      path: path62,
+      path: path63,
       preview
     });
   });
@@ -32988,14 +32988,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path62, text) {
+function parseInit(bare, path63, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path62, false, result[1]);
+    return new InitSummary(bare, path63, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path62, true, result[1]);
+    return new InitSummary(bare, path63, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -33006,7 +33006,7 @@ function parseInit(bare, path62, text) {
       break;
     }
   }
-  return new InitSummary(bare, path62, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path63, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -33015,9 +33015,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path62, existing, gitDir) {
+      constructor(bare, path63, existing, gitDir) {
         this.bare = bare;
-        this.path = path62;
+        this.path = path63;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -33029,7 +33029,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path62, customArgs) {
+function initTask(bare = false, path63, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -33038,7 +33038,7 @@ function initTask(bare = false, path62, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path62, text);
+      return parseInit(commands.includes("--bare"), path63, text);
     }
   };
 }
@@ -33854,12 +33854,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path62, index, working_dir) {
-        this.path = path62;
+      constructor(path63, index, working_dir) {
+        this.path = path63;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path62) || [null, path62, path62];
+          const detail = fromPathRegex.exec(path63) || [null, path63, path63];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -33890,14 +33890,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path62) {
+  function data(index, workingDir, path63) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path62);
+      handler(result, path63);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path62, index, workingDir));
+      result.files.push(new FileStatusSummary(path63, index, workingDir));
     }
   }
 }
@@ -34206,9 +34206,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path62, write) {
+      hashObject(path63, write) {
         return this._runTask(
-          hashObjectTask(path62, write === true),
+          hashObjectTask(path63, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -34561,8 +34561,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path62 = input.trim().replace(/^["']|["']$/g, "");
-  return path62 && normalize3(path62);
+  const path63 = input.trim().replace(/^["']|["']$/g, "");
+  return path63 && normalize3(path63);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -34876,8 +34876,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path62) {
-  return subModuleTask(["add", repo, path62]);
+function addSubModuleTask(repo, path63) {
+  return subModuleTask(["add", repo, path63]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -35210,8 +35210,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path62, then) {
-      return this._runTask(addSubModuleTask2(repo, path62), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path63, then) {
+      return this._runTask(addSubModuleTask2(repo, path63), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -35848,8 +35848,8 @@ async function runGitTask(fn) {
 }
 async function yieldToEventLoop2() {
   throwIfGitShutdownRequested();
-  await new Promise((resolve34) => {
-    setImmediate(resolve34);
+  await new Promise((resolve35) => {
+    setImmediate(resolve35);
   });
   throwIfGitShutdownRequested();
 }
@@ -35929,10 +35929,10 @@ async function discoverGitRepos(cwd = getBridgeRoot()) {
     await yieldGitDiscoverWork(i + 1);
     const ent = entries[i];
     if (!ent.isDirectory()) continue;
-    const childPath = path17.join(cwdResolved, ent.name);
-    if (await isGitRepoDirectory(childPath)) {
-      const remoteUrl = await getRemoteOriginUrl(childPath);
-      result.push({ absolutePath: childPath, remoteUrl });
+    const childPath2 = path17.join(cwdResolved, ent.name);
+    if (await isGitRepoDirectory(childPath2)) {
+      const remoteUrl = await getRemoteOriginUrl(childPath2);
+      result.push({ absolutePath: childPath2, remoteUrl });
     }
   }
   return result;
@@ -36184,9 +36184,9 @@ async function collectTurnGitDiffFromPreTurnSnapshot(options) {
 // src/agents/acp/put-summarize-change-summaries.ts
 async function putEncryptedChangeSummaryRows(params) {
   const base = params.apiBaseUrl.replace(/\/+$/, "");
-  const entries = params.rows.map(({ path: path62, summary }) => {
+  const entries = params.rows.map(({ path: path63, summary }) => {
     const enc = params.e2ee.encryptFields({ summary }, ["summary"]);
-    return { path: path62, summary: JSON.stringify(enc) };
+    return { path: path63, summary: JSON.stringify(enc) };
   });
   const res = await fetch(
     `${base}/internal/sessions/${encodeURIComponent(params.sessionId)}/follow-ups/summarize-changes`,
@@ -37034,8 +37034,8 @@ async function commitSessionWorktree(cache2, params) {
 }
 
 // src/git/changes/parse/normalize-git-diff-path.ts
-function normalizeGitDiffPath(path62) {
-  return path62.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
+function normalizeGitDiffPath(path63) {
+  return path63.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
 }
 
 // src/git/changes/parse/expand-git-rename-numstat-path.ts
@@ -37135,8 +37135,8 @@ function parseNumstatEntries(lines) {
 }
 function parseNumstat(lines) {
   const m = /* @__PURE__ */ new Map();
-  for (const [path62, entry] of parseNumstatEntries(lines)) {
-    m.set(path62, { additions: entry.additions, deletions: entry.deletions });
+  for (const [path63, entry] of parseNumstatEntries(lines)) {
+    m.set(path63, { additions: entry.additions, deletions: entry.deletions });
   }
   return m;
 }
@@ -39362,7 +39362,7 @@ function startFileIndexWatcher(cwd = getBridgeRoot()) {
 }
 
 // src/connection/create-bridge-connection.ts
-import * as path60 from "node:path";
+import * as path61 from "node:path";
 
 // src/dev-servers/manager/dev-server-manager.ts
 import { rm as rm2 } from "node:fs/promises";
@@ -39384,15 +39384,15 @@ function sendDevServerStatus(getWs, serverId, status, options) {
 
 // src/dev-servers/process/terminate-child-process.ts
 async function sigtermAndWaitForExit(proc, graceMs, log2, shortId) {
-  const exited = new Promise((resolve34) => {
-    proc.once("exit", () => resolve34());
+  const exited = new Promise((resolve35) => {
+    proc.once("exit", () => resolve35());
   });
   log2(`[dev-server] Sending SIGTERM to ${shortId} (pid=${proc.pid ?? "?"}).`);
   try {
     proc.kill("SIGTERM");
   } catch {
   }
-  await Promise.race([exited, new Promise((resolve34) => setTimeout(resolve34, graceMs))]);
+  await Promise.race([exited, new Promise((resolve35) => setTimeout(resolve35, graceMs))]);
 }
 function forceKillChild(proc, log2, shortId, graceMs) {
   log2(
@@ -40273,7 +40273,7 @@ async function proxyToLocal(request) {
   };
   const maxAttempts = isIdempotentProxyMethod(request.method) ? LOCAL_PREVIEW_FETCH_RETRY_DELAYS_MS.length + 1 : 1;
   for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-    const once = await new Promise((resolve34) => {
+    const once = await new Promise((resolve35) => {
       const req = mod.request(opts, (res) => {
         const chunks = [];
         res.on("data", (c) => chunks.push(c));
@@ -40284,7 +40284,7 @@ async function proxyToLocal(request) {
             if (typeof v === "string") headers[k] = v;
             else if (Array.isArray(v) && v[0]) headers[k] = v[0];
           }
-          resolve34({
+          resolve35({
             id: request.id,
             statusCode: res.statusCode ?? 0,
             headers,
@@ -40293,7 +40293,7 @@ async function proxyToLocal(request) {
         });
       });
       req.on("error", (err) => {
-        resolve34({
+        resolve35({
           id: request.id,
           statusCode: 0,
           headers: {},
@@ -41430,9 +41430,9 @@ function parseChangeSummarySnapshots(raw) {
   for (const item of raw) {
     if (!item || typeof item !== "object") continue;
     const o = item;
-    const path62 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
-    if (!path62) continue;
-    const row = { path: path62 };
+    const path63 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
+    if (!path63) continue;
+    const row = { path: path63 };
     if (typeof o.patchContent === "string") row.patchContent = o.patchContent;
     if (typeof o.oldText === "string") row.oldText = o.oldText;
     if (typeof o.newText === "string") row.newText = o.newText;
@@ -41642,8 +41642,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path62, body) {
-  const url2 = `http://127.0.0.1:${port}${path62}`;
+async function requestPreviewApi(port, secret, method, path63, body) {
+  const url2 = `http://127.0.0.1:${port}${path63}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -41655,7 +41655,7 @@ async function requestPreviewApi(port, secret, method, path62, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path62}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path63}: ${res.status}`);
   }
   return data;
 }
@@ -41819,6 +41819,17 @@ var handleSkillCallMessage = (msg, { getWs, log: log2 }) => {
   );
 };
 
+// src/files/resolve-file-browser-session-parent.ts
+async function resolveFileBrowserSessionParent(sessionWorktreeManager, sessionId) {
+  const sid = sessionId?.trim();
+  if (sid) {
+    await sessionWorktreeManager.ensureRepoCheckoutPathsForSessionAsync(sid);
+    const worktreeRoot = sessionWorktreeManager.getSessionWorktreeRootForSession(sid);
+    if (worktreeRoot) return worktreeRoot;
+  }
+  return getBridgeRoot();
+}
+
 // src/files/list-dir/index.ts
 import fs40 from "node:fs";
 
@@ -41890,10 +41901,447 @@ async function listDirAsync(relativePath, sessionParentPath = getBridgeRoot()) {
   }
 }
 
+// src/files/handle-file-browser-search.ts
+import path55 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 = path55.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/git/tree/resolve-repo-abs-path.ts
+import * as path56 from "node:path";
+function resolveRepoAbsPathFromBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
+  const bridgeResolved = path56.resolve(bridgeRoot);
+  const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
+  const repoPath = rel === "" ? bridgeResolved : path56.join(bridgeResolved, rel);
+  const resolved = path56.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path56.sep) && resolved !== bridgeResolved) {
+    return null;
+  }
+  return resolved;
+}
+
+// src/git/tree/resolve-branch-commit.ts
+async function resolveBranchCommit(repoAbsPath, branch) {
+  const branchRef = branch.trim();
+  if (!branchRef) return null;
+  try {
+    return (await cliSimpleGit(repoAbsPath).revparse([`${branchRef}^{commit}`])).trim();
+  } catch {
+    return null;
+  }
+}
+
+// src/git/tree/list-git-tree-dir.ts
+function parseLsTreeLine(line) {
+  const tab = line.indexOf("	");
+  if (tab < 0) return null;
+  const meta = line.slice(0, tab).trim().split(/\s+/);
+  if (meta.length < 3) return null;
+  const mode = meta[0];
+  const objectType2 = meta[1];
+  let name = line.slice(tab + 1);
+  if (name.startsWith('"') && name.endsWith('"')) {
+    name = name.slice(1, -1).replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  }
+  return { mode, objectType: objectType2, name };
+}
+function childPath(relativePath, name) {
+  const base = relativePath.replace(/^\/+/, "").replace(/\\/g, "/");
+  if (!base || base === ".") return name;
+  return `${base}/${name}`.replace(/\\/g, "/");
+}
+function lsTreeArgs(commit, relativePath) {
+  const rel = relativePath.replace(/^\/+/, "").replace(/\\/g, "/");
+  if (!rel || rel === ".") return ["ls-tree", commit];
+  return ["ls-tree", `${commit}:${rel}`];
+}
+async function listGitTreeDirAsync(repoAbsPath, branch, relativePath) {
+  await yieldToEventLoop();
+  const commit = await resolveBranchCommit(repoAbsPath, branch);
+  if (!commit) return { error: "Branch not found" };
+  try {
+    const raw = await cliSimpleGit(repoAbsPath).raw(lsTreeArgs(commit, relativePath));
+    await yieldToEventLoop();
+    const lines = String(raw ?? "").split(/\r?\n/).filter((line) => line.trim().length > 0);
+    const entries = [];
+    for (let i = 0; i < lines.length; i++) {
+      if (i > 0 && i % LIST_DIR_YIELD_EVERY === 0) {
+        await yieldToEventLoop();
+      }
+      const parsed = parseLsTreeLine(lines[i]);
+      if (!parsed) continue;
+      const { mode, objectType: objectType2, name } = parsed;
+      if (!name || name === "." || name === "..") continue;
+      const isSymlink = mode === "120000";
+      const isDir = objectType2 === "tree";
+      entries.push({
+        name,
+        path: childPath(relativePath, name),
+        isDir,
+        ...isSymlink ? { isSymlink: true } : {}
+      });
+    }
+    if (entries.length >= LIST_DIR_YIELD_EVERY) {
+      await yieldToEventLoop();
+    }
+    return { entries: sortListEntries(entries) };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (/not a tree object|does not exist|bad revision/i.test(message)) {
+      return { error: "Path not found in branch" };
+    }
+    return { error: message };
+  }
+}
+
 // src/files/read-file/types.ts
 var LINE_CHUNK_SIZE = 64 * 1024;
 var READ_RANGE_YIELD_EVERY_BYTES = 256 * 1024;
 
+// src/files/read-file/guess-mime-type.ts
+var MIME_BY_EXT = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  bmp: "image/bmp",
+  ico: "image/x-icon",
+  webp: "image/webp",
+  avif: "image/avif",
+  svg: "image/svg+xml",
+  pdf: "application/pdf",
+  json: "application/json",
+  html: "text/html",
+  htm: "text/html",
+  css: "text/css",
+  js: "text/javascript",
+  mjs: "text/javascript",
+  ts: "text/typescript",
+  txt: "text/plain",
+  md: "text/markdown",
+  xml: "application/xml",
+  zip: "application/zip",
+  gz: "application/gzip",
+  wasm: "application/wasm"
+};
+function guessMimeType(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+  return MIME_BY_EXT[ext] ?? "application/octet-stream";
+}
+
+// src/git/tree/file/git-blob-ref.ts
+async function gitBlobRef(repoAbsPath, branch, relativePath) {
+  const commit = await resolveBranchCommit(repoAbsPath, branch);
+  await yieldToEventLoop();
+  if (!commit) return null;
+  const rel = relativePath.replace(/^\/+/, "").replace(/\\/g, "/");
+  if (!rel || rel === ".") return null;
+  return `${commit}:${rel}`;
+}
+
+// src/git/tree/file/is-binary-buffer.ts
+function isBinaryBuffer(buf) {
+  const sample = buf.subarray(0, Math.min(buf.length, 8192));
+  for (let i = 0; i < sample.length; i++) {
+    if (sample[i] === 0) return true;
+  }
+  return false;
+}
+
+// src/git/tree/file/read-git-blob-text-async.ts
+import { StringDecoder } from "node:string_decoder";
+async function countGitBlobLinesAsync(buf) {
+  if (buf.length === 0) return 1;
+  let lines = 1;
+  let bytesSinceYield = 0;
+  for (let i = 0; i < buf.length; i++) {
+    const b = buf[i];
+    if (b === 10) {
+      lines++;
+    } else if (b === 13) {
+      if (i + 1 < buf.length && buf[i + 1] === 10) {
+        lines++;
+        i++;
+      } else {
+        lines++;
+      }
+    }
+    bytesSinceYield++;
+    if (bytesSinceYield >= READ_RANGE_YIELD_EVERY_BYTES) {
+      await yieldToEventLoop();
+      bytesSinceYield = 0;
+    }
+  }
+  return lines;
+}
+async function readGitBlobLineRangeAsync(buf, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
+  const bufSize = 64 * 1024;
+  const decoder = new StringDecoder("utf8");
+  let currentLine = 0;
+  const resultLines = [];
+  let partial2 = "";
+  let done = false;
+  let skipLine0Chars = typeof lineOffsetIn === "number" ? lineOffsetIn : 0;
+  let line0CharsReturned = 0;
+  let line0Accum = "";
+  let bytesSinceYield = 0;
+  let position = 0;
+  const finish = async () => {
+    const totalLines = await countGitBlobLinesAsync(buf);
+    return { content: resultLines.join("\n"), totalLines };
+  };
+  while (!done && position < buf.length) {
+    const chunkEnd = Math.min(position + bufSize, buf.length);
+    const bytesRead = chunkEnd - position;
+    position = chunkEnd;
+    bytesSinceYield += bytesRead;
+    if (bytesSinceYield >= READ_RANGE_YIELD_EVERY_BYTES) {
+      await yieldToEventLoop();
+      bytesSinceYield = 0;
+    }
+    const text = partial2 + decoder.write(buf.subarray(position - bytesRead, position));
+    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) {
+              const totalLines = await countGitBlobLinesAsync(buf);
+              return {
+                content: resultLines.join("\n"),
+                totalLines,
+                lineOffset: lineOffsetIn + line0CharsReturned
+              };
+            }
+            line0Accum = "";
+            skipLine0Chars = 0;
+            line0CharsReturned = 0;
+          } else if (totalLine0 > lineChunkSize) {
+            resultLines.push(line0Accum.slice(0, lineChunkSize));
+            const totalLines = await countGitBlobLinesAsync(buf);
+            return {
+              content: resultLines.join("\n"),
+              totalLines,
+              lineOffset: lineChunkSize
+            };
+          } else {
+            resultLines.push(line0Accum);
+            line0Accum = "";
+          }
+        } else if (currentLine >= startLine && currentLine <= endLine) {
+          resultLines.push(lineContent);
+        }
+        currentLine++;
+        lineStart = i + 1;
+        if (currentLine > endLine) {
+          done = true;
+          break;
+        }
+      }
+    }
+    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));
+            const totalLines = await countGitBlobLinesAsync(buf);
+            return {
+              content: resultLines.join("\n"),
+              totalLines,
+              lineOffset: (lineOffsetIn ?? 0) + take
+            };
+          }
+        } else if (totalLine0 > lineChunkSize) {
+          resultLines.push(line0Accum.slice(0, lineChunkSize));
+          const totalLines = await countGitBlobLinesAsync(buf);
+          return {
+            content: resultLines.join("\n"),
+            totalLines,
+            lineOffset: lineChunkSize
+          };
+        }
+      }
+      partial2 = text.slice(lineStart);
+    }
+  }
+  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 finish();
+        }
+        const from = skipLine0Chars;
+        const take = Math.min(lineChunkSize, totalLine0 - from);
+        resultLines.push(line0Accum.slice(from, from + take));
+        line0CharsReturned += take;
+        if (from + take < totalLine0) {
+          const totalLines = await countGitBlobLinesAsync(buf);
+          return {
+            content: resultLines.join("\n"),
+            totalLines,
+            lineOffset: (lineOffsetIn ?? 0) + line0CharsReturned
+          };
+        }
+      } else if (totalLine0 > lineChunkSize) {
+        resultLines.push(line0Accum.slice(0, lineChunkSize));
+        const totalLines = await countGitBlobLinesAsync(buf);
+        return {
+          content: resultLines.join("\n"),
+          totalLines,
+          lineOffset: lineChunkSize
+        };
+      } else {
+        resultLines.push(line0Accum);
+      }
+    } else if (tail.length > 0 && currentLine >= startLine && currentLine <= endLine) {
+      resultLines.push(tail.endsWith("\r") ? tail.slice(0, -1) : tail);
+    }
+  }
+  return finish();
+}
+async function decodeGitBlobUtf8Async(buf) {
+  await yieldToEventLoop();
+  const text = buf.toString("utf8");
+  await yieldToEventLoop();
+  return text;
+}
+async function readGitBlobUtf8FullAsync(buf) {
+  const text = await decodeGitBlobUtf8Async(buf);
+  const totalLines = await countGitBlobLinesAsync(buf);
+  return { content: text, totalLines };
+}
+
+// src/git/tree/file/index.ts
+async function readGitTreeFileAsync(repoAbsPath, branch, relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE, encoding = "utf8") {
+  await yieldToEventLoop();
+  const branchRef = branch.trim();
+  if (!branchRef) return { error: "branch required" };
+  const rel = relativePath.replace(/^\/+/, "").replace(/\\/g, "/");
+  if (!rel || rel === ".") return { error: "file path required" };
+  const blobRef = await gitBlobRef(repoAbsPath, branchRef, rel);
+  if (!blobRef) return { error: "Branch not found" };
+  const hasRange = typeof startLine === "number" && typeof endLine === "number";
+  try {
+    if (encoding === "base64") {
+      if (hasRange) return { error: "base64 encoding requires a full file read (no line range)" };
+      const buf2 = await cliSimpleGit(repoAbsPath).showBuffer([blobRef]);
+      await yieldToEventLoop();
+      return {
+        content: buf2.toString("base64"),
+        size: buf2.length,
+        mimeType: guessMimeType(rel)
+      };
+    }
+    const buf = await cliSimpleGit(repoAbsPath).showBuffer([blobRef]);
+    await yieldToEventLoop();
+    const size = buf.length;
+    if (isBinaryBuffer(buf)) {
+      return { error: "Binary file cannot be displayed as text" };
+    }
+    if (hasRange) {
+      const ranged = await readGitBlobLineRangeAsync(buf, startLine, endLine, lineOffset, lineChunkSize);
+      return {
+        content: ranged.content,
+        totalLines: ranged.totalLines,
+        size,
+        ...ranged.lineOffset != null ? { lineOffset: ranged.lineOffset } : {}
+      };
+    }
+    const full = await readGitBlobUtf8FullAsync(buf);
+    return { content: full.content, totalLines: full.totalLines, size, mimeType: guessMimeType(rel) };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (/does not exist|bad revision|exists on disk, but not in/i.test(message)) {
+      return { error: "File not found in branch" };
+    }
+    return { error: message };
+  }
+}
+
+// src/files/browser/send-file-browser-message.ts
+function sendFileBrowserMessage(socket, e2ee, payload) {
+  sendWsMessage(socket, e2ee ? e2ee.encryptFields(payload, ["entries", "content", "totalLines", "size", "lineOffset"]) : payload);
+}
+
+// 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);
+  if ("error" in result) {
+    sendWsMessage(socket, { type: "file_browser_response", id, error: result.error });
+    return;
+  }
+  sendFileBrowserMessage(socket, e2ee, { type: "file_browser_response", id, entries: result.entries });
+  if (!gitScope && (reqPath === "." || reqPath === "")) {
+    triggerFileIndexBuild(sessionParentPath);
+  }
+}
+
 // src/files/read-file/resolve-file-path.ts
 import fs41 from "node:fs";
 async function resolveFilePathAsync(relativePath, sessionParentPath = getBridgeRoot()) {
@@ -41916,13 +42364,13 @@ async function resolveFilePathAsync(relativePath, sessionParentPath = getBridgeR
 
 // src/files/read-file/read-file-range-async.ts
 import fs42 from "node:fs";
-import { StringDecoder } from "node:string_decoder";
+import { StringDecoder as StringDecoder2 } from "node:string_decoder";
 async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
   const fileSize = (await fs42.promises.stat(filePath)).size;
   const fd = await fs42.promises.open(filePath, "r");
   const bufSize = 64 * 1024;
   const buf = Buffer.alloc(bufSize);
-  const decoder = new StringDecoder("utf8");
+  const decoder = new StringDecoder2("utf8");
   let currentLine = 0;
   const resultLines = [];
   let partial2 = "";
@@ -42116,37 +42564,6 @@ async function readFileFullAsync(filePath) {
   return { content: raw, totalLines: lines.length, size };
 }
 
-// src/files/read-file/guess-mime-type.ts
-var MIME_BY_EXT = {
-  png: "image/png",
-  jpg: "image/jpeg",
-  jpeg: "image/jpeg",
-  gif: "image/gif",
-  bmp: "image/bmp",
-  ico: "image/x-icon",
-  webp: "image/webp",
-  avif: "image/avif",
-  svg: "image/svg+xml",
-  pdf: "application/pdf",
-  json: "application/json",
-  html: "text/html",
-  htm: "text/html",
-  css: "text/css",
-  js: "text/javascript",
-  mjs: "text/javascript",
-  ts: "text/typescript",
-  txt: "text/plain",
-  md: "text/markdown",
-  xml: "application/xml",
-  zip: "application/zip",
-  gz: "application/gzip",
-  wasm: "application/wasm"
-};
-function guessMimeType(filePath) {
-  const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
-  return MIME_BY_EXT[ext] ?? "application/octet-stream";
-}
-
 // src/files/read-file/read-file-binary-full-async.ts
 async function readFileBinaryFullAsync(filePath) {
   const { buffer, size } = await readFileBufferFullAsync(filePath);
@@ -42180,104 +42597,72 @@ async function readFileAsync(relativePath, startLine, endLine, lineOffset, lineC
   }
 }
 
-// src/files/resolve-file-browser-session-parent.ts
-async function resolveFileBrowserSessionParent(sessionWorktreeManager, sessionId) {
-  const sid = sessionId?.trim();
-  if (sid) {
-    await sessionWorktreeManager.ensureRepoCheckoutPathsForSessionAsync(sid);
-    const worktreeRoot = sessionWorktreeManager.getSessionWorktreeRootForSession(sid);
-    if (worktreeRoot) return worktreeRoot;
+// 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;
+  const endLine = typeof msg.endLine === "number" ? msg.endLine : void 0;
+  const lineOffset = typeof msg.lineOffset === "number" ? msg.lineOffset : void 0;
+  const lineChunkSize = typeof msg.lineChunkSize === "number" ? msg.lineChunkSize : void 0;
+  const encoding = msg.encoding === "base64" ? "base64" : "utf8";
+  const result = gitScope ? await readGitTreeFileAsync(
+    gitScope.repoAbsPath,
+    gitScope.branch,
+    reqPath,
+    startLine,
+    endLine,
+    lineOffset,
+    lineChunkSize,
+    encoding
+  ) : await readFileAsync(
+    reqPath,
+    startLine,
+    endLine,
+    lineOffset,
+    lineChunkSize,
+    sessionParentPath,
+    encoding
+  );
+  if ("error" in result) {
+    sendWsMessage(socket, { type: "file_browser_response", id: msg.id, error: result.error });
+    return;
   }
-  return getBridgeRoot();
+  const payload = {
+    type: "file_browser_response",
+    id: msg.id,
+    content: result.content,
+    totalLines: result.totalLines,
+    size: result.size
+  };
+  if (result.lineOffset != null) payload.lineOffset = result.lineOffset;
+  if (result.mimeType != null) payload.mimeType = result.mimeType;
+  if (result.resolvedPath != null) payload.resolvedPath = result.resolvedPath;
+  sendFileBrowserMessage(socket, e2ee, payload);
 }
 
-// src/files/handle-file-browser-search.ts
-import path55 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 = path55.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/files/browser/resolve-git-branch-scope.ts
+function resolveGitBranchScope(msg) {
+  const gitBranchScope = msg.source === "git_branch" && typeof msg.repoRelPath === "string" && typeof msg.branch === "string" && msg.branch.trim().length > 0;
+  if (!gitBranchScope) return null;
+  const repoAbsPath = resolveRepoAbsPathFromBridge(msg.repoRelPath);
+  if (!repoAbsPath) return null;
+  return { repoAbsPath, branch: msg.branch.trim() };
 }
 
-// src/files/handle-file-browser-request.ts
-function sendFileBrowserMessage(socket, e2ee, payload) {
-  sendWsMessage(socket, e2ee ? e2ee.encryptFields(payload, ["entries", "content", "totalLines", "size", "lineOffset"]) : payload);
-}
+// src/files/browser/index.ts
 function handleFileBrowserRequest(msg, socket, e2ee, sessionWorktreeManager) {
   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;
+    }
     if (op === "list") {
-      const result = await listDirAsync(reqPath, sessionParentPath);
-      if ("error" in result) {
-        sendWsMessage(socket, { type: "file_browser_response", id: msg.id, error: result.error });
-      } else {
-        sendFileBrowserMessage(socket, e2ee, { type: "file_browser_response", id: msg.id, entries: result.entries });
-        if (reqPath === "." || reqPath === "") {
-          triggerFileIndexBuild(sessionParentPath);
-        }
-      }
+      await handleFileBrowserList(socket, e2ee, msg.id, reqPath, sessionParentPath, gitScope);
     } else {
-      const startLine = typeof msg.startLine === "number" ? msg.startLine : void 0;
-      const endLine = typeof msg.endLine === "number" ? msg.endLine : void 0;
-      const lineOffset = typeof msg.lineOffset === "number" ? msg.lineOffset : void 0;
-      const lineChunkSize = typeof msg.lineChunkSize === "number" ? msg.lineChunkSize : void 0;
-      const encoding = msg.encoding === "base64" ? "base64" : "utf8";
-      const result = await readFileAsync(
-        reqPath,
-        startLine,
-        endLine,
-        lineOffset,
-        lineChunkSize,
-        sessionParentPath,
-        encoding
-      );
-      if ("error" in result) {
-        sendWsMessage(socket, { type: "file_browser_response", id: msg.id, error: result.error });
-      } else {
-        const payload = {
-          type: "file_browser_response",
-          id: msg.id,
-          content: result.content,
-          totalLines: result.totalLines,
-          size: result.size
-        };
-        if (result.lineOffset != null) payload.lineOffset = result.lineOffset;
-        if (result.mimeType != null) payload.mimeType = result.mimeType;
-        if (result.resolvedPath != null) payload.resolvedPath = result.resolvedPath;
-        sendFileBrowserMessage(socket, e2ee, payload);
-      }
+      await handleFileBrowserRead(socket, e2ee, msg, reqPath, sessionParentPath, gitScope);
     }
   })();
 }
@@ -42287,12 +42672,7 @@ function handleFileBrowserRequestMessage(msg, { getWs, e2ee, sessionWorktreeMana
   if (typeof msg.id !== "string" || typeof msg.path !== "string") return;
   const socket = getWs();
   if (!socket) return;
-  handleFileBrowserRequest(
-    msg,
-    socket,
-    e2ee,
-    sessionWorktreeManager
-  );
+  handleFileBrowserRequest(msg, socket, e2ee, sessionWorktreeManager);
 }
 function handleFileBrowserSearchMessage(msg, { getWs, e2ee, sessionWorktreeManager }) {
   if (typeof msg.id !== "string") return;
@@ -42327,7 +42707,7 @@ function isValidRemoteSkillInstallItem(item) {
 
 // src/skills/install/install-remote-skills-async.ts
 import fs44 from "node:fs";
-import path56 from "node:path";
+import path57 from "node:path";
 
 // src/skills/install/constants.ts
 var INSTALL_SKILLS_YIELD_EVERY = 16;
@@ -42338,8 +42718,8 @@ async function writeInstallFileAsync(skillDir, f, filesWritten) {
   if (++filesWritten.count % INSTALL_SKILLS_YIELD_EVERY === 0) {
     await yieldToEventLoop();
   }
-  const dest = path56.join(skillDir, f.path);
-  await fs44.promises.mkdir(path56.dirname(dest), { recursive: true });
+  const dest = path57.join(skillDir, f.path);
+  await fs44.promises.mkdir(path57.dirname(dest), { recursive: true });
   if (f.text !== void 0) {
     await fs44.promises.writeFile(dest, f.text, "utf8");
   } else if (f.base64) {
@@ -42355,7 +42735,7 @@ async function installRemoteSkillsAsync(cwd, targetDir, items) {
   try {
     for (const item of items) {
       if (!isValidRemoteSkillInstallItem(item)) continue;
-      const skillDir = path56.join(cwd, targetDir, item.skillName);
+      const skillDir = path57.join(cwd, targetDir, item.skillName);
       for (const f of item.files) {
         await writeInstallFileAsync(skillDir, f, filesWritten);
       }
@@ -42694,7 +43074,7 @@ var handleDevServersConfig = (msg, deps) => {
 };
 
 // src/git/bridge-git-context.ts
-import * as path57 from "node:path";
+import * as path58 from "node:path";
 
 // src/git/branches/get-current-branch.ts
 async function getCurrentBranch(repoPath) {
@@ -42744,12 +43124,12 @@ async function listRepoBranchRefs(repoPath) {
 // src/git/bridge-git-context.ts
 function folderNameForRelPath(relPath, bridgeRoot) {
   if (relPath === "." || relPath === "") {
-    return path57.basename(path57.resolve(bridgeRoot)) || "repo";
+    return path58.basename(path58.resolve(bridgeRoot)) || "repo";
   }
-  return path57.basename(relPath) || relPath;
+  return path58.basename(relPath) || relPath;
 }
 async function discoverGitReposForBridgeContext(bridgeRoot) {
-  const root = path57.resolve(bridgeRoot);
+  const root = path58.resolve(bridgeRoot);
   if (await isGitRepoDirectory(root)) {
     const remoteUrl = await getRemoteOriginUrl(root);
     return [{ absolutePath: root, remoteUrl }];
@@ -42757,19 +43137,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(path57.resolve(repo.absolutePath), repo);
+    byPath.set(path58.resolve(repo.absolutePath), repo);
   }
   return [...byPath.values()];
 }
 async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path57.resolve(bridgeRoot);
+  const bridgeResolved = path58.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 = path57.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path57.isAbsolute(rel)) continue;
+    let rel = path58.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path58.isAbsolute(rel)) continue;
     const relPath = rel === "" ? "." : rel.replace(/\\/g, "/");
     const currentBranch = await getCurrentBranch(repo.absolutePath);
     const remoteUrl = repo.remoteUrl.trim() || null;
@@ -42784,11 +43164,11 @@ async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
   return rows;
 }
 async function listRepoBranchesForBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path57.resolve(bridgeRoot);
+  const bridgeResolved = path58.resolve(bridgeRoot);
   const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
-  const repoPath = rel === "" ? bridgeResolved : path57.join(bridgeResolved, rel);
-  const resolved = path57.resolve(repoPath);
-  if (!resolved.startsWith(bridgeResolved + path57.sep) && resolved !== bridgeResolved) {
+  const repoPath = rel === "" ? bridgeResolved : path58.join(bridgeResolved, rel);
+  const resolved = path58.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path58.sep) && resolved !== bridgeResolved) {
     return [];
   }
   return listRepoBranchRefs(resolved);
@@ -43293,10 +43673,10 @@ function listCliAgentCapabilityCacheForWorkspace(db, workspaceId) {
 }
 
 // src/agents/capabilities/warmup-agent-capabilities-on-connect.ts
-import * as path59 from "node:path";
+import * as path60 from "node:path";
 
 // src/agents/capabilities/probe-one-agent-type-for-capabilities.ts
-import * as path58 from "node:path";
+import * as path59 from "node:path";
 async function probeOneAgentTypeForCapabilities(params) {
   const { agentType, cwd, workspaceId, log: log2, reportAgentCapabilities, bridgeReport = true, shouldContinue } = params;
   const canContinue = () => shouldContinue?.() !== false;
@@ -43334,7 +43714,7 @@ async function probeOneAgentTypeForCapabilities(params) {
     if (!canContinue()) return false;
     handle = await resolved.createClient({
       command: resolved.command,
-      cwd: path58.resolve(cwd),
+      cwd: path59.resolve(cwd),
       backendAgentType: agentType,
       sessionMode: "agent",
       persistedAcpSessionId: null,
@@ -43412,7 +43792,7 @@ async function warmupAgentCapabilitiesOnConnect(params) {
   const { workspaceId, log: log2, getWs } = params;
   const isCurrent = beginAgentCapabilityWarmupRun();
   if (!isCurrent()) return;
-  const cwd = path59.resolve(getBridgeRoot());
+  const cwd = path60.resolve(getBridgeRoot());
   async function sendBatchFromCache() {
     if (!isCurrent()) return;
     const socket = getWs();
@@ -43758,18 +44138,18 @@ import * as http from "node:http";
 
 // src/mcp/bridge-access/read-json-body.ts
 function readJsonBody(req) {
-  return new Promise((resolve34, reject) => {
+  return new Promise((resolve35, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
     req.on("end", () => {
       try {
         const raw = Buffer.concat(chunks).toString("utf8").trim();
         if (!raw) {
-          resolve34({});
+          resolve35({});
           return;
         }
         const parsed = JSON.parse(raw);
-        resolve34(parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {});
+        resolve35(parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {});
       } catch (e) {
         reject(e);
       }
@@ -43827,7 +44207,7 @@ function createBridgeAccessRequestHandler(registry2) {
 // src/mcp/bridge-access/start-server.ts
 function startBridgeAccessServer(registry2) {
   const server = http.createServer(createBridgeAccessRequestHandler(registry2));
-  return new Promise((resolve34, reject) => {
+  return new Promise((resolve35, reject) => {
     server.once("error", reject);
     server.listen(0, "127.0.0.1", () => {
       const addr = server.address();
@@ -43835,7 +44215,7 @@ function startBridgeAccessServer(registry2) {
         reject(new Error("Bridge access server did not bind"));
         return;
       }
-      resolve34({
+      resolve35({
         port: addr.port,
         close: () => new Promise((closeResolve, closeReject) => {
           server.close((err) => err ? closeReject(err) : closeResolve());
@@ -43975,8 +44355,8 @@ async function createBridgeConnection(options) {
     getCloudAccessToken: () => tokens.accessToken
   };
   const identifyReportedPaths = {
-    bridgeRootPath: path60.resolve(getBridgeRoot()),
-    worktreesRootPath: path60.resolve(worktreesRootPath)
+    bridgeRootPath: path61.resolve(getBridgeRoot()),
+    worktreesRootPath: path61.resolve(worktreesRootPath)
   };
   const { connect } = createMainBridgeWebSocketLifecycle({
     state,
@@ -44231,7 +44611,7 @@ 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 = path61.resolve(process.cwd(), bridgeRootOpt);
+    const resolvedBridgeRoot = path62.resolve(process.cwd(), bridgeRootOpt);
     try {
       const st = fs46.statSync(resolvedBridgeRoot);
       if (!st.isDirectory()) {
@@ -44253,7 +44633,7 @@ async function runCliAction(program2, opts) {
   );
   let worktreesRootPath;
   if (opts.worktreesRoot && opts.worktreesRoot.trim()) {
-    worktreesRootPath = path61.resolve(opts.worktreesRoot.trim());
+    worktreesRootPath = path62.resolve(opts.worktreesRoot.trim());
   }
   const e2eCertificates = opts.e2eeCertificatesDir?.trim() ? await loadOrCreateE2eCertificates(opts.e2eeCertificatesDir.trim()) : void 0;
   if (e2eCertificates) {