@buildautomaton/cli 0.1.48 → 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?.();
     });
   }
@@ -22733,6 +22733,238 @@ var WebSocketMessageSchema = external_exports.object({
   error: external_exports.string().optional()
 });
 
+// ../types/src/integrations/link-detection/linear.ts
+function detectLinearLink(url2) {
+  const linearMatch = url2.match(
+    /https?:\/\/(?:app\.)?linear\.app\/([^/]+)\/issue\/([A-Z]+-\d+)/i
+  );
+  if (linearMatch) {
+    return {
+      url: url2,
+      integrationType: "linear",
+      resourceType: "work-item",
+      resourceId: linearMatch[2],
+      workspaceId: linearMatch[1]
+    };
+  }
+  return null;
+}
+
+// ../types/src/integrations/link-detection/github.ts
+function detectGitHubLink(url2) {
+  const githubIssueMatch = url2.match(
+    /https?:\/\/github\.com\/([^/]+)\/([^/]+)\/issues\/(\d+)/i
+  );
+  if (githubIssueMatch) {
+    return {
+      url: url2,
+      integrationType: "github",
+      resourceType: "issue",
+      resourceId: githubIssueMatch[3],
+      owner: githubIssueMatch[1],
+      repo: githubIssueMatch[2]
+    };
+  }
+  const githubPRMatch = url2.match(
+    /https?:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/i
+  );
+  if (githubPRMatch) {
+    return {
+      url: url2,
+      integrationType: "github",
+      resourceType: "pull-request",
+      resourceId: githubPRMatch[3],
+      owner: githubPRMatch[1],
+      repo: githubPRMatch[2]
+    };
+  }
+  return null;
+}
+
+// ../types/src/integrations/link-detection/jira.ts
+function detectJIRALink(url2) {
+  const jiraMatch = url2.match(
+    /https?:\/\/([^/]+)\.atlassian\.net\/(?:browse|jira\/software\/projects\/[^/]+\/issues)\/([A-Z]+-\d+)/i
+  );
+  if (jiraMatch) {
+    return {
+      url: url2,
+      integrationType: "jira",
+      resourceType: "issue",
+      resourceId: jiraMatch[2],
+      projectKey: jiraMatch[2].split("-")[0]
+    };
+  }
+  return null;
+}
+
+// ../types/src/integrations/link-detection/notion.ts
+function formatNotionPageId(hex) {
+  if (hex.length !== 32) return hex;
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+function detectNotionLink(url2) {
+  const standardMatch = url2.match(
+    /https?:\/\/(?:www\.)?notion\.(?:so|site)\/(?:[^/#?]+\/)?(?:[^/#?-]+-)?([a-f0-9]{32})/i
+  );
+  if (standardMatch) {
+    return {
+      url: url2,
+      integrationType: "notion",
+      resourceType: "page",
+      resourceId: formatNotionPageId(standardMatch[1])
+    };
+  }
+  const siteMatch = url2.match(
+    /https?:\/\/([^.]+)\.notion\.(?:so|site)\/(?:[^/#?-]+-)?([a-f0-9]{32})/i
+  );
+  if (siteMatch) {
+    return {
+      url: url2,
+      integrationType: "notion",
+      resourceType: "page",
+      resourceId: formatNotionPageId(siteMatch[2]),
+      notionWorkspaceId: siteMatch[1]
+    };
+  }
+  return null;
+}
+
+// ../types/src/integrations/link-detection/slack.ts
+function detectSlackLink(url2) {
+  const archiveThreadMatch = url2.match(
+    /https?:\/\/(?:([^./]+)\.)?slack\.com\/archives\/([A-Z0-9]+)\/p(\d+)(?:\?.*)?$/i
+  );
+  if (archiveThreadMatch) {
+    return {
+      url: url2,
+      integrationType: "slack",
+      resourceType: "thread",
+      resourceId: `${archiveThreadMatch[2]}-${archiveThreadMatch[3]}`,
+      isChannel: false
+    };
+  }
+  const appThreadMatch = url2.match(
+    /https?:\/\/app\.slack\.com\/client\/([^/]+)\/([A-Z0-9]+)\/thread\/[A-Z0-9]+-(\d+)/i
+  );
+  if (appThreadMatch) {
+    return {
+      url: url2,
+      integrationType: "slack",
+      resourceType: "thread",
+      resourceId: `${appThreadMatch[2]}-${appThreadMatch[3]}`,
+      isChannel: false
+    };
+  }
+  const channelOnlyMatch = url2.match(
+    /https?:\/\/(?:app\.)?(?:([^./]+)\.)?slack\.com\/archives\/([A-Z0-9]+)\/?(\?.*)?$/i
+  );
+  if (channelOnlyMatch && !url2.includes("/p")) {
+    return {
+      url: url2,
+      integrationType: "slack",
+      resourceType: "channel",
+      resourceId: channelOnlyMatch[2],
+      isChannel: true
+    };
+  }
+  return null;
+}
+
+// ../types/src/integrations/link-detection/zoom.ts
+function detectZoomLink(url2) {
+  try {
+    const u = new URL(url2);
+    const host = u.hostname.toLowerCase();
+    if (!host.endsWith("zoom.us") && !host.endsWith("zoom.com")) return null;
+    const pathParts = u.pathname.split("/").filter(Boolean);
+    if (pathParts.length >= 2 && (pathParts[0] === "j" || pathParts[0] === "s" || pathParts[0] === "my")) {
+      const meetingId = pathParts[1].replace(/\s/g, "");
+      if (meetingId.length >= 9) {
+        return {
+          url: url2,
+          integrationType: "zoom",
+          resourceType: "meeting",
+          resourceId: meetingId,
+          zoomMeetingId: meetingId
+        };
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+
+// ../types/src/integrations/link-detection/asana.ts
+var ASANA_TASK_GID = /\d{10,}/;
+function parseAsanaTaskGid(segment) {
+  const trimmed2 = segment.trim();
+  if (!ASANA_TASK_GID.test(trimmed2)) return null;
+  return trimmed2;
+}
+function detectAsanaLink(url2) {
+  const v1ProjectMatch = url2.match(
+    /https?:\/\/app\.asana\.com\/1\/[^/]+\/project\/([^/?#]+)\/task\/([^/?#]+)/i
+  );
+  if (v1ProjectMatch) {
+    const taskGid = parseAsanaTaskGid(v1ProjectMatch[2]);
+    if (!taskGid) return null;
+    return {
+      url: url2,
+      integrationType: "asana",
+      resourceType: "task",
+      resourceId: taskGid,
+      asanaProjectGid: v1ProjectMatch[1]
+    };
+  }
+  const v1TaskMatch = url2.match(/https?:\/\/app\.asana\.com\/1\/[^/]+(?:\/[^/]+)*\/task\/([^/?#]+)/i);
+  if (v1TaskMatch) {
+    const taskGid = parseAsanaTaskGid(v1TaskMatch[1]);
+    if (!taskGid) return null;
+    return {
+      url: url2,
+      integrationType: "asana",
+      resourceType: "task",
+      resourceId: taskGid
+    };
+  }
+  const legacyMatch = url2.match(/https?:\/\/app\.asana\.com\/0\/([^/?#]+)\/([^/?#]+)/i);
+  if (legacyMatch) {
+    const projectGid = legacyMatch[1];
+    const taskGid = parseAsanaTaskGid(legacyMatch[2]);
+    if (!taskGid) return null;
+    if (projectGid === "inbox" || projectGid === "my_tasks") {
+      return null;
+    }
+    return {
+      url: url2,
+      integrationType: "asana",
+      resourceType: "task",
+      resourceId: taskGid,
+      asanaProjectGid: projectGid === "0" ? void 0 : projectGid
+    };
+  }
+  return null;
+}
+
+// ../types/src/integrations/link-detection/index.ts
+function detectIntegrationLink(url2) {
+  return detectLinearLink(url2) || detectGitHubLink(url2) || detectJIRALink(url2) || detectNotionLink(url2) || detectSlackLink(url2) || detectZoomLink(url2) || detectAsanaLink(url2);
+}
+function extractIntegrationLinks(text) {
+  const urlRegex = /https?:\/\/[^\s<>"{}|\\^`[\]]+/gi;
+  const urls = text.match(urlRegex) || [];
+  const links = [];
+  for (const url2 of urls) {
+    const detected = detectIntegrationLink(url2);
+    if (detected) links.push(detected);
+  }
+  return links;
+}
+function extractFetchableIntegrationLinks(text) {
+  return extractIntegrationLinks(text).filter((link) => !(link.integrationType === "slack" && link.isChannel));
+}
+
 // ../types/src/checkpoints.ts
 init_zod();
 var CheckpointKindSchema = external_exports.enum(["daily", "weekly", "overall"]);
@@ -22940,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;
 }
@@ -23160,6 +23392,16 @@ var GitRepoMetaSchema = external_exports.object({
   updatedAt: external_exports.string()
 });
 
+// ../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";
+var BRIDGE_MCP_TOOL_LABELS = {
+  [GET_INTEGRATION_CONTENT_TOOL]: "Fetch external ticket content",
+  [LIST_PARENT_SESSION_PROMPTS_TOOL]: "List parent session prompts",
+  [GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL]: "Read parent session transcript"
+};
+
 // ../types/src/claude-code-permission-mode.ts
 var CLAUDE_CODE_PERMISSION_MODES = [
   "default",
@@ -23386,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 {
@@ -23934,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);
     }
   };
 }
@@ -24006,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])));
@@ -24031,7 +24273,7 @@ async function createSdkStdioAcpClient(options) {
           protocolVersion: PROTOCOL_VERSION2
         });
         init.settleResolve(
-          resolve20,
+          resolve26,
           createSdkStdioHandle({
             child,
             sessionId: established.sessionId,
@@ -24139,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));
@@ -24150,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,
@@ -24159,7 +24401,7 @@ async function proxyToLocal(request) {
         });
       });
       req.on("error", (err) => {
-        resolve20({
+        resolve26({
           id: request.id,
           statusCode: 0,
           headers: {},
@@ -24241,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"
@@ -24254,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;
 }
@@ -24469,7 +24711,7 @@ function installBridgeProcessResilience() {
 }
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.48".length > 0 ? "0.1.48" : "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;
@@ -24910,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);
       });
     });
   }
@@ -25461,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();
@@ -25613,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
@@ -26777,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])));
@@ -26789,7 +27031,7 @@ async function createCursorAcpClient(options) {
           sessionCtx,
           incomingDeps: { dbgFs, sessionCtx, onSessionUpdate, onRequest }
         });
-        resolve20(
+        resolve26(
           createCursorAcpHandle({
             child,
             sessionId: established.sessionId,
@@ -27727,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";
@@ -27742,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: []
@@ -27995,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) || [];
@@ -28085,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)) {
@@ -28490,8 +28732,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path46) {
-      return /^\.(git)?$/.test(path46.trim());
+    parser(path53) {
+      return /^\.(git)?$/.test(path53.trim());
     }
   };
 }
@@ -28925,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
     });
   });
