@buildautomaton/cli 0.1.45 → 0.1.47

package/dist/index.js

@@ -2237,7 +2237,7 @@ var require_websocket = __commonJS({
     "use strict";
     var EventEmitter2 = __require("events");
     var https2 = __require("https");
-    var http = __require("http");
+    var http2 = __require("http");
     var net = __require("net");
     var tls = __require("tls");
     var { randomBytes: randomBytes2, createHash: createHash2 } = __require("crypto");
@@ -2771,7 +2771,7 @@ var require_websocket = __commonJS({
       }
       const defaultPort = isSecure ? 443 : 80;
       const key = randomBytes2(16).toString("base64");
-      const request = isSecure ? https2.request : http.request;
+      const request = isSecure ? https2.request : http2.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
       opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
@@ -3265,7 +3265,7 @@ var require_websocket_server = __commonJS({
   "../../node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket-server.js"(exports, module) {
     "use strict";
     var EventEmitter2 = __require("events");
-    var http = __require("http");
+    var http2 = __require("http");
     var { Duplex } = __require("stream");
     var { createHash: createHash2 } = __require("crypto");
     var extension = require_extension();
@@ -3340,8 +3340,8 @@ var require_websocket_server = __commonJS({
           );
         }
         if (options.port != null) {
-          this._server = http.createServer((req, res) => {
-            const body = http.STATUS_CODES[426];
+          this._server = http2.createServer((req, res) => {
+            const body = http2.STATUS_CODES[426];
             res.writeHead(426, {
               "Content-Length": body.length,
               "Content-Type": "text/plain"
@@ -3628,7 +3628,7 @@ var require_websocket_server = __commonJS({
       this.destroy();
     }
     function abortHandshake(socket, code, message, headers) {
-      message = message || http.STATUS_CODES[code];
+      message = message || http2.STATUS_CODES[code];
       headers = {
         Connection: "close",
         "Content-Type": "text/html",
@@ -3637,7 +3637,7 @@ var require_websocket_server = __commonJS({
       };
       socket.once("finish", socket.destroy);
       socket.end(
-        `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r
+        `HTTP/1.1 ${code} ${http2.STATUS_CODES[code]}\r
 ` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message
       );
     }
@@ -4175,8 +4175,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path44, errorMaps, issueData } = params;
-      const fullPath = [...path44, ...issueData.path || []];
+      const { data, path: path46, errorMaps, issueData } = params;
+      const fullPath = [...path46, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -4484,11 +4484,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path44, key) {
+      constructor(parent, value, path46, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path44;
+        this._path = path46;
         this._key = key;
       }
       get path() {
@@ -8103,15 +8103,15 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path44) {
-  if (!path44)
+function getElementAtPath(obj, path46) {
+  if (!path46)
     return obj;
-  return path44.reduce((acc, key) => acc?.[key], obj);
+  return path46.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
-  const promises5 = keys.map((key) => promisesObj[key]);
-  return Promise.all(promises5).then((results) => {
+  const promises6 = keys.map((key) => promisesObj[key]);
+  return Promise.all(promises6).then((results) => {
     const resolvedObj = {};
     for (let i = 0; i < keys.length; i++) {
       resolvedObj[keys[i]] = results[i];
@@ -8355,11 +8355,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path44, issues) {
+function prefixIssues(path46, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path44);
+    iss.path.unshift(path46);
     return iss;
   });
 }
@@ -8548,7 +8548,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path44 = []) => {
+  const processError = (error41, path46 = []) => {
     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 = [...path44, ...issue2.path];
+        const fullpath = [...path46, ...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(path44) {
+function toDotPath(path46) {
   const segs = [];
-  for (const seg of path44) {
+  for (const seg of path46) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -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(path44, isFile, isDirectory) {
-      log2(`checking %s`, path44);
+    function check2(path46, isFile, isDirectory) {
+      log2(`checking %s`, path46);
       try {
-        const stat2 = fs_1.statSync(path44);
+        const stat2 = fs_1.statSync(path46);
         if (stat2.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -22096,8 +22096,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path44, type = exports.READABLE) {
-      return check2(path44, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path46, type = exports.READABLE) {
+      return check2(path46, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -22940,9 +22940,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 path44 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
-    if (!path44) continue;
-    rows.push({ path: path44, summary: clampSummaryToAtMostTwoLines(summary) });
+    const path46 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
+    if (!path46) continue;
+    rows.push({ path: path46, summary: clampSummaryToAtMostTwoLines(summary) });
   }
   return rows;
 }
@@ -23553,7 +23553,7 @@ function createSdkStdioSessionContext(options) {
   return {
     cwd: options.cwd,
     onFileChange: options.onFileChange,
-    mcpServers: [],
+    mcpServers: options.mcpServers ?? [],
     persistedAcpSessionId: options.persistedAcpSessionId,
     agentLabel: "ACP",
     suppressLoadReplay: suppressLoadReplayRef,
@@ -23996,6 +23996,7 @@ async function createSdkStdioAcpClient(options) {
   });
   const sessionCtx = createSdkStdioSessionContext({
     cwd,
+    mcpServers: options.mcpServers,
     persistedAcpSessionId,
     backendAgentType,
     agentConfig,
@@ -24240,8 +24241,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path44, body) {
-  const url2 = `http://127.0.0.1:${port}${path44}`;
+async function requestPreviewApi(port, secret, method, path46, body) {
+  const url2 = `http://127.0.0.1:${port}${path46}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -24253,7 +24254,7 @@ async function requestPreviewApi(port, secret, method, path44, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path44}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path46}: ${res.status}`);
   }
   return data;
 }
@@ -24468,7 +24469,7 @@ function installBridgeProcessResilience() {
 }
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.45".length > 0 ? "0.1.45" : "0.0.0-dev";
+var CLI_VERSION = "0.1.47".length > 0 ? "0.1.47" : "0.0.0-dev";
 
 // src/connection/heartbeat/constants.ts
 var BRIDGE_APP_HEARTBEAT_INTERVAL_MS = 1e4;
@@ -26157,6 +26158,7 @@ var AcpPromptRoutingRegistry = class {
 function createAcpManagerContext(options) {
   return {
     log: options.log,
+    getBridgeAccessPort: options.getBridgeAccessPort,
     reportAgentCapabilities: options.reportAgentCapabilities,
     backendFallbackAgentType: null,
     acpAgents: /* @__PURE__ */ new Map(),
@@ -26339,7 +26341,7 @@ function createCursorAcpSessionContext(options) {
   return {
     cwd: options.cwd,
     onFileChange: options.onFileChange,
-    mcpServers: [],
+    mcpServers: options.mcpServers ?? [],
     persistedAcpSessionId: options.persistedAcpSessionId,
     agentLabel: "Cursor",
     suppressLoadReplay: suppressLoadReplayRef,
@@ -26765,6 +26767,7 @@ async function createCursorAcpClient(options) {
   });
   const sessionCtx = createCursorAcpSessionContext({
     cwd,
+    mcpServers: options.mcpServers,
     persistedAcpSessionId,
     backendAgentType,
     agentConfig: options.agentConfig,
@@ -27723,6 +27726,30 @@ function computeAcpAgentKey(preferredAgentType, mode, agentConfig) {
   return `${resolved.label}::${fullCmd.join("\0")}${cacheConfig}`;
 }
 
+// src/mcp/bridge-mcp-constants.ts
+var BRIDGE_MCP_SERVER_NAME = "buildautomaton-bridge";
+
+// src/mcp/resolve-bridge-mcp-server-path.ts
+import { dirname as dirname4, join as join2 } from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+function resolveBridgeMcpServerScriptPath() {
+  const cliDir = dirname4(fileURLToPath4(import.meta.url));
+  return join2(cliDir, "bridge-mcp-server.js");
+}
+
+// src/mcp/build-acp-mcp-servers.ts
+function buildAcpMcpServers(bridgeAccessPort) {
+  if (!Number.isFinite(bridgeAccessPort) || bridgeAccessPort <= 0) return [];
+  return [
+    {
+      name: BRIDGE_MCP_SERVER_NAME,
+      command: process.execPath,
+      args: [resolveBridgeMcpServerScriptPath(), String(bridgeAccessPort)],
+      env: []
+    }
+  ];
+}
+
 // src/agents/acp/ensure-acp-client.ts
 function invalidateAcpClientState(state) {
   state.clientEpoch += 1;
@@ -27754,11 +27781,13 @@ async function ensureAcpClient(options) {
     sessionParentPath,
     resolveRouting,
     cloudSessionId,
+    bridgeAccessPort,
     reportAgentCapabilities,
     sendSessionUpdate,
     sendRequest,
     log: log2
   } = options;
+  const mcpServers = buildAcpMcpServers(bridgeAccessPort ?? 0);
   state.latestAgentConfigForBridgeHooks = agentConfig != null && typeof agentConfig === "object" && !Array.isArray(agentConfig) ? agentConfig : null;
   const targetSessionParentPath = resolveSessionParentPathForAgentProcess(sessionParentPath);
   if (state.acpStartPromise && !state.acpHandle) {
@@ -27874,7 +27903,8 @@ async function ensureAcpClient(options) {
         state.lastAcpStartError = "Agent subprocess exited";
       },
       ...hooks,
-      cwd: targetSessionParentPath
+      cwd: targetSessionParentPath,
+      mcpServers
     }).then(async (h) => {
       if (spawnEpoch !== state.clientEpoch || isCliImmediateShutdownRequested()) {
         try {
@@ -27965,8 +27995,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path44) {
-  return path44 instanceof String && cache.has(path44);
+function isPathSpec(path46) {
+  return path46 instanceof String && cache.has(path46);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -28055,8 +28085,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path44) {
-  return (0, import_file_exists.exists)(path44, import_file_exists.FOLDER);
+function folderExists(path46) {
+  return (0, import_file_exists.exists)(path46, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -28460,8 +28490,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path44) {
-      return /^\.(git)?$/.test(path44.trim());
+    parser(path46) {
+      return /^\.(git)?$/.test(path46.trim());
     }
   };
 }
@@ -28895,11 +28925,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path44, line, preview] = input.split(NULL);
-    paths.add(path44);
-    (results[path44] = results[path44] || []).push({
+    const [path46, line, preview] = input.split(NULL);
+    paths.add(path46);
+    (results[path46] = results[path46] || []).push({
       line: asNumber(line),
-      path: path44,
+      path: path46,
       preview
     });
   });
@@ -29664,14 +29694,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path44, text) {
+function parseInit(bare, path46, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path44, false, result[1]);
+    return new InitSummary(bare, path46, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path44, true, result[1]);
+    return new InitSummary(bare, path46, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -29682,7 +29712,7 @@ function parseInit(bare, path44, text) {
       break;
     }
   }
-  return new InitSummary(bare, path44, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path46, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -29691,9 +29721,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path44, existing, gitDir) {
+      constructor(bare, path46, existing, gitDir) {
         this.bare = bare;
-        this.path = path44;
+        this.path = path46;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -29705,7 +29735,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path44, customArgs) {
+function initTask(bare = false, path46, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -29714,7 +29744,7 @@ function initTask(bare = false, path44, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path44, text);
+      return parseInit(commands.includes("--bare"), path46, text);
     }
   };
 }
@@ -30530,12 +30560,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path44, index, working_dir) {
-        this.path = path44;
+      constructor(path46, index, working_dir) {
+        this.path = path46;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path44) || [null, path44, path44];
+          const detail = fromPathRegex.exec(path46) || [null, path46, path46];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -30566,14 +30596,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path44) {
+  function data(index, workingDir, path46) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path44);
+      handler(result, path46);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path44, index, workingDir));
+      result.files.push(new FileStatusSummary(path46, index, workingDir));
     }
   }
 }
@@ -30882,9 +30912,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path44, write) {
+      hashObject(path46, write) {
         return this._runTask(
-          hashObjectTask(path44, write === true),
+          hashObjectTask(path46, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -31237,8 +31267,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path44 = input.trim().replace(/^["']|["']$/g, "");
-  return path44 && normalize3(path44);
+  const path46 = input.trim().replace(/^["']|["']$/g, "");
+  return path46 && normalize3(path46);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -31552,8 +31582,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path44) {
-  return subModuleTask(["add", repo, path44]);
+function addSubModuleTask(repo, path46) {
+  return subModuleTask(["add", repo, path46]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -31886,8 +31916,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path44, then) {
-      return this._runTask(addSubModuleTask2(repo, path44), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path46, then) {
+      return this._runTask(addSubModuleTask2(repo, path46), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -32850,12 +32880,12 @@ 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: path44, summary }) => {
+  const entries = params.rows.map(({ path: path46, summary }) => {
     const enc = params.e2ee.encryptFields({ summary }, ["summary"]);
-    return { path: path44, summary: JSON.stringify(enc) };
+    return { path: path46, summary: JSON.stringify(enc) };
   });
   const res = await fetch(
-    `${base}/api/sessions/${encodeURIComponent(params.sessionId)}/follow-ups/summarize-changes`,
+    `${base}/internal/sessions/${encodeURIComponent(params.sessionId)}/follow-ups/summarize-changes`,
     {
       method: "PUT",
       headers: {
@@ -33020,8 +33050,8 @@ async function fetchSessionAttachmentPayloadsForAgent(params) {
   for (const a of attachments) {
     const id = typeof a.attachmentId === "string" ? a.attachmentId.trim() : "";
     if (!id) continue;
-    const metaUrl = `${base}/api/sessions/${encodeURIComponent(sessionId)}/attachments/${encodeURIComponent(id)}/meta`;
-    const blobUrl = `${base}/api/sessions/${encodeURIComponent(sessionId)}/attachments/${encodeURIComponent(id)}/blob`;
+    const metaUrl = `${base}/internal/sessions/${encodeURIComponent(sessionId)}/attachments/${encodeURIComponent(id)}/meta`;
+    const blobUrl = `${base}/internal/sessions/${encodeURIComponent(sessionId)}/attachments/${encodeURIComponent(id)}/blob`;
     const metaRes = await fetch(metaUrl, { headers: { Authorization: `Bearer ${token}` } });
     if (!metaRes.ok) {
       const t = await metaRes.text().catch(() => "");
@@ -33069,6 +33099,106 @@ async function fetchSessionAttachmentPayloadsForAgent(params) {
   return { ok: true, images: out };
 }
 
+// src/agents/acp/build-forked-session-agent-prompt.ts
+function buildForkedSessionAgentPrompt(userPrompt, childSessionId, parentSessionId) {
+  const childRef = childSessionId.trim();
+  const parentRef = parentSessionId.trim();
+  return [
+    "You are working in a new session that was forked from a prior session.",
+    `This forked session id: ${childRef}`,
+    `Parent session id: ${parentRef}`,
+    "",
+    "The parent session history is available through MCP tools on the buildautomaton-bridge server:",
+    "- list_parent_session_prompts \u2014 list each user prompt / turn in the parent session",
+    "- get_parent_session_turn_transcript \u2014 full transcript for one turn (including tool calls); requires turnId",
+    "",
+    "When calling these tools, always pass this forked session id as sessionId (not the parent session id).",
+    "",
+    "Use these tools when you need prior context instead of guessing.",
+    "",
+    "User request:",
+    userPrompt.trim()
+  ].join("\n");
+}
+
+// src/mcp/tools/session-history/fetch-parent-session-cloud.ts
+function internalApiBase(cloudApiBaseUrl) {
+  return cloudApiBaseUrl.replace(/\/+$/, "");
+}
+async function fetchCloudSessionMeta(params) {
+  const token = params.getCloudAccessToken();
+  if (!token) return { ok: false, error: "Missing cloud access token." };
+  const url2 = `${internalApiBase(params.cloudApiBaseUrl)}/internal/sessions/${encodeURIComponent(params.sessionId)}/meta`;
+  const res = await fetch(url2, { headers: { Authorization: `Bearer ${token}` } });
+  if (!res.ok) {
+    const t = await res.text().catch(() => "");
+    return { ok: false, error: `Session meta fetch failed (${res.status}): ${t.slice(0, 200)}` };
+  }
+  const data = await res.json().catch(() => null);
+  if (!data) return { ok: false, error: "Invalid session meta response." };
+  return { ok: true, data };
+}
+async function fetchCloudParentSessionPrompts(params) {
+  const token = params.getCloudAccessToken();
+  if (!token) return { ok: false, error: "Missing cloud access token." };
+  const url2 = `${internalApiBase(params.cloudApiBaseUrl)}/internal/sessions/${encodeURIComponent(params.childSessionId)}/parent/prompts`;
+  const res = await fetch(url2, { headers: { Authorization: `Bearer ${token}` } });
+  if (!res.ok) {
+    const t = await res.text().catch(() => "");
+    return { ok: false, error: `Parent prompts fetch failed (${res.status}): ${t.slice(0, 200)}` };
+  }
+  const data = await res.json().catch(() => null);
+  if (!data) return { ok: false, error: "Invalid parent prompts response." };
+  return { ok: true, data };
+}
+async function fetchCloudParentTurnTranscript(params) {
+  const token = params.getCloudAccessToken();
+  if (!token) return { ok: false, error: "Missing cloud access token." };
+  const url2 = `${internalApiBase(params.cloudApiBaseUrl)}/internal/sessions/${encodeURIComponent(params.childSessionId)}/parent/turns/${encodeURIComponent(params.turnId)}/transcript`;
+  const res = await fetch(url2, { headers: { Authorization: `Bearer ${token}` } });
+  if (!res.ok) {
+    const t = await res.text().catch(() => "");
+    return { ok: false, error: `Transcript fetch failed (${res.status}): ${t.slice(0, 200)}` };
+  }
+  const data = await res.json().catch(() => null);
+  const rows = Array.isArray(data?.transcript) ? data.transcript : [];
+  const lines = rows.map((row) => {
+    const kind = typeof row.kind === "string" ? row.kind : "event";
+    const payload = typeof row.payload === "string" ? row.payload : JSON.stringify(row.payload ?? "");
+    return `[${kind}] ${payload}`;
+  });
+  return { ok: true, text: lines.join("\n") };
+}
+async function resolveParentSessionIdForChild(params) {
+  const meta = await fetchCloudSessionMeta({
+    sessionId: params.childSessionId,
+    cloudApiBaseUrl: params.cloudApiBaseUrl,
+    getCloudAccessToken: params.getCloudAccessToken
+  });
+  if (!meta.ok) return meta;
+  const parent = meta.data.parentSessionId?.trim() ?? "";
+  if (!parent) {
+    return {
+      ok: false,
+      error: `Session ${params.childSessionId} has no parent session history. It was not forked from another session (no parent_session_id). Pass the forked child session id as sessionId, not the parent session id.`
+    };
+  }
+  return { ok: true, parentSessionId: parent };
+}
+
+// src/agents/acp/enrich-forked-session-prompt-for-agent.ts
+async function enrichForkedSessionPromptForAgent(params) {
+  const meta = await fetchCloudSessionMeta({
+    sessionId: params.sessionId,
+    cloudApiBaseUrl: params.cloudApiBaseUrl,
+    getCloudAccessToken: params.getCloudAccessToken
+  });
+  if (!meta.ok) return params.promptText;
+  const parentSessionId = meta.data.parentSessionId?.trim() ?? "";
+  if (!parentSessionId) return params.promptText;
+  return buildForkedSessionAgentPrompt(params.promptText, params.sessionId, parentSessionId);
+}
+
 // src/agents/acp/send-prompt-to-agent.ts
 async function sendPromptToAgent(options) {
   const {
@@ -33090,6 +33220,15 @@ async function sendPromptToAgent(options) {
     attachments
   } = options;
   try {
+    let agentPromptText = promptText;
+    if (sessionId && cloudApiBaseUrl && getCloudAccessToken) {
+      agentPromptText = await enrichForkedSessionPromptForAgent({
+        sessionId,
+        promptText,
+        cloudApiBaseUrl,
+        getCloudAccessToken
+      });
+    }
     let sendOpts = {};
     if (attachments && attachments.length > 0) {
       if (!sessionId || !cloudApiBaseUrl || !getCloudAccessToken) {
@@ -33128,7 +33267,7 @@ async function sendPromptToAgent(options) {
       }
       sendOpts = { images: resolved.images };
     }
-    const result = await handle.sendPrompt(promptText, sendOpts);
+    const result = await handle.sendPrompt(agentPromptText, sendOpts);
     if (sessionId && runId && sendSessionUpdate && agentCwd && result.success) {
       await collectTurnGitDiffFromPreTurnSnapshot({
         sessionId,
@@ -33252,6 +33391,7 @@ function handlePrompt(ctx, opts) {
       sessionParentPath,
       resolveRouting: () => ctx.promptRouting.resolveRouting(activeAcpSessionAgentKey),
       cloudSessionId: sessionId,
+      bridgeAccessPort: ctx.getBridgeAccessPort(),
       sendSessionUpdate,
       sendRequest: sendSessionUpdate,
       log: ctx.log,
@@ -33338,6 +33478,7 @@ function logPromptReceivedFromBridge(ctx, opts) {
 async function createAcpManager(options) {
   const ctx = createAcpManagerContext({
     log: options.log,
+    getBridgeAccessPort: options.getBridgeAccessPort,
     reportAgentCapabilities: options.reportAgentCapabilities
   });
   return {
@@ -33361,7 +33502,7 @@ async function createAcpManager(options) {
 // src/git/changes/types.ts
 var MAX_PATCH_CHARS = 35e4;
 
-// src/git/changes/lib/repo-format.ts
+// src/git/changes/paths/repo-format.ts
 function posixJoinDirFile(dir, file2) {
   const d = dir === "." || dir === "" ? "" : dir.replace(/\\/g, "/").replace(/\/+$/, "");
   const f = file2.replace(/\\/g, "/").replace(/^\/+/, "");
@@ -33416,7 +33557,7 @@ function formatRemoteDisplayLabel(remoteUrl) {
 }
 
 // src/git/changes/get-working-tree-change-repo-details.ts
-import * as path20 from "node:path";
+import * as path22 from "node:path";
 
 // src/git/commits/resolve-remote-tracking.ts
 async function tryConfigGet(g, key) {
@@ -33586,9 +33727,232 @@ async function listRecentCommits(repoDir, limitInput) {
   }
 }
 
-// src/git/changes/lib/parse-git-status.ts
-function parseNameStatusLines(lines) {
-  const m = /* @__PURE__ */ new Map();
+// src/git/changes/parse/normalize-git-diff-path.ts
+function normalizeGitDiffPath(path46) {
+  return path46.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
+}
+
+// src/git/changes/parse/expand-git-rename-numstat-path.ts
+function expandGitRenameNumstatPath(rawPath) {
+  const open2 = rawPath.indexOf("{");
+  const arrow = rawPath.indexOf("=>");
+  const close = rawPath.lastIndexOf("}");
+  if (open2 === -1 || arrow === -1 || close === -1 || open2 > arrow || arrow > close) {
+    return null;
+  }
+  const prefix = rawPath.slice(0, open2);
+  const suffix = rawPath.slice(close + 1);
+  const oldPart = rawPath.slice(open2 + 1, arrow).trim();
+  const newPart = rawPath.slice(arrow + 2, close).trim();
+  return {
+    oldPath: normalizeGitDiffPath(`${prefix}${oldPart}${suffix}`),
+    newPath: normalizeGitDiffPath(`${prefix}${newPart}${suffix}`)
+  };
+}
+function isGitRenameNumstatPath(rawPath) {
+  return expandGitRenameNumstatPath(rawPath) != null;
+}
+
+// src/git/changes/rows/build-changed-file-row.ts
+function buildChangedFileRow(options) {
+  const pathInRepo = normalizeGitDiffPath(options.pathInRepo);
+  const relLauncher = posixJoinDirFile(options.repoRelPath, pathInRepo);
+  const additions = options.numEntry?.additions ?? 0;
+  const deletions = options.numEntry?.deletions ?? 0;
+  let change = options.nameEntry?.change ?? "modified";
+  let movedFromPathRelLauncher;
+  let movedFromPathInRepo;
+  const oldPathInRepo = options.nameEntry?.oldPathInRepo ?? options.numEntry?.oldPathInRepo;
+  if (change === "moved" && oldPathInRepo) {
+    movedFromPathInRepo = normalizeGitDiffPath(oldPathInRepo);
+    movedFromPathRelLauncher = posixJoinDirFile(options.repoRelPath, movedFromPathInRepo);
+  } else if (oldPathInRepo && change === "modified") {
+    change = "moved";
+    movedFromPathInRepo = normalizeGitDiffPath(oldPathInRepo);
+    movedFromPathRelLauncher = posixJoinDirFile(options.repoRelPath, movedFromPathInRepo);
+  }
+  if (options.untracked && !options.nameEntry) {
+    change = "added";
+  } else if (!options.nameEntry && options.numEntry && change !== "moved") {
+    if (additions > 0 && deletions === 0) change = "added";
+    else if (deletions > 0 && additions === 0) change = "removed";
+    else change = "modified";
+  }
+  return {
+    pathRelLauncher: relLauncher,
+    additions,
+    deletions,
+    change,
+    ...movedFromPathRelLauncher ? { movedFromPathRelLauncher } : {},
+    ...movedFromPathInRepo ? { movedFromPathInRepo } : {}
+  };
+}
+
+// src/git/changes/listing/build-changed-file-rows.ts
+async function buildChangedFileRowsFromPaths(options) {
+  const rows = [];
+  await forEachWithGitYield([...options.paths], async (pathInRepo) => {
+    if (isGitRenameNumstatPath(pathInRepo)) return;
+    if (options.movedSourcePaths.has(pathInRepo)) return;
+    const nameEntry = options.nameByPath.get(pathInRepo);
+    const numEntry = options.numByPath.get(pathInRepo);
+    const row = buildChangedFileRow({
+      pathInRepo,
+      repoRelPath: options.repoRelPath,
+      nameEntry,
+      numEntry,
+      untracked: options.untrackedSet?.has(pathInRepo)
+    });
+    if (options.applyUntrackedStats) {
+      await options.applyUntrackedStats(row, pathInRepo);
+    }
+    rows.push(row);
+  });
+  return rows;
+}
+
+// src/git/changes/patch/patch-truncate.ts
+function truncatePatch(s) {
+  if (s.length <= MAX_PATCH_CHARS) return s;
+  return `${s.slice(0, MAX_PATCH_CHARS)}
+
+\u2026 (diff truncated)`;
+}
+
+// src/git/changes/patch/unified-diff-for-file.ts
+function patchTextFromGitDiffOutput(raw) {
+  if (raw.trim() === "") return void 0;
+  return normalizePatchContent(raw);
+}
+async function unifiedDiffForFile(repoCwd, pathInRepo, change, movedFromPathInRepo) {
+  const g = cliSimpleGit(repoCwd);
+  const renameArgs = ["-M", "--find-renames"];
+  const args = change === "moved" && movedFromPathInRepo ? ["diff", "--no-color", ...renameArgs, "HEAD", "--", movedFromPathInRepo, pathInRepo] : change === "removed" ? ["diff", "--no-color", ...renameArgs, "HEAD", "--", pathInRepo] : ["diff", "--no-color", ...renameArgs, "HEAD", "--", pathInRepo];
+  const raw = await g.raw([...args]).catch(() => "");
+  const patch = patchTextFromGitDiffOutput(String(raw));
+  return patch ? truncatePatch(patch) : void 0;
+}
+async function unifiedDiffForFileInRange(repoCwd, range, pathInRepo, change, movedFromPathInRepo) {
+  const g = cliSimpleGit(repoCwd);
+  const renameArgs = ["-M", "--find-renames"];
+  const args = change === "moved" && movedFromPathInRepo ? ["diff", "--no-color", ...renameArgs, "-U20000", range, "--", movedFromPathInRepo, pathInRepo] : ["diff", "--no-color", ...renameArgs, "-U20000", range, "--", pathInRepo];
+  const raw = await g.raw([...args]).catch(() => "");
+  const patch = patchTextFromGitDiffOutput(String(raw));
+  return patch ? truncatePatch(patch) : void 0;
+}
+
+// src/git/changes/total-lines/resolve-changed-file-total-lines.ts
+import * as fs16 from "node:fs";
+import * as path19 from "node:path";
+
+// src/git/changes/lines/count-lines.ts
+import { createReadStream } from "node:fs";
+import * as readline2 from "node:readline";
+function countLinesInText(text) {
+  return splitTextIntoDiffLines(text).length;
+}
+async function countTextFileLines(filePath) {
+  let bytes = 0;
+  const maxBytes = 512e3;
+  let lines = 0;
+  const stream = createReadStream(filePath, { encoding: "utf8" });
+  const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
+  for await (const _line of rl) {
+    lines += 1;
+    bytes += Buffer.byteLength(String(_line), "utf8") + 1;
+    if (bytes > maxBytes) {
+      rl.close();
+      stream.destroy();
+      return lines;
+    }
+  }
+  return lines;
+}
+
+// src/git/changes/total-lines/resolve-changed-file-total-lines.ts
+var MAX_BYTES = 512e3;
+async function countLinesInGitRef(repoGitCwd, ref, pathInRepo) {
+  const spec = `${ref}:${pathInRepo}`;
+  const g = cliSimpleGit(repoGitCwd);
+  try {
+    await g.raw(["cat-file", "-e", spec]);
+  } catch {
+    return null;
+  }
+  try {
+    const raw = String(await g.raw(["show", spec]));
+    const capped = raw.length > MAX_BYTES ? raw.slice(0, MAX_BYTES) : raw;
+    return countLinesInText(capped);
+  } catch {
+    return null;
+  }
+}
+async function resolveWorkingTreeFileTotalLines(options) {
+  if (options.isBinary) return null;
+  const filePath = path19.join(options.repoGitCwd, options.pathInRepo);
+  if (options.change === "removed") {
+    return countLinesInGitRef(options.repoGitCwd, "HEAD", options.pathInRepo);
+  }
+  if (options.change === "moved" || options.change === "modified") {
+    try {
+      const st = await fs16.promises.stat(filePath);
+      if (!st.isFile()) return null;
+      return await countTextFileLines(filePath);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+async function resolveCommitFileTotalLines(options) {
+  if (options.isBinary) return null;
+  if (options.change === "removed") {
+    return countLinesInGitRef(options.repoGitCwd, options.parentSha, options.pathInRepo);
+  }
+  if (options.change === "moved" || options.change === "modified") {
+    return countLinesInGitRef(options.repoGitCwd, options.commitSha, options.pathInRepo);
+  }
+  return null;
+}
+
+// src/git/changes/listing/path-in-repo-from-launcher.ts
+function pathInRepoFromLauncher(pathRelLauncher, repoRelPath) {
+  const normRel = repoRelPath === "." || repoRelPath === "" ? "." : repoRelPath;
+  if (normRel === ".") return pathRelLauncher;
+  if (pathRelLauncher.startsWith(`${normRel}/`)) {
+    return pathRelLauncher.slice(normRel.length + 1);
+  }
+  return pathRelLauncher;
+}
+function normalizeRepoRelPath(repoRelPath) {
+  return repoRelPath === "." || repoRelPath === "" ? "." : repoRelPath;
+}
+
+// src/git/changes/listing/enrich-commit-file-rows.ts
+async function enrichCommitFileRows(options) {
+  await forEachWithGitYield(options.rows, async (row) => {
+    const pathInRepo = pathInRepoFromLauncher(row.pathRelLauncher, options.repoRelPath);
+    row.patchContent = await unifiedDiffForFileInRange(
+      options.repoGitCwd,
+      options.range,
+      pathInRepo,
+      row.change,
+      row.movedFromPathInRepo
+    );
+    row.totalLines = await resolveCommitFileTotalLines({
+      repoGitCwd: options.repoGitCwd,
+      pathInRepo,
+      change: row.change,
+      commitSha: options.commitSha,
+      parentSha: options.parentSha,
+      isBinary: options.binaryByPath.has(pathInRepo)
+    });
+  });
+}
+
+// src/git/changes/parse/parse-name-status-entries.ts
+function parseNameStatusEntries(lines) {
+  const entries = [];
   for (const line of lines) {
     if (!line.trim()) continue;
     const tabParts = line.split("	");
@@ -33596,58 +33960,143 @@ function parseNameStatusLines(lines) {
     const status = tabParts[0].trim();
     const code = status[0];
     if (code === "A") {
-      m.set(tabParts[tabParts.length - 1], "added");
+      entries.push({ pathInRepo: normalizeGitDiffPath(tabParts[tabParts.length - 1]), change: "added" });
     } else if (code === "D") {
-      m.set(tabParts[tabParts.length - 1], "removed");
+      entries.push({ pathInRepo: normalizeGitDiffPath(tabParts[tabParts.length - 1]), change: "removed" });
     } else if (code === "R" || code === "C") {
-      if (tabParts.length >= 3) m.set(tabParts[tabParts.length - 1], "modified");
+      if (tabParts.length >= 3) {
+        entries.push({
+          pathInRepo: normalizeGitDiffPath(tabParts[tabParts.length - 1]),
+          oldPathInRepo: normalizeGitDiffPath(tabParts[tabParts.length - 2]),
+          change: "moved"
+        });
+      }
     } else if (code === "M" || code === "U" || code === "T") {
-      m.set(tabParts[tabParts.length - 1], "modified");
+      entries.push({ pathInRepo: normalizeGitDiffPath(tabParts[tabParts.length - 1]), change: "modified" });
     }
   }
+  return entries;
+}
+function parseNameStatusLines(lines) {
+  const m = /* @__PURE__ */ new Map();
+  for (const entry of parseNameStatusEntries(lines)) {
+    m.set(entry.pathInRepo, entry.change);
+  }
   return m;
 }
-function parseNumstatFirstLine(line) {
+
+// src/git/changes/parse/parse-numstat-entries.ts
+function parseNumstatCounts(parts) {
+  const [a, d] = parts;
+  return {
+    additions: a === "-" ? 0 : parseInt(String(a), 10) || 0,
+    deletions: d === "-" ? 0 : parseInt(String(d), 10) || 0
+  };
+}
+function parseNumstatLine(line) {
   const parts = line.split("	");
   if (parts.length < 3) return null;
-  const [a, d] = parts;
-  const additions = a === "-" ? 0 : parseInt(String(a), 10) || 0;
-  const deletions = d === "-" ? 0 : parseInt(String(d), 10) || 0;
-  return { additions, deletions };
+  const rawPath = parts[parts.length - 1];
+  const { additions, deletions } = parseNumstatCounts(parts);
+  const expanded = expandGitRenameNumstatPath(rawPath);
+  const pathInRepo = normalizeGitDiffPath(expanded?.newPath ?? rawPath);
+  return {
+    pathInRepo,
+    additions,
+    deletions,
+    ...expanded ? { oldPathInRepo: expanded.oldPath } : {}
+  };
 }
-function parseNumstat(lines) {
+function parseNumstatEntries(lines) {
   const m = /* @__PURE__ */ new Map();
   for (const line of lines) {
     if (!line.trim()) continue;
     const parts = line.split("	");
     if (parts.length < 3) continue;
-    const [a, d, p] = parts;
-    const additions = a === "-" ? 0 : parseInt(String(a), 10) || 0;
-    const deletions = d === "-" ? 0 : parseInt(String(d), 10) || 0;
-    m.set(p, { additions, deletions });
+    const rawPath = parts[parts.length - 1];
+    const expanded = expandGitRenameNumstatPath(rawPath);
+    const entry = parseNumstatLine(line);
+    if (!entry) continue;
+    const existing = m.get(entry.pathInRepo);
+    if (!existing || expanded) {
+      m.set(entry.pathInRepo, entry);
+    }
   }
   return m;
 }
+function parseNumstat(lines) {
+  const m = /* @__PURE__ */ new Map();
+  for (const [path46, entry] of parseNumstatEntries(lines)) {
+    m.set(path46, { additions: entry.additions, deletions: entry.deletions });
+  }
+  return m;
+}
+
+// src/git/changes/parse/numstat-from-git-no-index.ts
 async function numstatFromGitNoIndex(g, pathInRepo) {
   const devNull = process.platform === "win32" ? "NUL" : "/dev/null";
   try {
     const out = await g.raw(["diff", "--numstat", "--no-index", "--", devNull, pathInRepo]);
     const first2 = String(out).split("\n").find((l) => l.trim()) ?? "";
-    return parseNumstatFirstLine(first2);
+    const parsed = parseNumstatLine(first2);
+    if (!parsed) return null;
+    return { additions: parsed.additions, deletions: parsed.deletions };
   } catch {
     return null;
   }
 }
 
-// src/git/changes/lib/patch-truncate.ts
-function truncatePatch(s) {
-  if (s.length <= MAX_PATCH_CHARS) return s;
-  return `${s.slice(0, MAX_PATCH_CHARS)}
+// src/git/changes/rows/collect-moved-source-paths.ts
+function collectMovedSourcePaths(nameEntries, numByPath) {
+  const sources = /* @__PURE__ */ new Set();
+  for (const entry of nameEntries) {
+    if (entry.change === "moved" && entry.oldPathInRepo) sources.add(entry.oldPathInRepo);
+  }
+  for (const entry of numByPath.values()) {
+    if (entry.oldPathInRepo) sources.add(entry.oldPathInRepo);
+  }
+  return sources;
+}
 
-\u2026 (diff truncated)`;
+// src/git/changes/numstat/is-binary-numstat-line.ts
+function isBinaryNumstatLine(line) {
+  const parts = line.split("	");
+  if (parts.length < 3) return false;
+  return parts[0] === "-" || parts[1] === "-";
+}
+
+// src/git/changes/listing/collect-binary-paths-from-numstat.ts
+function collectBinaryPathsFromNumstat(numstatRaw) {
+  const binaryByPath = /* @__PURE__ */ new Set();
+  for (const line of numstatRaw.split("\n")) {
+    if (!line.trim()) continue;
+    const parts = line.split("	");
+    if (parts.length < 3) continue;
+    const rawPath = parts[parts.length - 1];
+    const expanded = expandGitRenameNumstatPath(rawPath);
+    if (isBinaryNumstatLine(line)) binaryByPath.add(expanded?.newPath ?? rawPath);
+  }
+  return binaryByPath;
+}
+
+// src/git/changes/listing/parse-diff-output.ts
+function parseDiffOutput(nameStatusRaw, numstatRaw) {
+  const nameEntries = parseNameStatusEntries(nameStatusRaw.split("\n"));
+  const nameByPath = new Map(nameEntries.map((entry) => [entry.pathInRepo, entry]));
+  const numByPath = parseNumstatEntries(numstatRaw.split("\n"));
+  const movedSourcePaths = collectMovedSourcePaths(nameEntries, numByPath);
+  const binaryByPath = collectBinaryPathsFromNumstat(numstatRaw);
+  return { nameEntries, nameByPath, numByPath, movedSourcePaths, binaryByPath };
+}
+function collectChangedPaths(options) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const entry of options.nameEntries) paths.add(entry.pathInRepo);
+  for (const pathInRepo of options.numByPath.keys()) paths.add(pathInRepo);
+  for (const pathInRepo of options.untracked ?? []) paths.add(pathInRepo);
+  return paths;
 }
 
-// src/git/commits/list-changed-files-for-commit.ts
+// src/git/changes/listing/parent-for-commit-diff.ts
 var EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 async function parentForCommitDiff(g, sha) {
   try {
@@ -33660,76 +34109,112 @@ async function parentForCommitDiff(g, sha) {
     }
   }
 }
+
+// src/git/changes/listing/rename-diff-args.ts
+var RENAME_DIFF_ARGS = ["-M", "--find-renames"];
+
+// src/git/changes/rows/pick-preferred-changed-file-row.ts
+function rowRank(row) {
+  if (row.change === "moved") return 3;
+  if (row.change === "modified") return 2;
+  if (row.change === "added") return 1;
+  return 0;
+}
+function pickPreferredChangedFileRow(a, b) {
+  if (rowRank(a) !== rowRank(b)) return rowRank(a) > rowRank(b) ? a : b;
+  const aHasPatch = Boolean(a.patchContent?.trim());
+  const bHasPatch = Boolean(b.patchContent?.trim());
+  if (aHasPatch !== bHasPatch) return aHasPatch ? a : b;
+  const aHasMoveMeta = Boolean(a.movedFromPathInRepo || a.movedFromPathRelLauncher);
+  const bHasMoveMeta = Boolean(b.movedFromPathInRepo || b.movedFromPathRelLauncher);
+  if (aHasMoveMeta !== bHasMoveMeta) return aHasMoveMeta ? a : b;
+  return a;
+}
+
+// src/git/changes/rows/dedupe-changed-file-rows.ts
+function dedupeChangedFileRows(rows) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = normalizeGitDiffPath(row.pathRelLauncher);
+    const normalizedRow = key === row.pathRelLauncher ? row : { ...row, pathRelLauncher: key };
+    const existing = byPath.get(key);
+    if (!existing) {
+      byPath.set(key, normalizedRow);
+      continue;
+    }
+    const preferRow = pickPreferredChangedFileRow(existing, normalizedRow);
+    byPath.set(key, { ...preferRow, pathRelLauncher: key });
+  }
+  return [...byPath.values()];
+}
+
+// src/git/changes/listing/list-changed-files-for-commit.ts
 async function listChangedFilesForCommit(repoGitCwd, repoRelPath, commitSha) {
   const g = cliSimpleGit(repoGitCwd);
   const parent = await parentForCommitDiff(g, commitSha);
   const range = `${parent}..${commitSha}`;
   const [nameStatusRaw, numstatRaw] = await Promise.all([
-    g.raw(["diff", "--name-status", range]).catch(() => ""),
-    g.raw(["diff", "--numstat", range]).catch(() => "")
+    g.raw(["diff", ...RENAME_DIFF_ARGS, "--name-status", range]).catch(() => ""),
+    g.raw(["diff", ...RENAME_DIFF_ARGS, "--numstat", range]).catch(() => "")
   ]);
-  const kindByPath = parseNameStatusLines(String(nameStatusRaw).split("\n"));
-  const numByPath = parseNumstat(String(numstatRaw).split("\n"));
-  const paths = new Set([...kindByPath.keys(), ...numByPath.keys()].filter(Boolean));
-  const rows = [];
-  const normRel = repoRelPath === "." || repoRelPath === "" ? "." : repoRelPath;
-  await forEachWithGitYield([...paths], async (pathInRepo) => {
-    const relLauncher = posixJoinDirFile(normRel, pathInRepo.replace(/\\/g, "/"));
-    const nums = numByPath.get(pathInRepo);
-    let additions = nums?.additions ?? 0;
-    let deletions = nums?.deletions ?? 0;
-    let change = kindByPath.get(pathInRepo) ?? "modified";
-    if (!kindByPath.has(pathInRepo) && nums) {
-      if (additions > 0 && deletions === 0) change = "added";
-      else if (deletions > 0 && additions === 0) change = "removed";
-      else change = "modified";
-    }
-    rows.push({ pathRelLauncher: relLauncher, additions, deletions, change });
-  });
-  await forEachWithGitYield(rows, async (row) => {
-    let pathInRepo;
-    if (normRel === ".") {
-      pathInRepo = row.pathRelLauncher;
-    } else if (row.pathRelLauncher.startsWith(`${normRel}/`)) {
-      pathInRepo = row.pathRelLauncher.slice(normRel.length + 1);
-    } else {
-      pathInRepo = row.pathRelLauncher;
-    }
-    const raw = await g.raw(["diff", "-U20000", range, "--", pathInRepo]).catch(() => "");
-    const t = String(raw).trim();
-    row.patchContent = t ? truncatePatch(t) : void 0;
+  const parsed = parseDiffOutput(String(nameStatusRaw), String(numstatRaw));
+  const normRel = normalizeRepoRelPath(repoRelPath);
+  const paths = collectChangedPaths({
+    nameEntries: parsed.nameEntries,
+    numByPath: parsed.numByPath
   });
-  rows.sort((a, b) => a.pathRelLauncher.localeCompare(b.pathRelLauncher));
-  return rows;
-}
-
-// src/git/changes/list-changed-files-for-repo.ts
+  let rows = await buildChangedFileRowsFromPaths({
+    paths,
+    repoRelPath: normRel,
+    nameByPath: parsed.nameByPath,
+    numByPath: parsed.numByPath,
+    movedSourcePaths: parsed.movedSourcePaths
+  });
+  rows = dedupeChangedFileRows(rows);
+  await enrichCommitFileRows({
+    rows,
+    repoGitCwd,
+    repoRelPath: normRel,
+    range,
+    commitSha,
+    parentSha: parent,
+    binaryByPath: parsed.binaryByPath
+  });
+  const finalRows = dedupeChangedFileRows(rows);
+  finalRows.sort((a, b) => a.pathRelLauncher.localeCompare(b.pathRelLauncher));
+  return finalRows;
+}
+
+// src/git/changes/listing/apply-untracked-file-stats.ts
 import * as fs17 from "node:fs";
-import * as path19 from "node:path";
-
-// src/git/changes/lib/count-lines.ts
-import { createReadStream } from "node:fs";
-import * as readline2 from "node:readline";
-async function countTextFileLines(filePath) {
-  let bytes = 0;
-  const maxBytes = 512e3;
-  let lines = 0;
-  const stream = createReadStream(filePath, { encoding: "utf8" });
-  const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
-  for await (const _line of rl) {
-    lines += 1;
-    bytes += Buffer.byteLength(String(_line), "utf8") + 1;
-    if (bytes > maxBytes) {
-      rl.close();
-      stream.destroy();
-      return lines;
+import * as path20 from "node:path";
+function createUntrackedStatsApplier(options) {
+  return async (row, pathInRepo) => {
+    if (!options.untrackedSet.has(pathInRepo)) return;
+    if (options.nameByPath.has(pathInRepo)) return;
+    if (row.change === "moved") return;
+    const repoFilePath = path20.join(options.repoGitCwd, pathInRepo);
+    const fromGit = await numstatFromGitNoIndex(options.g, pathInRepo);
+    if (fromGit) {
+      row.additions = fromGit.additions;
+      row.deletions = fromGit.deletions;
+      return;
     }
-  }
-  return lines;
+    try {
+      const st = await fs17.promises.stat(repoFilePath);
+      row.additions = st.isFile() ? await countTextFileLines(repoFilePath) : 0;
+    } catch {
+      row.additions = 0;
+    }
+    row.deletions = 0;
+  };
 }
 
-// src/git/changes/hydrate-patch.ts
-import * as fs16 from "node:fs";
+// src/git/changes/listing/enrich-working-tree-file-rows.ts
+import * as path21 from "node:path";
+
+// src/git/changes/patch/hydrate-patch.ts
+import * as fs18 from "node:fs";
 var UNIFIED_HUNK_HEADER_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
 var MAX_HYDRATE_LINES_PER_GAP = 8e3;
 var MAX_HYDRATE_LINES_PER_FILE = 8e4;
@@ -33744,7 +34229,7 @@ async function readGitBlobLines(repoCwd, pathInRepo) {
 }
 async function readWorktreeFileLines(filePath) {
   try {
-    const raw = await fs16.promises.readFile(filePath, "utf8");
+    const raw = await fs18.promises.readFile(filePath, "utf8");
     return raw.split(/\r?\n/);
   } catch {
     return null;
@@ -33844,82 +34329,70 @@ async function hydrateUnifiedPatchWithFileContext(patch, filePath, repoGitCwd, p
   return truncatePatch(out.join("\n"));
 }
 
-// src/git/changes/unified-diff-for-file.ts
-function patchTextFromGitDiffOutput(raw) {
-  if (raw.trim() === "") return void 0;
-  return normalizePatchContent(raw);
-}
-async function unifiedDiffForFile(repoCwd, pathInRepo, change) {
-  const g = cliSimpleGit(repoCwd);
-  const args = change === "added" ? ["diff", "--no-color", "HEAD", "--", pathInRepo] : change === "removed" ? ["diff", "--no-color", "HEAD", "--", pathInRepo] : ["diff", "--no-color", "HEAD", "--", pathInRepo];
-  const raw = await g.raw([...args]).catch(() => "");
-  const patch = patchTextFromGitDiffOutput(String(raw));
-  return patch ? truncatePatch(patch) : void 0;
+// src/git/changes/listing/enrich-working-tree-file-rows.ts
+async function enrichWorkingTreeFileRows(options) {
+  await forEachWithGitYield(options.rows, async (row) => {
+    const pathInRepo = pathInRepoFromLauncher(row.pathRelLauncher, options.repoRelPath);
+    const filePath = path21.join(options.repoGitCwd, pathInRepo);
+    const hydrateKind = row.change === "moved" ? "modified" : row.change;
+    let patch = await unifiedDiffForFile(options.repoGitCwd, pathInRepo, row.change, row.movedFromPathInRepo);
+    if (patch) {
+      patch = await hydrateUnifiedPatchWithFileContext(
+        patch,
+        filePath,
+        options.repoGitCwd,
+        pathInRepo,
+        hydrateKind
+      );
+    }
+    row.patchContent = patch;
+    row.totalLines = await resolveWorkingTreeFileTotalLines({
+      repoGitCwd: options.repoGitCwd,
+      pathInRepo,
+      change: row.change,
+      isBinary: options.binaryByPath.has(pathInRepo)
+    });
+  });
 }
 
-// src/git/changes/list-changed-files-for-repo.ts
+// src/git/changes/listing/list-changed-files-for-repo.ts
 async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
   const g = cliSimpleGit(repoGitCwd);
   const [nameStatusRaw, numstatRaw, untrackedRaw] = await Promise.all([
-    g.raw(["diff", "--name-status", "HEAD"]).catch(() => ""),
-    g.raw(["diff", "HEAD", "--numstat"]).catch(() => ""),
+    g.raw(["diff", ...RENAME_DIFF_ARGS, "--name-status", "HEAD"]).catch(() => ""),
+    g.raw(["diff", ...RENAME_DIFF_ARGS, "HEAD", "--numstat"]).catch(() => ""),
     g.raw(["ls-files", "--others", "--exclude-standard"]).catch(() => "")
   ]);
-  const kindByPath = parseNameStatusLines(String(nameStatusRaw).split("\n"));
-  const numByPath = parseNumstat(String(numstatRaw).split("\n"));
-  const paths = /* @__PURE__ */ new Set([...kindByPath.keys(), ...numByPath.keys()]);
+  const parsed = parseDiffOutput(String(nameStatusRaw), String(numstatRaw));
   const untracked = String(untrackedRaw).split("\n").map((s) => s.trim()).filter(Boolean);
-  for (const p of untracked) paths.add(p);
-  const rows = [];
-  await forEachWithGitYield([...paths], async (pathInRepo) => {
-    const relLauncher = posixJoinDirFile(repoRelPath, pathInRepo.replace(/\\/g, "/"));
-    const repoFilePath = path19.join(repoGitCwd, pathInRepo);
-    const nums = numByPath.get(pathInRepo);
-    let additions = nums?.additions ?? 0;
-    let deletions = nums?.deletions ?? 0;
-    let change = kindByPath.get(pathInRepo) ?? "modified";
-    if (untracked.includes(pathInRepo) && !kindByPath.has(pathInRepo)) {
-      change = "added";
-      const fromGit = await numstatFromGitNoIndex(g, pathInRepo);
-      if (fromGit) {
-        additions = fromGit.additions;
-        deletions = fromGit.deletions;
-      } else {
-        try {
-          const st = await fs17.promises.stat(repoFilePath);
-          if (st.isFile()) additions = await countTextFileLines(repoFilePath);
-          else additions = 0;
-        } catch {
-          additions = 0;
-        }
-        deletions = 0;
-      }
-    }
-    if (!kindByPath.has(pathInRepo) && nums) {
-      if (additions > 0 && deletions === 0) change = "added";
-      else if (deletions > 0 && additions === 0) change = "removed";
-      else change = "modified";
-    }
-    rows.push({ pathRelLauncher: relLauncher, additions, deletions, change });
+  const untrackedSet = new Set(untracked);
+  const paths = collectChangedPaths({
+    nameEntries: parsed.nameEntries,
+    numByPath: parsed.numByPath,
+    untracked
   });
-  const normRel = repoRelPath === "." || repoRelPath === "" ? "." : repoRelPath;
-  await forEachWithGitYield(rows, async (row) => {
-    let pathInRepo;
-    if (normRel === ".") {
-      pathInRepo = row.pathRelLauncher;
-    } else if (row.pathRelLauncher.startsWith(`${normRel}/`)) {
-      pathInRepo = row.pathRelLauncher.slice(normRel.length + 1);
-    } else {
-      pathInRepo = row.pathRelLauncher;
-    }
-    const filePath = path19.join(repoGitCwd, pathInRepo);
-    let patch = await unifiedDiffForFile(repoGitCwd, pathInRepo, row.change);
-    if (patch) {
-      patch = await hydrateUnifiedPatchWithFileContext(patch, filePath, repoGitCwd, pathInRepo, row.change);
-    }
-    row.patchContent = patch;
+  let rows = await buildChangedFileRowsFromPaths({
+    paths,
+    repoRelPath,
+    nameByPath: parsed.nameByPath,
+    numByPath: parsed.numByPath,
+    movedSourcePaths: parsed.movedSourcePaths,
+    untrackedSet,
+    applyUntrackedStats: createUntrackedStatsApplier({
+      g,
+      repoGitCwd,
+      untrackedSet,
+      nameByPath: parsed.nameByPath
+    })
   });
-  return rows;
+  rows = dedupeChangedFileRows(rows);
+  await enrichWorkingTreeFileRows({
+    rows,
+    repoGitCwd,
+    repoRelPath,
+    binaryByPath: parsed.binaryByPath
+  });
+  return dedupeChangedFileRows(rows);
 }
 
 // src/git/changes/get-working-tree-change-repo-details.ts
@@ -33928,8 +34401,8 @@ function normRepoRel(p) {
   return x === "" ? "." : x;
 }
 async function getWorkingTreeChangeRepoDetails(options) {
-  const bridgeRoot = path20.resolve(getBridgeRoot());
-  const sessionWtRoot = options.sessionWorktreeRootPath ? path20.resolve(options.sessionWorktreeRootPath) : null;
+  const bridgeRoot = path22.resolve(getBridgeRoot());
+  const sessionWtRoot = options.sessionWorktreeRootPath ? path22.resolve(options.sessionWorktreeRootPath) : null;
   const legacyNested = options.legacyRepoNestedSessionLayout === true;
   const out = [];
   const filter = options.repoFilterRelPath != null ? normRepoRel(options.repoFilterRelPath) : null;
@@ -33944,7 +34417,7 @@ async function getWorkingTreeChangeRepoDetails(options) {
   for (let i = 0; i < options.commitTargetPaths.length; i++) {
     if (i > 0) await yieldToEventLoop2();
     const target = options.commitTargetPaths[i];
-    const t = path20.resolve(target);
+    const t = path22.resolve(target);
     if (!await isGitRepoDirectory(t)) continue;
     const g = cliSimpleGit(t);
     let branch = "HEAD";
@@ -33957,8 +34430,8 @@ async function getWorkingTreeChangeRepoDetails(options) {
     const remoteDisplay = formatRemoteDisplayLabel(remoteUrl);
     let repoRelPath;
     if (sessionWtRoot) {
-      const anchor = legacyNested ? path20.dirname(t) : t;
-      const relNorm = path20.relative(sessionWtRoot, anchor);
+      const anchor = legacyNested ? path22.dirname(t) : t;
+      const relNorm = path22.relative(sessionWtRoot, anchor);
       repoRelPath = relNorm === "" ? "." : relNorm.replace(/\\/g, "/");
     } else {
       let top = t;
@@ -33967,8 +34440,8 @@ async function getWorkingTreeChangeRepoDetails(options) {
       } catch {
         top = t;
       }
-      const rel = path20.relative(bridgeRoot, path20.resolve(top)).replace(/\\/g, "/") || ".";
-      repoRelPath = rel.startsWith("..") ? path20.basename(path20.resolve(top)) : rel;
+      const rel = path22.relative(bridgeRoot, path22.resolve(top)).replace(/\\/g, "/") || ".";
+      repoRelPath = rel.startsWith("..") ? path22.basename(path22.resolve(top)) : rel;
     }
     const norm = normRepoRel(repoRelPath === "" ? "." : repoRelPath);
     if (filter && norm !== filter) continue;
@@ -34000,7 +34473,7 @@ async function getWorkingTreeChangeRepoDetails(options) {
   return out;
 }
 
-// src/git/changes/lib/working-tree-changed-path-count.ts
+// src/git/changes/status/working-tree-changed-path-count.ts
 function workingTreeChangedPathCount(nameStatusLines, numstatLines, untrackedLines) {
   const kindByPath = parseNameStatusLines(nameStatusLines);
   const numByPath = parseNumstat(numstatLines);
@@ -34096,23 +34569,23 @@ async function commitSessionWorktrees(options) {
 }
 
 // src/worktrees/remove-session-worktrees.ts
-import * as fs20 from "node:fs";
+import * as fs21 from "node:fs";
 
 // src/git/worktrees/worktree-remove.ts
-import * as fs19 from "node:fs";
+import * as fs20 from "node:fs";
 
 // src/git/worktrees/resolve-main-repo-from-git-file.ts
-import * as fs18 from "node:fs";
-import * as path21 from "node:path";
+import * as fs19 from "node:fs";
+import * as path23 from "node:path";
 function resolveMainRepoFromWorktreeGitFile(wt) {
-  const gitDirFile = path21.join(wt, ".git");
-  if (!fs18.existsSync(gitDirFile) || !fs18.statSync(gitDirFile).isFile()) return "";
-  const first2 = fs18.readFileSync(gitDirFile, "utf8").trim();
+  const gitDirFile = path23.join(wt, ".git");
+  if (!fs19.existsSync(gitDirFile) || !fs19.statSync(gitDirFile).isFile()) return "";
+  const first2 = fs19.readFileSync(gitDirFile, "utf8").trim();
   const m = first2.match(/^gitdir:\s*(.+)$/im);
   if (!m) return "";
-  const gitWorktreePath = path21.resolve(wt, m[1].trim());
-  const gitDir = path21.dirname(path21.dirname(gitWorktreePath));
-  return path21.dirname(gitDir);
+  const gitWorktreePath = path23.resolve(wt, m[1].trim());
+  const gitDir = path23.dirname(path23.dirname(gitWorktreePath));
+  return path23.dirname(gitDir);
 }
 
 // src/git/worktrees/worktree-remove.ts
@@ -34121,7 +34594,7 @@ async function gitWorktreeRemoveForce(worktreePath) {
   if (mainRepo) {
     await cliSimpleGit(mainRepo).raw(["worktree", "remove", "--force", worktreePath]);
   } else {
-    fs19.rmSync(worktreePath, { recursive: true, force: true });
+    fs20.rmSync(worktreePath, { recursive: true, force: true });
   }
 }
 
@@ -34134,7 +34607,7 @@ async function removeSessionWorktrees(paths, log2) {
     } catch (e) {
       log2(`[worktrees] Remove failed for ${wt}: ${e instanceof Error ? e.message : String(e)}`);
       try {
-        fs20.rmSync(wt, { recursive: true, force: true });
+        fs21.rmSync(wt, { recursive: true, force: true });
       } catch {
       }
     }
@@ -34163,12 +34636,12 @@ async function renameSessionWorktreeBranches(paths, newBranch, log2) {
 }
 
 // src/worktrees/worktree-layout-file.ts
-import * as fs21 from "node:fs";
-import * as path22 from "node:path";
+import * as fs22 from "node:fs";
+import * as path24 from "node:path";
 import os7 from "node:os";
 var LAYOUT_FILENAME = "worktree-launcher-layout.json";
 function defaultWorktreeLayoutPath() {
-  return path22.join(os7.homedir(), ".buildautomaton", LAYOUT_FILENAME);
+  return path24.join(os7.homedir(), ".buildautomaton", LAYOUT_FILENAME);
 }
 function normalizeLoadedLayout(raw) {
   if (raw && typeof raw === "object" && "launcherCwds" in raw) {
@@ -34180,8 +34653,8 @@ function normalizeLoadedLayout(raw) {
 function loadWorktreeLayout() {
   try {
     const p = defaultWorktreeLayoutPath();
-    if (!fs21.existsSync(p)) return { launcherCwds: [] };
-    const raw = JSON.parse(fs21.readFileSync(p, "utf8"));
+    if (!fs22.existsSync(p)) return { launcherCwds: [] };
+    const raw = JSON.parse(fs22.readFileSync(p, "utf8"));
     return normalizeLoadedLayout(raw);
   } catch {
     return { launcherCwds: [] };
@@ -34189,24 +34662,24 @@ function loadWorktreeLayout() {
 }
 function saveWorktreeLayout(layout) {
   try {
-    const dir = path22.dirname(defaultWorktreeLayoutPath());
-    fs21.mkdirSync(dir, { recursive: true });
-    fs21.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
+    const dir = path24.dirname(defaultWorktreeLayoutPath());
+    fs22.mkdirSync(dir, { recursive: true });
+    fs22.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
   } catch {
   }
 }
 function baseNameSafe(pathString) {
-  return path22.basename(pathString).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
+  return path24.basename(pathString).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
 }
 function getLauncherDirNameIfPresent(layout, bridgeRootPath2) {
-  const norm = path22.resolve(bridgeRootPath2);
-  const existing = layout.launcherCwds.find((e) => path22.resolve(e.absolutePath) === norm);
+  const norm = path24.resolve(bridgeRootPath2);
+  const existing = layout.launcherCwds.find((e) => path24.resolve(e.absolutePath) === norm);
   return existing?.dirName;
 }
 function allocateDirNameForLauncherCwd(layout, bridgeRootPath2) {
   const existing = getLauncherDirNameIfPresent(layout, bridgeRootPath2);
   if (existing) return existing;
-  const norm = path22.resolve(bridgeRootPath2);
+  const norm = path24.resolve(bridgeRootPath2);
   const base = baseNameSafe(norm);
   const used = new Set(layout.launcherCwds.map((e) => e.dirName));
   let name = base;
@@ -34221,11 +34694,11 @@ function allocateDirNameForLauncherCwd(layout, bridgeRootPath2) {
 }
 
 // src/worktrees/discover-session-worktree-on-disk.ts
-import * as fs22 from "node:fs";
-import * as path23 from "node:path";
+import * as fs23 from "node:fs";
+import * as path25 from "node:path";
 function isGitDir(dirPath) {
   try {
-    return fs22.existsSync(path23.join(dirPath, ".git"));
+    return fs23.existsSync(path25.join(dirPath, ".git"));
   } catch {
     return false;
   }
@@ -34234,23 +34707,23 @@ function collectGitRepoRootsUnderDirectory(rootPath) {
   const out = [];
   const walk = (dir) => {
     if (isGitDir(dir)) {
-      out.push(path23.resolve(dir));
+      out.push(path25.resolve(dir));
       return;
     }
     let entries;
     try {
-      entries = fs22.readdirSync(dir, { withFileTypes: true });
+      entries = fs23.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
-      const full = path23.join(dir, e.name);
+      const full = path25.join(dir, e.name);
       if (!e.isDirectory()) continue;
       walk(full);
     }
   };
-  walk(path23.resolve(rootPath));
+  walk(path25.resolve(rootPath));
   return [...new Set(out)];
 }
 function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
@@ -34259,16 +34732,16 @@ function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = fs22.readdirSync(dir, { withFileTypes: true });
+      entries = fs23.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
-      const full = path23.join(dir, e.name);
+      const full = path25.join(dir, e.name);
       if (!e.isDirectory()) continue;
       if (e.name === sessionId) {
-        if (isGitDir(full)) out.push(path23.resolve(full));
+        if (isGitDir(full)) out.push(path25.resolve(full));
       } else {
         walk(full, depth + 1);
       }
@@ -34280,14 +34753,14 @@ function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
 function tryBindingFromSessionDirectory(sessionDir) {
   let st;
   try {
-    st = fs22.statSync(sessionDir);
+    st = fs23.statSync(sessionDir);
   } catch {
     return null;
   }
   if (!st.isDirectory()) return null;
   const worktreePaths = collectGitRepoRootsUnderDirectory(sessionDir);
   if (worktreePaths.length === 0) return null;
-  const abs = path23.resolve(sessionDir);
+  const abs = path25.resolve(sessionDir);
   return {
     sessionParentPath: abs,
     workingTreeRelRoot: abs,
@@ -34297,20 +34770,20 @@ function tryBindingFromSessionDirectory(sessionDir) {
 function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hintR = path23.resolve(checkoutPath);
+  const hintR = path25.resolve(checkoutPath);
   let best = null;
-  let cur = path23.dirname(hintR);
+  let cur = path25.dirname(hintR);
   for (let i = 0; i < 40; i++) {
     const paths = collectWorktreeRootsNamed(cur, sid, 24);
-    if (paths.some((p) => path23.resolve(p) === hintR)) {
-      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths) ?? path23.resolve(paths[0]);
+    if (paths.some((p) => path25.resolve(p) === hintR)) {
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths) ?? path25.resolve(paths[0]);
       best = {
-        sessionParentPath: path23.resolve(isolated),
-        workingTreeRelRoot: path23.resolve(cur),
-        repoCheckoutPaths: paths.map((p) => path23.resolve(p))
+        sessionParentPath: path25.resolve(isolated),
+        workingTreeRelRoot: path25.resolve(cur),
+        repoCheckoutPaths: paths.map((p) => path25.resolve(p))
       };
     }
-    const next = path23.dirname(cur);
+    const next = path25.dirname(cur);
     if (next === cur) break;
     cur = next;
   }
@@ -34318,33 +34791,33 @@ function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
 }
 function discoverSessionWorktreeOnDisk(options) {
   const { sessionId, worktreesRootPath, layout, bridgeRoot } = options;
-  if (!sessionId.trim() || !fs22.existsSync(worktreesRootPath)) return null;
+  if (!sessionId.trim() || !fs23.existsSync(worktreesRootPath)) return null;
   const preferredKey = getLauncherDirNameIfPresent(layout, bridgeRoot);
   const keys = [];
   if (preferredKey) keys.push(preferredKey);
   try {
-    for (const name of fs22.readdirSync(worktreesRootPath)) {
+    for (const name of fs23.readdirSync(worktreesRootPath)) {
       if (name.startsWith(".")) continue;
-      const p = path23.join(worktreesRootPath, name);
-      if (!fs22.statSync(p).isDirectory()) continue;
+      const p = path25.join(worktreesRootPath, name);
+      if (!fs23.statSync(p).isDirectory()) continue;
       if (name !== preferredKey) keys.push(name);
     }
   } catch {
     return null;
   }
   for (const key of keys) {
-    const layoutRoot = path23.join(worktreesRootPath, key);
-    if (!fs22.existsSync(layoutRoot) || !fs22.statSync(layoutRoot).isDirectory()) continue;
-    const sessionDir = path23.join(layoutRoot, sessionId);
+    const layoutRoot = path25.join(worktreesRootPath, key);
+    if (!fs23.existsSync(layoutRoot) || !fs23.statSync(layoutRoot).isDirectory()) continue;
+    const sessionDir = path25.join(layoutRoot, sessionId);
     const nested = tryBindingFromSessionDirectory(sessionDir);
     if (nested) return nested;
     const legacyPaths = collectWorktreeRootsNamed(layoutRoot, sessionId, 24);
     if (legacyPaths.length > 0) {
-      const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path23.resolve(legacyPaths[0]);
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path25.resolve(legacyPaths[0]);
       return {
-        sessionParentPath: path23.resolve(isolated),
-        workingTreeRelRoot: path23.resolve(layoutRoot),
-        repoCheckoutPaths: legacyPaths.map((p) => path23.resolve(p))
+        sessionParentPath: path25.resolve(isolated),
+        workingTreeRelRoot: path25.resolve(layoutRoot),
+        repoCheckoutPaths: legacyPaths.map((p) => path25.resolve(p))
       };
     }
   }
@@ -34353,12 +34826,12 @@ function discoverSessionWorktreeOnDisk(options) {
 function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeRootPathOrHint, sessionId) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hint = path23.resolve(sessionWorktreeRootPathOrHint);
-  const underHint = tryBindingFromSessionDirectory(path23.join(hint, sid));
+  const hint = path25.resolve(sessionWorktreeRootPathOrHint);
+  const underHint = tryBindingFromSessionDirectory(path25.join(hint, sid));
   if (underHint) return underHint;
   const direct = tryBindingFromSessionDirectory(hint);
   if (direct) {
-    if (path23.basename(hint) === sid && isGitDir(hint)) {
+    if (path25.basename(hint) === sid && isGitDir(hint)) {
       const legacyFromCheckout = discoverLegacyBindingAscendingFromCheckout(sid, hint);
       if (legacyFromCheckout && legacyFromCheckout.repoCheckoutPaths.length > direct.repoCheckoutPaths.length) {
         return legacyFromCheckout;
@@ -34366,24 +34839,24 @@ function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeRootPat
     }
     return direct;
   }
-  if (path23.basename(hint) === sid && isGitDir(hint)) {
+  if (path25.basename(hint) === sid && isGitDir(hint)) {
     const legacyFromCheckout = discoverLegacyBindingAscendingFromCheckout(sid, hint);
     if (legacyFromCheckout) return legacyFromCheckout;
   }
   let st;
   try {
-    st = fs22.statSync(hint);
+    st = fs23.statSync(hint);
   } catch {
     return null;
   }
   if (!st.isDirectory()) return null;
   const legacyPaths = collectWorktreeRootsNamed(hint, sid, 24);
   if (legacyPaths.length === 0) return null;
-  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path23.resolve(legacyPaths[0]);
+  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path25.resolve(legacyPaths[0]);
   return {
-    sessionParentPath: path23.resolve(isolated),
+    sessionParentPath: path25.resolve(isolated),
     workingTreeRelRoot: hint,
-    repoCheckoutPaths: legacyPaths.map((p) => path23.resolve(p))
+    repoCheckoutPaths: legacyPaths.map((p) => path25.resolve(p))
   };
 }
 
@@ -34440,8 +34913,8 @@ function parseSessionParent(v) {
 }
 
 // src/worktrees/prepare-new-session-worktrees.ts
-import * as fs23 from "node:fs";
-import * as path24 from "node:path";
+import * as fs24 from "node:fs";
+import * as path26 from "node:path";
 
 // src/git/worktrees/worktree-add.ts
 async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch, baseRef = "HEAD") {
@@ -34451,7 +34924,7 @@ async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch, baseRef
 }
 
 // src/worktrees/prepare-new-session-worktrees.ts
-function normalizeRepoRelPath(rel) {
+function normalizeRepoRelPath2(rel) {
   return rel === "" ? "." : rel.replace(/\\/g, "/");
 }
 function resolveBaseRefForRepo(relNorm, baseBranches) {
@@ -34463,10 +34936,10 @@ function resolveBaseRefForRepo(relNorm, baseBranches) {
 }
 async function prepareNewSessionWorktrees(options) {
   const { worktreesRootPath, bridgeRoot, sessionId, layout, log: log2, worktreeBaseBranches } = options;
-  const bridgeResolved = path24.resolve(bridgeRoot);
+  const bridgeResolved = path26.resolve(bridgeRoot);
   const cwdKey = allocateDirNameForLauncherCwd(layout, bridgeResolved);
-  const bridgeKeyDir = path24.join(worktreesRootPath, cwdKey);
-  const sessionDir = path24.join(bridgeKeyDir, sessionId);
+  const bridgeKeyDir = path26.join(worktreesRootPath, cwdKey);
+  const sessionDir = path26.join(bridgeKeyDir, sessionId);
   const repos = await discoverGitReposUnderRoot(bridgeResolved);
   if (repos.length === 0) {
     log2("[worktrees] No Git repositories under bridge root; skipping worktree creation.");
@@ -34474,14 +34947,14 @@ async function prepareNewSessionWorktrees(options) {
   }
   const branch = `session-${sessionId}`;
   const worktreePaths = [];
-  fs23.mkdirSync(sessionDir, { recursive: true });
+  fs24.mkdirSync(sessionDir, { recursive: true });
   for (const repo of repos) {
-    let rel = path24.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path24.isAbsolute(rel)) continue;
-    const relNorm = normalizeRepoRelPath(rel === "" ? "." : rel);
-    const wtPath = relNorm === "." ? sessionDir : path24.join(sessionDir, relNorm);
+    let rel = path26.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path26.isAbsolute(rel)) continue;
+    const relNorm = normalizeRepoRelPath2(rel === "" ? "." : rel);
+    const wtPath = relNorm === "." ? sessionDir : path26.join(sessionDir, relNorm);
     if (relNorm !== ".") {
-      fs23.mkdirSync(path24.dirname(wtPath), { recursive: true });
+      fs24.mkdirSync(path26.dirname(wtPath), { recursive: true });
     }
     const baseRef = resolveBaseRefForRepo(relNorm, worktreeBaseBranches);
     try {
@@ -34534,9 +35007,9 @@ function resolveExistingSessionParentPath(sessionId, cache2, discover) {
 }
 
 // src/worktrees/manager/resolve-explicit-session-parent-path.ts
-import * as path25 from "node:path";
+import * as path27 from "node:path";
 function resolveExplicitSessionParentPath(params) {
-  const resolved = path25.resolve(params.parentPathRaw);
+  const resolved = path27.resolve(params.parentPathRaw);
   if (parseSessionParent(params.sessionParent) !== "worktrees_root") {
     return resolved;
   }
@@ -34552,7 +35025,7 @@ function resolveExplicitSessionParentPath(params) {
   for (let i = 0; i < 16; i++) {
     const tryRoot = discoverSessionWorktreesUnderSessionWorktreeRoot(cur, params.sessionId);
     if (tryRoot) return rememberAndReturn(tryRoot);
-    const next = path25.dirname(cur);
+    const next = path27.dirname(cur);
     if (next === cur) break;
     cur = next;
   }
@@ -34604,16 +35077,16 @@ async function resolveSessionParentPathForPrompt(params) {
 }
 
 // src/worktrees/manager/session-worktree-cache.ts
-import * as path26 from "node:path";
+import * as path28 from "node:path";
 var SessionWorktreeCache = class {
   sessionRepoCheckoutPaths = /* @__PURE__ */ new Map();
   sessionParentPathBySession = /* @__PURE__ */ new Map();
   sessionWorkingTreeRelRootBySession = /* @__PURE__ */ new Map();
   remember(sessionId, binding) {
-    const paths = binding.repoCheckoutPaths.map((p) => path26.resolve(p));
+    const paths = binding.repoCheckoutPaths.map((p) => path28.resolve(p));
     this.sessionRepoCheckoutPaths.set(sessionId, paths);
-    this.sessionParentPathBySession.set(sessionId, path26.resolve(binding.sessionParentPath));
-    this.sessionWorkingTreeRelRootBySession.set(sessionId, path26.resolve(binding.workingTreeRelRoot));
+    this.sessionParentPathBySession.set(sessionId, path28.resolve(binding.sessionParentPath));
+    this.sessionWorkingTreeRelRootBySession.set(sessionId, path28.resolve(binding.workingTreeRelRoot));
   }
   clearSession(sessionId) {
     const paths = this.sessionRepoCheckoutPaths.get(sessionId);
@@ -34643,7 +35116,7 @@ var SessionWorktreeCache = class {
     const parent = this.sessionParentPathBySession.get(sessionId);
     const relRoot = this.sessionWorkingTreeRelRootBySession.get(sessionId);
     if (!parent || !relRoot) return false;
-    return path26.resolve(parent) !== path26.resolve(relRoot);
+    return path28.resolve(parent) !== path28.resolve(relRoot);
   }
 };
 
@@ -34747,29 +35220,29 @@ var SessionWorktreeManager = class {
 };
 
 // src/worktrees/manager/default-worktrees-root-path.ts
-import * as path27 from "node:path";
+import * as path29 from "node:path";
 import os8 from "node:os";
 function defaultWorktreesRootPath() {
-  return path27.join(os8.homedir(), ".buildautomaton", "worktrees");
+  return path29.join(os8.homedir(), ".buildautomaton", "worktrees");
 }
 
 // src/files/watch-file-index.ts
 import { watch } from "node:fs";
-import path32 from "node:path";
+import path34 from "node:path";
 
 // src/files/index/paths.ts
-import path28 from "node:path";
+import path30 from "node:path";
 import crypto2 from "node:crypto";
 function getCwdHashForFileIndex(resolvedCwd) {
-  return crypto2.createHash("sha256").update(path28.resolve(resolvedCwd)).digest("hex").slice(0, INDEX_HASH_LEN);
+  return crypto2.createHash("sha256").update(path30.resolve(resolvedCwd)).digest("hex").slice(0, INDEX_HASH_LEN);
 }
 
 // src/files/index/build-file-index.ts
-import path30 from "node:path";
+import path32 from "node:path";
 
 // src/files/index/walk-workspace-tree.ts
-import fs24 from "node:fs";
-import path29 from "node:path";
+import fs25 from "node:fs";
+import path31 from "node:path";
 var DEPENDENCY_INSTALL_DIR_NAMES = /* @__PURE__ */ new Set([
   "node_modules",
   "bower_components",
@@ -34786,7 +35259,7 @@ function shouldSkipWorkspaceWalkEntry(name) {
 async function walkWorkspaceTreeAsync(dir, baseDir, onFile, state) {
   let names;
   try {
-    names = await fs24.promises.readdir(dir);
+    names = await fs25.promises.readdir(dir);
   } catch {
     return;
   }
@@ -34798,14 +35271,14 @@ async function walkWorkspaceTreeAsync(dir, baseDir, onFile, state) {
       if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
     }
     state.n++;
-    const full = path29.join(dir, name);
+    const full = path31.join(dir, name);
     let stat2;
     try {
-      stat2 = await fs24.promises.stat(full);
+      stat2 = await fs25.promises.stat(full);
     } catch {
       continue;
     }
-    const relative6 = path29.relative(baseDir, full).replace(/\\/g, "/");
+    const relative6 = path31.relative(baseDir, full).replace(/\\/g, "/");
     if (stat2.isDirectory()) {
       await walkWorkspaceTreeAsync(full, baseDir, onFile, state);
     } else if (stat2.isFile()) {
@@ -34818,7 +35291,7 @@ function createWalkYieldState() {
 }
 
 // src/files/index/file-index-sqlite-lock.ts
-import fs25 from "node:fs";
+import fs26 from "node:fs";
 function isSqliteCorruptError(e) {
   const msg = e instanceof Error ? e.message : String(e);
   return msg.includes("malformed") || msg.includes("database disk image is malformed") || msg.includes("corrupt");
@@ -34832,7 +35305,7 @@ function withFileIndexSqliteLock(fn) {
       if (!isSqliteCorruptError(e)) throw e;
       closeAllCliSqliteConnections();
       try {
-        fs25.unlinkSync(getCliSqlitePath());
+        fs26.unlinkSync(getCliSqlitePath());
       } catch {
       }
       chain = Promise.resolve();
@@ -34907,7 +35380,7 @@ async function collectWorkspacePathsAsync(resolved) {
 }
 async function buildFileIndexAsync(cwd) {
   return withFileIndexSqliteLock(async () => {
-    const resolved = path30.resolve(cwd);
+    const resolved = path32.resolve(cwd);
     await yieldToEventLoop();
     assertNotShutdown();
     const paths = await collectWorkspacePathsAsync(resolved);
@@ -34919,7 +35392,7 @@ async function buildFileIndexAsync(cwd) {
 }
 
 // src/files/index/ensure-file-index.ts
-import path31 from "node:path";
+import path33 from "node:path";
 
 // src/files/index/search-file-index.ts
 function escapeLikePattern(fragment) {
@@ -34971,7 +35444,7 @@ async function searchBridgeFilePathsAsync(resolvedCwd, query, limit = 100) {
 
 // src/files/index/ensure-file-index.ts
 async function ensureFileIndexAsync(cwd) {
-  const resolved = path31.resolve(cwd);
+  const resolved = path33.resolve(cwd);
   if (await bridgeFileIndexIsPopulated(resolved)) {
     return { fromCache: true, pathCount: await bridgeFileIndexPathCount(resolved) };
   }
@@ -35015,7 +35488,7 @@ function createFsWatcher(resolved, schedule) {
   }
 }
 function startFileIndexWatcher(cwd = getBridgeRoot()) {
-  const resolved = path32.resolve(cwd);
+  const resolved = path34.resolve(cwd);
   void buildFileIndexAsync(resolved).catch((e) => {
     if (e instanceof CliSqliteInterrupted) return;
     console.error("[file-index] Initial index build failed:", e);
@@ -35045,7 +35518,7 @@ function startFileIndexWatcher(cwd = getBridgeRoot()) {
 }
 
 // src/connection/create-bridge-connection.ts
-import * as path43 from "node:path";
+import * as path45 from "node:path";
 
 // src/dev-servers/manager/dev-server-manager.ts
 import { rm as rm2 } from "node:fs/promises";
@@ -35089,7 +35562,7 @@ function forceKillChild(proc, log2, shortId, graceMs) {
 }
 
 // src/dev-servers/process/wire-dev-server-child-process.ts
-import fs26 from "node:fs";
+import fs27 from "node:fs";
 
 // src/dev-servers/manager/forward-pipe.ts
 function forwardChildPipe(childReadable, terminal, onData) {
@@ -35125,7 +35598,7 @@ function wireDevServerChildProcess(d) {
         d.setPollInterval(void 0);
         return;
       }
-      fs26.readFile(d.mergedLogPath, (err, buf) => {
+      fs27.readFile(d.mergedLogPath, (err, buf) => {
         if (err || (d.getSpawnGeneration() ?? 0) !== d.scheduledGen) return;
         if (buf.length <= d.mergedReadPos.value) return;
         const chunk = Buffer.from(buf.subarray(d.mergedReadPos.value));
@@ -35163,7 +35636,7 @@ ${errTail}` : ""}`);
       d.sendStatus(code === 0 || code == null ? "stopped" : "error", detail, tails);
     };
     if (mergedPath) {
-      fs26.readFile(mergedPath, (err, buf) => {
+      fs27.readFile(mergedPath, (err, buf) => {
         if (!err && buf.length > d.mergedReadPos.value) {
           const chunk = Buffer.from(buf.subarray(d.mergedReadPos.value));
           if (chunk.length > 0) {
@@ -35265,13 +35738,13 @@ function parseDevServerDefs(servers) {
 }
 
 // src/dev-servers/manager/shell-spawn/utils.ts
-import fs27 from "node:fs";
+import fs28 from "node:fs";
 function isSpawnEbadf(e) {
   return typeof e === "object" && e !== null && "code" in e && e.code === "EBADF";
 }
 function rmDirQuiet(dir) {
   try {
-    fs27.rmSync(dir, { recursive: true, force: true });
+    fs28.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -35279,7 +35752,7 @@ var cachedDevNullReadFd;
 function devNullReadFd() {
   if (cachedDevNullReadFd === void 0) {
     const devPath = process.platform === "win32" ? "nul" : "/dev/null";
-    cachedDevNullReadFd = fs27.openSync(devPath, "r");
+    cachedDevNullReadFd = fs28.openSync(devPath, "r");
   }
   return cachedDevNullReadFd;
 }
@@ -35353,15 +35826,15 @@ function trySpawnShellTruePiped(command, env, cwd, devNullFd, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-merged-log-file.ts
 import { spawn as spawn8 } from "node:child_process";
-import fs28 from "node:fs";
+import fs29 from "node:fs";
 import { tmpdir } from "node:os";
-import path33 from "node:path";
+import path35 from "node:path";
 function trySpawnMergedLogFile(command, env, cwd, signal) {
-  const tmpRoot = fs28.mkdtempSync(path33.join(tmpdir(), "ba-devsrv-log-"));
-  const logPath = path33.join(tmpRoot, "combined.log");
+  const tmpRoot = fs29.mkdtempSync(path35.join(tmpdir(), "ba-devsrv-log-"));
+  const logPath = path35.join(tmpRoot, "combined.log");
   let logFd;
   try {
-    logFd = fs28.openSync(logPath, "a");
+    logFd = fs29.openSync(logPath, "a");
   } catch {
     rmDirQuiet(tmpRoot);
     return null;
@@ -35380,7 +35853,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     } else {
       proc = spawn8("/bin/sh", ["-c", command], { env, cwd, stdio, ...signal ? { signal } : {} });
     }
-    fs28.closeSync(logFd);
+    fs29.closeSync(logFd);
     return {
       proc,
       pipedStdoutStderr: true,
@@ -35389,7 +35862,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     };
   } catch (e) {
     try {
-      fs28.closeSync(logFd);
+      fs29.closeSync(logFd);
     } catch {
     }
     rmDirQuiet(tmpRoot);
@@ -35400,22 +35873,22 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-shell-script-log-redirect.ts
 import { spawn as spawn9 } from "node:child_process";
-import fs29 from "node:fs";
+import fs30 from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path34 from "node:path";
+import path36 from "node:path";
 function shSingleQuote(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 function trySpawnShellScriptLogRedirectUnix(command, env, cwd, signal) {
-  const tmpRoot = fs29.mkdtempSync(path34.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path34.join(tmpRoot, "combined.log");
-  const innerPath = path34.join(tmpRoot, "_cmd.sh");
-  const runnerPath = path34.join(tmpRoot, "_run.sh");
+  const tmpRoot = fs30.mkdtempSync(path36.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path36.join(tmpRoot, "combined.log");
+  const innerPath = path36.join(tmpRoot, "_cmd.sh");
+  const runnerPath = path36.join(tmpRoot, "_run.sh");
   try {
-    fs29.writeFileSync(innerPath, `#!/bin/sh
+    fs30.writeFileSync(innerPath, `#!/bin/sh
 ${command}
 `);
-    fs29.writeFileSync(
+    fs30.writeFileSync(
       runnerPath,
       `#!/bin/sh
 cd ${shSingleQuote(cwd)}
@@ -35441,13 +35914,13 @@ cd ${shSingleQuote(cwd)}
   }
 }
 function trySpawnShellScriptLogRedirectWin(command, env, cwd, signal) {
-  const tmpRoot = fs29.mkdtempSync(path34.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path34.join(tmpRoot, "combined.log");
-  const runnerPath = path34.join(tmpRoot, "_run.bat");
+  const tmpRoot = fs30.mkdtempSync(path36.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path36.join(tmpRoot, "combined.log");
+  const runnerPath = path36.join(tmpRoot, "_run.bat");
   const q = (p) => `"${p.replace(/"/g, '""')}"`;
   const com = process.env.ComSpec || "cmd.exe";
   try {
-    fs29.writeFileSync(
+    fs30.writeFileSync(
       runnerPath,
       `@ECHO OFF\r
 CD /D ${q(cwd)}\r
@@ -36216,30 +36689,30 @@ function createOnBridgeIdentified(opts) {
 }
 
 // src/skills/discover-local-agent-skills.ts
-import fs30 from "node:fs";
-import path35 from "node:path";
+import fs31 from "node:fs";
+import path37 from "node:path";
 var SKILL_DISCOVERY_ROOTS = [".agents/skills", ".claude/skills", ".cursor/skills", "skills"];
 function discoverLocalSkills(cwd) {
   const out = [];
   const seenKeys = /* @__PURE__ */ new Set();
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path35.join(cwd, rel);
-    if (!fs30.existsSync(base) || !fs30.statSync(base).isDirectory()) continue;
+    const base = path37.join(cwd, rel);
+    if (!fs31.existsSync(base) || !fs31.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs30.readdirSync(base);
+      entries = fs31.readdirSync(base);
     } catch {
       continue;
     }
     for (const name of entries) {
-      const dir = path35.join(base, name);
+      const dir = path37.join(base, name);
       try {
-        if (!fs30.statSync(dir).isDirectory()) continue;
+        if (!fs31.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      const skillMd = path35.join(dir, "SKILL.md");
-      if (!fs30.existsSync(skillMd)) continue;
+      const skillMd = path37.join(dir, "SKILL.md");
+      if (!fs31.existsSync(skillMd)) continue;
       const key = `${rel}/${name}`;
       if (seenKeys.has(key)) continue;
       seenKeys.add(key);
@@ -36251,23 +36724,23 @@ function discoverLocalSkills(cwd) {
 function discoverSkillLayoutRoots(cwd) {
   const roots = [];
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path35.join(cwd, rel);
-    if (!fs30.existsSync(base) || !fs30.statSync(base).isDirectory()) continue;
+    const base = path37.join(cwd, rel);
+    if (!fs31.existsSync(base) || !fs31.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs30.readdirSync(base);
+      entries = fs31.readdirSync(base);
     } catch {
       continue;
     }
     const skills2 = [];
     for (const name of entries) {
-      const dir = path35.join(base, name);
+      const dir = path37.join(base, name);
       try {
-        if (!fs30.statSync(dir).isDirectory()) continue;
+        if (!fs31.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      if (!fs30.existsSync(path35.join(dir, "SKILL.md"))) continue;
+      if (!fs31.existsSync(path37.join(dir, "SKILL.md"))) continue;
       const relPath = `${rel}/${name}`.replace(/\\/g, "/");
       skills2.push({ name, relPath });
     }
@@ -36623,7 +37096,7 @@ function syncRunningTurnQueueKeys(turns, queueKey) {
 }
 
 // src/prompt-turn-queue/runner/run-local-revert-before-queued-prompt.ts
-import fs31 from "node:fs";
+import fs32 from "node:fs";
 async function runLocalRevertBeforeQueuedPrompt(next, deps) {
   if (next.serverState !== "requeued_with_revert") return true;
   const sid = next.sessionId;
@@ -36632,7 +37105,7 @@ async function runLocalRevertBeforeQueuedPrompt(next, deps) {
   const agentBase = deps.sessionWorktreeManager.getSessionWorktreeRootForSession(sid) ?? getBridgeRoot();
   const file2 = snapshotFilePath(agentBase, tid);
   try {
-    await fs31.promises.access(file2, fs31.constants.F_OK);
+    await fs32.promises.access(file2, fs32.constants.F_OK);
   } catch {
     deps.log(
       `[Queue] requeued_with_revert: no pre-turn snapshot for ${tid.slice(0, 8)}\u2026; continuing without revert.`
@@ -36920,9 +37393,9 @@ function parseChangeSummarySnapshots(raw) {
   for (const item of raw) {
     if (!item || typeof item !== "object") continue;
     const o = item;
-    const path44 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
-    if (!path44) continue;
-    const row = { path: path44 };
+    const path46 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
+    if (!path46) continue;
+    const row = { path: path46 };
     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;
@@ -37136,14 +37609,14 @@ var handleSkillCallMessage = (msg, { getWs, log: log2 }) => {
 };
 
 // src/files/list-dir/index.ts
-import fs33 from "node:fs";
+import fs34 from "node:fs";
 
 // src/files/ensure-under-cwd.ts
-import path36 from "node:path";
+import path38 from "node:path";
 function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
-  const normalized = path36.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path36.resolve(cwd, normalized);
-  if (!resolved.startsWith(cwd + path36.sep) && resolved !== cwd) {
+  const normalized = path38.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path38.resolve(cwd, normalized);
+  if (!resolved.startsWith(cwd + path38.sep) && resolved !== cwd) {
     return null;
   }
   return resolved;
@@ -37153,15 +37626,15 @@ function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
 var LIST_DIR_YIELD_EVERY = 256;
 
 // src/files/list-dir/map-dir-entry.ts
-import path37 from "node:path";
-import fs32 from "node:fs";
+import path39 from "node:path";
+import fs33 from "node:fs";
 async function mapDirEntry(d, relativePath, resolved) {
-  const entryPath = path37.join(relativePath || ".", d.name).replace(/\\/g, "/");
-  const fullPath = path37.join(resolved, d.name);
+  const entryPath = path39.join(relativePath || ".", d.name).replace(/\\/g, "/");
+  const fullPath = path39.join(resolved, d.name);
   let isDir = d.isDirectory();
   if (d.isSymbolicLink()) {
     try {
-      const targetStat = await fs32.promises.stat(fullPath);
+      const targetStat = await fs33.promises.stat(fullPath);
       isDir = targetStat.isDirectory();
     } catch {
       isDir = false;
@@ -37191,7 +37664,7 @@ async function listDirAsync(relativePath, sessionParentPath = getBridgeRoot()) {
     return { error: "Path is outside working directory" };
   }
   try {
-    const names = await fs33.promises.readdir(resolved, { withFileTypes: true });
+    const names = await fs34.promises.readdir(resolved, { withFileTypes: true });
     const entries = [];
     for (let i = 0; i < names.length; i++) {
       if (i > 0 && i % LIST_DIR_YIELD_EVERY === 0) {
@@ -37211,18 +37684,18 @@ var LINE_CHUNK_SIZE = 64 * 1024;
 var READ_RANGE_YIELD_EVERY_BYTES = 256 * 1024;
 
 // src/files/read-file/resolve-file-path.ts
-import fs34 from "node:fs";
+import fs35 from "node:fs";
 async function resolveFilePathAsync(relativePath, sessionParentPath = getBridgeRoot()) {
   const resolved = ensureUnderCwd(relativePath, sessionParentPath);
   if (!resolved) return { error: "Path is outside working directory" };
   let real;
   try {
-    real = await fs34.promises.realpath(resolved);
+    real = await fs35.promises.realpath(resolved);
   } catch {
     real = resolved;
   }
   try {
-    const stat2 = await fs34.promises.stat(real);
+    const stat2 = await fs35.promises.stat(real);
     if (!stat2.isFile()) return { error: "Not a file" };
     return real;
   } catch (err) {
@@ -37231,11 +37704,11 @@ async function resolveFilePathAsync(relativePath, sessionParentPath = getBridgeR
 }
 
 // src/files/read-file/read-file-range-async.ts
-import fs35 from "node:fs";
+import fs36 from "node:fs";
 import { StringDecoder } from "node:string_decoder";
 async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
-  const fileSize = (await fs35.promises.stat(filePath)).size;
-  const fd = await fs35.promises.open(filePath, "r");
+  const fileSize = (await fs36.promises.stat(filePath)).size;
+  const fd = await fs36.promises.open(filePath, "r");
   const bufSize = 64 * 1024;
   const buf = Buffer.alloc(bufSize);
   const decoder = new StringDecoder("utf8");
@@ -37397,11 +37870,11 @@ async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, li
 }
 
 // src/files/read-file/read-file-buffer-full-async.ts
-import fs36 from "node:fs";
+import fs37 from "node:fs";
 var READ_CHUNK_BYTES = 256 * 1024;
 async function readFileBufferFullAsync(filePath) {
-  const stat2 = await fs36.promises.stat(filePath);
-  const fd = await fs36.promises.open(filePath, "r");
+  const stat2 = await fs37.promises.stat(filePath);
+  const fd = await fs37.promises.open(filePath, "r");
   const chunks = [];
   let position = 0;
   let bytesSinceYield = 0;
@@ -37508,13 +37981,13 @@ function resolveFileBrowserSessionParent(sessionWorktreeManager, sessionId) {
 }
 
 // src/files/handle-file-browser-search.ts
-import path38 from "node:path";
+import path40 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 = path38.resolve(
+    const sessionParentPath = path40.resolve(
       sessionWorktreeManager != null ? resolveFileBrowserSessionParent(sessionWorktreeManager, msg.sessionId) : getBridgeRoot()
     );
     if (!await bridgeFileIndexIsPopulated(sessionParentPath)) {
@@ -37633,8 +38106,8 @@ function handleSkillLayoutRequest(msg, deps) {
 }
 
 // src/skills/install-remote-skills.ts
-import fs37 from "node:fs";
-import path39 from "node:path";
+import fs38 from "node:fs";
+import path41 from "node:path";
 function installRemoteSkills(cwd, targetDir, items) {
   const installed2 = [];
   if (!Array.isArray(items)) {
@@ -37645,15 +38118,15 @@ function installRemoteSkills(cwd, targetDir, items) {
       if (typeof item.sourceId !== "string" || typeof item.skillName !== "string" || typeof item.versionHash !== "string" || !Array.isArray(item.files)) {
         continue;
       }
-      const skillDir = path39.join(cwd, targetDir, item.skillName);
+      const skillDir = path41.join(cwd, targetDir, item.skillName);
       for (const f of item.files) {
         if (typeof f.path !== "string" || !f.text && !f.base64) continue;
-        const dest = path39.join(skillDir, f.path);
-        fs37.mkdirSync(path39.dirname(dest), { recursive: true });
+        const dest = path41.join(skillDir, f.path);
+        fs38.mkdirSync(path41.dirname(dest), { recursive: true });
         if (f.text !== void 0) {
-          fs37.writeFileSync(dest, f.text, "utf8");
+          fs38.writeFileSync(dest, f.text, "utf8");
         } else if (f.base64) {
-          fs37.writeFileSync(dest, Buffer.from(f.base64, "base64"));
+          fs38.writeFileSync(dest, Buffer.from(f.base64, "base64"));
         }
       }
       installed2.push({
@@ -37811,7 +38284,7 @@ var handleSessionDiscardedMessage = (msg, deps) => {
 };
 
 // src/routing/handlers/revert-turn-snapshot.ts
-import * as fs38 from "node:fs";
+import * as fs39 from "node:fs";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
@@ -37824,7 +38297,7 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
     const agentBase = sessionWorktreeManager.getSessionWorktreeRootForSession(sessionId) ?? getBridgeRoot();
     const file2 = snapshotFilePath(agentBase, turnId);
     try {
-      await fs38.promises.access(file2, fs38.constants.F_OK);
+      await fs39.promises.access(file2, fs39.constants.F_OK);
     } catch {
       sendWsMessage(s, {
         type: "revert_turn_snapshot_result",
@@ -37866,7 +38339,7 @@ var handleDevServersConfig = (msg, deps) => {
 };
 
 // src/git/bridge-git-context.ts
-import * as path40 from "node:path";
+import * as path42 from "node:path";
 
 // src/git/branches/get-current-branch.ts
 async function getCurrentBranch(repoPath) {
@@ -37916,12 +38389,12 @@ async function listRepoBranchRefs(repoPath) {
 // src/git/bridge-git-context.ts
 function folderNameForRelPath(relPath, bridgeRoot) {
   if (relPath === "." || relPath === "") {
-    return path40.basename(path40.resolve(bridgeRoot)) || "repo";
+    return path42.basename(path42.resolve(bridgeRoot)) || "repo";
   }
-  return path40.basename(relPath) || relPath;
+  return path42.basename(relPath) || relPath;
 }
 async function discoverGitReposForBridgeContext(bridgeRoot) {
-  const root = path40.resolve(bridgeRoot);
+  const root = path42.resolve(bridgeRoot);
   if (await isGitRepoDirectory(root)) {
     const remoteUrl = await getRemoteOriginUrl(root);
     return [{ absolutePath: root, remoteUrl }];
@@ -37929,17 +38402,17 @@ 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(path40.resolve(repo.absolutePath), repo);
+    byPath.set(path42.resolve(repo.absolutePath), repo);
   }
   return [...byPath.values()];
 }
 async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path40.resolve(bridgeRoot);
+  const bridgeResolved = path42.resolve(bridgeRoot);
   const repos = await discoverGitReposForBridgeContext(bridgeResolved);
   const rows = [];
   for (const repo of repos) {
-    let rel = path40.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path40.isAbsolute(rel)) continue;
+    let rel = path42.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path42.isAbsolute(rel)) continue;
     const relPath = rel === "" ? "." : rel.replace(/\\/g, "/");
     const currentBranch = await getCurrentBranch(repo.absolutePath);
     const remoteUrl = repo.remoteUrl.trim() || null;
@@ -37954,11 +38427,11 @@ async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
   return rows;
 }
 async function listRepoBranchesForBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path40.resolve(bridgeRoot);
+  const bridgeResolved = path42.resolve(bridgeRoot);
   const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
-  const repoPath = rel === "" ? bridgeResolved : path40.join(bridgeResolved, rel);
-  const resolved = path40.resolve(repoPath);
-  if (!resolved.startsWith(bridgeResolved + path40.sep) && resolved !== bridgeResolved) {
+  const repoPath = rel === "" ? bridgeResolved : path42.join(bridgeResolved, rel);
+  const resolved = path42.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path42.sep) && resolved !== bridgeResolved) {
     return [];
   }
   return listRepoBranchRefs(resolved);
@@ -38542,10 +39015,10 @@ function listCliAgentCapabilityCacheForWorkspace(db, workspaceId) {
 }
 
 // src/agents/capabilities/warmup-agent-capabilities-on-connect.ts
-import * as path42 from "node:path";
+import * as path44 from "node:path";
 
 // src/agents/capabilities/probe-one-agent-type-for-capabilities.ts
-import * as path41 from "node:path";
+import * as path43 from "node:path";
 async function probeOneAgentTypeForCapabilities(params) {
   const { agentType, cwd, workspaceId, log: log2, reportAgentCapabilities, bridgeReport = true, shouldContinue } = params;
   const canContinue = () => shouldContinue?.() !== false;
@@ -38583,7 +39056,7 @@ async function probeOneAgentTypeForCapabilities(params) {
     if (!canContinue()) return false;
     handle = await resolved.createClient({
       command: resolved.command,
-      cwd: path41.resolve(cwd),
+      cwd: path43.resolve(cwd),
       backendAgentType: agentType,
       sessionMode: "agent",
       persistedAcpSessionId: null,
@@ -38661,7 +39134,7 @@ async function warmupAgentCapabilitiesOnConnect(params) {
   const { workspaceId, log: log2, getWs } = params;
   const isCurrent = beginAgentCapabilityWarmupRun();
   if (!isCurrent()) return;
-  const cwd = path42.resolve(getBridgeRoot());
+  const cwd = path44.resolve(getBridgeRoot());
   async function sendBatchFromCache() {
     if (!isCurrent()) return;
     const socket = getWs();
@@ -38727,6 +39200,232 @@ async function warmupAgentCapabilitiesOnConnect(params) {
   })();
 }
 
+// src/mcp/tools/session-history/fork-session-mcp-tools.ts
+var LIST_PARENT_SESSION_PROMPTS_TOOL = "list_parent_session_prompts";
+var GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL = "get_parent_session_turn_transcript";
+var SESSION_ID_SCHEMA = {
+  type: "string",
+  description: "Id of this forked (child) session \u2014 not the parent session id. Required on every tool call."
+};
+var FORK_SESSION_MCP_TOOL_DEFINITIONS = [
+  {
+    name: LIST_PARENT_SESSION_PROMPTS_TOOL,
+    description: "List user prompts (main turns) from the parent session a fork was created from. Requires sessionId. Returns an error if the session has no parent history (not a fork).",
+    inputSchema: {
+      type: "object",
+      properties: { sessionId: SESSION_ID_SCHEMA },
+      required: ["sessionId"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL,
+    description: "Full transcript for one parent-session turn, including tool calls and agent messages. Requires sessionId and turnId. Returns an error if the session has no parent history (not a fork).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: SESSION_ID_SCHEMA,
+        turnId: { type: "string", description: "Turn id from list_parent_session_prompts" }
+      },
+      required: ["sessionId", "turnId"],
+      additionalProperties: false
+    }
+  }
+];
+function textResult(text, isError = false) {
+  return { content: [{ type: "text", text }], ...isError ? { isError: true } : {} };
+}
+function isForkSessionMcpToolName(name) {
+  return name === LIST_PARENT_SESSION_PROMPTS_TOOL || name === GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL;
+}
+async function callForkSessionMcpTool(ctx, cloud, name, args) {
+  const childSessionId = ctx.sessionId.trim();
+  if (!childSessionId) {
+    return textResult("sessionId is required.", true);
+  }
+  const parentResolved = await resolveParentSessionIdForChild({
+    childSessionId,
+    cloudApiBaseUrl: cloud.cloudApiBaseUrl,
+    getCloudAccessToken: cloud.getCloudAccessToken
+  });
+  if (!parentResolved.ok) {
+    return textResult(parentResolved.error, true);
+  }
+  const parentSessionId = parentResolved.parentSessionId;
+  if (name === LIST_PARENT_SESSION_PROMPTS_TOOL) {
+    const detail = await fetchCloudParentSessionPrompts({
+      childSessionId,
+      cloudApiBaseUrl: cloud.cloudApiBaseUrl,
+      getCloudAccessToken: cloud.getCloudAccessToken
+    });
+    if (!detail.ok) return textResult(detail.error, true);
+    const turns = Array.isArray(detail.data.turns) ? detail.data.turns : [];
+    const payload = turns.map((t) => ({
+      turnId: typeof t.turnId === "string" ? t.turnId : "",
+      title: typeof t.title === "string" ? t.title : null,
+      status: typeof t.status === "string" ? t.status : null,
+      promptText: typeof t.promptText === "string" ? t.promptText : null
+    }));
+    return textResult(JSON.stringify({ parentSessionId, turns: payload }, null, 2));
+  }
+  if (name === GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL) {
+    const turnId = typeof args.turnId === "string" ? args.turnId.trim() : "";
+    if (!turnId) return textResult("turnId is required.", true);
+    const transcript = await fetchCloudParentTurnTranscript({
+      childSessionId,
+      turnId,
+      cloudApiBaseUrl: cloud.cloudApiBaseUrl,
+      getCloudAccessToken: cloud.getCloudAccessToken,
+      e2ee: ctx.e2ee
+    });
+    if (!transcript.ok) return textResult(transcript.error, true);
+    return textResult(transcript.text);
+  }
+  return textResult(`Unknown fork session tool: ${name}`, true);
+}
+
+// src/mcp/bridge-mcp-tools.ts
+function requireCloud(shared) {
+  const cloudApiBaseUrl = shared.cloudApiBaseUrl?.trim() ?? "";
+  const getCloudAccessToken = shared.getCloudAccessToken;
+  if (!cloudApiBaseUrl || !getCloudAccessToken) return null;
+  return { cloudApiBaseUrl, getCloudAccessToken };
+}
+function createBridgeMcpToolRegistry(shared) {
+  const cloud = requireCloud(shared);
+  return {
+    listTools: async () => [...FORK_SESSION_MCP_TOOL_DEFINITIONS],
+    callTool: async (name, args) => {
+      if (isForkSessionMcpToolName(name)) {
+        if (!cloud) {
+          return {
+            content: [{ type: "text", text: "Bridge MCP tools require cloud API credentials." }],
+            isError: true
+          };
+        }
+        const sessionId = typeof args.sessionId === "string" ? args.sessionId.trim() : "";
+        if (!sessionId) {
+          return {
+            content: [{ type: "text", text: "sessionId is required." }],
+            isError: true
+          };
+        }
+        return callForkSessionMcpTool({ ...shared, sessionId }, cloud, name, args);
+      }
+      throw new Error(`Unknown bridge MCP tool: ${name}`);
+    }
+  };
+}
+
+// src/mcp/bridge-access/start-server.ts
+import * as http from "node:http";
+
+// src/mcp/bridge-access/read-json-body.ts
+function readJsonBody(req) {
+  return new Promise((resolve20, 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) {
+          resolve20({});
+          return;
+        }
+        const parsed = JSON.parse(raw);
+        resolve20(parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {});
+      } catch (e) {
+        reject(e);
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+// src/mcp/bridge-access/send-json-response.ts
+function sendJsonResponse(res, status, body) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+
+// src/mcp/bridge-access/handle-request.ts
+function createBridgeAccessRequestHandler(registry2) {
+  return (req, res) => {
+    void (async () => {
+      if (req.method !== "POST") {
+        sendJsonResponse(res, 405, { ok: false, error: "Method not allowed" });
+        return;
+      }
+      try {
+        const body = await readJsonBody(req);
+        if (req.url === "/tools/list") {
+          const tools = await Promise.resolve(registry2.listTools());
+          sendJsonResponse(res, 200, { ok: true, data: tools });
+          return;
+        }
+        if (req.url === "/tools/call") {
+          const sessionId = typeof body.sessionId === "string" ? body.sessionId.trim() : "";
+          if (!sessionId) {
+            sendJsonResponse(res, 400, { ok: false, error: "sessionId is required" });
+            return;
+          }
+          const name = typeof body.name === "string" ? body.name.trim() : "";
+          const args = body.args && typeof body.args === "object" && !Array.isArray(body.args) ? body.args : {};
+          if (!name) {
+            sendJsonResponse(res, 400, { ok: false, error: "name is required" });
+            return;
+          }
+          const data = await registry2.callTool(name, { ...args, sessionId });
+          sendJsonResponse(res, 200, { ok: true, data });
+          return;
+        }
+        sendJsonResponse(res, 404, { ok: false, error: "Not found" });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        sendJsonResponse(res, 500, { ok: false, error: message });
+      }
+    })();
+  };
+}
+
+// src/mcp/bridge-access/start-server.ts
+function startBridgeAccessServer(registry2) {
+  const server = http.createServer(createBridgeAccessRequestHandler(registry2));
+  return new Promise((resolve20, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        reject(new Error("Bridge access server did not bind"));
+        return;
+      }
+      resolve20({
+        port: addr.port,
+        close: () => new Promise((closeResolve, closeReject) => {
+          server.close((err) => err ? closeReject(err) : closeResolve());
+        })
+      });
+    });
+  });
+}
+
+// src/mcp/bridge-access/create-state.ts
+async function createBridgeAccessState(options = {}) {
+  const registry2 = createBridgeMcpToolRegistry({
+    cloudApiBaseUrl: options.cloudApiBaseUrl,
+    getCloudAccessToken: options.getCloudAccessToken,
+    e2ee: options.e2ee
+  });
+  const server = await startBridgeAccessServer(registry2);
+  return {
+    getPort: () => server.port,
+    getRegistry: () => registry2,
+    close: async () => {
+      await server.close();
+    }
+  };
+}
+
 // src/connection/create-bridge-connection.ts
 async function createBridgeConnection(options) {
   const { apiUrl, workspaceId, justAuthenticated, onAuthInvalid, persistTokens } = options;
@@ -38789,12 +39488,18 @@ async function createBridgeConnection(options) {
     worktreesRootPath,
     log: logFn
   });
+  const e2ee = options.e2eCertificate ? createCliE2eeRuntime(options.e2eCertificate) : void 0;
+  const bridgeAccess = await createBridgeAccessState({
+    cloudApiBaseUrl: apiUrl,
+    getCloudAccessToken: () => tokens.accessToken,
+    e2ee
+  });
   const acpManager = await createAcpManager({
     log: logFn,
+    getBridgeAccessPort: () => bridgeAccess.getPort(),
     reportAgentCapabilities: sendAgentCapabilitiesToBridge
   });
   logFn("CLI running. Press Ctrl+C to exit.");
-  const e2ee = options.e2eCertificate ? createCliE2eeRuntime(options.e2eCertificate) : void 0;
   const devServerManager = new DevServerManager({ getWs, log: logFn, getBridgeRoot, e2ee });
   const bridgeHeartbeat = createBridgeHeartbeatController({ getWs, log: logFn });
   const baseOnBridgeIdentified = createOnBridgeIdentified({
@@ -38834,8 +39539,8 @@ async function createBridgeConnection(options) {
     getCloudAccessToken: () => tokens.accessToken
   };
   const identifyReportedPaths = {
-    bridgeRootPath: path43.resolve(getBridgeRoot()),
-    worktreesRootPath: path43.resolve(worktreesRootPath)
+    bridgeRootPath: path45.resolve(getBridgeRoot()),
+    worktreesRootPath: path45.resolve(worktreesRootPath)
   };
   const { connect } = createMainBridgeWebSocketLifecycle({
     state,
@@ -38860,6 +39565,7 @@ async function createBridgeConnection(options) {
       stopFileIndexWatcher();
       bridgeHeartbeat.stop();
       await closeBridgeConnection(state, acpManager, devServerManager, logFn);
+      await bridgeAccess.close();
     }
   };
 }