@buildautomaton/cli 0.1.49 → 0.1.50

package/dist/index.js

@@ -4175,8 +4175,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path46, errorMaps, issueData } = params;
-      const fullPath = [...path46, ...issueData.path || []];
+      const { data, path: path53, errorMaps, issueData } = params;
+      const fullPath = [...path53, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -4484,11 +4484,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path46, key) {
+      constructor(parent, value, path53, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path46;
+        this._path = path53;
         this._key = key;
       }
       get path() {
@@ -8103,15 +8103,15 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path46) {
-  if (!path46)
+function getElementAtPath(obj, path53) {
+  if (!path53)
     return obj;
-  return path46.reduce((acc, key) => acc?.[key], obj);
+  return path53.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
-  const promises6 = keys.map((key) => promisesObj[key]);
-  return Promise.all(promises6).then((results) => {
+  const promises11 = keys.map((key) => promisesObj[key]);
+  return Promise.all(promises11).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(path46, issues) {
+function prefixIssues(path53, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path46);
+    iss.path.unshift(path53);
     return iss;
   });
 }
@@ -8548,7 +8548,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path46 = []) => {
+  const processError = (error41, path53 = []) => {
     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 = [...path46, ...issue2.path];
+        const fullpath = [...path53, ...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(path46) {
+function toDotPath(path53) {
   const segs = [];
-  for (const seg of path46) {
+  for (const seg of path53) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -21053,8 +21053,8 @@ var init_acp = __esm({
         this.#requestHandler = requestHandler;
         this.#notificationHandler = notificationHandler;
         this.#stream = stream;
-        this.#closedPromise = new Promise((resolve20) => {
-          this.#abortController.signal.addEventListener("abort", () => resolve20());
+        this.#closedPromise = new Promise((resolve26) => {
+          this.#abortController.signal.addEventListener("abort", () => resolve26());
         });
         this.#receive();
       }
@@ -21203,8 +21203,8 @@ var init_acp = __esm({
       }
       async sendRequest(method, params) {
         const id = this.#nextRequestId++;
-        const responsePromise = new Promise((resolve20, reject) => {
-          this.#pendingResponses.set(id, { resolve: resolve20, reject });
+        const responsePromise = new Promise((resolve26, reject) => {
+          this.#pendingResponses.set(id, { resolve: resolve26, reject });
         });
         await this.#sendMessage({ jsonrpc: "2.0", id, method, params });
         return responsePromise;
@@ -22073,10 +22073,10 @@ var require_src2 = __commonJS({
     var fs_1 = __require("fs");
     var debug_1 = __importDefault(require_src());
     var log2 = debug_1.default("@kwsites/file-exists");
-    function check2(path46, isFile, isDirectory) {
-      log2(`checking %s`, path46);
+    function check2(path53, isFile, isDirectory) {
+      log2(`checking %s`, path53);
       try {
-        const stat2 = fs_1.statSync(path46);
+        const stat2 = fs_1.statSync(path53);
         if (stat2.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -22096,8 +22096,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path46, type = exports.READABLE) {
-      return check2(path46, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path53, type = exports.READABLE) {
+      return check2(path53, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -22446,10 +22446,10 @@ async function killChildProcessTreeGracefully(child, graceMs = ACP_PROCESS_TREE_
   }
   await killProcessTree(pid, "SIGTERM");
   if (graceMs <= 0) return;
-  const exited = new Promise((resolve20) => {
-    child.once("exit", () => resolve20());
+  const exited = new Promise((resolve26) => {
+    child.once("exit", () => resolve26());
   });
-  await Promise.race([exited, new Promise((resolve20) => setTimeout(resolve20, graceMs))]);
+  await Promise.race([exited, new Promise((resolve26) => setTimeout(resolve26, graceMs))]);
   if (child.exitCode == null && child.signalCode == null) {
     await killProcessTree(pid, "SIGKILL");
   }
@@ -22466,8 +22466,8 @@ async function gracefulAcpSubprocessDisconnect(params) {
       await transport.closeSession?.(sessionId);
     } catch {
     }
-    await new Promise((resolve20) => {
-      const timer = setTimeout(resolve20, ACP_GRACEFUL_SESSION_CLOSE_WAIT_MS);
+    await new Promise((resolve26) => {
+      const timer = setTimeout(resolve26, ACP_GRACEFUL_SESSION_CLOSE_WAIT_MS);
       timer.unref?.();
     });
   }
@@ -23172,9 +23172,9 @@ function parseChangeSummaryJson(raw, allowedPaths, options) {
     const rawPath = typeof o.path === "string" ? o.path.trim() : "";
     const summary = typeof o.summary === "string" ? o.summary.trim() : "";
     if (!rawPath || !summary) continue;
-    const path46 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
-    if (!path46) continue;
-    rows.push({ path: path46, summary: clampSummaryToAtMostTwoLines(summary) });
+    const path53 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
+    if (!path53) continue;
+    rows.push({ path: path53, summary: clampSummaryToAtMostTwoLines(summary) });
   }
   return rows;
 }
@@ -23392,7 +23392,7 @@ var GitRepoMetaSchema = external_exports.object({
   updatedAt: external_exports.string()
 });
 
-// ../types/src/bridge-mcp-tool-display.ts
+// ../types/src/mcp/bridge-mcp-constants.ts
 var GET_INTEGRATION_CONTENT_TOOL = "get_integration_content";
 var LIST_PARENT_SESSION_PROMPTS_TOOL = "list_parent_session_prompts";
 var GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL = "get_parent_session_turn_transcript";
@@ -23628,11 +23628,11 @@ function createSdkStdioExtNotificationHandler(options) {
 // src/agents/acp/clients/sdk/sdk-stdio-permission-request-handshake.ts
 function awaitSdkStdioPermissionRequestHandshake(params) {
   const { requestId, paramsRecord, pending, onRequest } = params;
-  return new Promise((resolve20) => {
-    pending.set(requestId, { resolve: resolve20, params: paramsRecord });
+  return new Promise((resolve26) => {
+    pending.set(requestId, { resolve: resolve26, params: paramsRecord });
     if (onRequest == null) {
       pending.delete(requestId);
-      resolve20({ outcome: { outcome: "denied" } });
+      resolve26({ outcome: { outcome: "denied" } });
       return;
     }
     try {
@@ -24176,10 +24176,10 @@ function createSdkStdioInitSettle(child) {
       forceAcpSubprocessDisconnect(child);
       reject(err);
     },
-    settleResolve(resolve20, handle) {
+    settleResolve(resolve26, handle) {
       if (initSettled) return;
       initSettled = true;
-      resolve20(handle);
+      resolve26(handle);
     }
   };
 }
@@ -24248,7 +24248,7 @@ async function createSdkStdioAcpClient(options) {
     onFileChange,
     stderrCapture
   });
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve26, reject) => {
     const init = createSdkStdioInitSettle(child);
     child.on("error", (err) => {
       init.settleReject(reject, new Error(formatSpawnError(err, command[0])));
@@ -24273,7 +24273,7 @@ async function createSdkStdioAcpClient(options) {
           protocolVersion: PROTOCOL_VERSION2
         });
         init.settleResolve(
-          resolve20,
+          resolve26,
           createSdkStdioHandle({
             child,
             sessionId: established.sessionId,
@@ -24381,7 +24381,7 @@ async function proxyToLocal(request) {
   };
   const maxAttempts = isIdempotentProxyMethod(request.method) ? LOCAL_PREVIEW_FETCH_RETRY_DELAYS_MS.length + 1 : 1;
   for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-    const once = await new Promise((resolve20) => {
+    const once = await new Promise((resolve26) => {
       const req = mod.request(opts, (res) => {
         const chunks = [];
         res.on("data", (c) => chunks.push(c));
@@ -24392,7 +24392,7 @@ async function proxyToLocal(request) {
             if (typeof v === "string") headers[k] = v;
             else if (Array.isArray(v) && v[0]) headers[k] = v[0];
           }
-          resolve20({
+          resolve26({
             id: request.id,
             statusCode: res.statusCode ?? 0,
             headers,
@@ -24401,7 +24401,7 @@ async function proxyToLocal(request) {
         });
       });
       req.on("error", (err) => {
-        resolve20({
+        resolve26({
           id: request.id,
           statusCode: 0,
           headers: {},
@@ -24483,8 +24483,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path46, body) {
-  const url2 = `http://127.0.0.1:${port}${path46}`;
+async function requestPreviewApi(port, secret, method, path53, body) {
+  const url2 = `http://127.0.0.1:${port}${path53}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -24496,7 +24496,7 @@ async function requestPreviewApi(port, secret, method, path46, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path46}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path53}: ${res.status}`);
   }
   return data;
 }
@@ -24711,7 +24711,7 @@ function installBridgeProcessResilience() {
 }
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.49".length > 0 ? "0.1.49" : "0.0.0-dev";
+var CLI_VERSION = "0.1.50".length > 0 ? "0.1.50" : "0.0.0-dev";
 
 // src/connection/heartbeat/constants.ts
 var BRIDGE_APP_HEARTBEAT_INTERVAL_MS = 1e4;
@@ -25152,14 +25152,14 @@ var baseOpen = async (options) => {
   }
   const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve20, reject) => {
+    return new Promise((resolve26, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode > 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve20(subprocess);
+        resolve26(subprocess);
       });
     });
   }
@@ -25703,8 +25703,8 @@ function runPendingAuth(options) {
   let hasOpenedBrowser = false;
   let resolved = false;
   let resolveAuth;
-  const authPromise = new Promise((resolve20) => {
-    resolveAuth = resolve20;
+  const authPromise = new Promise((resolve26) => {
+    resolveAuth = resolve26;
   });
   let reconnectAttempt = 0;
   const signInQuiet = createEmptyReconnectQuietSlot();
@@ -25855,7 +25855,7 @@ import sqliteWasm from "node-sqlite3-wasm";
 
 // src/runtime/yield-to-event-loop.ts
 function yieldToEventLoop() {
-  return new Promise((resolve20) => setImmediate(resolve20));
+  return new Promise((resolve26) => setImmediate(resolve26));
 }
 
 // src/sqlite/cli-sqlite-paths.ts
@@ -27019,7 +27019,7 @@ async function createCursorAcpClient(options) {
     onFileChange,
     stderrCapture
   });
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve26, reject) => {
     child.on("error", (err) => {
       killChildProcessTree(child, "SIGKILL");
       reject(new Error(formatSpawnError(err, command[0])));
@@ -27031,7 +27031,7 @@ async function createCursorAcpClient(options) {
           sessionCtx,
           incomingDeps: { dbgFs, sessionCtx, onSessionUpdate, onRequest }
         });
-        resolve20(
+        resolve26(
           createCursorAcpHandle({
             child,
             sessionId: established.sessionId,
@@ -27969,7 +27969,7 @@ function computeAcpAgentKey(preferredAgentType, mode, agentConfig) {
 }
 
 // src/mcp/bridge-mcp-constants.ts
-var BRIDGE_MCP_SERVER_NAME = "buildautomaton-bridge";
+var BRIDGE_MCP_SERVER_NAME2 = "buildautomaton-bridge";
 
 // src/mcp/resolve-bridge-mcp-server-path.ts
 import { dirname as dirname4, join as join2 } from "node:path";
@@ -27984,7 +27984,7 @@ function buildAcpMcpServers(bridgeAccessPort) {
   if (!Number.isFinite(bridgeAccessPort) || bridgeAccessPort <= 0) return [];
   return [
     {
-      name: BRIDGE_MCP_SERVER_NAME,
+      name: BRIDGE_MCP_SERVER_NAME2,
       command: process.execPath,
       args: [resolveBridgeMcpServerScriptPath(), String(bridgeAccessPort)],
       env: []
@@ -28237,8 +28237,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path46) {
-  return path46 instanceof String && cache.has(path46);
+function isPathSpec(path53) {
+  return path53 instanceof String && cache.has(path53);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -28327,8 +28327,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path46) {
-  return (0, import_file_exists.exists)(path46, import_file_exists.FOLDER);
+function folderExists(path53) {
+  return (0, import_file_exists.exists)(path53, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -28732,8 +28732,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path46) {
-      return /^\.(git)?$/.test(path46.trim());
+    parser(path53) {
+      return /^\.(git)?$/.test(path53.trim());
     }
   };
 }
@@ -29167,11 +29167,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path46, line, preview] = input.split(NULL);
-    paths.add(path46);
-    (results[path46] = results[path46] || []).push({
+    const [path53, line, preview] = input.split(NULL);
+    paths.add(path53);
+    (results[path53] = results[path53] || []).push({
       line: asNumber(line),
-      path: path46,
+      path: path53,
       preview
     });
   });
@@ -29936,14 +29936,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path46, text) {
+function parseInit(bare, path53, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path46, false, result[1]);
+    return new InitSummary(bare, path53, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path46, true, result[1]);
+    return new InitSummary(bare, path53, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -29954,7 +29954,7 @@ function parseInit(bare, path46, text) {
       break;
     }
   }
-  return new InitSummary(bare, path46, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path53, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -29963,9 +29963,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path46, existing, gitDir) {
+      constructor(bare, path53, existing, gitDir) {
         this.bare = bare;
-        this.path = path46;
+        this.path = path53;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -29977,7 +29977,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path46, customArgs) {
+function initTask(bare = false, path53, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -29986,7 +29986,7 @@ function initTask(bare = false, path46, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path46, text);
+      return parseInit(commands.includes("--bare"), path53, text);
     }
   };
 }
@@ -30802,12 +30802,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path46, index, working_dir) {
-        this.path = path46;
+      constructor(path53, index, working_dir) {
+        this.path = path53;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path46) || [null, path46, path46];
+          const detail = fromPathRegex.exec(path53) || [null, path53, path53];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -30838,14 +30838,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path46) {
+  function data(index, workingDir, path53) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path46);
+      handler(result, path53);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path46, index, workingDir));
+      result.files.push(new FileStatusSummary(path53, index, workingDir));
     }
   }
 }
@@ -31154,9 +31154,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path46, write) {
+      hashObject(path53, write) {
         return this._runTask(
-          hashObjectTask(path46, write === true),
+          hashObjectTask(path53, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -31509,8 +31509,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path46 = input.trim().replace(/^["']|["']$/g, "");
-  return path46 && normalize3(path46);
+  const path53 = input.trim().replace(/^["']|["']$/g, "");
+  return path53 && normalize3(path53);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -31824,8 +31824,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path46) {
-  return subModuleTask(["add", repo, path46]);
+function addSubModuleTask(repo, path53) {
+  return subModuleTask(["add", repo, path53]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -32158,8 +32158,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path46, then) {
-      return this._runTask(addSubModuleTask2(repo, path46), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path53, then) {
+      return this._runTask(addSubModuleTask2(repo, path53), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -32796,14 +32796,14 @@ async function runGitTask(fn) {
 }
 async function yieldToEventLoop2() {
   throwIfGitShutdownRequested();
-  await new Promise((resolve20) => {
-    setImmediate(resolve20);
+  await new Promise((resolve26) => {
+    setImmediate(resolve26);
   });
   throwIfGitShutdownRequested();
 }
 async function forEachWithGitYield(items, fn) {
   for (let i = 0; i < items.length; i++) {
-    if (i > 0 || items.length > 1) await yieldToEventLoop2();
+    await yieldToEventLoop2();
     await fn(items[i], i);
   }
 }
@@ -33122,9 +33122,9 @@ async function collectTurnGitDiffFromPreTurnSnapshot(options) {
 // src/agents/acp/put-summarize-change-summaries.ts
 async function putEncryptedChangeSummaryRows(params) {
   const base = params.apiBaseUrl.replace(/\/+$/, "");
-  const entries = params.rows.map(({ path: path46, summary }) => {
+  const entries = params.rows.map(({ path: path53, summary }) => {
     const enc = params.e2ee.encryptFields({ summary }, ["summary"]);
-    return { path: path46, summary: JSON.stringify(enc) };
+    return { path: path53, summary: JSON.stringify(enc) };
   });
   const res = await fetch(
     `${base}/internal/sessions/${encodeURIComponent(params.sessionId)}/follow-ups/summarize-changes`,
@@ -33570,7 +33570,7 @@ function buildIntegrationContentAgentPromptNote(sessionId) {
     "Use the get_integration_content MCP tool on the buildautomaton-bridge server to fetch the full content of each link.",
     `When calling the tool, pass sessionId "${sessionRef}" and the URL as url.`,
     "By default the tool links the fetched URL as this session external ticket when the session has none yet. Pass associateAsSessionTicket: false when fetching additional links for context only (after the primary ticket is linked, or when you do not want association).",
-    "If the tool reports unsupported_url, do not retry with the same URL. If it reports temporarily_unavailable, you may retry later."
+    "If the tool reports unsupported_url, do not retry with the same URL. If it reports integration_reconnect_required, ask the user to reconnect the integration in workspace settings. If it reports temporarily_unavailable, you may retry later."
   ].join("\n");
 }
 function injectIntegrationContentAgentPromptNote(agentPrompt, sessionId) {
@@ -33605,7 +33605,7 @@ async function sendPromptToAgent(options) {
     runId,
     agentType,
     agentCwd,
-    sendResult: sendResult2,
+    sendResult,
     sendSessionUpdate,
     log: log2,
     followUpCatalogPromptId,
@@ -33635,7 +33635,7 @@ async function sendPromptToAgent(options) {
     let sendOpts = {};
     if (attachments && attachments.length > 0) {
       if (!sessionId || !cloudApiBaseUrl || !getCloudAccessToken) {
-        sendResult2({
+        sendResult({
           type: "prompt_result",
           id: promptId,
           ...sessionId ? { sessionId } : {},
@@ -33656,7 +33656,7 @@ async function sendPromptToAgent(options) {
         log: log2
       });
       if (!resolved.ok) {
-        sendResult2({
+        sendResult({
           type: "prompt_result",
           id: promptId,
           ...sessionId ? { sessionId } : {},
@@ -33695,7 +33695,7 @@ async function sendPromptToAgent(options) {
     const errStr = typeof result.error === "string" ? result.error : void 0;
     const resultStop = typeof result.stopReason === "string" ? result.stopReason.trim() : "";
     const cancelledByAgent = resultStop.toLowerCase() === "cancelled" || errStr != null && isUserEndedSessionTurnErrorText(errStr);
-    sendResult2({
+    sendResult({
       type: "prompt_result",
       id: promptId,
       ...sessionId ? { sessionId } : {},
@@ -33717,7 +33717,7 @@ async function sendPromptToAgent(options) {
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     log2(`[Agent] Send failed: ${errMsg}`);
-    sendResult2({
+    sendResult({
       type: "prompt_result",
       id: promptId,
       ...sessionId ? { sessionId } : {},
@@ -33751,7 +33751,7 @@ function handlePrompt(ctx, opts) {
     agentType,
     agentConfig,
     sessionParentPath,
-    sendResult: sendResult2,
+    sendResult,
     sendSessionUpdate,
     followUpCatalogPromptId,
     sessionChangeSummaryFilePaths,
@@ -33768,7 +33768,7 @@ function handlePrompt(ctx, opts) {
   const activeRunId = runId;
   const acpAgentKey = computeAcpAgentKey(preferredForPrompt, mode, agentConfig ?? null);
   if (!acpAgentKey) {
-    sendResult2({
+    sendResult({
       type: "prompt_result",
       id: promptId,
       ...sessionId ? { sessionId } : {},
@@ -33805,7 +33805,7 @@ function handlePrompt(ctx, opts) {
       const evaluated = Boolean(preferredForPrompt && errMsg.trim());
       const suggestsAuth = evaluated ? localAgentErrorSuggestsAuth(preferredForPrompt, errMsg) : false;
       const auth = suggestsAuth && preferredForPrompt ? { agentAuthRequired: true, agentType: preferredForPrompt } : {};
-      sendResult2({
+      sendResult({
         type: "prompt_result",
         id: promptId,
         ...sessionId ? { sessionId } : {},
@@ -33825,7 +33825,7 @@ function handlePrompt(ctx, opts) {
         await handle.cancel?.();
       } catch {
       }
-      sendResult2({
+      sendResult({
         type: "prompt_result",
         id: promptId,
         ...sessionId ? { sessionId } : {},
@@ -33846,7 +33846,7 @@ function handlePrompt(ctx, opts) {
         runId: activeRunId,
         agentType: preferredForPrompt,
         agentCwd: resolveSessionParentPathForAgentProcess(sessionParentPath),
-        sendResult: sendResult2,
+        sendResult,
         sendSessionUpdate,
         log: ctx.log,
         followUpCatalogPromptId,
@@ -33902,6 +33902,563 @@ async function createAcpManager(options) {
   };
 }
 
+// src/worktrees/worktree-layout-file.ts
+import * as fs16 from "node:fs";
+import * as path19 from "node:path";
+import os7 from "node:os";
+var LAYOUT_FILENAME = "worktree-launcher-layout.json";
+function defaultWorktreeLayoutPath() {
+  return path19.join(os7.homedir(), ".buildautomaton", LAYOUT_FILENAME);
+}
+function normalizeLoadedLayout(raw) {
+  if (raw && typeof raw === "object" && "launcherCwds" in raw) {
+    const j = raw;
+    if (Array.isArray(j.launcherCwds)) return { launcherCwds: j.launcherCwds };
+  }
+  return { launcherCwds: [] };
+}
+function loadWorktreeLayout() {
+  try {
+    const p = defaultWorktreeLayoutPath();
+    if (!fs16.existsSync(p)) return { launcherCwds: [] };
+    const raw = JSON.parse(fs16.readFileSync(p, "utf8"));
+    return normalizeLoadedLayout(raw);
+  } catch {
+    return { launcherCwds: [] };
+  }
+}
+function saveWorktreeLayout(layout) {
+  try {
+    const dir = path19.dirname(defaultWorktreeLayoutPath());
+    fs16.mkdirSync(dir, { recursive: true });
+    fs16.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
+  } catch {
+  }
+}
+function baseNameSafe(pathString) {
+  return path19.basename(pathString).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
+}
+function getLauncherDirNameIfPresent(layout, bridgeRootPath2) {
+  const norm = path19.resolve(bridgeRootPath2);
+  const existing = layout.launcherCwds.find((e) => path19.resolve(e.absolutePath) === norm);
+  return existing?.dirName;
+}
+function allocateDirNameForLauncherCwd(layout, bridgeRootPath2) {
+  const existing = getLauncherDirNameIfPresent(layout, bridgeRootPath2);
+  if (existing) return existing;
+  const norm = path19.resolve(bridgeRootPath2);
+  const base = baseNameSafe(norm);
+  const used = new Set(layout.launcherCwds.map((e) => e.dirName));
+  let name = base;
+  let n = 2;
+  while (used.has(name)) {
+    name = `${base}-${n}`;
+    n += 1;
+  }
+  layout.launcherCwds.push({ absolutePath: norm, dirName: name });
+  saveWorktreeLayout(layout);
+  return name;
+}
+
+// src/worktrees/discovery/discover-session-worktree-on-disk.ts
+import * as fs20 from "node:fs";
+import * as path24 from "node:path";
+
+// src/worktrees/discovery/collect-worktree-paths.ts
+import * as fs18 from "node:fs";
+import * as path21 from "node:path";
+
+// src/worktrees/discovery/disk-walk-constants.ts
+var DISK_WALK_YIELD_EVERY = 64;
+var LEGACY_WALK_MAX_DEPTH = 12;
+var SKIP_DISK_WALK_DIR_NAMES = /* @__PURE__ */ new Set([
+  "node_modules",
+  "bower_components",
+  "vendor",
+  "Pods",
+  "Carthage",
+  "DerivedData",
+  ".yarn",
+  ".pnpm-store",
+  "dist",
+  "build",
+  ".next",
+  "coverage",
+  ".turbo",
+  ".cache",
+  "target",
+  "__pycache__"
+]);
+function shouldSkipDiskWalkEntry(name) {
+  return name.startsWith(".") || SKIP_DISK_WALK_DIR_NAMES.has(name);
+}
+
+// src/worktrees/discovery/disk-walk-utils.ts
+import * as fs17 from "node:fs";
+import * as path20 from "node:path";
+async function yieldDuringDiskWalk(state) {
+  state.entries++;
+  if (state.entries % DISK_WALK_YIELD_EVERY !== 0) return true;
+  if (isCliImmediateShutdownRequested()) return false;
+  await yieldToEventLoop();
+  return !isCliImmediateShutdownRequested();
+}
+async function isGitDir(dirPath) {
+  try {
+    await fs17.promises.access(path20.join(dirPath, ".git"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/worktrees/discovery/collect-worktree-paths.ts
+async function collectGitRepoRootsUnderDirectory(rootPath) {
+  const out = [];
+  const state = { entries: 0 };
+  const walk = async (dir) => {
+    if (!await yieldDuringDiskWalk(state)) return;
+    if (await isGitDir(dir)) {
+      out.push(path21.resolve(dir));
+      return;
+    }
+    let entries;
+    try {
+      entries = await fs18.promises.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (shouldSkipDiskWalkEntry(e.name)) continue;
+      const full = path21.join(dir, e.name);
+      if (!e.isDirectory()) continue;
+      await walk(full);
+    }
+  };
+  await walk(path21.resolve(rootPath));
+  return { paths: [...new Set(out)], entriesVisited: state.entries };
+}
+async function collectWorktreeRootsNamed(root, sessionId, maxDepth = LEGACY_WALK_MAX_DEPTH) {
+  const out = [];
+  const state = { entries: 0 };
+  const walk = async (dir, depth) => {
+    if (depth > maxDepth) return;
+    if (!await yieldDuringDiskWalk(state)) return;
+    let entries;
+    try {
+      entries = await fs18.promises.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (shouldSkipDiskWalkEntry(e.name)) continue;
+      const full = path21.join(dir, e.name);
+      if (!e.isDirectory()) continue;
+      if (e.name === sessionId) {
+        if (await isGitDir(full)) out.push(path21.resolve(full));
+        continue;
+      }
+      if (await isGitDir(full)) continue;
+      await walk(full, depth + 1);
+    }
+  };
+  await walk(root, 0);
+  return { paths: out, entriesVisited: state.entries };
+}
+
+// src/worktrees/discovery/layout-keys-for-bridge-root.ts
+import * as path22 from "node:path";
+function layoutKeysForBridgeRoot(layout, bridgeRoot, keysOnDisk) {
+  const bridge = path22.resolve(bridgeRoot);
+  const preferred = getLauncherDirNameIfPresent(layout, bridgeRoot);
+  const relevant = layout.launcherCwds.filter((e) => {
+    const entry = path22.resolve(e.absolutePath);
+    return bridge === entry || bridge.startsWith(entry + path22.sep) || entry.startsWith(bridge + path22.sep);
+  }).sort((a, b) => path22.resolve(b.absolutePath).length - path22.resolve(a.absolutePath).length).map((e) => e.dirName).filter((name) => keysOnDisk.includes(name));
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (k) => {
+    if (seen.has(k) || !keysOnDisk.includes(k)) return;
+    seen.add(k);
+    ordered.push(k);
+  };
+  if (preferred) add(preferred);
+  for (const k of relevant) add(k);
+  if (relevant.length > 0) {
+    return ordered;
+  }
+  for (const k of keysOnDisk) add(k);
+  return ordered;
+}
+
+// src/worktrees/discovery/try-binding-from-session-directory.ts
+import * as fs19 from "node:fs";
+import * as path23 from "node:path";
+async function tryBindingFromSessionDirectory(sessionDir) {
+  let st;
+  try {
+    st = await fs19.promises.stat(sessionDir);
+  } catch {
+    return null;
+  }
+  if (!st.isDirectory()) return null;
+  const { paths: worktreePaths } = await collectGitRepoRootsUnderDirectory(sessionDir);
+  if (worktreePaths.length === 0) return null;
+  const abs = path23.resolve(sessionDir);
+  return {
+    sessionParentPath: abs,
+    workingTreeRelRoot: abs,
+    repoCheckoutPaths: worktreePaths
+  };
+}
+
+// src/worktrees/discovery/discover-session-worktree-on-disk.ts
+async function discoverSessionWorktreeOnDisk(options) {
+  const { sessionId, worktreesRootPath, layout, bridgeRoot } = options;
+  const sid = sessionId.trim();
+  if (!sid) return null;
+  try {
+    await fs20.promises.access(worktreesRootPath);
+  } catch {
+    return null;
+  }
+  const preferredKey = getLauncherDirNameIfPresent(layout, bridgeRoot);
+  const keysOnDisk = [];
+  if (preferredKey) keysOnDisk.push(preferredKey);
+  try {
+    for (const name of await fs20.promises.readdir(worktreesRootPath)) {
+      if (name.startsWith(".")) continue;
+      const p = path24.join(worktreesRootPath, name);
+      let st;
+      try {
+        st = await fs20.promises.stat(p);
+      } catch {
+        continue;
+      }
+      if (!st.isDirectory()) continue;
+      if (!keysOnDisk.includes(name)) keysOnDisk.push(name);
+    }
+  } catch {
+    return null;
+  }
+  const keys = layoutKeysForBridgeRoot(layout, bridgeRoot, keysOnDisk);
+  for (const key of keys) {
+    if (isCliImmediateShutdownRequested()) return null;
+    await yieldToEventLoop();
+    const layoutRoot = path24.join(worktreesRootPath, key);
+    let layoutSt;
+    try {
+      layoutSt = await fs20.promises.stat(layoutRoot);
+    } catch {
+      continue;
+    }
+    if (!layoutSt.isDirectory()) continue;
+    const sessionDir = path24.join(layoutRoot, sid);
+    const nested = await tryBindingFromSessionDirectory(sessionDir);
+    if (nested) return nested;
+    const legacy = await collectWorktreeRootsNamed(layoutRoot, sid);
+    if (legacy.paths.length > 0) {
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacy.paths) ?? path24.resolve(legacy.paths[0]);
+      return {
+        sessionParentPath: path24.resolve(isolated),
+        workingTreeRelRoot: path24.resolve(layoutRoot),
+        repoCheckoutPaths: legacy.paths.map((p) => path24.resolve(p))
+      };
+    }
+  }
+  return null;
+}
+
+// src/worktrees/discovery/discover-session-worktrees-under-session-worktree-root.ts
+import * as fs21 from "node:fs";
+import * as path26 from "node:path";
+
+// src/worktrees/discovery/discover-legacy-binding-ascending-from-checkout.ts
+import * as path25 from "node:path";
+async function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
+  const sid = sessionId.trim();
+  if (!sid) return null;
+  const hintR = path25.resolve(checkoutPath);
+  let best = null;
+  let cur = path25.dirname(hintR);
+  for (let i = 0; i < 40; i++) {
+    if (isCliImmediateShutdownRequested()) return best;
+    await yieldToEventLoop();
+    const paths = await collectWorktreeRootsNamed(cur, sid);
+    if (paths.paths.some((p) => path25.resolve(p) === hintR)) {
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths.paths) ?? path25.resolve(paths.paths[0]);
+      best = {
+        sessionParentPath: path25.resolve(isolated),
+        workingTreeRelRoot: path25.resolve(cur),
+        repoCheckoutPaths: paths.paths.map((p) => path25.resolve(p))
+      };
+    }
+    const next = path25.dirname(cur);
+    if (next === cur) break;
+    cur = next;
+  }
+  return best;
+}
+
+// src/worktrees/discovery/discover-session-worktrees-under-session-worktree-root.ts
+async function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeRootPathOrHint, sessionId) {
+  const sid = sessionId.trim();
+  if (!sid) return null;
+  const hint = path26.resolve(sessionWorktreeRootPathOrHint);
+  const underHint = await tryBindingFromSessionDirectory(path26.join(hint, sid));
+  if (underHint) return underHint;
+  const direct = await tryBindingFromSessionDirectory(hint);
+  if (direct) {
+    if (path26.basename(hint) === sid && await isGitDir(hint)) {
+      const legacyFromCheckout = await discoverLegacyBindingAscendingFromCheckout(sid, hint);
+      if (legacyFromCheckout && legacyFromCheckout.repoCheckoutPaths.length > direct.repoCheckoutPaths.length) {
+        return legacyFromCheckout;
+      }
+    }
+    return direct;
+  }
+  if (path26.basename(hint) === sid && await isGitDir(hint)) {
+    const legacyFromCheckout = await discoverLegacyBindingAscendingFromCheckout(sid, hint);
+    if (legacyFromCheckout) return legacyFromCheckout;
+  }
+  let st;
+  try {
+    st = await fs21.promises.stat(hint);
+  } catch {
+    return null;
+  }
+  if (!st.isDirectory()) return null;
+  const legacyPaths = await collectWorktreeRootsNamed(hint, sid);
+  if (legacyPaths.paths.length === 0) return null;
+  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths.paths) ?? path26.resolve(legacyPaths.paths[0]);
+  return {
+    sessionParentPath: path26.resolve(isolated),
+    workingTreeRelRoot: hint,
+    repoCheckoutPaths: legacyPaths.paths.map((p) => path26.resolve(p))
+  };
+}
+
+// src/worktrees/manager/discover-session-binding.ts
+var discoverInflightBySessionId = /* @__PURE__ */ new Map();
+function discoverSessionBindingAsync(params) {
+  const sid = params.sessionId.trim();
+  if (!sid) return Promise.resolve(null);
+  const existing = discoverInflightBySessionId.get(sid);
+  if (existing) return existing;
+  const promise2 = discoverSessionWorktreeOnDisk({
+    sessionId: sid,
+    worktreesRootPath: params.worktreesRootPath,
+    layout: params.layout,
+    bridgeRoot: getBridgeRoot()
+  }).finally(() => {
+    if (discoverInflightBySessionId.get(sid) === promise2) {
+      discoverInflightBySessionId.delete(sid);
+    }
+  });
+  discoverInflightBySessionId.set(sid, promise2);
+  return promise2;
+}
+
+// src/worktrees/manager/resolve-isolated-session-parent-path.ts
+function resolveIsolatedSessionParentPath(sessionId, cache2, ensureRepoCheckoutPaths) {
+  if (!sessionId) return null;
+  const sid = sessionId.trim();
+  const cached2 = cache2.getSessionParentPath(sid);
+  if (cached2) return cached2;
+  const paths = ensureRepoCheckoutPaths(sid);
+  if (!paths?.length) return null;
+  return resolveIsolatedSessionParentPathFromCheckouts(paths);
+}
+function ensureRepoCheckoutPathsForSession(sessionId, cache2) {
+  if (!sessionId?.trim()) return void 0;
+  const cached2 = cache2.getRepoCheckoutPaths(sessionId.trim());
+  return cached2?.length ? [...cached2] : void 0;
+}
+async function ensureRepoCheckoutPathsForSessionAsync(sessionId, cache2, discover) {
+  if (!sessionId?.trim()) return void 0;
+  const sid = sessionId.trim();
+  const cached2 = cache2.getRepoCheckoutPaths(sid);
+  if (cached2?.length) return cached2;
+  const disc = await discover(sid);
+  if (disc?.repoCheckoutPaths.length) {
+    cache2.remember(sid, disc);
+    return [...disc.repoCheckoutPaths];
+  }
+  return void 0;
+}
+
+// src/worktrees/manager/parse-session-parent.ts
+function parseSessionParent(v) {
+  if (v === "bridge_root" || v === "worktrees_root") return v;
+  if (v === "session_worktrees_root") return "worktrees_root";
+  return null;
+}
+
+// src/worktrees/prepare-new-session-worktrees.ts
+import * as fs22 from "node:fs";
+import * as path27 from "node:path";
+
+// src/git/worktrees/worktree-add.ts
+async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch, baseRef = "HEAD") {
+  const mainGit = cliSimpleGit(mainRepoPath);
+  const base = baseRef.trim() || "HEAD";
+  await mainGit.raw(["worktree", "add", "-b", branch, worktreePath, base]);
+}
+
+// src/worktrees/prepare-new-session-worktrees.ts
+function normalizeRepoRelPath(rel) {
+  return rel === "" ? "." : rel.replace(/\\/g, "/");
+}
+function resolveBaseRefForRepo(relNorm, baseBranches) {
+  if (!baseBranches) return "HEAD";
+  const direct = baseBranches[relNorm]?.trim();
+  if (direct) return direct;
+  if (relNorm !== "." && baseBranches["."]?.trim()) return baseBranches["."].trim();
+  return "HEAD";
+}
+async function prepareNewSessionWorktrees(options) {
+  const { worktreesRootPath, bridgeRoot, sessionId, layout, log: log2, worktreeBaseBranches } = options;
+  const bridgeResolved = path27.resolve(bridgeRoot);
+  const cwdKey = allocateDirNameForLauncherCwd(layout, bridgeResolved);
+  const bridgeKeyDir = path27.join(worktreesRootPath, cwdKey);
+  const sessionDir = path27.join(bridgeKeyDir, sessionId);
+  const repos = await discoverGitReposUnderRoot(bridgeResolved);
+  if (repos.length === 0) {
+    log2("[worktrees] No Git repositories under bridge root; skipping worktree creation.");
+    return null;
+  }
+  const branch = `session-${sessionId}`;
+  const worktreePaths = [];
+  fs22.mkdirSync(sessionDir, { recursive: true });
+  for (const repo of repos) {
+    let rel = path27.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path27.isAbsolute(rel)) continue;
+    const relNorm = normalizeRepoRelPath(rel === "" ? "." : rel);
+    const wtPath = relNorm === "." ? sessionDir : path27.join(sessionDir, relNorm);
+    if (relNorm !== ".") {
+      fs22.mkdirSync(path27.dirname(wtPath), { recursive: true });
+    }
+    const baseRef = resolveBaseRefForRepo(relNorm, worktreeBaseBranches);
+    try {
+      await gitWorktreeAddBranch(repo.absolutePath, wtPath, branch, baseRef);
+      log2(`[worktrees] Added worktree ${wtPath} (branch ${branch}, base ${baseRef}).`);
+      worktreePaths.push(wtPath);
+    } catch (e) {
+      log2(
+        `[worktrees] Worktree add failed for ${repo.absolutePath}: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+  }
+  if (worktreePaths.length === 0) return null;
+  return {
+    worktreePaths,
+    sessionParentPath: sessionDir,
+    workingTreeRelRoot: sessionDir
+  };
+}
+
+// src/worktrees/manager/prepare-and-remember-session-worktrees.ts
+async function prepareAndRememberSessionWorktrees(params) {
+  const prep = await prepareNewSessionWorktrees({
+    worktreesRootPath: params.worktreesRootPath,
+    bridgeRoot: getBridgeRoot(),
+    sessionId: params.sessionId,
+    layout: params.layout,
+    log: params.log,
+    ...params.worktreeBaseBranches && Object.keys(params.worktreeBaseBranches).length > 0 ? { worktreeBaseBranches: params.worktreeBaseBranches } : {}
+  });
+  if (!prep) return void 0;
+  params.cache.remember(params.sessionId, {
+    sessionParentPath: prep.sessionParentPath,
+    workingTreeRelRoot: prep.workingTreeRelRoot,
+    repoCheckoutPaths: prep.worktreePaths
+  });
+  return params.cache.getSessionParentPath(params.sessionId);
+}
+
+// src/worktrees/manager/resolve-existing-session-parent-path.ts
+async function resolveExistingSessionParentPath(sessionId, cache2, discover) {
+  const cached2 = cache2.getSessionParentPath(sessionId);
+  if (cached2) return cached2;
+  const disc = await discover();
+  if (disc) {
+    cache2.remember(sessionId, disc);
+    return cache2.getSessionParentPath(sessionId);
+  }
+  return void 0;
+}
+
+// src/worktrees/manager/resolve-explicit-session-parent-path.ts
+import * as path28 from "node:path";
+async function resolveExplicitSessionParentPath(params) {
+  const resolved = path28.resolve(params.parentPathRaw);
+  if (parseSessionParent(params.sessionParent) !== "worktrees_root") {
+    return resolved;
+  }
+  const rememberAndReturn = (binding) => {
+    params.cache.remember(params.sessionId, binding);
+    return params.cache.getSessionParentPath(params.sessionId) ?? resolved;
+  };
+  const diskFirst = await params.discover();
+  if (diskFirst) return rememberAndReturn(diskFirst);
+  const fromRoot = await discoverSessionWorktreesUnderSessionWorktreeRoot(resolved, params.sessionId);
+  if (fromRoot) return rememberAndReturn(fromRoot);
+  let cur = resolved;
+  for (let i = 0; i < 16; i++) {
+    await yieldToEventLoop();
+    const tryRoot = await discoverSessionWorktreesUnderSessionWorktreeRoot(cur, params.sessionId);
+    if (tryRoot) return rememberAndReturn(tryRoot);
+    const next = path28.dirname(cur);
+    if (next === cur) break;
+    cur = next;
+  }
+  return resolved;
+}
+
+// src/worktrees/manager/resolve-session-parent-path-for-prompt.ts
+async function resolveSessionParentPathForPrompt(params) {
+  const { sessionId, cache: cache2, worktreesRootPath, layout, log: log2, discover, opts } = params;
+  if (!sessionId) return void 0;
+  const sid = sessionId.trim();
+  const parentPathRaw = opts.sessionParentPath?.trim();
+  if (parentPathRaw) {
+    return resolveExplicitSessionParentPath({
+      sessionId: sid,
+      sessionParent: opts.sessionParent,
+      parentPathRaw,
+      cache: cache2,
+      discover: () => discover(sid)
+    });
+  }
+  const parentKind = parseSessionParent(opts.sessionParent);
+  if (parentKind === "bridge_root") {
+    return void 0;
+  }
+  if (parentKind === "worktrees_root") {
+    if (!opts.isNewSession) {
+      return resolveExistingSessionParentPath(sid, cache2, () => discover(sid));
+    }
+    return prepareAndRememberSessionWorktrees({
+      cache: cache2,
+      sessionId: sid,
+      worktreesRootPath,
+      layout,
+      log: log2,
+      ...opts.worktreeBaseBranches ? { worktreeBaseBranches: opts.worktreeBaseBranches } : {}
+    });
+  }
+  if (!opts.isNewSession) {
+    return resolveExistingSessionParentPath(sid, cache2, () => discover(sid));
+  }
+  return prepareAndRememberSessionWorktrees({
+    cache: cache2,
+    sessionId: sid,
+    worktreesRootPath,
+    layout,
+    log: log2
+  });
+}
+
 // src/git/changes/types.ts
 var MAX_PATCH_CHARS = 35e4;
 
@@ -33959,8 +34516,11 @@ function formatRemoteDisplayLabel(remoteUrl) {
   return `origin \xB7 ${hostPath}`;
 }
 
-// src/git/changes/get-working-tree-change-repo-details.ts
-import * as path22 from "node:path";
+// src/git/changes/repo/get-working-tree-change-repo-details.ts
+import * as path33 from "node:path";
+
+// src/git/changes/repo/build-working-tree-change-repo-detail.ts
+import * as path32 from "node:path";
 
 // src/git/commits/resolve-remote-tracking.ts
 async function tryConfigGet(g, key) {
@@ -34131,8 +34691,8 @@ async function listRecentCommits(repoDir, limitInput) {
 }
 
 // src/git/changes/parse/normalize-git-diff-path.ts
-function normalizeGitDiffPath(path46) {
-  return path46.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
+function normalizeGitDiffPath(path53) {
+  return path53.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
 }
 
 // src/git/changes/parse/expand-git-rename-numstat-path.ts
@@ -34245,8 +34805,8 @@ async function unifiedDiffForFileInRange(repoCwd, range, pathInRepo, change, mov
 }
 
 // src/git/changes/total-lines/resolve-changed-file-total-lines.ts
-import * as fs16 from "node:fs";
-import * as path19 from "node:path";
+import * as fs23 from "node:fs";
+import * as path29 from "node:path";
 
 // src/git/changes/lines/count-lines.ts
 import { createReadStream } from "node:fs";
@@ -34292,13 +34852,13 @@ async function countLinesInGitRef(repoGitCwd, ref, pathInRepo) {
 }
 async function resolveWorkingTreeFileTotalLines(options) {
   if (options.isBinary) return null;
-  const filePath = path19.join(options.repoGitCwd, options.pathInRepo);
+  const filePath = path29.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);
+      const st = await fs23.promises.stat(filePath);
       if (!st.isFile()) return null;
       return await countTextFileLines(filePath);
     } catch {
@@ -34327,7 +34887,7 @@ function pathInRepoFromLauncher(pathRelLauncher, repoRelPath) {
   }
   return pathRelLauncher;
 }
-function normalizeRepoRelPath(repoRelPath) {
+function normalizeRepoRelPath2(repoRelPath) {
   return repoRelPath === "." || repoRelPath === "" ? "." : repoRelPath;
 }
 
@@ -34429,8 +34989,8 @@ function parseNumstatEntries(lines) {
 }
 function parseNumstat(lines) {
   const m = /* @__PURE__ */ new Map();
-  for (const [path46, entry] of parseNumstatEntries(lines)) {
-    m.set(path46, { additions: entry.additions, deletions: entry.deletions });
+  for (const [path53, entry] of parseNumstatEntries(lines)) {
+    m.set(path53, { additions: entry.additions, deletions: entry.deletions });
   }
   return m;
 }
@@ -34561,7 +35121,7 @@ async function listChangedFilesForCommit(repoGitCwd, repoRelPath, commitSha) {
     g.raw(["diff", ...RENAME_DIFF_ARGS, "--numstat", range]).catch(() => "")
   ]);
   const parsed = parseDiffOutput(String(nameStatusRaw), String(numstatRaw));
-  const normRel = normalizeRepoRelPath(repoRelPath);
+  const normRel = normalizeRepoRelPath2(repoRelPath);
   const paths = collectChangedPaths({
     nameEntries: parsed.nameEntries,
     numByPath: parsed.numByPath
@@ -34589,14 +35149,14 @@ async function listChangedFilesForCommit(repoGitCwd, repoRelPath, commitSha) {
 }
 
 // src/git/changes/listing/apply-untracked-file-stats.ts
-import * as fs17 from "node:fs";
-import * as path20 from "node:path";
+import * as fs24 from "node:fs";
+import * as path30 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 repoFilePath = path30.join(options.repoGitCwd, pathInRepo);
     const fromGit = await numstatFromGitNoIndex(options.g, pathInRepo);
     if (fromGit) {
       row.additions = fromGit.additions;
@@ -34604,7 +35164,7 @@ function createUntrackedStatsApplier(options) {
       return;
     }
     try {
-      const st = await fs17.promises.stat(repoFilePath);
+      const st = await fs24.promises.stat(repoFilePath);
       row.additions = st.isFile() ? await countTextFileLines(repoFilePath) : 0;
     } catch {
       row.additions = 0;
@@ -34614,13 +35174,75 @@ function createUntrackedStatsApplier(options) {
 }
 
 // src/git/changes/listing/enrich-working-tree-file-rows.ts
-import * as path21 from "node:path";
+import * as path31 from "node:path";
 
-// src/git/changes/patch/hydrate-patch.ts
-import * as fs18 from "node:fs";
+// src/git/changes/patch/hydrate/append-injected-context-lines.ts
+async function appendInjectedContextLines(out, inject, maybeYield, injectedTotal) {
+  for (const t of inject) {
+    out.push(` ${t}`);
+    injectedTotal.value++;
+    await maybeYield();
+  }
+}
+
+// src/git/changes/patch/hydrate/constants.ts
 var UNIFIED_HUNK_HEADER_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
 var MAX_HYDRATE_LINES_PER_GAP = 8e3;
 var MAX_HYDRATE_LINES_PER_FILE = 8e4;
+var HYDRATE_YIELD_EVERY_LINES = 512;
+
+// src/git/changes/patch/hydrate/collect-gap-inject-lines.ts
+async function collectGapInjectLines(options) {
+  if (options.injectedTotal >= MAX_HYDRATE_LINES_PER_FILE) return null;
+  const remaining = MAX_HYDRATE_LINES_PER_FILE - options.injectedTotal;
+  if (options.gapNewEnd >= options.gapNewStart && options.change !== "removed") {
+    const nNew = options.gapNewEnd - options.gapNewStart + 1;
+    if (options.gapOldEnd < options.gapOldStart || options.gapOldEnd - options.gapOldStart + 1 === nNew) {
+      const cap = Math.min(nNew, MAX_HYDRATE_LINES_PER_GAP, remaining);
+      const dl = await options.diskLines();
+      if (dl && cap > 0) {
+        return dl.slice(options.gapNewStart - 1, options.gapNewStart - 1 + cap);
+      }
+    }
+    return null;
+  }
+  if (options.gapOldEnd >= options.gapOldStart && options.change === "removed") {
+    const nOld = options.gapOldEnd - options.gapOldStart + 1;
+    const cap = Math.min(nOld, MAX_HYDRATE_LINES_PER_GAP, remaining);
+    const bl = await options.blobLines();
+    if (bl && cap > 0) {
+      return bl.slice(options.gapOldStart - 1, options.gapOldStart - 1 + cap);
+    }
+  }
+  return null;
+}
+
+// src/git/changes/patch/hydrate/consume-unified-hunk-body.ts
+async function consumeUnifiedHunkBody(options) {
+  let i = options.startIndex;
+  let oldConsumed = 0;
+  let newConsumed = 0;
+  while (i < options.all.length) {
+    await options.maybeYield();
+    const bl = options.all[i];
+    if (UNIFIED_HUNK_HEADER_RE.test(bl)) break;
+    options.out.push(bl);
+    i++;
+    if (bl.startsWith("\\")) continue;
+    const ch = bl[0];
+    if (ch === " ") {
+      oldConsumed++;
+      newConsumed++;
+    } else if (ch === "-") {
+      oldConsumed++;
+    } else if (ch === "+") {
+      newConsumed++;
+    }
+  }
+  return { nextIndex: i, oldConsumed, newConsumed };
+}
+
+// src/git/changes/patch/hydrate/read-git-blob-lines.ts
 async function readGitBlobLines(repoCwd, pathInRepo) {
   try {
     const rel = pathInRepo.replace(/\\/g, "/");
@@ -34630,35 +35252,66 @@ async function readGitBlobLines(repoCwd, pathInRepo) {
     return null;
   }
 }
+
+// src/git/changes/patch/hydrate/read-worktree-file-lines.ts
+import * as fs25 from "node:fs";
 async function readWorktreeFileLines(filePath) {
   try {
-    const raw = await fs18.promises.readFile(filePath, "utf8");
+    const raw = await fs25.promises.readFile(filePath, "utf8");
     return raw.split(/\r?\n/);
   } catch {
     return null;
   }
 }
-async function hydrateUnifiedPatchWithFileContext(patch, filePath, repoGitCwd, pathInRepo, change) {
-  if (!patch.trim() || patch.includes("Binary files")) return patch;
-  const all = patch.split("\n");
-  const out = [];
-  let prevOldEnd = 0;
-  let prevNewEnd = 0;
-  let injectedTotal = 0;
-  let i = 0;
+
+// src/git/changes/patch/hydrate/create-hydrate-source-lines.ts
+function createHydrateSourceLines(options) {
   let blobCache;
   let diskCache;
   const blobLines = async () => {
     if (blobCache !== void 0) return blobCache;
-    blobCache = await readGitBlobLines(repoGitCwd, pathInRepo);
+    blobCache = await readGitBlobLines(options.repoGitCwd, options.pathInRepo);
     return blobCache;
   };
   const diskLines = async () => {
     if (diskCache !== void 0) return diskCache;
-    diskCache = await readWorktreeFileLines(filePath);
+    diskCache = await readWorktreeFileLines(options.filePath);
     return diskCache;
   };
+  return { blobLines, diskLines };
+}
+
+// src/git/changes/patch/hydrate/create-hydrate-yield.ts
+function createHydrateYield() {
+  let processedLines = 0;
+  return async () => {
+    processedLines++;
+    if (processedLines % HYDRATE_YIELD_EVERY_LINES === 0) {
+      await yieldToEventLoop();
+    }
+  };
+}
+
+// src/git/changes/patch/hydrate/update-hunk-line-ends.ts
+function updateHunkLineEnds(options) {
+  const prevOldEnd = options.oldStart > 0 ? options.oldStart + options.oldConsumed - 1 : 0;
+  const prevNewEnd = options.newStart > 0 ? options.newStart + options.newConsumed - 1 : 0;
+  return { prevOldEnd, prevNewEnd };
+}
+
+// src/git/changes/patch/hydrate/hydrate-unified-patch-with-file-context.ts
+async function hydrateUnifiedPatchWithFileContext(patch, filePath, repoGitCwd, pathInRepo, change) {
+  if (!patch.trim() || patch.includes("Binary files")) return patch;
+  const all = patch.split("\n");
+  const out = [];
+  let prevOldEnd = 0;
+  let prevNewEnd = 0;
+  const injectedTotal = { value: 0 };
+  let i = 0;
+  const maybeYield = createHydrateYield();
+  const { blobLines, diskLines } = createHydrateSourceLines({ repoGitCwd, pathInRepo, filePath });
   while (i < all.length) {
+    await maybeYield();
     const line = all[i];
     const hm = line.match(UNIFIED_HUNK_HEADER_RE);
     if (!hm) {
@@ -34668,66 +35321,31 @@ async function hydrateUnifiedPatchWithFileContext(patch, filePath, repoGitCwd, p
     }
     const oldStart = parseInt(hm[1], 10) || 0;
     const newStart = parseInt(hm[3], 10) || 0;
-    const gapOldStart = prevOldEnd + 1;
-    const gapOldEnd = oldStart - 1;
-    const gapNewStart = prevNewEnd + 1;
-    const gapNewEnd = newStart - 1;
-    if (injectedTotal < MAX_HYDRATE_LINES_PER_FILE) {
-      let inject = null;
-      if (gapNewEnd >= gapNewStart && change !== "removed") {
-        const nNew = gapNewEnd - gapNewStart + 1;
-        if (gapOldEnd < gapOldStart || gapOldEnd - gapOldStart + 1 === nNew) {
-          const cap = Math.min(nNew, MAX_HYDRATE_LINES_PER_GAP, MAX_HYDRATE_LINES_PER_FILE - injectedTotal);
-          const dl = await diskLines();
-          if (dl && cap > 0) {
-            inject = dl.slice(gapNewStart - 1, gapNewStart - 1 + cap);
-          }
-        }
-      } else if (gapOldEnd >= gapOldStart && change === "removed") {
-        const nOld = gapOldEnd - gapOldStart + 1;
-        const cap = Math.min(nOld, MAX_HYDRATE_LINES_PER_GAP, MAX_HYDRATE_LINES_PER_FILE - injectedTotal);
-        const bl = await blobLines();
-        if (bl && cap > 0) {
-          inject = bl.slice(gapOldStart - 1, gapOldStart - 1 + cap);
-        }
-      }
-      if (inject && inject.length > 0) {
-        for (const t of inject) {
-          out.push(` ${t}`);
-          injectedTotal++;
-        }
-      }
+    const inject = await collectGapInjectLines({
+      change,
+      gapOldStart: prevOldEnd + 1,
+      gapOldEnd: oldStart - 1,
+      gapNewStart: prevNewEnd + 1,
+      gapNewEnd: newStart - 1,
+      injectedTotal: injectedTotal.value,
+      blobLines,
+      diskLines
+    });
+    if (inject && inject.length > 0) {
+      await appendInjectedContextLines(out, inject, maybeYield, injectedTotal);
     }
     out.push(line);
     i++;
-    let oldConsumed = 0;
-    let newConsumed = 0;
-    while (i < all.length) {
-      const bl = all[i];
-      if (UNIFIED_HUNK_HEADER_RE.test(bl)) break;
-      out.push(bl);
-      i++;
-      if (bl.startsWith("\\")) continue;
-      const ch = bl[0];
-      if (ch === " ") {
-        oldConsumed++;
-        newConsumed++;
-      } else if (ch === "-") {
-        oldConsumed++;
-      } else if (ch === "+") {
-        newConsumed++;
-      }
-    }
-    if (oldStart > 0) {
-      prevOldEnd = oldStart + oldConsumed - 1;
-    } else {
-      prevOldEnd = 0;
-    }
-    if (newStart > 0) {
-      prevNewEnd = newStart + newConsumed - 1;
-    } else {
-      prevNewEnd = 0;
-    }
+    const body = await consumeUnifiedHunkBody({ all, startIndex: i, out, maybeYield });
+    i = body.nextIndex;
+    const ends = updateHunkLineEnds({
+      oldStart,
+      newStart,
+      oldConsumed: body.oldConsumed,
+      newConsumed: body.newConsumed
+    });
+    prevOldEnd = ends.prevOldEnd;
+    prevNewEnd = ends.prevNewEnd;
   }
   return truncatePatch(out.join("\n"));
 }
@@ -34736,7 +35354,7 @@ async function hydrateUnifiedPatchWithFileContext(patch, filePath, repoGitCwd, p
 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 filePath = path31.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) {
@@ -34798,14 +35416,76 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
   return dedupeChangedFileRows(rows);
 }
 
-// src/git/changes/get-working-tree-change-repo-details.ts
+// src/git/changes/repo/norm-repo-rel-path.ts
 function normRepoRel(p) {
   const x = p.replace(/\\/g, "/").trim();
   return x === "" ? "." : x;
 }
+
+// src/git/changes/repo/build-working-tree-change-repo-detail.ts
+async function buildWorkingTreeChangeRepoDetail(options) {
+  const t = path32.resolve(options.targetPath);
+  if (!await isGitRepoDirectory(t)) return null;
+  const g = cliSimpleGit(t);
+  let branch = "HEAD";
+  try {
+    await yieldToEventLoop2();
+    branch = (await g.raw(["rev-parse", "--abbrev-ref", "HEAD"])).trim() || "HEAD";
+  } catch {
+    branch = "HEAD";
+  }
+  await yieldToEventLoop2();
+  const remoteUrl = await getRemoteOriginUrl(t);
+  const remoteDisplay = formatRemoteDisplayLabel(remoteUrl);
+  const sessionWtRoot = options.sessionWorktreeRootPath ? path32.resolve(options.sessionWorktreeRootPath) : null;
+  const legacyNested = options.legacyRepoNestedSessionLayout;
+  let repoRelPath;
+  if (sessionWtRoot) {
+    const anchor = legacyNested ? path32.dirname(t) : t;
+    const relNorm = path32.relative(sessionWtRoot, anchor);
+    repoRelPath = relNorm === "" ? "." : relNorm.replace(/\\/g, "/");
+  } else {
+    let top = t;
+    try {
+      await yieldToEventLoop2();
+      top = (await g.raw(["rev-parse", "--show-toplevel"])).trim();
+    } catch {
+      top = t;
+    }
+    const rel = path32.relative(options.bridgeRoot, path32.resolve(top)).replace(/\\/g, "/") || ".";
+    repoRelPath = rel.startsWith("..") ? path32.basename(path32.resolve(top)) : rel;
+  }
+  const norm = normRepoRel(repoRelPath === "" ? "." : repoRelPath);
+  if (options.repoFilterRelPath && norm !== options.repoFilterRelPath) return null;
+  const repoDisplayName = formatRepoShortTitle(remoteUrl, norm === "." ? "." : norm);
+  const relForList = norm === "." ? "." : norm;
+  const files = options.basis.kind === "commit" ? await listChangedFilesForCommit(t, relForList, options.basis.sha.trim()) : await listChangedFilesForRepo(t, relForList);
+  const st = await g.status();
+  const hasUncommittedChanges = (st.files?.length ?? 0) > 0;
+  const [unpushedCommits, recentCommitList] = await Promise.all([
+    listUnpushedCommits(t),
+    listRecentCommits(t, options.recentCommitsLimit)
+  ]);
+  return {
+    repoRelPath: norm,
+    repoDisplayName,
+    branch,
+    remoteUrl,
+    remoteDisplay,
+    files,
+    hasUncommittedChanges,
+    unpushedCommits,
+    recentCommits: recentCommitList.commits,
+    recentCommitsHasMore: recentCommitList.hasMore,
+    changesView: options.basis.kind === "commit" ? "commit" : "working",
+    changesCommitSha: options.basis.kind === "commit" ? options.basis.sha.trim() : null
+  };
+}
+
+// src/git/changes/repo/get-working-tree-change-repo-details.ts
 async function getWorkingTreeChangeRepoDetails(options) {
-  const bridgeRoot = path22.resolve(getBridgeRoot());
-  const sessionWtRoot = options.sessionWorktreeRootPath ? path22.resolve(options.sessionWorktreeRootPath) : null;
+  const bridgeRoot = path33.resolve(getBridgeRoot());
+  const sessionWtRoot = options.sessionWorktreeRootPath ? path33.resolve(options.sessionWorktreeRootPath) : null;
   const legacyNested = options.legacyRepoNestedSessionLayout === true;
   const out = [];
   const filter = options.repoFilterRelPath != null ? normRepoRel(options.repoFilterRelPath) : null;
@@ -34818,59 +35498,18 @@ async function getWorkingTreeChangeRepoDetails(options) {
   }
   const basis = filter == null && basisInput.kind === "commit" ? { kind: "working" } : basisInput;
   for (let i = 0; i < options.commitTargetPaths.length; i++) {
-    if (i > 0) await yieldToEventLoop2();
-    const target = options.commitTargetPaths[i];
-    const t = path22.resolve(target);
-    if (!await isGitRepoDirectory(t)) continue;
-    const g = cliSimpleGit(t);
-    let branch = "HEAD";
-    try {
-      branch = (await g.raw(["rev-parse", "--abbrev-ref", "HEAD"])).trim() || "HEAD";
-    } catch {
-      branch = "HEAD";
-    }
-    const remoteUrl = await getRemoteOriginUrl(t);
-    const remoteDisplay = formatRemoteDisplayLabel(remoteUrl);
-    let repoRelPath;
-    if (sessionWtRoot) {
-      const anchor = legacyNested ? path22.dirname(t) : t;
-      const relNorm = path22.relative(sessionWtRoot, anchor);
-      repoRelPath = relNorm === "" ? "." : relNorm.replace(/\\/g, "/");
-    } else {
-      let top = t;
-      try {
-        top = (await g.raw(["rev-parse", "--show-toplevel"])).trim();
-      } catch {
-        top = t;
-      }
-      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;
-    const repoDisplayName = formatRepoShortTitle(remoteUrl, norm === "." ? "." : norm);
-    const relForList = norm === "." ? "." : norm;
-    const files = basis.kind === "commit" ? await listChangedFilesForCommit(t, relForList, basis.sha.trim()) : await listChangedFilesForRepo(t, relForList);
-    const st = await g.status();
-    const hasUncommittedChanges = (st.files?.length ?? 0) > 0;
-    const [unpushedCommits, recentCommitList] = await Promise.all([
-      listUnpushedCommits(t),
-      listRecentCommits(t, options.recentCommitsLimit)
-    ]);
-    out.push({
-      repoRelPath: norm,
-      repoDisplayName,
-      branch,
-      remoteUrl,
-      remoteDisplay,
-      files,
-      hasUncommittedChanges,
-      unpushedCommits,
-      recentCommits: recentCommitList.commits,
-      recentCommitsHasMore: recentCommitList.hasMore,
-      changesView: basis.kind === "commit" ? "commit" : "working",
-      changesCommitSha: basis.kind === "commit" ? basis.sha.trim() : null
-    });
+    await yieldToEventLoop2();
+    const detail = await buildWorkingTreeChangeRepoDetail({
+      targetPath: options.commitTargetPaths[i],
+      bridgeRoot,
+      sessionWorktreeRootPath: sessionWtRoot,
+      legacyRepoNestedSessionLayout: legacyNested,
+      repoFilterRelPath: filter,
+      basis,
+      recentCommitsLimit: options.recentCommitsLimit
+    });
+    if (!detail) continue;
+    out.push(detail);
     if (filter) return out;
   }
   return out;
@@ -34972,23 +35611,23 @@ async function commitSessionWorktrees(options) {
 }
 
 // src/worktrees/remove-session-worktrees.ts
-import * as fs21 from "node:fs";
+import * as fs28 from "node:fs";
 
 // src/git/worktrees/worktree-remove.ts
-import * as fs20 from "node:fs";
+import * as fs27 from "node:fs";
 
 // src/git/worktrees/resolve-main-repo-from-git-file.ts
-import * as fs19 from "node:fs";
-import * as path23 from "node:path";
+import * as fs26 from "node:fs";
+import * as path34 from "node:path";
 function resolveMainRepoFromWorktreeGitFile(wt) {
-  const gitDirFile = path23.join(wt, ".git");
-  if (!fs19.existsSync(gitDirFile) || !fs19.statSync(gitDirFile).isFile()) return "";
-  const first2 = fs19.readFileSync(gitDirFile, "utf8").trim();
+  const gitDirFile = path34.join(wt, ".git");
+  if (!fs26.existsSync(gitDirFile) || !fs26.statSync(gitDirFile).isFile()) return "";
+  const first2 = fs26.readFileSync(gitDirFile, "utf8").trim();
   const m = first2.match(/^gitdir:\s*(.+)$/im);
   if (!m) return "";
-  const gitWorktreePath = path23.resolve(wt, m[1].trim());
-  const gitDir = path23.dirname(path23.dirname(gitWorktreePath));
-  return path23.dirname(gitDir);
+  const gitWorktreePath = path34.resolve(wt, m[1].trim());
+  const gitDir = path34.dirname(path34.dirname(gitWorktreePath));
+  return path34.dirname(gitDir);
 }
 
 // src/git/worktrees/worktree-remove.ts
@@ -34997,7 +35636,7 @@ async function gitWorktreeRemoveForce(worktreePath) {
   if (mainRepo) {
     await cliSimpleGit(mainRepo).raw(["worktree", "remove", "--force", worktreePath]);
   } else {
-    fs20.rmSync(worktreePath, { recursive: true, force: true });
+    fs27.rmSync(worktreePath, { recursive: true, force: true });
   }
 }
 
@@ -35010,7 +35649,7 @@ async function removeSessionWorktrees(paths, log2) {
     } catch (e) {
       log2(`[worktrees] Remove failed for ${wt}: ${e instanceof Error ? e.message : String(e)}`);
       try {
-        fs21.rmSync(wt, { recursive: true, force: true });
+        fs28.rmSync(wt, { recursive: true, force: true });
       } catch {
       }
     }
@@ -35038,458 +35677,86 @@ async function renameSessionWorktreeBranches(paths, newBranch, log2) {
   }
 }
 
-// src/worktrees/worktree-layout-file.ts
-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 path24.join(os7.homedir(), ".buildautomaton", LAYOUT_FILENAME);
-}
-function normalizeLoadedLayout(raw) {
-  if (raw && typeof raw === "object" && "launcherCwds" in raw) {
-    const j = raw;
-    if (Array.isArray(j.launcherCwds)) return { launcherCwds: j.launcherCwds };
-  }
-  return { launcherCwds: [] };
-}
-function loadWorktreeLayout() {
-  try {
-    const p = defaultWorktreeLayoutPath();
-    if (!fs22.existsSync(p)) return { launcherCwds: [] };
-    const raw = JSON.parse(fs22.readFileSync(p, "utf8"));
-    return normalizeLoadedLayout(raw);
-  } catch {
-    return { launcherCwds: [] };
-  }
-}
-function saveWorktreeLayout(layout) {
-  try {
-    const dir = path24.dirname(defaultWorktreeLayoutPath());
-    fs22.mkdirSync(dir, { recursive: true });
-    fs22.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
-  } catch {
-  }
-}
-function baseNameSafe(pathString) {
-  return path24.basename(pathString).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
-}
-function getLauncherDirNameIfPresent(layout, bridgeRootPath2) {
-  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 = path24.resolve(bridgeRootPath2);
-  const base = baseNameSafe(norm);
-  const used = new Set(layout.launcherCwds.map((e) => e.dirName));
-  let name = base;
-  let n = 2;
-  while (used.has(name)) {
-    name = `${base}-${n}`;
-    n += 1;
-  }
-  layout.launcherCwds.push({ absolutePath: norm, dirName: name });
-  saveWorktreeLayout(layout);
-  return name;
-}
-
-// src/worktrees/discover-session-worktree-on-disk.ts
-import * as fs23 from "node:fs";
-import * as path25 from "node:path";
-function isGitDir(dirPath) {
-  try {
-    return fs23.existsSync(path25.join(dirPath, ".git"));
-  } catch {
-    return false;
-  }
-}
-function collectGitRepoRootsUnderDirectory(rootPath) {
-  const out = [];
-  const walk = (dir) => {
-    if (isGitDir(dir)) {
-      out.push(path25.resolve(dir));
-      return;
-    }
-    let entries;
-    try {
-      entries = fs23.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const e of entries) {
-      if (e.name.startsWith(".")) continue;
-      const full = path25.join(dir, e.name);
-      if (!e.isDirectory()) continue;
-      walk(full);
-    }
-  };
-  walk(path25.resolve(rootPath));
-  return [...new Set(out)];
-}
-function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
-  const out = [];
-  const walk = (dir, depth) => {
-    if (depth > maxDepth) return;
-    let entries;
-    try {
-      entries = fs23.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const e of entries) {
-      if (e.name.startsWith(".")) continue;
-      const full = path25.join(dir, e.name);
-      if (!e.isDirectory()) continue;
-      if (e.name === sessionId) {
-        if (isGitDir(full)) out.push(path25.resolve(full));
-      } else {
-        walk(full, depth + 1);
-      }
-    }
-  };
-  walk(root, 0);
-  return out;
-}
-function tryBindingFromSessionDirectory(sessionDir) {
-  let st;
-  try {
-    st = fs23.statSync(sessionDir);
-  } catch {
-    return null;
-  }
-  if (!st.isDirectory()) return null;
-  const worktreePaths = collectGitRepoRootsUnderDirectory(sessionDir);
-  if (worktreePaths.length === 0) return null;
-  const abs = path25.resolve(sessionDir);
-  return {
-    sessionParentPath: abs,
-    workingTreeRelRoot: abs,
-    repoCheckoutPaths: worktreePaths
-  };
-}
-function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
-  const sid = sessionId.trim();
-  if (!sid) return null;
-  const hintR = path25.resolve(checkoutPath);
-  let best = null;
-  let cur = path25.dirname(hintR);
-  for (let i = 0; i < 40; i++) {
-    const paths = collectWorktreeRootsNamed(cur, sid, 24);
-    if (paths.some((p) => path25.resolve(p) === hintR)) {
-      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths) ?? path25.resolve(paths[0]);
-      best = {
-        sessionParentPath: path25.resolve(isolated),
-        workingTreeRelRoot: path25.resolve(cur),
-        repoCheckoutPaths: paths.map((p) => path25.resolve(p))
-      };
-    }
-    const next = path25.dirname(cur);
-    if (next === cur) break;
-    cur = next;
-  }
-  return best;
-}
-function discoverSessionWorktreeOnDisk(options) {
-  const { sessionId, worktreesRootPath, layout, bridgeRoot } = options;
-  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 fs23.readdirSync(worktreesRootPath)) {
-      if (name.startsWith(".")) 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 = 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) ?? path25.resolve(legacyPaths[0]);
-      return {
-        sessionParentPath: path25.resolve(isolated),
-        workingTreeRelRoot: path25.resolve(layoutRoot),
-        repoCheckoutPaths: legacyPaths.map((p) => path25.resolve(p))
-      };
-    }
-  }
-  return null;
-}
-function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeRootPathOrHint, sessionId) {
-  const sid = sessionId.trim();
-  if (!sid) return null;
-  const hint = path25.resolve(sessionWorktreeRootPathOrHint);
-  const underHint = tryBindingFromSessionDirectory(path25.join(hint, sid));
-  if (underHint) return underHint;
-  const direct = tryBindingFromSessionDirectory(hint);
-  if (direct) {
-    if (path25.basename(hint) === sid && isGitDir(hint)) {
-      const legacyFromCheckout = discoverLegacyBindingAscendingFromCheckout(sid, hint);
-      if (legacyFromCheckout && legacyFromCheckout.repoCheckoutPaths.length > direct.repoCheckoutPaths.length) {
-        return legacyFromCheckout;
-      }
-    }
-    return direct;
-  }
-  if (path25.basename(hint) === sid && isGitDir(hint)) {
-    const legacyFromCheckout = discoverLegacyBindingAscendingFromCheckout(sid, hint);
-    if (legacyFromCheckout) return legacyFromCheckout;
-  }
-  let st;
-  try {
-    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) ?? path25.resolve(legacyPaths[0]);
+// src/worktrees/manager/resolve-commit-targets.ts
+function bridgeRootBinding(bridgeRoot) {
   return {
-    sessionParentPath: path25.resolve(isolated),
-    workingTreeRelRoot: hint,
-    repoCheckoutPaths: legacyPaths.map((p) => path25.resolve(p))
+    sessionParentPath: bridgeRoot,
+    workingTreeRelRoot: bridgeRoot,
+    repoCheckoutPaths: [bridgeRoot]
   };
 }
-
-// src/worktrees/manager/discover-session-binding.ts
-function discoverSessionBinding(params) {
-  return discoverSessionWorktreeOnDisk({
-    sessionId: params.sessionId,
-    worktreesRootPath: params.worktreesRootPath,
-    layout: params.layout,
-    bridgeRoot: getBridgeRoot()
-  });
-}
-
-// src/worktrees/manager/resolve-isolated-session-parent-path.ts
-function resolveIsolatedSessionParentPath(sessionId, cache2, ensureRepoCheckoutPaths) {
-  if (!sessionId) return null;
-  const sid = sessionId.trim();
-  const cached2 = cache2.getSessionParentPath(sid);
-  if (cached2) return cached2;
-  const paths = ensureRepoCheckoutPaths(sid);
-  if (!paths?.length) return null;
-  return resolveIsolatedSessionParentPathFromCheckouts(paths);
-}
-function ensureRepoCheckoutPathsForSession(sessionId, cache2, discover) {
-  if (!sessionId?.trim()) return void 0;
+async function resolveCommitTargetsAsync(sessionId, cache2, discover) {
   const sid = sessionId.trim();
-  const cached2 = cache2.getRepoCheckoutPaths(sid);
-  if (cached2?.length) return cached2;
-  const disc = discover(sid);
-  if (disc?.repoCheckoutPaths.length) {
-    cache2.remember(sid, disc);
-    return [...disc.repoCheckoutPaths];
-  }
-  return void 0;
-}
-
-// src/worktrees/manager/resolve-commit-targets.ts
-function resolveCommitTargets(sessionId, cache2, discover) {
-  const paths = cache2.getRepoCheckoutPathsRef(sessionId);
+  const paths = cache2.getRepoCheckoutPathsRef(sid);
   if (paths?.length) return paths;
-  const disc = discover(sessionId);
+  const disc = await discover(sid);
   if (disc?.repoCheckoutPaths.length) {
-    cache2.remember(sessionId, disc);
+    cache2.remember(sid, disc);
     return disc.repoCheckoutPaths;
   }
-  return [getBridgeRoot()];
+  const bridgeRoot = getBridgeRoot();
+  cache2.remember(sid, bridgeRootBinding(bridgeRoot));
+  return [bridgeRoot];
 }
 
-// src/worktrees/manager/parse-session-parent.ts
-function parseSessionParent(v) {
-  if (v === "bridge_root" || v === "worktrees_root") return v;
-  if (v === "session_worktrees_root") return "worktrees_root";
-  return null;
-}
-
-// src/worktrees/prepare-new-session-worktrees.ts
-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") {
-  const mainGit = cliSimpleGit(mainRepoPath);
-  const base = baseRef.trim() || "HEAD";
-  await mainGit.raw(["worktree", "add", "-b", branch, worktreePath, base]);
-}
-
-// src/worktrees/prepare-new-session-worktrees.ts
-function normalizeRepoRelPath2(rel) {
-  return rel === "" ? "." : rel.replace(/\\/g, "/");
-}
-function resolveBaseRefForRepo(relNorm, baseBranches) {
-  if (!baseBranches) return "HEAD";
-  const direct = baseBranches[relNorm]?.trim();
-  if (direct) return direct;
-  if (relNorm !== "." && baseBranches["."]?.trim()) return baseBranches["."].trim();
-  return "HEAD";
+// src/worktrees/manager/session-git-ops.ts
+async function commitSessionWorktree(cache2, params) {
+  const paths = cache2.getRepoCheckoutPathsRef(params.sessionId);
+  const targets = paths?.length ? paths : [getBridgeRoot()];
+  return commitSessionWorktrees({
+    paths: targets,
+    branch: params.branch,
+    message: params.message,
+    push: params.push
+  });
 }
-async function prepareNewSessionWorktrees(options) {
-  const { worktreesRootPath, bridgeRoot, sessionId, layout, log: log2, worktreeBaseBranches } = options;
-  const bridgeResolved = path26.resolve(bridgeRoot);
-  const cwdKey = allocateDirNameForLauncherCwd(layout, bridgeResolved);
-  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.");
-    return null;
-  }
-  const branch = `session-${sessionId}`;
-  const worktreePaths = [];
-  fs24.mkdirSync(sessionDir, { recursive: true });
-  for (const repo of repos) {
-    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 !== ".") {
-      fs24.mkdirSync(path26.dirname(wtPath), { recursive: true });
-    }
-    const baseRef = resolveBaseRefForRepo(relNorm, worktreeBaseBranches);
-    try {
-      await gitWorktreeAddBranch(repo.absolutePath, wtPath, branch, baseRef);
-      log2(`[worktrees] Added worktree ${wtPath} (branch ${branch}, base ${baseRef}).`);
-      worktreePaths.push(wtPath);
-    } catch (e) {
-      log2(
-        `[worktrees] Worktree add failed for ${repo.absolutePath}: ${e instanceof Error ? e.message : String(e)}`
-      );
-    }
-  }
-  if (worktreePaths.length === 0) return null;
-  return {
-    worktreePaths,
-    sessionParentPath: sessionDir,
-    workingTreeRelRoot: sessionDir
-  };
+async function getSessionWorkingTreeStatus(cache2, sessionId, discover) {
+  return aggregateSessionPathsWorkingTreeStatus(
+    await resolveCommitTargetsAsync(sessionId, cache2, discover)
+  );
 }
-
-// src/worktrees/manager/prepare-and-remember-session-worktrees.ts
-async function prepareAndRememberSessionWorktrees(params) {
-  const prep = await prepareNewSessionWorktrees({
-    worktreesRootPath: params.worktreesRootPath,
-    bridgeRoot: getBridgeRoot(),
-    sessionId: params.sessionId,
-    layout: params.layout,
-    log: params.log,
-    ...params.worktreeBaseBranches && Object.keys(params.worktreeBaseBranches).length > 0 ? { worktreeBaseBranches: params.worktreeBaseBranches } : {}
-  });
-  if (!prep) return void 0;
-  params.cache.remember(params.sessionId, {
-    sessionParentPath: prep.sessionParentPath,
-    workingTreeRelRoot: prep.workingTreeRelRoot,
-    repoCheckoutPaths: prep.worktreePaths
+async function getSessionWorkingTreeChangeDetails(cache2, sessionId, discover, opts) {
+  const targets = await resolveCommitTargetsAsync(sessionId, cache2, discover);
+  return getWorkingTreeChangeRepoDetails({
+    commitTargetPaths: targets,
+    sessionWorktreeRootPath: cache2.getWorkingTreeRelRoot(sessionId),
+    legacyRepoNestedSessionLayout: cache2.isLegacyNestedLayout(sessionId),
+    repoFilterRelPath: opts?.repoRelPath?.trim() ? opts.repoRelPath.trim() : null,
+    basis: opts?.basis,
+    recentCommitsLimit: opts?.recentCommitsLimit
   });
-  return params.cache.getSessionParentPath(params.sessionId);
 }
-
-// src/worktrees/manager/resolve-existing-session-parent-path.ts
-function resolveExistingSessionParentPath(sessionId, cache2, discover) {
-  const cached2 = cache2.getSessionParentPath(sessionId);
-  if (cached2) return cached2;
-  const disc = discover();
-  if (disc) {
-    cache2.remember(sessionId, disc);
-    return cache2.getSessionParentPath(sessionId);
+async function pushSessionUpstream(cache2, sessionId, discover) {
+  try {
+    await pushAheadOfUpstreamForPaths(await resolveCommitTargetsAsync(sessionId, cache2, discover));
+    return { ok: true };
+  } catch (e) {
+    const err = e instanceof Error ? e.message : String(e);
+    return { ok: false, error: err };
   }
-  return void 0;
 }
-
-// src/worktrees/manager/resolve-explicit-session-parent-path.ts
-import * as path27 from "node:path";
-function resolveExplicitSessionParentPath(params) {
-  const resolved = path27.resolve(params.parentPathRaw);
-  if (parseSessionParent(params.sessionParent) !== "worktrees_root") {
-    return resolved;
-  }
-  const rememberAndReturn = (binding) => {
-    params.cache.remember(params.sessionId, binding);
-    return params.cache.getSessionParentPath(params.sessionId) ?? resolved;
-  };
-  const diskFirst = params.discover();
-  if (diskFirst) return rememberAndReturn(diskFirst);
-  const fromRoot = discoverSessionWorktreesUnderSessionWorktreeRoot(resolved, params.sessionId);
-  if (fromRoot) return rememberAndReturn(fromRoot);
-  let cur = resolved;
-  for (let i = 0; i < 16; i++) {
-    const tryRoot = discoverSessionWorktreesUnderSessionWorktreeRoot(cur, params.sessionId);
-    if (tryRoot) return rememberAndReturn(tryRoot);
-    const next = path27.dirname(cur);
-    if (next === cur) break;
-    cur = next;
-  }
-  return resolved;
+async function removeSessionWorktreeCheckouts(cache2, sessionId, log2) {
+  const paths = cache2.clearSession(sessionId);
+  if (!paths?.length) return;
+  await removeSessionWorktrees(paths, log2);
 }
-
-// src/worktrees/manager/resolve-session-parent-path-for-prompt.ts
-async function resolveSessionParentPathForPrompt(params) {
-  const { sessionId, cache: cache2, worktreesRootPath, layout, log: log2, discover, opts } = params;
-  if (!sessionId) return void 0;
-  const sid = sessionId.trim();
-  const parentPathRaw = opts.sessionParentPath?.trim();
-  if (parentPathRaw) {
-    return resolveExplicitSessionParentPath({
-      sessionId: sid,
-      sessionParent: opts.sessionParent,
-      parentPathRaw,
-      cache: cache2,
-      discover: () => discover(sid)
-    });
-  }
-  const parentKind = parseSessionParent(opts.sessionParent);
-  if (parentKind === "bridge_root") {
-    return void 0;
-  }
-  if (parentKind === "worktrees_root") {
-    if (!opts.isNewSession) {
-      return resolveExistingSessionParentPath(sid, cache2, () => discover(sid));
-    }
-    return prepareAndRememberSessionWorktrees({
-      cache: cache2,
-      sessionId: sid,
-      worktreesRootPath,
-      layout,
-      log: log2,
-      ...opts.worktreeBaseBranches ? { worktreeBaseBranches: opts.worktreeBaseBranches } : {}
-    });
-  }
-  if (!opts.isNewSession) {
-    return resolveExistingSessionParentPath(sid, cache2, () => discover(sid));
-  }
-  return prepareAndRememberSessionWorktrees({
-    cache: cache2,
-    sessionId: sid,
-    worktreesRootPath,
-    layout,
-    log: log2
-  });
+async function renameSessionWorktreeBranch(cache2, sessionId, newBranch, log2) {
+  const paths = cache2.getRepoCheckoutPathsRef(sessionId);
+  if (!paths?.length) return;
+  await renameSessionWorktreeBranches(paths, newBranch, log2);
 }
 
 // src/worktrees/manager/session-worktree-cache.ts
-import * as path28 from "node:path";
+import * as path35 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) => path28.resolve(p));
+    const paths = binding.repoCheckoutPaths.map((p) => path35.resolve(p));
     this.sessionRepoCheckoutPaths.set(sessionId, paths);
-    this.sessionParentPathBySession.set(sessionId, path28.resolve(binding.sessionParentPath));
-    this.sessionWorkingTreeRelRootBySession.set(sessionId, path28.resolve(binding.workingTreeRelRoot));
+    this.sessionParentPathBySession.set(sessionId, path35.resolve(binding.sessionParentPath));
+    this.sessionWorkingTreeRelRootBySession.set(sessionId, path35.resolve(binding.workingTreeRelRoot));
   }
   clearSession(sessionId) {
     const paths = this.sessionRepoCheckoutPaths.get(sessionId);
@@ -35519,7 +35786,7 @@ var SessionWorktreeCache = class {
     const parent = this.sessionParentPathBySession.get(sessionId);
     const relRoot = this.sessionWorkingTreeRelRootBySession.get(sessionId);
     if (!parent || !relRoot) return false;
-    return path28.resolve(parent) !== path28.resolve(relRoot);
+    return path35.resolve(parent) !== path35.resolve(relRoot);
   }
 };
 
@@ -35534,8 +35801,8 @@ var SessionWorktreeManager = class {
     this.log = options.log;
     this.layout = loadWorktreeLayout();
   }
-  discover(sessionId) {
-    return discoverSessionBinding({
+  discoverAsync(sessionId) {
+    return discoverSessionBindingAsync({
       sessionId,
       worktreesRootPath: this.worktreesRootPath,
       layout: this.layout
@@ -35555,14 +35822,12 @@ var SessionWorktreeManager = class {
       worktreesRootPath: this.worktreesRootPath,
       layout: this.layout,
       log: this.log,
-      discover: (sid) => this.discover(sid),
+      discover: (sid) => this.discoverAsync(sid),
       opts
     });
   }
   async renameSessionBranch(sessionId, newBranch) {
-    const paths = this.cache.getRepoCheckoutPathsRef(sessionId);
-    if (!paths?.length) return;
-    await renameSessionWorktreeBranches(paths, newBranch, this.log);
+    await renameSessionWorktreeBranch(this.cache, sessionId, newBranch, this.log);
   }
   usesWorktreeSession(sessionId) {
     if (!sessionId) return false;
@@ -35573,79 +35838,55 @@ var SessionWorktreeManager = class {
     return this.cache.getRepoCheckoutPaths(sessionId);
   }
   ensureRepoCheckoutPathsForSession(sessionId) {
-    return ensureRepoCheckoutPathsForSession(sessionId, this.cache, (sid) => this.discover(sid));
+    return ensureRepoCheckoutPathsForSession(sessionId, this.cache);
+  }
+  async ensureRepoCheckoutPathsForSessionAsync(sessionId) {
+    return ensureRepoCheckoutPathsForSessionAsync(sessionId, this.cache, (sid) => this.discoverAsync(sid));
   }
   getSessionWorktreeRootForSession(sessionId) {
     return this.getIsolatedSessionParentPathForSession(sessionId);
   }
   async removeSessionWorktrees(sessionId) {
-    const paths = this.cache.clearSession(sessionId);
-    if (!paths?.length) return;
-    await removeSessionWorktrees(paths, this.log);
+    await removeSessionWorktreeCheckouts(this.cache, sessionId, this.log);
   }
   async commitSession(params) {
-    const paths = this.cache.getRepoCheckoutPathsRef(params.sessionId);
-    const targets = paths?.length ? paths : [getBridgeRoot()];
-    return commitSessionWorktrees({
-      paths: targets,
-      branch: params.branch,
-      message: params.message,
-      push: params.push
-    });
+    return commitSessionWorktree(this.cache, params);
   }
   async getSessionWorkingTreeStatus(sessionId) {
-    return aggregateSessionPathsWorkingTreeStatus(
-      resolveCommitTargets(sessionId, this.cache, (sid) => this.discover(sid))
-    );
+    return getSessionWorkingTreeStatus(this.cache, sessionId, (sid) => this.discoverAsync(sid));
   }
   async getSessionWorkingTreeChangeDetails(sessionId, opts) {
-    const targets = resolveCommitTargets(sessionId, this.cache, (sid) => this.discover(sid));
-    return getWorkingTreeChangeRepoDetails({
-      commitTargetPaths: targets,
-      sessionWorktreeRootPath: this.cache.getWorkingTreeRelRoot(sessionId),
-      legacyRepoNestedSessionLayout: this.cache.isLegacyNestedLayout(sessionId),
-      repoFilterRelPath: opts?.repoRelPath?.trim() ? opts.repoRelPath.trim() : null,
-      basis: opts?.basis,
-      recentCommitsLimit: opts?.recentCommitsLimit
-    });
+    return getSessionWorkingTreeChangeDetails(this.cache, sessionId, (sid) => this.discoverAsync(sid), opts);
   }
   async pushSessionUpstream(sessionId) {
-    try {
-      await pushAheadOfUpstreamForPaths(
-        resolveCommitTargets(sessionId, this.cache, (sid) => this.discover(sid))
-      );
-      return { ok: true };
-    } catch (e) {
-      const err = e instanceof Error ? e.message : String(e);
-      return { ok: false, error: err };
-    }
+    return pushSessionUpstream(this.cache, sessionId, (sid) => this.discoverAsync(sid));
   }
 };
 
 // src/worktrees/manager/default-worktrees-root-path.ts
-import * as path29 from "node:path";
+import * as path36 from "node:path";
 import os8 from "node:os";
 function defaultWorktreesRootPath() {
-  return path29.join(os8.homedir(), ".buildautomaton", "worktrees");
+  return path36.join(os8.homedir(), ".buildautomaton", "worktrees");
 }
 
 // src/files/watch-file-index.ts
 import { watch } from "node:fs";
-import path34 from "node:path";
+import path41 from "node:path";
 
 // src/files/index/paths.ts
-import path30 from "node:path";
+import path37 from "node:path";
 import crypto2 from "node:crypto";
 function getCwdHashForFileIndex(resolvedCwd) {
-  return crypto2.createHash("sha256").update(path30.resolve(resolvedCwd)).digest("hex").slice(0, INDEX_HASH_LEN);
+  return crypto2.createHash("sha256").update(path37.resolve(resolvedCwd)).digest("hex").slice(0, INDEX_HASH_LEN);
 }
 
 // src/files/index/build-file-index.ts
-import path32 from "node:path";
+import path39 from "node:path";
 
 // src/files/index/walk-workspace-tree.ts
-import fs25 from "node:fs";
-import path31 from "node:path";
+import fs29 from "node:fs";
+import path38 from "node:path";
 var DEPENDENCY_INSTALL_DIR_NAMES = /* @__PURE__ */ new Set([
   "node_modules",
   "bower_components",
@@ -35662,7 +35903,7 @@ function shouldSkipWorkspaceWalkEntry(name) {
 async function walkWorkspaceTreeAsync(dir, baseDir, onFile, state) {
   let names;
   try {
-    names = await fs25.promises.readdir(dir);
+    names = await fs29.promises.readdir(dir);
   } catch {
     return;
   }
@@ -35674,14 +35915,14 @@ async function walkWorkspaceTreeAsync(dir, baseDir, onFile, state) {
       if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
     }
     state.n++;
-    const full = path31.join(dir, name);
+    const full = path38.join(dir, name);
     let stat2;
     try {
-      stat2 = await fs25.promises.stat(full);
+      stat2 = await fs29.promises.stat(full);
     } catch {
       continue;
     }
-    const relative6 = path31.relative(baseDir, full).replace(/\\/g, "/");
+    const relative6 = path38.relative(baseDir, full).replace(/\\/g, "/");
     if (stat2.isDirectory()) {
       await walkWorkspaceTreeAsync(full, baseDir, onFile, state);
     } else if (stat2.isFile()) {
@@ -35694,7 +35935,7 @@ function createWalkYieldState() {
 }
 
 // src/files/index/file-index-sqlite-lock.ts
-import fs26 from "node:fs";
+import fs30 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");
@@ -35708,7 +35949,7 @@ function withFileIndexSqliteLock(fn) {
       if (!isSqliteCorruptError(e)) throw e;
       closeAllCliSqliteConnections();
       try {
-        fs26.unlinkSync(getCliSqlitePath());
+        fs30.unlinkSync(getCliSqlitePath());
       } catch {
       }
       chain = Promise.resolve();
@@ -35783,7 +36024,7 @@ async function collectWorkspacePathsAsync(resolved) {
 }
 async function buildFileIndexAsync(cwd) {
   return withFileIndexSqliteLock(async () => {
-    const resolved = path32.resolve(cwd);
+    const resolved = path39.resolve(cwd);
     await yieldToEventLoop();
     assertNotShutdown();
     const paths = await collectWorkspacePathsAsync(resolved);
@@ -35795,7 +36036,7 @@ async function buildFileIndexAsync(cwd) {
 }
 
 // src/files/index/ensure-file-index.ts
-import path33 from "node:path";
+import path40 from "node:path";
 
 // src/files/index/search-file-index.ts
 function escapeLikePattern(fragment) {
@@ -35847,7 +36088,7 @@ async function searchBridgeFilePathsAsync(resolvedCwd, query, limit = 100) {
 
 // src/files/index/ensure-file-index.ts
 async function ensureFileIndexAsync(cwd) {
-  const resolved = path33.resolve(cwd);
+  const resolved = path40.resolve(cwd);
   if (await bridgeFileIndexIsPopulated(resolved)) {
     return { fromCache: true, pathCount: await bridgeFileIndexPathCount(resolved) };
   }
@@ -35891,7 +36132,7 @@ function createFsWatcher(resolved, schedule) {
   }
 }
 function startFileIndexWatcher(cwd = getBridgeRoot()) {
-  const resolved = path34.resolve(cwd);
+  const resolved = path41.resolve(cwd);
   void buildFileIndexAsync(resolved).catch((e) => {
     if (e instanceof CliSqliteInterrupted) return;
     console.error("[file-index] Initial index build failed:", e);
@@ -35921,7 +36162,7 @@ function startFileIndexWatcher(cwd = getBridgeRoot()) {
 }
 
 // src/connection/create-bridge-connection.ts
-import * as path45 from "node:path";
+import * as path52 from "node:path";
 
 // src/dev-servers/manager/dev-server-manager.ts
 import { rm as rm2 } from "node:fs/promises";
@@ -35943,15 +36184,15 @@ function sendDevServerStatus(getWs, serverId, status, options) {
 
 // src/dev-servers/process/terminate-child-process.ts
 async function sigtermAndWaitForExit(proc, graceMs, log2, shortId) {
-  const exited = new Promise((resolve20) => {
-    proc.once("exit", () => resolve20());
+  const exited = new Promise((resolve26) => {
+    proc.once("exit", () => resolve26());
   });
   log2(`[dev-server] Sending SIGTERM to ${shortId} (pid=${proc.pid ?? "?"}).`);
   try {
     proc.kill("SIGTERM");
   } catch {
   }
-  await Promise.race([exited, new Promise((resolve20) => setTimeout(resolve20, graceMs))]);
+  await Promise.race([exited, new Promise((resolve26) => setTimeout(resolve26, graceMs))]);
 }
 function forceKillChild(proc, log2, shortId, graceMs) {
   log2(
@@ -35965,7 +36206,7 @@ function forceKillChild(proc, log2, shortId, graceMs) {
 }
 
 // src/dev-servers/process/wire-dev-server-child-process.ts
-import fs27 from "node:fs";
+import fs31 from "node:fs";
 
 // src/dev-servers/manager/forward-pipe.ts
 function forwardChildPipe(childReadable, terminal, onData) {
@@ -36001,7 +36242,7 @@ function wireDevServerChildProcess(d) {
         d.setPollInterval(void 0);
         return;
       }
-      fs27.readFile(d.mergedLogPath, (err, buf) => {
+      fs31.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));
@@ -36039,7 +36280,7 @@ ${errTail}` : ""}`);
       d.sendStatus(code === 0 || code == null ? "stopped" : "error", detail, tails);
     };
     if (mergedPath) {
-      fs27.readFile(mergedPath, (err, buf) => {
+      fs31.readFile(mergedPath, (err, buf) => {
         if (!err && buf.length > d.mergedReadPos.value) {
           const chunk = Buffer.from(buf.subarray(d.mergedReadPos.value));
           if (chunk.length > 0) {
@@ -36141,13 +36382,13 @@ function parseDevServerDefs(servers) {
 }
 
 // src/dev-servers/manager/shell-spawn/utils.ts
-import fs28 from "node:fs";
+import fs32 from "node:fs";
 function isSpawnEbadf(e) {
   return typeof e === "object" && e !== null && "code" in e && e.code === "EBADF";
 }
 function rmDirQuiet(dir) {
   try {
-    fs28.rmSync(dir, { recursive: true, force: true });
+    fs32.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -36155,7 +36396,7 @@ var cachedDevNullReadFd;
 function devNullReadFd() {
   if (cachedDevNullReadFd === void 0) {
     const devPath = process.platform === "win32" ? "nul" : "/dev/null";
-    cachedDevNullReadFd = fs28.openSync(devPath, "r");
+    cachedDevNullReadFd = fs32.openSync(devPath, "r");
   }
   return cachedDevNullReadFd;
 }
@@ -36229,15 +36470,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 fs29 from "node:fs";
+import fs33 from "node:fs";
 import { tmpdir } from "node:os";
-import path35 from "node:path";
+import path42 from "node:path";
 function trySpawnMergedLogFile(command, env, cwd, signal) {
-  const tmpRoot = fs29.mkdtempSync(path35.join(tmpdir(), "ba-devsrv-log-"));
-  const logPath = path35.join(tmpRoot, "combined.log");
+  const tmpRoot = fs33.mkdtempSync(path42.join(tmpdir(), "ba-devsrv-log-"));
+  const logPath = path42.join(tmpRoot, "combined.log");
   let logFd;
   try {
-    logFd = fs29.openSync(logPath, "a");
+    logFd = fs33.openSync(logPath, "a");
   } catch {
     rmDirQuiet(tmpRoot);
     return null;
@@ -36256,7 +36497,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     } else {
       proc = spawn8("/bin/sh", ["-c", command], { env, cwd, stdio, ...signal ? { signal } : {} });
     }
-    fs29.closeSync(logFd);
+    fs33.closeSync(logFd);
     return {
       proc,
       pipedStdoutStderr: true,
@@ -36265,7 +36506,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     };
   } catch (e) {
     try {
-      fs29.closeSync(logFd);
+      fs33.closeSync(logFd);
     } catch {
     }
     rmDirQuiet(tmpRoot);
@@ -36276,22 +36517,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 fs30 from "node:fs";
+import fs34 from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path36 from "node:path";
+import path43 from "node:path";
 function shSingleQuote(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 function trySpawnShellScriptLogRedirectUnix(command, env, cwd, signal) {
-  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");
+  const tmpRoot = fs34.mkdtempSync(path43.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path43.join(tmpRoot, "combined.log");
+  const innerPath = path43.join(tmpRoot, "_cmd.sh");
+  const runnerPath = path43.join(tmpRoot, "_run.sh");
   try {
-    fs30.writeFileSync(innerPath, `#!/bin/sh
+    fs34.writeFileSync(innerPath, `#!/bin/sh
 ${command}
 `);
-    fs30.writeFileSync(
+    fs34.writeFileSync(
       runnerPath,
       `#!/bin/sh
 cd ${shSingleQuote(cwd)}
@@ -36317,13 +36558,13 @@ cd ${shSingleQuote(cwd)}
   }
 }
 function trySpawnShellScriptLogRedirectWin(command, env, cwd, signal) {
-  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 tmpRoot = fs34.mkdtempSync(path43.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path43.join(tmpRoot, "combined.log");
+  const runnerPath = path43.join(tmpRoot, "_run.bat");
   const q = (p) => `"${p.replace(/"/g, '""')}"`;
   const com = process.env.ComSpec || "cmd.exe";
   try {
-    fs30.writeFileSync(
+    fs34.writeFileSync(
       runnerPath,
       `@ECHO OFF\r
 CD /D ${q(cwd)}\r
@@ -37092,30 +37333,30 @@ function createOnBridgeIdentified(opts) {
 }
 
 // src/skills/discover-local-agent-skills.ts
-import fs31 from "node:fs";
-import path37 from "node:path";
+import fs35 from "node:fs";
+import path44 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 = path37.join(cwd, rel);
-    if (!fs31.existsSync(base) || !fs31.statSync(base).isDirectory()) continue;
+    const base = path44.join(cwd, rel);
+    if (!fs35.existsSync(base) || !fs35.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs31.readdirSync(base);
+      entries = fs35.readdirSync(base);
     } catch {
       continue;
     }
     for (const name of entries) {
-      const dir = path37.join(base, name);
+      const dir = path44.join(base, name);
       try {
-        if (!fs31.statSync(dir).isDirectory()) continue;
+        if (!fs35.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      const skillMd = path37.join(dir, "SKILL.md");
-      if (!fs31.existsSync(skillMd)) continue;
+      const skillMd = path44.join(dir, "SKILL.md");
+      if (!fs35.existsSync(skillMd)) continue;
       const key = `${rel}/${name}`;
       if (seenKeys.has(key)) continue;
       seenKeys.add(key);
@@ -37127,23 +37368,23 @@ function discoverLocalSkills(cwd) {
 function discoverSkillLayoutRoots(cwd) {
   const roots = [];
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path37.join(cwd, rel);
-    if (!fs31.existsSync(base) || !fs31.statSync(base).isDirectory()) continue;
+    const base = path44.join(cwd, rel);
+    if (!fs35.existsSync(base) || !fs35.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs31.readdirSync(base);
+      entries = fs35.readdirSync(base);
     } catch {
       continue;
     }
     const skills2 = [];
     for (const name of entries) {
-      const dir = path37.join(base, name);
+      const dir = path44.join(base, name);
       try {
-        if (!fs31.statSync(dir).isDirectory()) continue;
+        if (!fs35.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      if (!fs31.existsSync(path37.join(dir, "SKILL.md"))) continue;
+      if (!fs35.existsSync(path44.join(dir, "SKILL.md"))) continue;
       const relPath = `${rel}/${name}`.replace(/\\/g, "/");
       skills2.push({ name, relPath });
     }
@@ -37499,7 +37740,7 @@ function syncRunningTurnQueueKeys(turns, queueKey) {
 }
 
 // src/prompt-turn-queue/runner/run-local-revert-before-queued-prompt.ts
-import fs32 from "node:fs";
+import fs36 from "node:fs";
 async function runLocalRevertBeforeQueuedPrompt(next, deps) {
   if (next.serverState !== "requeued_with_revert") return true;
   const sid = next.sessionId;
@@ -37508,7 +37749,7 @@ async function runLocalRevertBeforeQueuedPrompt(next, deps) {
   const agentBase = deps.sessionWorktreeManager.getSessionWorktreeRootForSession(sid) ?? getBridgeRoot();
   const file2 = snapshotFilePath(agentBase, tid);
   try {
-    await fs32.promises.access(file2, fs32.constants.F_OK);
+    await fs36.promises.access(file2, fs36.constants.F_OK);
   } catch {
     deps.log(
       `[Queue] requeued_with_revert: no pre-turn snapshot for ${tid.slice(0, 8)}\u2026; continuing without revert.`
@@ -37623,7 +37864,7 @@ function createBridgePromptSenders(deps, getWs) {
     sendWsMessage(s, wire);
     return true;
   };
-  const sendResult2 = (result) => {
+  const sendResult = (result) => {
     const skipEncryptForChangeSummaryFollowUp = result.type === "prompt_result" && result.followUpCatalogPromptId === BUILTIN_SESSION_CHANGE_SUMMARY_FOLLOW_UP_CATALOG_PROMPT_ID;
     const encryptedFields = result.type === "prompt_result" && !skipEncryptForChangeSummaryFollowUp ? ["output", "error"] : [];
     sendBridgeMessage(result, encryptedFields);
@@ -37656,7 +37897,7 @@ function createBridgePromptSenders(deps, getWs) {
     ]) : payload;
     sendWsMessage(s, wire);
   };
-  return { sendBridgeMessage, sendResult: sendResult2, sendSessionUpdate };
+  return { sendBridgeMessage, sendResult, sendSessionUpdate };
 }
 
 // src/agents/acp/from-bridge/handle-bridge-prompt/parse-bridge-attachments.ts
@@ -37760,7 +38001,7 @@ async function readGitBranch(cwd) {
 async function runBridgePromptPreamble(params) {
   const { getWs, log: log2, sessionWorktreeManager, sessionId, runId, effectiveCwd } = params;
   const s = getWs();
-  const repoCheckoutPaths = sessionWorktreeManager.ensureRepoCheckoutPathsForSession(sessionId);
+  const repoCheckoutPaths = await sessionWorktreeManager.ensureRepoCheckoutPathsForSessionAsync(sessionId);
   const repoRoots = await resolveSnapshotRepoRoots({
     worktreePaths: repoCheckoutPaths,
     fallbackCwd: effectiveCwd,
@@ -37796,9 +38037,9 @@ function parseChangeSummarySnapshots(raw) {
   for (const item of raw) {
     if (!item || typeof item !== "object") continue;
     const o = item;
-    const path46 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
-    if (!path46) continue;
-    const row = { path: path46 };
+    const path53 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
+    if (!path53) continue;
+    const row = { path: path53 };
     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;
@@ -37832,7 +38073,7 @@ async function runPreambleAndPrompt(params) {
     agentId,
     agentConfig,
     resolvedCwd,
-    senders: { sendResult: sendResult2, sendSessionUpdate }
+    senders: { sendResult, sendSessionUpdate }
   } = params;
   const effectiveCwd = resolveSessionParentPathForAgentProcess(resolvedCwd);
   await runBridgePromptPreamble({
@@ -37870,7 +38111,7 @@ async function runPreambleAndPrompt(params) {
     agentId,
     agentConfig,
     sessionParentPath: effectiveCwd,
-    sendResult: sendResult2,
+    sendResult,
     sendSessionUpdate,
     followUpCatalogPromptId,
     sessionChangeSummaryFilePaths: pathsForUpload,
@@ -38012,14 +38253,14 @@ var handleSkillCallMessage = (msg, { getWs, log: log2 }) => {
 };
 
 // src/files/list-dir/index.ts
-import fs34 from "node:fs";
+import fs38 from "node:fs";
 
 // src/files/ensure-under-cwd.ts
-import path38 from "node:path";
+import path45 from "node:path";
 function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
-  const normalized = path38.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path38.resolve(cwd, normalized);
-  if (!resolved.startsWith(cwd + path38.sep) && resolved !== cwd) {
+  const normalized = path45.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path45.resolve(cwd, normalized);
+  if (!resolved.startsWith(cwd + path45.sep) && resolved !== cwd) {
     return null;
   }
   return resolved;
@@ -38029,15 +38270,15 @@ function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
 var LIST_DIR_YIELD_EVERY = 256;
 
 // src/files/list-dir/map-dir-entry.ts
-import path39 from "node:path";
-import fs33 from "node:fs";
+import path46 from "node:path";
+import fs37 from "node:fs";
 async function mapDirEntry(d, relativePath, resolved) {
-  const entryPath = path39.join(relativePath || ".", d.name).replace(/\\/g, "/");
-  const fullPath = path39.join(resolved, d.name);
+  const entryPath = path46.join(relativePath || ".", d.name).replace(/\\/g, "/");
+  const fullPath = path46.join(resolved, d.name);
   let isDir = d.isDirectory();
   if (d.isSymbolicLink()) {
     try {
-      const targetStat = await fs33.promises.stat(fullPath);
+      const targetStat = await fs37.promises.stat(fullPath);
       isDir = targetStat.isDirectory();
     } catch {
       isDir = false;
@@ -38067,7 +38308,7 @@ async function listDirAsync(relativePath, sessionParentPath = getBridgeRoot()) {
     return { error: "Path is outside working directory" };
   }
   try {
-    const names = await fs34.promises.readdir(resolved, { withFileTypes: true });
+    const names = await fs38.promises.readdir(resolved, { withFileTypes: true });
     const entries = [];
     for (let i = 0; i < names.length; i++) {
       if (i > 0 && i % LIST_DIR_YIELD_EVERY === 0) {
@@ -38087,18 +38328,18 @@ var LINE_CHUNK_SIZE = 64 * 1024;
 var READ_RANGE_YIELD_EVERY_BYTES = 256 * 1024;
 
 // src/files/read-file/resolve-file-path.ts
-import fs35 from "node:fs";
+import fs39 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 fs35.promises.realpath(resolved);
+    real = await fs39.promises.realpath(resolved);
   } catch {
     real = resolved;
   }
   try {
-    const stat2 = await fs35.promises.stat(real);
+    const stat2 = await fs39.promises.stat(real);
     if (!stat2.isFile()) return { error: "Not a file" };
     return real;
   } catch (err) {
@@ -38107,11 +38348,11 @@ async function resolveFilePathAsync(relativePath, sessionParentPath = getBridgeR
 }
 
 // src/files/read-file/read-file-range-async.ts
-import fs36 from "node:fs";
+import fs40 from "node:fs";
 import { StringDecoder } from "node:string_decoder";
 async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
-  const fileSize = (await fs36.promises.stat(filePath)).size;
-  const fd = await fs36.promises.open(filePath, "r");
+  const fileSize = (await fs40.promises.stat(filePath)).size;
+  const fd = await fs40.promises.open(filePath, "r");
   const bufSize = 64 * 1024;
   const buf = Buffer.alloc(bufSize);
   const decoder = new StringDecoder("utf8");
@@ -38273,11 +38514,11 @@ async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, li
 }
 
 // src/files/read-file/read-file-buffer-full-async.ts
-import fs37 from "node:fs";
+import fs41 from "node:fs";
 var READ_CHUNK_BYTES = 256 * 1024;
 async function readFileBufferFullAsync(filePath) {
-  const stat2 = await fs37.promises.stat(filePath);
-  const fd = await fs37.promises.open(filePath, "r");
+  const stat2 = await fs41.promises.stat(filePath);
+  const fd = await fs41.promises.open(filePath, "r");
   const chunks = [];
   let position = 0;
   let bytesSinceYield = 0;
@@ -38373,10 +38614,10 @@ async function readFileAsync(relativePath, startLine, endLine, lineOffset, lineC
 }
 
 // src/files/resolve-file-browser-session-parent.ts
-function resolveFileBrowserSessionParent(sessionWorktreeManager, sessionId) {
+async function resolveFileBrowserSessionParent(sessionWorktreeManager, sessionId) {
   const sid = sessionId?.trim();
   if (sid) {
-    sessionWorktreeManager.ensureRepoCheckoutPathsForSession(sid);
+    await sessionWorktreeManager.ensureRepoCheckoutPathsForSessionAsync(sid);
     const worktreeRoot = sessionWorktreeManager.getSessionWorktreeRootForSession(sid);
     if (worktreeRoot) return worktreeRoot;
   }
@@ -38384,14 +38625,14 @@ function resolveFileBrowserSessionParent(sessionWorktreeManager, sessionId) {
 }
 
 // src/files/handle-file-browser-search.ts
-import path40 from "node:path";
+import path47 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 = path40.resolve(
-      sessionWorktreeManager != null ? resolveFileBrowserSessionParent(sessionWorktreeManager, msg.sessionId) : getBridgeRoot()
+    const sessionParentPath = path47.resolve(
+      sessionWorktreeManager != null ? await resolveFileBrowserSessionParent(sessionWorktreeManager, msg.sessionId) : getBridgeRoot()
     );
     if (!await bridgeFileIndexIsPopulated(sessionParentPath)) {
       const payload2 = {
@@ -38429,7 +38670,7 @@ function handleFileBrowserRequest(msg, socket, e2ee, sessionWorktreeManager) {
   void (async () => {
     const reqPath = msg.path.replace(/^\/+/, "") || ".";
     const op = msg.op === "read" ? "read" : "list";
-    const sessionParentPath = sessionWorktreeManager != null ? resolveFileBrowserSessionParent(sessionWorktreeManager, msg.sessionId) : void 0;
+    const sessionParentPath = sessionWorktreeManager != null ? await resolveFileBrowserSessionParent(sessionWorktreeManager, msg.sessionId) : void 0;
     if (op === "list") {
       const result = await listDirAsync(reqPath, sessionParentPath);
       if ("error" in result) {
@@ -38509,8 +38750,8 @@ function handleSkillLayoutRequest(msg, deps) {
 }
 
 // src/skills/install-remote-skills.ts
-import fs38 from "node:fs";
-import path41 from "node:path";
+import fs42 from "node:fs";
+import path48 from "node:path";
 function installRemoteSkills(cwd, targetDir, items) {
   const installed2 = [];
   if (!Array.isArray(items)) {
@@ -38521,15 +38762,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 = path41.join(cwd, targetDir, item.skillName);
+      const skillDir = path48.join(cwd, targetDir, item.skillName);
       for (const f of item.files) {
         if (typeof f.path !== "string" || !f.text && !f.base64) continue;
-        const dest = path41.join(skillDir, f.path);
-        fs38.mkdirSync(path41.dirname(dest), { recursive: true });
+        const dest = path48.join(skillDir, f.path);
+        fs42.mkdirSync(path48.dirname(dest), { recursive: true });
         if (f.text !== void 0) {
-          fs38.writeFileSync(dest, f.text, "utf8");
+          fs42.writeFileSync(dest, f.text, "utf8");
         } else if (f.base64) {
-          fs38.writeFileSync(dest, Buffer.from(f.base64, "base64"));
+          fs42.writeFileSync(dest, Buffer.from(f.base64, "base64"));
         }
       }
       installed2.push({
@@ -38570,12 +38811,116 @@ var handleRefreshLocalSkills = (_msg, deps) => {
   deps.sendLocalSkillsReport?.();
 };
 
-// src/routing/handlers/session-git-request.ts
-function sendResult(ws, id, payload, e2ee, encryptedFields = []) {
+// src/routing/handlers/git/handle-session-git-commit.ts
+async function handleSessionGitCommitAction(deps, sessionId, msg, reply) {
+  const branch = typeof msg.branch === "string" ? msg.branch : "";
+  const message = typeof msg.message === "string" ? msg.message : "";
+  const pushAfterCommit = msg.pushAfterCommit === true;
+  if (!branch.trim() || !message.trim()) {
+    reply({ ok: false, error: "branch and message are required for commit" });
+    return;
+  }
+  const commitRes = await deps.sessionWorktreeManager.commitSession({
+    sessionId,
+    branch: branch.trim(),
+    message: message.trim(),
+    push: pushAfterCommit
+  });
+  if (!commitRes.ok) {
+    reply({ ok: false, error: commitRes.error ?? "Commit failed" });
+    return;
+  }
+  const st = await deps.sessionWorktreeManager.getSessionWorkingTreeStatus(sessionId);
+  reply({
+    ok: true,
+    hasUncommittedChanges: st.hasUncommittedChanges,
+    hasUnpushedCommits: st.hasUnpushedCommits,
+    uncommittedFileCount: st.uncommittedFileCount
+  });
+}
+
+// src/routing/handlers/git/coalesce-list-changes.ts
+var listChangesInflight = /* @__PURE__ */ new Map();
+function listChangesInflightKey(sessionId, opts) {
+  const basis = opts?.basis;
+  return [
+    sessionId,
+    opts?.repoRelPath ?? "",
+    basis?.kind === "commit" ? `commit:${basis.sha}` : "working",
+    String(opts?.recentCommitsLimit ?? "")
+  ].join("|");
+}
+function getSessionWorkingTreeChangeDetailsCoalesced(sessionWorktreeManager, sessionId, opts) {
+  const key = listChangesInflightKey(sessionId, opts);
+  const existing = listChangesInflight.get(key);
+  if (existing) return existing;
+  const promise2 = sessionWorktreeManager.getSessionWorkingTreeChangeDetails(sessionId, opts).finally(() => {
+    if (listChangesInflight.get(key) === promise2) listChangesInflight.delete(key);
+  });
+  listChangesInflight.set(key, promise2);
+  return promise2;
+}
+
+// src/routing/handlers/git/handle-session-git-list-changes.ts
+async function handleSessionGitListChangesAction(deps, msg, reply) {
+  const repoRel = typeof msg.changesRepoRelPath === "string" ? msg.changesRepoRelPath.trim() : "";
+  const view = msg.changesView === "commit" ? "commit" : "working";
+  const commitSha = typeof msg.changesCommitSha === "string" ? msg.changesCommitSha.trim() : "";
+  if (view === "commit") {
+    if (!repoRel || !commitSha) {
+      reply({ ok: false, error: "changesRepoRelPath and changesCommitSha are required for commit view" });
+      return;
+    }
+  }
+  const recentCommitsLimit = typeof msg.changesRecentCommitsLimit === "number" || typeof msg.changesRecentCommitsLimit === "string" ? msg.changesRecentCommitsLimit : void 0;
+  const opts = repoRel && view === "commit" && commitSha ? {
+    repoRelPath: repoRel,
+    basis: { kind: "commit", sha: commitSha },
+    recentCommitsLimit
+  } : repoRel ? { repoRelPath: repoRel, basis: { kind: "working" }, recentCommitsLimit } : recentCommitsLimit !== void 0 ? { recentCommitsLimit } : void 0;
+  const repos = await getSessionWorkingTreeChangeDetailsCoalesced(
+    deps.sessionWorktreeManager,
+    msg.sessionId,
+    opts
+  );
+  reply({ ok: true, repos }, ["repos"]);
+}
+
+// src/routing/handlers/git/handle-session-git-push.ts
+async function handleSessionGitPushAction(deps, sessionId, reply) {
+  const pushRes = await deps.sessionWorktreeManager.pushSessionUpstream(sessionId);
+  if (!pushRes.ok) {
+    reply({ ok: false, error: pushRes.error ?? "Push failed" });
+    return;
+  }
+  const st = await deps.sessionWorktreeManager.getSessionWorkingTreeStatus(sessionId);
+  reply({
+    ok: true,
+    hasUncommittedChanges: st.hasUncommittedChanges,
+    hasUnpushedCommits: st.hasUnpushedCommits,
+    uncommittedFileCount: st.uncommittedFileCount
+  });
+}
+
+// src/routing/handlers/git/handle-session-git-status.ts
+async function handleSessionGitStatusAction(deps, sessionId, reply) {
+  const r = await deps.sessionWorktreeManager.getSessionWorkingTreeStatus(sessionId);
+  reply({
+    ok: true,
+    hasUncommittedChanges: r.hasUncommittedChanges,
+    hasUnpushedCommits: r.hasUnpushedCommits,
+    uncommittedFileCount: r.uncommittedFileCount
+  });
+}
+
+// src/routing/handlers/git/send-session-git-result.ts
+function sendSessionGitResult(ws, id, payload, e2ee, encryptedFields = []) {
   if (!ws) return;
   const message = { type: "session_git_result", id, ...payload };
   sendWsMessage(ws, e2ee && encryptedFields.length > 0 ? e2ee.encryptFields(message, encryptedFields) : message);
 }
+
+// src/routing/handlers/git/session-git-request.ts
 var handleSessionGitRequestMessage = (msg, deps) => {
   if (typeof msg.id !== "string") return;
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
@@ -38584,80 +38929,21 @@ var handleSessionGitRequestMessage = (msg, deps) => {
     return;
   void (async () => {
     const ws = deps.getWs();
-    const reply = (payload, encryptedFields = []) => sendResult(ws, msg.id, payload, deps.e2ee, encryptedFields);
+    const reply = (payload, encryptedFields = []) => sendSessionGitResult(ws, msg.id, payload, deps.e2ee, encryptedFields);
     try {
       if (action === "status") {
-        const r = await deps.sessionWorktreeManager.getSessionWorkingTreeStatus(sessionId);
-        reply({
-          ok: true,
-          hasUncommittedChanges: r.hasUncommittedChanges,
-          hasUnpushedCommits: r.hasUnpushedCommits,
-          uncommittedFileCount: r.uncommittedFileCount
-        });
+        await handleSessionGitStatusAction(deps, sessionId, reply);
         return;
       }
       if (action === "list_changes") {
-        const repoRel = typeof msg.changesRepoRelPath === "string" ? msg.changesRepoRelPath.trim() : "";
-        const view = msg.changesView === "commit" ? "commit" : "working";
-        const commitSha = typeof msg.changesCommitSha === "string" ? msg.changesCommitSha.trim() : "";
-        if (view === "commit") {
-          if (!repoRel || !commitSha) {
-            reply({ ok: false, error: "changesRepoRelPath and changesCommitSha are required for commit view" });
-            return;
-          }
-        }
-        const recentCommitsLimit = typeof msg.changesRecentCommitsLimit === "number" || typeof msg.changesRecentCommitsLimit === "string" ? msg.changesRecentCommitsLimit : void 0;
-        const opts = repoRel && view === "commit" && commitSha ? {
-          repoRelPath: repoRel,
-          basis: { kind: "commit", sha: commitSha },
-          recentCommitsLimit
-        } : repoRel ? { repoRelPath: repoRel, basis: { kind: "working" }, recentCommitsLimit } : recentCommitsLimit !== void 0 ? { recentCommitsLimit } : void 0;
-        const repos = await deps.sessionWorktreeManager.getSessionWorkingTreeChangeDetails(sessionId, opts);
-        reply({
-          ok: true,
-          repos
-        }, ["repos"]);
+        await handleSessionGitListChangesAction(deps, { ...msg, sessionId }, reply);
         return;
       }
       if (action === "push") {
-        const pushRes = await deps.sessionWorktreeManager.pushSessionUpstream(sessionId);
-        if (!pushRes.ok) {
-          reply({ ok: false, error: pushRes.error ?? "Push failed" });
-          return;
-        }
-        const st2 = await deps.sessionWorktreeManager.getSessionWorkingTreeStatus(sessionId);
-        reply({
-          ok: true,
-          hasUncommittedChanges: st2.hasUncommittedChanges,
-          hasUnpushedCommits: st2.hasUnpushedCommits,
-          uncommittedFileCount: st2.uncommittedFileCount
-        });
-        return;
-      }
-      const branch = typeof msg.branch === "string" ? msg.branch : "";
-      const message = typeof msg.message === "string" ? msg.message : "";
-      const pushAfterCommit = msg.pushAfterCommit === true;
-      if (!branch.trim() || !message.trim()) {
-        reply({ ok: false, error: "branch and message are required for commit" });
+        await handleSessionGitPushAction(deps, sessionId, reply);
         return;
       }
-      const commitRes = await deps.sessionWorktreeManager.commitSession({
-        sessionId,
-        branch: branch.trim(),
-        message: message.trim(),
-        push: pushAfterCommit
-      });
-      if (!commitRes.ok) {
-        reply({ ok: false, error: commitRes.error ?? "Commit failed" });
-        return;
-      }
-      const st = await deps.sessionWorktreeManager.getSessionWorkingTreeStatus(sessionId);
-      reply({
-        ok: true,
-        hasUncommittedChanges: st.hasUncommittedChanges,
-        hasUnpushedCommits: st.hasUnpushedCommits,
-        uncommittedFileCount: st.uncommittedFileCount
-      });
+      await handleSessionGitCommitAction(deps, sessionId, msg, reply);
     } catch (e) {
       reply({ ok: false, error: e instanceof Error ? e.message : String(e) });
     }
@@ -38687,7 +38973,7 @@ var handleSessionDiscardedMessage = (msg, deps) => {
 };
 
 // src/routing/handlers/revert-turn-snapshot.ts
-import * as fs39 from "node:fs";
+import * as fs43 from "node:fs";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
@@ -38700,7 +38986,7 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
     const agentBase = sessionWorktreeManager.getSessionWorktreeRootForSession(sessionId) ?? getBridgeRoot();
     const file2 = snapshotFilePath(agentBase, turnId);
     try {
-      await fs39.promises.access(file2, fs39.constants.F_OK);
+      await fs43.promises.access(file2, fs43.constants.F_OK);
     } catch {
       sendWsMessage(s, {
         type: "revert_turn_snapshot_result",
@@ -38742,7 +39028,7 @@ var handleDevServersConfig = (msg, deps) => {
 };
 
 // src/git/bridge-git-context.ts
-import * as path42 from "node:path";
+import * as path49 from "node:path";
 
 // src/git/branches/get-current-branch.ts
 async function getCurrentBranch(repoPath) {
@@ -38792,12 +39078,12 @@ async function listRepoBranchRefs(repoPath) {
 // src/git/bridge-git-context.ts
 function folderNameForRelPath(relPath, bridgeRoot) {
   if (relPath === "." || relPath === "") {
-    return path42.basename(path42.resolve(bridgeRoot)) || "repo";
+    return path49.basename(path49.resolve(bridgeRoot)) || "repo";
   }
-  return path42.basename(relPath) || relPath;
+  return path49.basename(relPath) || relPath;
 }
 async function discoverGitReposForBridgeContext(bridgeRoot) {
-  const root = path42.resolve(bridgeRoot);
+  const root = path49.resolve(bridgeRoot);
   if (await isGitRepoDirectory(root)) {
     const remoteUrl = await getRemoteOriginUrl(root);
     return [{ absolutePath: root, remoteUrl }];
@@ -38805,17 +39091,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(path42.resolve(repo.absolutePath), repo);
+    byPath.set(path49.resolve(repo.absolutePath), repo);
   }
   return [...byPath.values()];
 }
 async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path42.resolve(bridgeRoot);
+  const bridgeResolved = path49.resolve(bridgeRoot);
   const repos = await discoverGitReposForBridgeContext(bridgeResolved);
   const rows = [];
   for (const repo of repos) {
-    let rel = path42.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path42.isAbsolute(rel)) continue;
+    let rel = path49.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path49.isAbsolute(rel)) continue;
     const relPath = rel === "" ? "." : rel.replace(/\\/g, "/");
     const currentBranch = await getCurrentBranch(repo.absolutePath);
     const remoteUrl = repo.remoteUrl.trim() || null;
@@ -38830,11 +39116,11 @@ async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
   return rows;
 }
 async function listRepoBranchesForBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path42.resolve(bridgeRoot);
+  const bridgeResolved = path49.resolve(bridgeRoot);
   const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
-  const repoPath = rel === "" ? bridgeResolved : path42.join(bridgeResolved, rel);
-  const resolved = path42.resolve(repoPath);
-  if (!resolved.startsWith(bridgeResolved + path42.sep) && resolved !== bridgeResolved) {
+  const repoPath = rel === "" ? bridgeResolved : path49.join(bridgeResolved, rel);
+  const resolved = path49.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path49.sep) && resolved !== bridgeResolved) {
     return [];
   }
   return listRepoBranchRefs(resolved);
@@ -39418,10 +39704,10 @@ function listCliAgentCapabilityCacheForWorkspace(db, workspaceId) {
 }
 
 // src/agents/capabilities/warmup-agent-capabilities-on-connect.ts
-import * as path44 from "node:path";
+import * as path51 from "node:path";
 
 // src/agents/capabilities/probe-one-agent-type-for-capabilities.ts
-import * as path43 from "node:path";
+import * as path50 from "node:path";
 async function probeOneAgentTypeForCapabilities(params) {
   const { agentType, cwd, workspaceId, log: log2, reportAgentCapabilities, bridgeReport = true, shouldContinue } = params;
   const canContinue = () => shouldContinue?.() !== false;
@@ -39459,7 +39745,7 @@ async function probeOneAgentTypeForCapabilities(params) {
     if (!canContinue()) return false;
     handle = await resolved.createClient({
       command: resolved.command,
-      cwd: path43.resolve(cwd),
+      cwd: path50.resolve(cwd),
       backendAgentType: agentType,
       sessionMode: "agent",
       persistedAcpSessionId: null,
@@ -39537,7 +39823,7 @@ async function warmupAgentCapabilitiesOnConnect(params) {
   const { workspaceId, log: log2, getWs } = params;
   const isCurrent = beginAgentCapabilityWarmupRun();
   if (!isCurrent()) return;
-  const cwd = path44.resolve(getBridgeRoot());
+  const cwd = path51.resolve(getBridgeRoot());
   async function sendBatchFromCache() {
     if (!isCurrent()) return;
     const socket = getWs();
@@ -39883,18 +40169,18 @@ import * as http from "node:http";
 
 // src/mcp/bridge-access/read-json-body.ts
 function readJsonBody(req) {
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve26, 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({});
+          resolve26({});
           return;
         }
         const parsed = JSON.parse(raw);
-        resolve20(parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {});
+        resolve26(parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {});
       } catch (e) {
         reject(e);
       }
@@ -39952,7 +40238,7 @@ function createBridgeAccessRequestHandler(registry2) {
 // src/mcp/bridge-access/start-server.ts
 function startBridgeAccessServer(registry2) {
   const server = http.createServer(createBridgeAccessRequestHandler(registry2));
-  return new Promise((resolve20, reject) => {
+  return new Promise((resolve26, reject) => {
     server.once("error", reject);
     server.listen(0, "127.0.0.1", () => {
       const addr = server.address();
@@ -39960,7 +40246,7 @@ function startBridgeAccessServer(registry2) {
         reject(new Error("Bridge access server did not bind"));
         return;
       }
-      resolve20({
+      resolve26({
         port: addr.port,
         close: () => new Promise((closeResolve, closeReject) => {
           server.close((err) => err ? closeReject(err) : closeResolve());
@@ -40100,8 +40386,8 @@ async function createBridgeConnection(options) {
     getCloudAccessToken: () => tokens.accessToken
   };
   const identifyReportedPaths = {
-    bridgeRootPath: path45.resolve(getBridgeRoot()),
-    worktreesRootPath: path45.resolve(worktreesRootPath)
+    bridgeRootPath: path52.resolve(getBridgeRoot()),
+    worktreesRootPath: path52.resolve(worktreesRootPath)
   };
   const { connect } = createMainBridgeWebSocketLifecycle({
     state,