@buildautomaton/cli 0.1.51 → 0.1.52

package/dist/index.js

@@ -4175,8 +4175,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path60, errorMaps, issueData } = params;
-      const fullPath = [...path60, ...issueData.path || []];
+      const { data, path: path61, errorMaps, issueData } = params;
+      const fullPath = [...path61, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -4484,11 +4484,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path60, key) {
+      constructor(parent, value, path61, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path60;
+        this._path = path61;
         this._key = key;
       }
       get path() {
@@ -8103,10 +8103,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path60) {
-  if (!path60)
+function getElementAtPath(obj, path61) {
+  if (!path61)
     return obj;
-  return path60.reduce((acc, key) => acc?.[key], obj);
+  return path61.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -8355,11 +8355,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path60, issues) {
+function prefixIssues(path61, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path60);
+    iss.path.unshift(path61);
     return iss;
   });
 }
@@ -8548,7 +8548,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path60 = []) => {
+  const processError = (error41, path61 = []) => {
     var _a2, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -8558,7 +8558,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path60, ...issue2.path];
+        const fullpath = [...path61, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -8588,9 +8588,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path60) {
+function toDotPath(path61) {
   const segs = [];
-  for (const seg of path60) {
+  for (const seg of path61) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -21053,8 +21053,8 @@ var init_acp = __esm({
         this.#requestHandler = requestHandler;
         this.#notificationHandler = notificationHandler;
         this.#stream = stream;
-        this.#closedPromise = new Promise((resolve32) => {
-          this.#abortController.signal.addEventListener("abort", () => resolve32());
+        this.#closedPromise = new Promise((resolve33) => {
+          this.#abortController.signal.addEventListener("abort", () => resolve33());
         });
         this.#receive();
       }
@@ -21203,8 +21203,8 @@ var init_acp = __esm({
       }
       async sendRequest(method, params) {
         const id = this.#nextRequestId++;
-        const responsePromise = new Promise((resolve32, reject) => {
-          this.#pendingResponses.set(id, { resolve: resolve32, reject });
+        const responsePromise = new Promise((resolve33, reject) => {
+          this.#pendingResponses.set(id, { resolve: resolve33, reject });
         });
         await this.#sendMessage({ jsonrpc: "2.0", id, method, params });
         return responsePromise;
@@ -22073,10 +22073,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(path60, isFile, isDirectory) {
-      log2(`checking %s`, path60);
+    function check2(path61, isFile, isDirectory) {
+      log2(`checking %s`, path61);
       try {
-        const stat2 = fs_1.statSync(path60);
+        const stat2 = fs_1.statSync(path61);
         if (stat2.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -22096,8 +22096,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path60, type = exports.READABLE) {
-      return check2(path60, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path61, type = exports.READABLE) {
+      return check2(path61, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -22446,10 +22446,10 @@ async function killChildProcessTreeGracefully(child, graceMs = ACP_PROCESS_TREE_
   }
   await killProcessTree(pid, "SIGTERM");
   if (graceMs <= 0) return;
-  const exited = new Promise((resolve32) => {
-    child.once("exit", () => resolve32());
+  const exited = new Promise((resolve33) => {
+    child.once("exit", () => resolve33());
   });
-  await Promise.race([exited, new Promise((resolve32) => setTimeout(resolve32, graceMs))]);
+  await Promise.race([exited, new Promise((resolve33) => setTimeout(resolve33, graceMs))]);
   if (child.exitCode == null && child.signalCode == null) {
     await killProcessTree(pid, "SIGKILL");
   }
@@ -22466,8 +22466,8 @@ async function gracefulAcpSubprocessDisconnect(params) {
       await transport.closeSession?.(sessionId);
     } catch {
     }
-    await new Promise((resolve32) => {
-      const timer = setTimeout(resolve32, ACP_GRACEFUL_SESSION_CLOSE_WAIT_MS);
+    await new Promise((resolve33) => {
+      const timer = setTimeout(resolve33, ACP_GRACEFUL_SESSION_CLOSE_WAIT_MS);
       timer.unref?.();
     });
   }
@@ -23172,9 +23172,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 path60 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
-    if (!path60) continue;
-    rows.push({ path: path60, summary: clampSummaryToAtMostTwoLines(summary) });
+    const path61 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
+    if (!path61) continue;
+    rows.push({ path: path61, summary: clampSummaryToAtMostTwoLines(summary) });
   }
   return rows;
 }
@@ -23628,11 +23628,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((resolve32) => {
-    pending.set(requestId, { resolve: resolve32, params: paramsRecord });
+  return new Promise((resolve33) => {
+    pending.set(requestId, { resolve: resolve33, params: paramsRecord });
     if (onRequest == null) {
       pending.delete(requestId);
-      resolve32({ outcome: { outcome: "denied" } });
+      resolve33({ outcome: { outcome: "denied" } });
       return;
     }
     try {
@@ -24176,10 +24176,10 @@ function createSdkStdioInitSettle(child) {
       forceAcpSubprocessDisconnect(child);
       reject(err);
     },
-    settleResolve(resolve32, handle) {
+    settleResolve(resolve33, handle) {
       if (initSettled) return;
       initSettled = true;
-      resolve32(handle);
+      resolve33(handle);
     }
   };
 }
@@ -24248,7 +24248,7 @@ async function createSdkStdioAcpClient(options) {
     onFileChange,
     stderrCapture
   });
-  return new Promise((resolve32, reject) => {
+  return new Promise((resolve33, reject) => {
     const init = createSdkStdioInitSettle(child);
     child.on("error", (err) => {
       init.settleReject(reject, new Error(formatSpawnError(err, command[0])));
@@ -24273,7 +24273,7 @@ async function createSdkStdioAcpClient(options) {
           protocolVersion: PROTOCOL_VERSION2
         });
         init.settleResolve(
-          resolve32,
+          resolve33,
           createSdkStdioHandle({
             child,
             sessionId: established.sessionId,
@@ -24381,7 +24381,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((resolve32) => {
+    const once = await new Promise((resolve33) => {
       const req = mod.request(opts, (res) => {
         const chunks = [];
         res.on("data", (c) => chunks.push(c));
@@ -24392,7 +24392,7 @@ async function proxyToLocal(request) {
             if (typeof v === "string") headers[k] = v;
             else if (Array.isArray(v) && v[0]) headers[k] = v[0];
           }
-          resolve32({
+          resolve33({
             id: request.id,
             statusCode: res.statusCode ?? 0,
             headers,
@@ -24401,7 +24401,7 @@ async function proxyToLocal(request) {
         });
       });
       req.on("error", (err) => {
-        resolve32({
+        resolve33({
           id: request.id,
           statusCode: 0,
           headers: {},
@@ -24483,8 +24483,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path60, body) {
-  const url2 = `http://127.0.0.1:${port}${path60}`;
+async function requestPreviewApi(port, secret, method, path61, body) {
+  const url2 = `http://127.0.0.1:${port}${path61}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -24496,7 +24496,7 @@ async function requestPreviewApi(port, secret, method, path60, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path60}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path61}: ${res.status}`);
   }
   return data;
 }
@@ -24711,7 +24711,7 @@ function installBridgeProcessResilience() {
 }
 
 // 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/connection/heartbeat/constants.ts
 var BRIDGE_APP_HEARTBEAT_INTERVAL_MS = 1e4;
@@ -25152,14 +25152,14 @@ var baseOpen = async (options) => {
   }
   const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve32, reject) => {
+    return new Promise((resolve33, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode > 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve32(subprocess);
+        resolve33(subprocess);
       });
     });
   }
@@ -25703,8 +25703,8 @@ function runPendingAuth(options) {
   let hasOpenedBrowser = false;
   let resolved = false;
   let resolveAuth;
-  const authPromise = new Promise((resolve32) => {
-    resolveAuth = resolve32;
+  const authPromise = new Promise((resolve33) => {
+    resolveAuth = resolve33;
   });
   let reconnectAttempt = 0;
   const signInQuiet = createEmptyReconnectQuietSlot();
@@ -25855,7 +25855,7 @@ import sqliteWasm from "node-sqlite3-wasm";
 
 // src/runtime/yield-to-event-loop.ts
 function yieldToEventLoop() {
-  return new Promise((resolve32) => setImmediate(resolve32));
+  return new Promise((resolve33) => setImmediate(resolve33));
 }
 
 // src/sqlite/cli-sqlite-paths.ts
@@ -27019,7 +27019,7 @@ async function createCursorAcpClient(options) {
     onFileChange,
     stderrCapture
   });
-  return new Promise((resolve32, reject) => {
+  return new Promise((resolve33, reject) => {
     child.on("error", (err) => {
       killChildProcessTree(child, "SIGKILL");
       reject(new Error(formatSpawnError(err, command[0])));
@@ -27031,7 +27031,7 @@ async function createCursorAcpClient(options) {
           sessionCtx,
           incomingDeps: { dbgFs, sessionCtx, onSessionUpdate, onRequest }
         });
-        resolve32(
+        resolve33(
           createCursorAcpHandle({
             child,
             sessionId: established.sessionId,
@@ -28237,8 +28237,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path60) {
-  return path60 instanceof String && cache.has(path60);
+function isPathSpec(path61) {
+  return path61 instanceof String && cache.has(path61);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -28327,8 +28327,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path60) {
-  return (0, import_file_exists.exists)(path60, import_file_exists.FOLDER);
+function folderExists(path61) {
+  return (0, import_file_exists.exists)(path61, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -28732,8 +28732,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path60) {
-      return /^\.(git)?$/.test(path60.trim());
+    parser(path61) {
+      return /^\.(git)?$/.test(path61.trim());
     }
   };
 }
@@ -29167,11 +29167,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path60, line, preview] = input.split(NULL);
-    paths.add(path60);
-    (results[path60] = results[path60] || []).push({
+    const [path61, line, preview] = input.split(NULL);
+    paths.add(path61);
+    (results[path61] = results[path61] || []).push({
       line: asNumber(line),
-      path: path60,
+      path: path61,
       preview
     });
   });
@@ -29936,14 +29936,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path60, text) {
+function parseInit(bare, path61, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path60, false, result[1]);
+    return new InitSummary(bare, path61, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path60, true, result[1]);
+    return new InitSummary(bare, path61, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -29954,7 +29954,7 @@ function parseInit(bare, path60, text) {
       break;
     }
   }
-  return new InitSummary(bare, path60, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path61, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -29963,9 +29963,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path60, existing, gitDir) {
+      constructor(bare, path61, existing, gitDir) {
         this.bare = bare;
-        this.path = path60;
+        this.path = path61;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -29977,7 +29977,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path60, customArgs) {
+function initTask(bare = false, path61, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -29986,7 +29986,7 @@ function initTask(bare = false, path60, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path60, text);
+      return parseInit(commands.includes("--bare"), path61, text);
     }
   };
 }
@@ -30802,12 +30802,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path60, index, working_dir) {
-        this.path = path60;
+      constructor(path61, index, working_dir) {
+        this.path = path61;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path60) || [null, path60, path60];
+          const detail = fromPathRegex.exec(path61) || [null, path61, path61];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -30838,14 +30838,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path60) {
+  function data(index, workingDir, path61) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path60);
+      handler(result, path61);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path60, index, workingDir));
+      result.files.push(new FileStatusSummary(path61, index, workingDir));
     }
   }
 }
@@ -31154,9 +31154,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path60, write) {
+      hashObject(path61, write) {
         return this._runTask(
-          hashObjectTask(path60, write === true),
+          hashObjectTask(path61, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -31509,8 +31509,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path60 = input.trim().replace(/^["']|["']$/g, "");
-  return path60 && normalize3(path60);
+  const path61 = input.trim().replace(/^["']|["']$/g, "");
+  return path61 && normalize3(path61);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -31824,8 +31824,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path60) {
-  return subModuleTask(["add", repo, path60]);
+function addSubModuleTask(repo, path61) {
+  return subModuleTask(["add", repo, path61]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -32158,8 +32158,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path60, then) {
-      return this._runTask(addSubModuleTask2(repo, path60), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path61, then) {
+      return this._runTask(addSubModuleTask2(repo, path61), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -32796,8 +32796,8 @@ async function runGitTask(fn) {
 }
 async function yieldToEventLoop2() {
   throwIfGitShutdownRequested();
-  await new Promise((resolve32) => {
-    setImmediate(resolve32);
+  await new Promise((resolve33) => {
+    setImmediate(resolve33);
   });
   throwIfGitShutdownRequested();
 }
@@ -32877,10 +32877,10 @@ async function discoverGitRepos(cwd = getBridgeRoot()) {
     await yieldGitDiscoverWork(i + 1);
     const ent = entries[i];
     if (!ent.isDirectory()) continue;
-    const childPath = path16.join(cwdResolved, ent.name);
-    if (await isGitRepoDirectory(childPath)) {
-      const remoteUrl = await getRemoteOriginUrl(childPath);
-      result.push({ absolutePath: childPath, remoteUrl });
+    const childPath2 = path16.join(cwdResolved, ent.name);
+    if (await isGitRepoDirectory(childPath2)) {
+      const remoteUrl = await getRemoteOriginUrl(childPath2);
+      result.push({ absolutePath: childPath2, remoteUrl });
     }
   }
   return result;
@@ -33132,9 +33132,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: path60, summary }) => {
+  const entries = params.rows.map(({ path: path61, summary }) => {
     const enc = params.e2ee.encryptFields({ summary }, ["summary"]);
-    return { path: path60, summary: JSON.stringify(enc) };
+    return { path: path61, summary: JSON.stringify(enc) };
   });
   const res = await fetch(
     `${base}/internal/sessions/${encodeURIComponent(params.sessionId)}/follow-ups/summarize-changes`,
@@ -34074,8 +34074,8 @@ async function commitSessionWorktree(cache2, params) {
 }
 
 // src/git/changes/parse/normalize-git-diff-path.ts
-function normalizeGitDiffPath(path60) {
-  return path60.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
+function normalizeGitDiffPath(path61) {
+  return path61.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
 }
 
 // src/git/changes/parse/expand-git-rename-numstat-path.ts
@@ -34175,8 +34175,8 @@ function parseNumstatEntries(lines) {
 }
 function parseNumstat(lines) {
   const m = /* @__PURE__ */ new Map();
-  for (const [path60, entry] of parseNumstatEntries(lines)) {
-    m.set(path60, { additions: entry.additions, deletions: entry.deletions });
+  for (const [path61, entry] of parseNumstatEntries(lines)) {
+    m.set(path61, { additions: entry.additions, deletions: entry.deletions });
   }
   return m;
 }
@@ -36402,7 +36402,7 @@ function startFileIndexWatcher(cwd = getBridgeRoot()) {
 }
 
 // src/connection/create-bridge-connection.ts
-import * as path59 from "node:path";
+import * as path60 from "node:path";
 
 // src/dev-servers/manager/dev-server-manager.ts
 import { rm as rm2 } from "node:fs/promises";
@@ -36424,15 +36424,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((resolve32) => {
-    proc.once("exit", () => resolve32());
+  const exited = new Promise((resolve33) => {
+    proc.once("exit", () => resolve33());
   });
   log2(`[dev-server] Sending SIGTERM to ${shortId} (pid=${proc.pid ?? "?"}).`);
   try {
     proc.kill("SIGTERM");
   } catch {
   }
-  await Promise.race([exited, new Promise((resolve32) => setTimeout(resolve32, graceMs))]);
+  await Promise.race([exited, new Promise((resolve33) => setTimeout(resolve33, graceMs))]);
 }
 function forceKillChild(proc, log2, shortId, graceMs) {
   log2(
@@ -38302,9 +38302,9 @@ function parseChangeSummarySnapshots(raw) {
   for (const item of raw) {
     if (!item || typeof item !== "object") continue;
     const o = item;
-    const path60 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
-    if (!path60) continue;
-    const row = { path: path60 };
+    const path61 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
+    if (!path61) continue;
+    const row = { path: path61 };
     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;
@@ -38517,6 +38517,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 fs39 from "node:fs";
 
@@ -38588,10 +38599,447 @@ async function listDirAsync(relativePath, sessionParentPath = getBridgeRoot()) {
   }
 }
 
+// src/files/handle-file-browser-search.ts
+import path54 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 = path54.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 path55 from "node:path";
+function resolveRepoAbsPathFromBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
+  const bridgeResolved = path55.resolve(bridgeRoot);
+  const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
+  const repoPath = rel === "" ? bridgeResolved : path55.join(bridgeResolved, rel);
+  const resolved = path55.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path55.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 fs40 from "node:fs";
 async function resolveFilePathAsync(relativePath, sessionParentPath = getBridgeRoot()) {
@@ -38614,13 +39062,13 @@ async function resolveFilePathAsync(relativePath, sessionParentPath = getBridgeR
 
 // src/files/read-file/read-file-range-async.ts
 import fs41 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 fs41.promises.stat(filePath)).size;
   const fd = await fs41.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 = "";
@@ -38814,37 +39262,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);
@@ -38878,104 +39295,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 path54 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 = path54.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);
     }
   })();
 }
@@ -38985,12 +39370,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;
@@ -39025,7 +39405,7 @@ function isValidRemoteSkillInstallItem(item) {
 
 // src/skills/install/install-remote-skills-async.ts
 import fs43 from "node:fs";
-import path55 from "node:path";
+import path56 from "node:path";
 
 // src/skills/install/constants.ts
 var INSTALL_SKILLS_YIELD_EVERY = 16;
@@ -39036,8 +39416,8 @@ async function writeInstallFileAsync(skillDir, f, filesWritten) {
   if (++filesWritten.count % INSTALL_SKILLS_YIELD_EVERY === 0) {
     await yieldToEventLoop();
   }
-  const dest = path55.join(skillDir, f.path);
-  await fs43.promises.mkdir(path55.dirname(dest), { recursive: true });
+  const dest = path56.join(skillDir, f.path);
+  await fs43.promises.mkdir(path56.dirname(dest), { recursive: true });
   if (f.text !== void 0) {
     await fs43.promises.writeFile(dest, f.text, "utf8");
   } else if (f.base64) {
@@ -39053,7 +39433,7 @@ async function installRemoteSkillsAsync(cwd, targetDir, items) {
   try {
     for (const item of items) {
       if (!isValidRemoteSkillInstallItem(item)) continue;
-      const skillDir = path55.join(cwd, targetDir, item.skillName);
+      const skillDir = path56.join(cwd, targetDir, item.skillName);
       for (const f of item.files) {
         await writeInstallFileAsync(skillDir, f, filesWritten);
       }
@@ -39392,7 +39772,7 @@ var handleDevServersConfig = (msg, deps) => {
 };
 
 // src/git/bridge-git-context.ts
-import * as path56 from "node:path";
+import * as path57 from "node:path";
 
 // src/git/branches/get-current-branch.ts
 async function getCurrentBranch(repoPath) {
@@ -39442,12 +39822,12 @@ async function listRepoBranchRefs(repoPath) {
 // src/git/bridge-git-context.ts
 function folderNameForRelPath(relPath, bridgeRoot) {
   if (relPath === "." || relPath === "") {
-    return path56.basename(path56.resolve(bridgeRoot)) || "repo";
+    return path57.basename(path57.resolve(bridgeRoot)) || "repo";
   }
-  return path56.basename(relPath) || relPath;
+  return path57.basename(relPath) || relPath;
 }
 async function discoverGitReposForBridgeContext(bridgeRoot) {
-  const root = path56.resolve(bridgeRoot);
+  const root = path57.resolve(bridgeRoot);
   if (await isGitRepoDirectory(root)) {
     const remoteUrl = await getRemoteOriginUrl(root);
     return [{ absolutePath: root, remoteUrl }];
@@ -39455,19 +39835,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(path56.resolve(repo.absolutePath), repo);
+    byPath.set(path57.resolve(repo.absolutePath), repo);
   }
   return [...byPath.values()];
 }
 async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path56.resolve(bridgeRoot);
+  const bridgeResolved = path57.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 = path56.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path56.isAbsolute(rel)) continue;
+    let rel = path57.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path57.isAbsolute(rel)) continue;
     const relPath = rel === "" ? "." : rel.replace(/\\/g, "/");
     const currentBranch = await getCurrentBranch(repo.absolutePath);
     const remoteUrl = repo.remoteUrl.trim() || null;
@@ -39482,11 +39862,11 @@ async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
   return rows;
 }
 async function listRepoBranchesForBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path56.resolve(bridgeRoot);
+  const bridgeResolved = path57.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) {
+  const repoPath = rel === "" ? bridgeResolved : path57.join(bridgeResolved, rel);
+  const resolved = path57.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path57.sep) && resolved !== bridgeResolved) {
     return [];
   }
   return listRepoBranchRefs(resolved);
@@ -40070,10 +40450,10 @@ function listCliAgentCapabilityCacheForWorkspace(db, workspaceId) {
 }
 
 // src/agents/capabilities/warmup-agent-capabilities-on-connect.ts
-import * as path58 from "node:path";
+import * as path59 from "node:path";
 
 // src/agents/capabilities/probe-one-agent-type-for-capabilities.ts
-import * as path57 from "node:path";
+import * as path58 from "node:path";
 async function probeOneAgentTypeForCapabilities(params) {
   const { agentType, cwd, workspaceId, log: log2, reportAgentCapabilities, bridgeReport = true, shouldContinue } = params;
   const canContinue = () => shouldContinue?.() !== false;
@@ -40111,7 +40491,7 @@ async function probeOneAgentTypeForCapabilities(params) {
     if (!canContinue()) return false;
     handle = await resolved.createClient({
       command: resolved.command,
-      cwd: path57.resolve(cwd),
+      cwd: path58.resolve(cwd),
       backendAgentType: agentType,
       sessionMode: "agent",
       persistedAcpSessionId: null,
@@ -40189,7 +40569,7 @@ async function warmupAgentCapabilitiesOnConnect(params) {
   const { workspaceId, log: log2, getWs } = params;
   const isCurrent = beginAgentCapabilityWarmupRun();
   if (!isCurrent()) return;
-  const cwd = path58.resolve(getBridgeRoot());
+  const cwd = path59.resolve(getBridgeRoot());
   async function sendBatchFromCache() {
     if (!isCurrent()) return;
     const socket = getWs();
@@ -40535,18 +40915,18 @@ import * as http from "node:http";
 
 // src/mcp/bridge-access/read-json-body.ts
 function readJsonBody(req) {
-  return new Promise((resolve32, reject) => {
+  return new Promise((resolve33, 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) {
-          resolve32({});
+          resolve33({});
           return;
         }
         const parsed = JSON.parse(raw);
-        resolve32(parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {});
+        resolve33(parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {});
       } catch (e) {
         reject(e);
       }
@@ -40604,7 +40984,7 @@ function createBridgeAccessRequestHandler(registry2) {
 // src/mcp/bridge-access/start-server.ts
 function startBridgeAccessServer(registry2) {
   const server = http.createServer(createBridgeAccessRequestHandler(registry2));
-  return new Promise((resolve32, reject) => {
+  return new Promise((resolve33, reject) => {
     server.once("error", reject);
     server.listen(0, "127.0.0.1", () => {
       const addr = server.address();
@@ -40612,7 +40992,7 @@ function startBridgeAccessServer(registry2) {
         reject(new Error("Bridge access server did not bind"));
         return;
       }
-      resolve32({
+      resolve33({
         port: addr.port,
         close: () => new Promise((closeResolve, closeReject) => {
           server.close((err) => err ? closeReject(err) : closeResolve());
@@ -40752,8 +41132,8 @@ async function createBridgeConnection(options) {
     getCloudAccessToken: () => tokens.accessToken
   };
   const identifyReportedPaths = {
-    bridgeRootPath: path59.resolve(getBridgeRoot()),
-    worktreesRootPath: path59.resolve(worktreesRootPath)
+    bridgeRootPath: path60.resolve(getBridgeRoot()),
+    worktreesRootPath: path60.resolve(worktreesRootPath)
   };
   const { connect } = createMainBridgeWebSocketLifecycle({
     state,