@@ -29694,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(" ");
@@ -29712,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;
@@ -29721,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;
       }
@@ -29735,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);
@@ -29744,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);
     }
   };
 }
@@ -30560,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] || "";
         }
@@ -30596,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));
     }
   }
 }
@@ -30912,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)
         );
       }
@@ -31267,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({
@@ -31582,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]);
@@ -31916,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(
@@ -32554,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);
   }
 }
@@ -32880,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`,
@@ -33129,7 +33371,15 @@ async function fetchInternalApiJson(params) {
   const token = params.getCloudAccessToken();
   if (!token) return { ok: false, error: "Missing cloud access token." };
   const url2 = `${internalApiBase(params.cloudApiBaseUrl)}${params.path}`;
-  const res = await fetch(url2, { headers: { Authorization: `Bearer ${token}` } });
+  const method = params.method ?? "GET";
+  const res = await fetch(url2, {
+    method,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      ...params.body != null ? { "Content-Type": "application/json" } : {}
+    },
+    ...params.body != null ? { body: JSON.stringify(params.body) } : {}
+  });
   if (!res.ok) {
     const t = await res.text().catch(() => "");
     return { ok: false, error: `${params.errorLabel} (${res.status}): ${t.slice(0, 200)}` };
@@ -33312,6 +33562,39 @@ async function enrichForkedSessionPromptForAgent(params) {
   return buildForkedSessionAgentPrompt(params.promptText, params.sessionId, parentSessionId);
 }
 
+// src/agents/acp/build-integration-content-agent-prompt-note.ts
+function buildIntegrationContentAgentPromptNote(sessionId) {
+  const sessionRef = sessionId.trim();
+  return [
+    "The user message includes link(s) to external integration resources (Linear, GitHub, Jira, Notion, Slack thread, Zoom, or Asana).",
+    "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 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) {
+  const note = buildIntegrationContentAgentPromptNote(sessionId);
+  const marker = "\nUser request:\n";
+  const idx = agentPrompt.indexOf(marker);
+  if (idx >= 0) {
+    return `${agentPrompt.slice(0, idx)}
+${note}${agentPrompt.slice(idx)}`;
+  }
+  return `${note}
+
+${agentPrompt.trim()}`;
+}
+
+// src/agents/acp/enrich-integration-content-prompt-for-agent.ts
+function enrichIntegrationContentPromptForAgent(params) {
+  if (!params.sessionId.trim()) return params.agentPromptText;
+  if (extractFetchableIntegrationLinks(params.originalPromptText).length === 0) {
+    return params.agentPromptText;
+  }
+  return injectIntegrationContentAgentPromptNote(params.agentPromptText, params.sessionId);
+}
+
 // src/agents/acp/send-prompt-to-agent.ts
 async function sendPromptToAgent(options) {
   const {
@@ -33322,7 +33605,7 @@ async function sendPromptToAgent(options) {
     runId,
     agentType,
     agentCwd,
-    sendResult: sendResult2,
+    sendResult,
     sendSessionUpdate,
     log: log2,
     followUpCatalogPromptId,
@@ -33342,10 +33625,17 @@ async function sendPromptToAgent(options) {
         getCloudAccessToken
       });
     }
+    if (sessionId) {
+      agentPromptText = enrichIntegrationContentPromptForAgent({
+        sessionId,
+        originalPromptText: promptText,
+        agentPromptText
+      });
+    }
     let sendOpts = {};
     if (attachments && attachments.length > 0) {
       if (!sessionId || !cloudApiBaseUrl || !getCloudAccessToken) {
-        sendResult2({
+        sendResult({
           type: "prompt_result",
           id: promptId,
           ...sessionId ? { sessionId } : {},
@@ -33366,7 +33656,7 @@ async function sendPromptToAgent(options) {
         log: log2
       });
       if (!resolved.ok) {
-        sendResult2({
+        sendResult({
           type: "prompt_result",
           id: promptId,
           ...sessionId ? { sessionId } : {},
@@ -33405,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 } : {},
@@ -33427,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 } : {},
@@ -33461,7 +33751,7 @@ function handlePrompt(ctx, opts) {
     agentType,
     agentConfig,
     sessionParentPath,
-    sendResult: sendResult2,
+    sendResult,
     sendSessionUpdate,
     followUpCatalogPromptId,
     sessionChangeSummaryFilePaths,
@@ -33478,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 } : {},
@@ -33515,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 } : {},
@@ -33535,7 +33825,7 @@ function handlePrompt(ctx, opts) {
         await handle.cancel?.();
       } catch {
       }
-      sendResult2({
+      sendResult({
         type: "prompt_result",
         id: promptId,
         ...sessionId ? { sessionId } : {},
@@ -33556,7 +33846,7 @@ function handlePrompt(ctx, opts) {
         runId: activeRunId,
         agentType: preferredForPrompt,
         agentCwd: resolveSessionParentPathForAgentProcess(sessionParentPath),
-        sendResult: sendResult2,
+        sendResult,
         sendSessionUpdate,
         log: ctx.log,
         followUpCatalogPromptId,
@@ -33612,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;
 
@@ -33669,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) {
@@ -33841,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
@@ -33955,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";
@@ -34002,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 {
@@ -34037,7 +34887,7 @@ function pathInRepoFromLauncher(pathRelLauncher, repoRelPath) {
   }
   return pathRelLauncher;
 }
-function normalizeRepoRelPath(repoRelPath) {
+function normalizeRepoRelPath2(repoRelPath) {
   return repoRelPath === "." || repoRelPath === "" ? "." : repoRelPath;
 }
 
@@ -34139,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;
 }
@@ -34271,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
@@ -34299,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;
@@ -34314,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;
@@ -34324,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, "/");
@@ -34340,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) {
@@ -34378,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"));
 }
@@ -34446,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) {
@@ -34508,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;
@@ -34528,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;
@@ -34682,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
@@ -34707,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 });
   }
 }
 
@@ -34720,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 {
       }
     }
@@ -34748,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 } : {}
+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
   });
-  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
-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);
@@ -35229,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);
   }
 };
 
@@ -35244,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
@@ -35265,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;
@@ -35283,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",
@@ -35372,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;
   }
@@ -35384,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()) {
@@ -35404,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");
@@ -35418,7 +35949,7 @@ function withFileIndexSqliteLock(fn) {
       if (!isSqliteCorruptError(e)) throw e;
       closeAllCliSqliteConnections();
       try {
-        fs26.unlinkSync(getCliSqlitePath());
+        fs30.unlinkSync(getCliSqlitePath());
       } catch {
       }
       chain = Promise.resolve();
@@ -35493,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);
@@ -35505,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) {
@@ -35557,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) };
   }
@@ -35601,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);
@@ -35631,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";
@@ -35653,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(
@@ -35675,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) {
@@ -35711,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));
@@ -35749,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) {
@@ -35851,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 {
   }
 }
@@ -35865,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;
 }
@@ -35939,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;
@@ -35966,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,
@@ -35975,7 +36506,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     };
   } catch (e) {
     try {
-      fs29.closeSync(logFd);
+      fs33.closeSync(logFd);
     } catch {
     }
     rmDirQuiet(tmpRoot);
@@ -35986,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)}
@@ -36027,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
@@ -36802,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);
@@ -36837,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 });
     }
@@ -37209,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;
@@ -37218,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.`
@@ -37333,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);
@@ -37366,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
@@ -37470,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,
@@ -37506,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;
@@ -37542,7 +38073,7 @@ async function runPreambleAndPrompt(params) {
     agentId,
     agentConfig,
     resolvedCwd,
-    senders: { sendResult: sendResult2, sendSessionUpdate }
+    senders: { sendResult, sendSessionUpdate }
   } = params;
   const effectiveCwd = resolveSessionParentPathForAgentProcess(resolvedCwd);
   await runBridgePromptPreamble({
@@ -37580,7 +38111,7 @@ async function runPreambleAndPrompt(params) {
     agentId,
     agentConfig,
     sessionParentPath: effectiveCwd,
-    sendResult: sendResult2,
+    sendResult,
     sendSessionUpdate,
     followUpCatalogPromptId,
     sessionChangeSummaryFilePaths: pathsForUpload,
@@ -37722,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;
@@ -37739,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;
@@ -37777,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) {
@@ -37797,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) {
@@ -37817,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");
@@ -37983,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;
@@ -38083,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;
   }
@@ -38094,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 = {
@@ -38139,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) {
@@ -38219,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)) {
@@ -38231,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({
@@ -38280,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 : "";
@@ -38294,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) });
     }
@@ -38397,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 : "";
@@ -38410,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",
@@ -38452,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) {
@@ -38502,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 }];
@@ -38515,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;
@@ -38540,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);
@@ -39128,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;
@@ -39169,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,
@@ -39247,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();
@@ -39353,8 +39929,8 @@ async function callListParentSessionPromptsTool(ctx, cloud, childSessionId, pare
 }
 
 // src/mcp/tools/session-history/fork/tool-names.ts
-var LIST_PARENT_SESSION_PROMPTS_TOOL = "list_parent_session_prompts";
-var GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL = "get_parent_session_turn_transcript";
+var LIST_PARENT_SESSION_PROMPTS_TOOL2 = "list_parent_session_prompts";
+var GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL2 = "get_parent_session_turn_transcript";
 
 // src/mcp/tools/session-history/fork/call-fork-session-mcp-tool.ts
 async function callForkSessionMcpTool(ctx, cloud, name, args) {
@@ -39371,10 +39947,10 @@ async function callForkSessionMcpTool(ctx, cloud, name, args) {
     return mcpTextResult(parentResolved.error, true);
   }
   const parentSessionId = parentResolved.parentSessionId;
-  if (name === LIST_PARENT_SESSION_PROMPTS_TOOL) {
+  if (name === LIST_PARENT_SESSION_PROMPTS_TOOL2) {
     return callListParentSessionPromptsTool(ctx, cloud, childSessionId, parentSessionId);
   }
-  if (name === GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL) {
+  if (name === GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL2) {
     return callGetParentSessionTurnTranscriptTool(ctx, cloud, childSessionId, args);
   }
   return mcpTextResult(`Unknown fork session tool: ${name}`, true);
@@ -39387,7 +39963,7 @@ var SESSION_ID_SCHEMA = {
 };
 var FORK_SESSION_MCP_TOOL_DEFINITIONS = [
   {
-    name: LIST_PARENT_SESSION_PROMPTS_TOOL,
+    name: LIST_PARENT_SESSION_PROMPTS_TOOL2,
     description: "List user prompts (main turns) from the parent session a fork was created from. Requires sessionId. Returns an error if the session has no parent history (not a fork).",
     inputSchema: {
       type: "object",
@@ -39397,7 +39973,7 @@ var FORK_SESSION_MCP_TOOL_DEFINITIONS = [
     }
   },
   {
-    name: GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL,
+    name: GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL2,
     description: "Full transcript for one parent-session turn, including tool calls and agent messages. Requires sessionId and turnId. Returns an error if the session has no parent history (not a fork).",
     inputSchema: {
       type: "object",
@@ -39413,7 +39989,130 @@ var FORK_SESSION_MCP_TOOL_DEFINITIONS = [
 
 // src/mcp/tools/session-history/fork/is-fork-session-mcp-tool-name.ts
 function isForkSessionMcpToolName(name) {
-  return name === LIST_PARENT_SESSION_PROMPTS_TOOL || name === GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL;
+  return name === LIST_PARENT_SESSION_PROMPTS_TOOL2 || name === GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL2;
+}
+
+// src/mcp/tools/integration-content/tool-names.ts
+var GET_INTEGRATION_CONTENT_TOOL2 = "get_integration_content";
+
+// src/mcp/tools/integration-content/cloud/fetch-integration-content.ts
+async function fetchCloudIntegrationContent(params) {
+  return fetchInternalApiJson({
+    ...params,
+    path: `/internal/sessions/${encodeURIComponent(params.sessionId)}/integrations/content`,
+    errorLabel: "Integration content fetch failed",
+    method: "POST",
+    body: {
+      url: params.url,
+      associateAsSessionTicket: params.associateAsSessionTicket !== false
+    }
+  });
+}
+
+// src/mcp/tools/integration-content/format-integration-content-for-mcp.ts
+function formatIntegrationContentForMcp(result) {
+  if (!result.ok) {
+    const lines2 = [`status: ${result.code}`, `message: ${result.message}`];
+    if (result.integrationType) lines2.push(`integrationType: ${result.integrationType}`);
+    if (result.retryable) lines2.push("retryable: true");
+    lines2.push(...formatSessionTicketAssociationLines(result.sessionTicketAssociation));
+    return lines2.join("\n");
+  }
+  const lines = [
+    formatIntegrationContentBody(result.integrationType, result.content),
+    ...formatSessionTicketAssociationLines(result.sessionTicketAssociation)
+  ];
+  return lines.join("\n");
+}
+function formatSessionTicketAssociationLines(association) {
+  if (association.status === "associated") {
+    const title = association.externalTicket.displayTitle?.trim() || association.externalTicket.normalizedUrl;
+    return ["", "--- session ticket ---", "status: associated", `displayTitle: ${title}`];
+  }
+  if (association.status === "failed") {
+    return ["", "--- session ticket ---", "status: failed", `reason: ${association.reason}`];
+  }
+  return ["", "--- session ticket ---", `status: ${association.status}`, `reason: ${association.reason}`];
+}
+function formatIntegrationContentBody(integrationType, content) {
+  const lines = [
+    `integrationType: ${integrationType}`,
+    `title: ${content.title}`,
+    `url: ${content.url}`,
+    "",
+    "--- body ---",
+    content.body
+  ];
+  if (content.comments?.length) {
+    lines.push("", "--- comments ---");
+    for (const comment of content.comments) {
+      lines.push(`[${comment.createdAt}] ${comment.author}:`, comment.body, "");
+    }
+  }
+  const threadMessages = content.threadMessages;
+  if (threadMessages?.length) {
+    lines.push("", "--- thread messages ---");
+    for (const msg of threadMessages) {
+      lines.push(`[${msg.ts}] ${msg.displayName}: ${msg.text}`);
+    }
+  }
+  if (content.metadata && Object.keys(content.metadata).length > 0) {
+    lines.push("", "--- metadata ---", JSON.stringify(content.metadata, null, 2));
+  }
+  return lines.join("\n");
+}
+
+// src/mcp/tools/integration-content/call-integration-content-mcp-tool.ts
+async function callIntegrationContentMcpTool(ctx, cloud, name, args) {
+  if (name !== GET_INTEGRATION_CONTENT_TOOL2) {
+    return mcpTextResult(`Unknown integration content tool: ${name}`, true);
+  }
+  const sessionId = ctx.sessionId.trim();
+  if (!sessionId) return mcpTextResult("sessionId is required.", true);
+  const url2 = typeof args.url === "string" ? args.url.trim() : "";
+  if (!url2) return mcpTextResult("url is required.", true);
+  const associateAsSessionTicket = args.associateAsSessionTicket !== false;
+  const fetched = await fetchCloudIntegrationContent({
+    sessionId,
+    url: url2,
+    associateAsSessionTicket,
+    cloudApiBaseUrl: cloud.cloudApiBaseUrl,
+    getCloudAccessToken: cloud.getCloudAccessToken
+  });
+  if (!fetched.ok) return mcpTextResult(fetched.error, true);
+  const text = formatIntegrationContentForMcp(fetched.data);
+  const isError = !fetched.data.ok;
+  return mcpTextResult(text, isError);
+}
+
+// src/mcp/tools/integration-content/tool-definitions.ts
+var SESSION_ID_SCHEMA2 = {
+  type: "string",
+  description: "Id of the current session. Required on every tool call so the workspace integration credentials can be resolved."
+};
+var INTEGRATION_CONTENT_MCP_TOOL_DEFINITIONS = [
+  {
+    name: GET_INTEGRATION_CONTENT_TOOL2,
+    description: "Fetch the full content of a supported external integration link (Linear, GitHub, Jira, Notion, Slack thread, Zoom meeting, Asana). Requires sessionId and url. By default, links the URL as this session external ticket when the session has none yet. Pass associateAsSessionTicket: false to fetch content only (e.g. additional context links). Returns an error when the URL is unsupported, the integration is not connected, or content is temporarily unavailable (retry may succeed).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: SESSION_ID_SCHEMA2,
+        url: { type: "string", description: "External integration URL to fetch" },
+        associateAsSessionTicket: {
+          type: "boolean",
+          description: "Defaults to true. When true and the session has no linked external ticket yet, links this URL as the session external ticket. Pass false when fetching additional links for context only."
+        }
+      },
+      required: ["sessionId", "url"],
+      additionalProperties: false
+    }
+  }
+];
+
+// src/mcp/tools/integration-content/index.ts
+function isIntegrationContentMcpToolName(name) {
+  return name === GET_INTEGRATION_CONTENT_TOOL2;
 }
 
 // src/mcp/bridge-mcp-tools.ts
@@ -39426,7 +40125,7 @@ function requireCloud(shared) {
 function createBridgeMcpToolRegistry(shared) {
   const cloud = requireCloud(shared);
   return {
-    listTools: async () => [...FORK_SESSION_MCP_TOOL_DEFINITIONS],
+    listTools: async () => [...FORK_SESSION_MCP_TOOL_DEFINITIONS, ...INTEGRATION_CONTENT_MCP_TOOL_DEFINITIONS],
     callTool: async (name, args) => {
       if (isForkSessionMcpToolName(name)) {
         if (!cloud) {
@@ -39444,6 +40143,22 @@ function createBridgeMcpToolRegistry(shared) {
         }
         return callForkSessionMcpTool({ ...shared, sessionId }, cloud, name, args);
       }
+      if (isIntegrationContentMcpToolName(name)) {
+        if (!cloud) {
+          return {
+            content: [{ type: "text", text: "Bridge MCP tools require cloud API credentials." }],
+            isError: true
+          };
+        }
+        const sessionId = typeof args.sessionId === "string" ? args.sessionId.trim() : "";
+        if (!sessionId) {
+          return {
+            content: [{ type: "text", text: "sessionId is required." }],
+            isError: true
+          };
+        }
+        return callIntegrationContentMcpTool({ ...shared, sessionId }, cloud, name, args);
+      }
       throw new Error(`Unknown bridge MCP tool: ${name}`);
     }
   };
@@ -39454,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);
       }
@@ -39523,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();
@@ -39531,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());
@@ -39671,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,