@buildautomaton/cli 0.1.50 → 0.1.51

package/dist/cli.js

@@ -973,8 +973,8 @@ var require_command = __commonJS({
   "../../node_modules/.pnpm/commander@12.1.0/node_modules/commander/lib/command.js"(exports) {
     var EventEmitter2 = __require("node:events").EventEmitter;
     var childProcess2 = __require("node:child_process");
-    var path55 = __require("node:path");
-    var fs46 = __require("node:fs");
+    var path62 = __require("node:path");
+    var fs47 = __require("node:fs");
     var process8 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1906,11 +1906,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path55.resolve(baseDir, baseName);
-          if (fs46.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path55.extname(baseName))) return void 0;
+          const localBin = path62.resolve(baseDir, baseName);
+          if (fs47.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path62.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs46.existsSync(`${localBin}${ext}`)
+            (ext) => fs47.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1922,21 +1922,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs46.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs47.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path55.resolve(
-            path55.dirname(resolvedScriptPath),
+          executableDir = path62.resolve(
+            path62.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path55.basename(
+            const legacyName = path62.basename(
               this._scriptPath,
-              path55.extname(this._scriptPath)
+              path62.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1947,7 +1947,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path55.extname(executableFile));
+        launchWithNode = sourceExt.includes(path62.extname(executableFile));
         let proc;
         if (process8.platform !== "win32") {
           if (launchWithNode) {
@@ -2787,7 +2787,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path55.basename(filename, path55.extname(filename));
+        this._name = path62.basename(filename, path62.extname(filename));
         return this;
       }
       /**
@@ -2801,9 +2801,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path56) {
-        if (path56 === void 0) return this._executableDir;
-        this._executableDir = path56;
+      executableDir(path63) {
+        if (path63 === void 0) return this._executableDir;
+        this._executableDir = path63;
         return this;
       }
       /**
@@ -7061,8 +7061,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path55, errorMaps, issueData } = params;
-      const fullPath = [...path55, ...issueData.path || []];
+      const { data, path: path62, errorMaps, issueData } = params;
+      const fullPath = [...path62, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -7370,11 +7370,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path55, key) {
+      constructor(parent, value, path62, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path55;
+        this._path = path62;
         this._key = key;
       }
       get path() {
@@ -11099,10 +11099,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path55) {
-  if (!path55)
+function getElementAtPath(obj, path62) {
+  if (!path62)
     return obj;
-  return path55.reduce((acc, key) => acc?.[key], obj);
+  return path62.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -11351,11 +11351,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path55, issues) {
+function prefixIssues(path62, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path55);
+    iss.path.unshift(path62);
     return iss;
   });
 }
@@ -11544,7 +11544,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path55 = []) => {
+  const processError = (error41, path62 = []) => {
     var _a2, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -11554,7 +11554,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path55, ...issue2.path];
+        const fullpath = [...path62, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -11584,9 +11584,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path55) {
+function toDotPath(path62) {
   const segs = [];
-  for (const seg of path55) {
+  for (const seg of path62) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -24049,8 +24049,8 @@ var init_acp = __esm({
         this.#requestHandler = requestHandler;
         this.#notificationHandler = notificationHandler;
         this.#stream = stream;
-        this.#closedPromise = new Promise((resolve28) => {
-          this.#abortController.signal.addEventListener("abort", () => resolve28());
+        this.#closedPromise = new Promise((resolve34) => {
+          this.#abortController.signal.addEventListener("abort", () => resolve34());
         });
         this.#receive();
       }
@@ -24199,8 +24199,8 @@ var init_acp = __esm({
       }
       async sendRequest(method, params) {
         const id = this.#nextRequestId++;
-        const responsePromise = new Promise((resolve28, reject) => {
-          this.#pendingResponses.set(id, { resolve: resolve28, reject });
+        const responsePromise = new Promise((resolve34, reject) => {
+          this.#pendingResponses.set(id, { resolve: resolve34, reject });
         });
         await this.#sendMessage({ jsonrpc: "2.0", id, method, params });
         return responsePromise;
@@ -25069,10 +25069,10 @@ var require_src2 = __commonJS({
     var fs_1 = __require("fs");
     var debug_1 = __importDefault(require_src());
     var log2 = debug_1.default("@kwsites/file-exists");
-    function check2(path55, isFile, isDirectory) {
-      log2(`checking %s`, path55);
+    function check2(path62, isFile, isDirectory) {
+      log2(`checking %s`, path62);
       try {
-        const stat3 = fs_1.statSync(path55);
+        const stat3 = fs_1.statSync(path62);
         if (stat3.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -25092,8 +25092,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path55, type = exports.READABLE) {
-      return check2(path55, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path62, type = exports.READABLE) {
+      return check2(path62, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -25174,15 +25174,15 @@ var {
 } = import_index.default;
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.50".length > 0 ? "0.1.50" : "0.0.0-dev";
+var CLI_VERSION = "0.1.51".length > 0 ? "0.1.51" : "0.0.0-dev";
 
 // src/cli/defaults.ts
 var DEFAULT_API_URL = process.env.BUILDAUTOMATON_API_URL ?? "https://api.buildautomaton.com";
 var DEFAULT_FIREHOSE_URL = "https://buildautomaton-firehose.fly.dev";
 
 // src/cli/run-cli-action.ts
-import * as fs45 from "node:fs";
-import * as path54 from "node:path";
+import * as fs46 from "node:fs";
+import * as path61 from "node:path";
 
 // src/cli-log-level.ts
 var verbosity = "info";
@@ -26297,14 +26297,14 @@ var baseOpen = async (options) => {
   }
   const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
-    return new Promise((resolve28, reject) => {
+    return new Promise((resolve34, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
         if (!options.allowNonzeroExitCode && exitCode > 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
-        resolve28(subprocess);
+        resolve34(subprocess);
       });
     });
   }
@@ -26848,8 +26848,8 @@ function runPendingAuth(options) {
   let hasOpenedBrowser = false;
   let resolved = false;
   let resolveAuth;
-  const authPromise = new Promise((resolve28) => {
-    resolveAuth = resolve28;
+  const authPromise = new Promise((resolve34) => {
+    resolveAuth = resolve34;
   });
   let reconnectAttempt = 0;
   const signInQuiet = createEmptyReconnectQuietSlot();
@@ -27000,7 +27000,7 @@ import sqliteWasm from "node-sqlite3-wasm";
 
 // src/runtime/yield-to-event-loop.ts
 function yieldToEventLoop() {
-  return new Promise((resolve28) => setImmediate(resolve28));
+  return new Promise((resolve34) => setImmediate(resolve34));
 }
 
 // src/sqlite/cli-sqlite-paths.ts
@@ -28117,9 +28117,9 @@ function parseChangeSummaryJson(raw, allowedPaths, options) {
     const rawPath = typeof o.path === "string" ? o.path.trim() : "";
     const summary = typeof o.summary === "string" ? o.summary.trim() : "";
     if (!rawPath || !summary) continue;
-    const path55 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
-    if (!path55) continue;
-    rows.push({ path: path55, summary: clampSummaryToAtMostTwoLines(summary) });
+    const path62 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
+    if (!path62) continue;
+    rows.push({ path: path62, summary: clampSummaryToAtMostTwoLines(summary) });
   }
   return rows;
 }
@@ -28631,10 +28631,10 @@ async function killChildProcessTreeGracefully(child, graceMs = ACP_PROCESS_TREE_
   }
   await killProcessTree(pid, "SIGTERM");
   if (graceMs <= 0) return;
-  const exited = new Promise((resolve28) => {
-    child.once("exit", () => resolve28());
+  const exited = new Promise((resolve34) => {
+    child.once("exit", () => resolve34());
   });
-  await Promise.race([exited, new Promise((resolve28) => setTimeout(resolve28, graceMs))]);
+  await Promise.race([exited, new Promise((resolve34) => setTimeout(resolve34, graceMs))]);
   if (child.exitCode == null && child.signalCode == null) {
     await killProcessTree(pid, "SIGKILL");
   }
@@ -28651,8 +28651,8 @@ async function gracefulAcpSubprocessDisconnect(params) {
       await transport.closeSession?.(sessionId);
     } catch {
     }
-    await new Promise((resolve28) => {
-      const timer = setTimeout(resolve28, ACP_GRACEFUL_SESSION_CLOSE_WAIT_MS);
+    await new Promise((resolve34) => {
+      const timer = setTimeout(resolve34, ACP_GRACEFUL_SESSION_CLOSE_WAIT_MS);
       timer.unref?.();
     });
   }
@@ -28927,11 +28927,11 @@ function createSdkStdioExtNotificationHandler(options) {
 // src/agents/acp/clients/sdk/sdk-stdio-permission-request-handshake.ts
 function awaitSdkStdioPermissionRequestHandshake(params) {
   const { requestId, paramsRecord, pending, onRequest } = params;
-  return new Promise((resolve28) => {
-    pending.set(requestId, { resolve: resolve28, params: paramsRecord });
+  return new Promise((resolve34) => {
+    pending.set(requestId, { resolve: resolve34, params: paramsRecord });
     if (onRequest == null) {
       pending.delete(requestId);
-      resolve28({ outcome: { outcome: "denied" } });
+      resolve34({ outcome: { outcome: "denied" } });
       return;
     }
     try {
@@ -29441,10 +29441,10 @@ function createSdkStdioInitSettle(child) {
       forceAcpSubprocessDisconnect(child);
       reject(err);
     },
-    settleResolve(resolve28, handle) {
+    settleResolve(resolve34, handle) {
       if (initSettled) return;
       initSettled = true;
-      resolve28(handle);
+      resolve34(handle);
     }
   };
 }
@@ -29513,7 +29513,7 @@ async function createSdkStdioAcpClient(options) {
     onFileChange,
     stderrCapture
   });
-  return new Promise((resolve28, reject) => {
+  return new Promise((resolve34, reject) => {
     const init = createSdkStdioInitSettle(child);
     child.on("error", (err) => {
       init.settleReject(reject, new Error(formatSpawnError(err, command[0])));
@@ -29538,7 +29538,7 @@ async function createSdkStdioAcpClient(options) {
           protocolVersion: PROTOCOL_VERSION2
         });
         init.settleResolve(
-          resolve28,
+          resolve34,
           createSdkStdioHandle({
             child,
             sessionId: established.sessionId,
@@ -30071,7 +30071,7 @@ async function createCursorAcpClient(options) {
     onFileChange,
     stderrCapture
   });
-  return new Promise((resolve28, reject) => {
+  return new Promise((resolve34, reject) => {
     child.on("error", (err) => {
       killChildProcessTree(child, "SIGKILL");
       reject(new Error(formatSpawnError(err, command[0])));
@@ -30083,7 +30083,7 @@ async function createCursorAcpClient(options) {
           sessionCtx,
           incomingDeps: { dbgFs, sessionCtx, onSessionUpdate, onRequest }
         });
-        resolve28(
+        resolve34(
           createCursorAcpHandle({
             child,
             sessionId: established.sessionId,
@@ -31289,8 +31289,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path55) {
-  return path55 instanceof String && cache.has(path55);
+function isPathSpec(path62) {
+  return path62 instanceof String && cache.has(path62);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -31379,8 +31379,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path55) {
-  return (0, import_file_exists.exists)(path55, import_file_exists.FOLDER);
+function folderExists(path62) {
+  return (0, import_file_exists.exists)(path62, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -31784,8 +31784,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path55) {
-      return /^\.(git)?$/.test(path55.trim());
+    parser(path62) {
+      return /^\.(git)?$/.test(path62.trim());
     }
   };
 }
@@ -32219,11 +32219,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path55, line, preview] = input.split(NULL);
-    paths.add(path55);
-    (results[path55] = results[path55] || []).push({
+    const [path62, line, preview] = input.split(NULL);
+    paths.add(path62);
+    (results[path62] = results[path62] || []).push({
       line: asNumber(line),
-      path: path55,
+      path: path62,
       preview
     });
   });
@@ -32988,14 +32988,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path55, text) {
+function parseInit(bare, path62, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path55, false, result[1]);
+    return new InitSummary(bare, path62, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path55, true, result[1]);
+    return new InitSummary(bare, path62, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -33006,7 +33006,7 @@ function parseInit(bare, path55, text) {
       break;
     }
   }
-  return new InitSummary(bare, path55, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path62, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -33015,9 +33015,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path55, existing, gitDir) {
+      constructor(bare, path62, existing, gitDir) {
         this.bare = bare;
-        this.path = path55;
+        this.path = path62;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -33029,7 +33029,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path55, customArgs) {
+function initTask(bare = false, path62, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -33038,7 +33038,7 @@ function initTask(bare = false, path55, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path55, text);
+      return parseInit(commands.includes("--bare"), path62, text);
     }
   };
 }
@@ -33854,12 +33854,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path55, index, working_dir) {
-        this.path = path55;
+      constructor(path62, index, working_dir) {
+        this.path = path62;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path55) || [null, path55, path55];
+          const detail = fromPathRegex.exec(path62) || [null, path62, path62];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -33890,14 +33890,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path55) {
+  function data(index, workingDir, path62) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path55);
+      handler(result, path62);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path55, index, workingDir));
+      result.files.push(new FileStatusSummary(path62, index, workingDir));
     }
   }
 }
@@ -34206,9 +34206,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path55, write) {
+      hashObject(path62, write) {
         return this._runTask(
-          hashObjectTask(path55, write === true),
+          hashObjectTask(path62, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -34561,8 +34561,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path55 = input.trim().replace(/^["']|["']$/g, "");
-  return path55 && normalize3(path55);
+  const path62 = input.trim().replace(/^["']|["']$/g, "");
+  return path62 && normalize3(path62);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -34876,8 +34876,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path55) {
-  return subModuleTask(["add", repo, path55]);
+function addSubModuleTask(repo, path62) {
+  return subModuleTask(["add", repo, path62]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -35210,8 +35210,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path55, then) {
-      return this._runTask(addSubModuleTask2(repo, path55), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path62, then) {
+      return this._runTask(addSubModuleTask2(repo, path62), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -35848,8 +35848,8 @@ async function runGitTask(fn) {
 }
 async function yieldToEventLoop2() {
   throwIfGitShutdownRequested();
-  await new Promise((resolve28) => {
-    setImmediate(resolve28);
+  await new Promise((resolve34) => {
+    setImmediate(resolve34);
   });
   throwIfGitShutdownRequested();
 }
@@ -35889,11 +35889,8 @@ function cliSimpleGit(baseDir) {
 async function getRemoteOriginUrl(gitDir) {
   try {
     const git = cliSimpleGit(gitDir);
-    const remotes = await git.getRemotes(true);
-    const list = Array.isArray(remotes) ? remotes : [];
-    const origin = list.find((r) => r.name === "origin");
-    if (!origin?.refs?.fetch && !origin?.refs?.push) return "";
-    return (origin.refs.fetch ?? origin.refs.push ?? "").trim();
+    const out = await git.raw(["config", "--get", "remote.origin.url"]);
+    return String(out).trim();
   } catch {
     return "";
   }
@@ -35909,6 +35906,12 @@ async function isGitRepoDirectory(dirPath) {
 }
 
 // src/git/discover-repos.ts
+var GIT_DISCOVER_YIELD_EVERY = 32;
+async function yieldGitDiscoverWork(entryCount) {
+  if (entryCount > 0 && entryCount % GIT_DISCOVER_YIELD_EVERY === 0) {
+    await yieldToEventLoop();
+  }
+}
 async function discoverGitRepos(cwd = getBridgeRoot()) {
   const result = [];
   const cwdResolved = path17.resolve(cwd);
@@ -35922,7 +35925,9 @@ async function discoverGitRepos(cwd = getBridgeRoot()) {
   } catch {
     return result;
   }
-  for (const ent of entries) {
+  for (let i = 0; i < entries.length; i++) {
+    await yieldGitDiscoverWork(i + 1);
+    const ent = entries[i];
     if (!ent.isDirectory()) continue;
     const childPath = path17.join(cwdResolved, ent.name);
     if (await isGitRepoDirectory(childPath)) {
@@ -35935,6 +35940,7 @@ async function discoverGitRepos(cwd = getBridgeRoot()) {
 async function discoverGitReposUnderRoot(rootPath) {
   const root = path17.resolve(rootPath);
   const roots = [];
+  let walkEntries = 0;
   async function walk(dir) {
     if (await isGitRepoDirectory(dir)) {
       roots.push(path17.resolve(dir));
@@ -35946,7 +35952,9 @@ async function discoverGitReposUnderRoot(rootPath) {
     } catch {
       return;
     }
-    for (const ent of entries) {
+    for (let i = 0; i < entries.length; i++) {
+      await yieldGitDiscoverWork(++walkEntries);
+      const ent = entries[i];
       if (!ent.isDirectory() || ent.name === ".git") continue;
       await walk(path17.join(dir, ent.name));
     }
@@ -35954,7 +35962,9 @@ async function discoverGitReposUnderRoot(rootPath) {
   await walk(root);
   const uniq = [...new Set(roots)];
   const out = [];
-  for (const p of uniq) {
+  for (let i = 0; i < uniq.length; i++) {
+    await yieldGitDiscoverWork(i + 1);
+    const p = uniq[i];
     const remoteUrl = await getRemoteOriginUrl(p);
     out.push({ absolutePath: p, remoteUrl });
   }
@@ -36174,9 +36184,9 @@ async function collectTurnGitDiffFromPreTurnSnapshot(options) {
 // src/agents/acp/put-summarize-change-summaries.ts
 async function putEncryptedChangeSummaryRows(params) {
   const base = params.apiBaseUrl.replace(/\/+$/, "");
-  const entries = params.rows.map(({ path: path55, summary }) => {
+  const entries = params.rows.map(({ path: path62, summary }) => {
     const enc = params.e2ee.encryptFields({ summary }, ["summary"]);
-    return { path: path55, summary: JSON.stringify(enc) };
+    return { path: path62, summary: JSON.stringify(enc) };
   });
   const res = await fetch(
     `${base}/internal/sessions/${encodeURIComponent(params.sessionId)}/follow-ups/summarize-changes`,
@@ -36920,503 +36930,436 @@ function allocateDirNameForLauncherCwd(layout, bridgeRootPath2) {
   return name;
 }
 
-// src/worktrees/discovery/discover-session-worktree-on-disk.ts
-import * as fs21 from "node:fs";
-import * as path25 from "node:path";
-
-// src/worktrees/discovery/collect-worktree-paths.ts
-import * as fs19 from "node:fs";
-import * as path22 from "node:path";
+// src/worktrees/manager/session-worktree-cache.ts
+import * as path21 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) => path21.resolve(p));
+    this.sessionRepoCheckoutPaths.set(sessionId, paths);
+    this.sessionParentPathBySession.set(sessionId, path21.resolve(binding.sessionParentPath));
+    this.sessionWorkingTreeRelRootBySession.set(sessionId, path21.resolve(binding.workingTreeRelRoot));
+  }
+  clearSession(sessionId) {
+    const paths = this.sessionRepoCheckoutPaths.get(sessionId);
+    this.sessionRepoCheckoutPaths.delete(sessionId);
+    this.sessionParentPathBySession.delete(sessionId);
+    this.sessionWorkingTreeRelRootBySession.delete(sessionId);
+    return paths;
+  }
+  getSessionParentPath(sessionId) {
+    return this.sessionParentPathBySession.get(sessionId);
+  }
+  getWorkingTreeRelRoot(sessionId) {
+    return this.sessionWorkingTreeRelRootBySession.get(sessionId) ?? null;
+  }
+  hasSession(sessionId) {
+    return this.sessionParentPathBySession.has(sessionId);
+  }
+  getRepoCheckoutPaths(sessionId) {
+    const paths = this.sessionRepoCheckoutPaths.get(sessionId);
+    return paths?.length ? [...paths] : void 0;
+  }
+  getRepoCheckoutPathsRef(sessionId) {
+    const paths = this.sessionRepoCheckoutPaths.get(sessionId);
+    return paths?.length ? paths : void 0;
+  }
+  isLegacyNestedLayout(sessionId) {
+    const parent = this.sessionParentPathBySession.get(sessionId);
+    const relRoot = this.sessionWorkingTreeRelRootBySession.get(sessionId);
+    if (!parent || !relRoot) return false;
+    return path21.resolve(parent) !== path21.resolve(relRoot);
+  }
+};
 
-// 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/manager/session-worktree-manager-context.ts
+function createSessionWorktreeManagerContext(options) {
+  return {
+    worktreesRootPath: options.worktreesRootPath,
+    log: options.log,
+    cache: new SessionWorktreeCache(),
+    layout: loadWorktreeLayout()
+  };
 }
 
-// src/worktrees/discovery/disk-walk-utils.ts
-import * as fs18 from "node:fs";
-import * as path21 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 fs18.promises.access(path21.join(dirPath, ".git"));
-    return true;
-  } catch {
-    return false;
+// src/git/branches/commit-and-push.ts
+async function gitCommitAllIfDirty(repoDir, message, options) {
+  const g = cliSimpleGit(repoDir);
+  const st = await g.status();
+  if (!st.files?.length) return;
+  const branch = options.branch.trim();
+  if (!branch) {
+    throw new Error("Branch name is required");
+  }
+  const branches = await g.branchLocal();
+  const localNames = new Set(branches.all.map((b) => b.replace(/^\*\s*/, "").trim()));
+  if (!localNames.has(branch)) {
+    await g.checkoutLocalBranch(branch);
+  } else {
+    await g.checkout(branch);
+  }
+  await g.add(".");
+  await g.commit(message);
+  if (options.push) {
+    await g.push(["-u", "origin", branch]);
   }
 }
 
-// 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(path22.resolve(dir));
-      return;
-    }
-    let entries;
-    try {
-      entries = await fs19.promises.readdir(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const e of entries) {
-      if (shouldSkipDiskWalkEntry(e.name)) continue;
-      const full = path22.join(dir, e.name);
-      if (!e.isDirectory()) continue;
-      await walk(full);
+// src/worktrees/commit-session-worktrees.ts
+async function commitSessionWorktrees(options) {
+  const { paths, branch, message, push } = options;
+  try {
+    for (const wt of paths) {
+      await gitCommitAllIfDirty(wt, message, { push, branch });
     }
-  };
-  await walk(path22.resolve(rootPath));
-  return { paths: [...new Set(out)], entriesVisited: state.entries };
+    return { ok: true };
+  } catch (e) {
+    const err = e instanceof Error ? e.message : String(e);
+    return { ok: false, error: err };
+  }
 }
-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 fs19.promises.readdir(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const e of entries) {
-      if (shouldSkipDiskWalkEntry(e.name)) continue;
-      const full = path22.join(dir, e.name);
-      if (!e.isDirectory()) continue;
-      if (e.name === sessionId) {
-        if (await isGitDir(full)) out.push(path22.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/manager/git/commit-session-worktree.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
+  });
 }
 
-// src/worktrees/discovery/layout-keys-for-bridge-root.ts
-import * as path23 from "node:path";
-function layoutKeysForBridgeRoot(layout, bridgeRoot, keysOnDisk) {
-  const bridge = path23.resolve(bridgeRoot);
-  const preferred = getLauncherDirNameIfPresent(layout, bridgeRoot);
-  const relevant = layout.launcherCwds.filter((e) => {
-    const entry = path23.resolve(e.absolutePath);
-    return bridge === entry || bridge.startsWith(entry + path23.sep) || entry.startsWith(bridge + path23.sep);
-  }).sort((a, b) => path23.resolve(b.absolutePath).length - path23.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/git/changes/parse/normalize-git-diff-path.ts
+function normalizeGitDiffPath(path62) {
+  return path62.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
 }
 
-// src/worktrees/discovery/try-binding-from-session-directory.ts
-import * as fs20 from "node:fs";
-import * as path24 from "node:path";
-async function tryBindingFromSessionDirectory(sessionDir) {
-  let st;
-  try {
-    st = await fs20.promises.stat(sessionDir);
-  } catch {
+// src/git/changes/parse/expand-git-rename-numstat-path.ts
+function expandGitRenameNumstatPath(rawPath) {
+  const open2 = rawPath.indexOf("{");
+  const arrow = rawPath.indexOf("=>");
+  const close = rawPath.lastIndexOf("}");
+  if (open2 === -1 || arrow === -1 || close === -1 || open2 > arrow || arrow > close) {
     return null;
   }
-  if (!st.isDirectory()) return null;
-  const { paths: worktreePaths } = await collectGitRepoRootsUnderDirectory(sessionDir);
-  if (worktreePaths.length === 0) return null;
-  const abs = path24.resolve(sessionDir);
+  const prefix = rawPath.slice(0, open2);
+  const suffix = rawPath.slice(close + 1);
+  const oldPart = rawPath.slice(open2 + 1, arrow).trim();
+  const newPart = rawPath.slice(arrow + 2, close).trim();
   return {
-    sessionParentPath: abs,
-    workingTreeRelRoot: abs,
-    repoCheckoutPaths: worktreePaths
+    oldPath: normalizeGitDiffPath(`${prefix}${oldPart}${suffix}`),
+    newPath: normalizeGitDiffPath(`${prefix}${newPart}${suffix}`)
   };
 }
+function isGitRenameNumstatPath(rawPath) {
+  return expandGitRenameNumstatPath(rawPath) != null;
+}
 
-// 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 fs21.promises.access(worktreesRootPath);
-  } catch {
-    return null;
-  }
-  const preferredKey = getLauncherDirNameIfPresent(layout, bridgeRoot);
-  const keysOnDisk = [];
-  if (preferredKey) keysOnDisk.push(preferredKey);
-  try {
-    for (const name of await fs21.promises.readdir(worktreesRootPath)) {
-      if (name.startsWith(".")) continue;
-      const p = path25.join(worktreesRootPath, name);
-      let st;
-      try {
-        st = await fs21.promises.stat(p);
-      } catch {
-        continue;
+// src/git/changes/parse/parse-name-status-entries.ts
+function parseNameStatusEntries(lines) {
+  const entries = [];
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const tabParts = line.split("	");
+    if (tabParts.length < 2) continue;
+    const status = tabParts[0].trim();
+    const code = status[0];
+    if (code === "A") {
+      entries.push({ pathInRepo: normalizeGitDiffPath(tabParts[tabParts.length - 1]), change: "added" });
+    } else if (code === "D") {
+      entries.push({ pathInRepo: normalizeGitDiffPath(tabParts[tabParts.length - 1]), change: "removed" });
+    } else if (code === "R" || code === "C") {
+      if (tabParts.length >= 3) {
+        entries.push({
+          pathInRepo: normalizeGitDiffPath(tabParts[tabParts.length - 1]),
+          oldPathInRepo: normalizeGitDiffPath(tabParts[tabParts.length - 2]),
+          change: "moved"
+        });
       }
-      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 = path25.join(worktreesRootPath, key);
-    let layoutSt;
-    try {
-      layoutSt = await fs21.promises.stat(layoutRoot);
-    } catch {
-      continue;
-    }
-    if (!layoutSt.isDirectory()) continue;
-    const sessionDir = path25.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) ?? path25.resolve(legacy.paths[0]);
-      return {
-        sessionParentPath: path25.resolve(isolated),
-        workingTreeRelRoot: path25.resolve(layoutRoot),
-        repoCheckoutPaths: legacy.paths.map((p) => path25.resolve(p))
-      };
+    } else if (code === "M" || code === "U" || code === "T") {
+      entries.push({ pathInRepo: normalizeGitDiffPath(tabParts[tabParts.length - 1]), change: "modified" });
     }
   }
-  return null;
+  return entries;
 }
-
-// src/worktrees/discovery/discover-session-worktrees-under-session-worktree-root.ts
-import * as fs22 from "node:fs";
-import * as path27 from "node:path";
-
-// src/worktrees/discovery/discover-legacy-binding-ascending-from-checkout.ts
-import * as path26 from "node:path";
-async function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
-  const sid = sessionId.trim();
-  if (!sid) return null;
-  const hintR = path26.resolve(checkoutPath);
-  let best = null;
-  let cur = path26.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) => path26.resolve(p) === hintR)) {
-      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths.paths) ?? path26.resolve(paths.paths[0]);
-      best = {
-        sessionParentPath: path26.resolve(isolated),
-        workingTreeRelRoot: path26.resolve(cur),
-        repoCheckoutPaths: paths.paths.map((p) => path26.resolve(p))
-      };
-    }
-    const next = path26.dirname(cur);
-    if (next === cur) break;
-    cur = next;
+function parseNameStatusLines(lines) {
+  const m = /* @__PURE__ */ new Map();
+  for (const entry of parseNameStatusEntries(lines)) {
+    m.set(entry.pathInRepo, entry.change);
   }
-  return best;
+  return m;
 }
 
-// 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 = path27.resolve(sessionWorktreeRootPathOrHint);
-  const underHint = await tryBindingFromSessionDirectory(path27.join(hint, sid));
-  if (underHint) return underHint;
-  const direct = await tryBindingFromSessionDirectory(hint);
-  if (direct) {
-    if (path27.basename(hint) === sid && await isGitDir(hint)) {
-      const legacyFromCheckout = await discoverLegacyBindingAscendingFromCheckout(sid, hint);
-      if (legacyFromCheckout && legacyFromCheckout.repoCheckoutPaths.length > direct.repoCheckoutPaths.length) {
-        return legacyFromCheckout;
-      }
+// src/git/changes/parse/parse-numstat-entries.ts
+function parseNumstatCounts(parts) {
+  const [a, d] = parts;
+  return {
+    additions: a === "-" ? 0 : parseInt(String(a), 10) || 0,
+    deletions: d === "-" ? 0 : parseInt(String(d), 10) || 0
+  };
+}
+function parseNumstatLine(line) {
+  const parts = line.split("	");
+  if (parts.length < 3) return null;
+  const rawPath = parts[parts.length - 1];
+  const { additions, deletions } = parseNumstatCounts(parts);
+  const expanded = expandGitRenameNumstatPath(rawPath);
+  const pathInRepo = normalizeGitDiffPath(expanded?.newPath ?? rawPath);
+  return {
+    pathInRepo,
+    additions,
+    deletions,
+    ...expanded ? { oldPathInRepo: expanded.oldPath } : {}
+  };
+}
+function parseNumstatEntries(lines) {
+  const m = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const parts = line.split("	");
+    if (parts.length < 3) continue;
+    const rawPath = parts[parts.length - 1];
+    const expanded = expandGitRenameNumstatPath(rawPath);
+    const entry = parseNumstatLine(line);
+    if (!entry) continue;
+    const existing = m.get(entry.pathInRepo);
+    if (!existing || expanded) {
+      m.set(entry.pathInRepo, entry);
     }
-    return direct;
   }
-  if (path27.basename(hint) === sid && await isGitDir(hint)) {
-    const legacyFromCheckout = await discoverLegacyBindingAscendingFromCheckout(sid, hint);
-    if (legacyFromCheckout) return legacyFromCheckout;
+  return m;
+}
+function parseNumstat(lines) {
+  const m = /* @__PURE__ */ new Map();
+  for (const [path62, entry] of parseNumstatEntries(lines)) {
+    m.set(path62, { additions: entry.additions, deletions: entry.deletions });
   }
-  let st;
+  return m;
+}
+
+// src/git/changes/parse/numstat-from-git-no-index.ts
+async function numstatFromGitNoIndex(g, pathInRepo) {
+  const devNull = process.platform === "win32" ? "NUL" : "/dev/null";
   try {
-    st = await fs22.promises.stat(hint);
+    const out = await g.raw(["diff", "--numstat", "--no-index", "--", devNull, pathInRepo]);
+    const first2 = String(out).split("\n").find((l) => l.trim()) ?? "";
+    const parsed = parseNumstatLine(first2);
+    if (!parsed) return null;
+    return { additions: parsed.additions, deletions: parsed.deletions };
   } 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) ?? path27.resolve(legacyPaths.paths[0]);
-  return {
-    sessionParentPath: path27.resolve(isolated),
-    workingTreeRelRoot: hint,
-    repoCheckoutPaths: legacyPaths.paths.map((p) => path27.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/git/changes/status/working-tree-changed-path-count.ts
+function workingTreeChangedPathCount(nameStatusLines, numstatLines, untrackedLines) {
+  const kindByPath = parseNameStatusLines(nameStatusLines);
+  const numByPath = parseNumstat(numstatLines);
+  const paths = /* @__PURE__ */ new Set([...kindByPath.keys(), ...numByPath.keys()]);
+  for (const p of untrackedLines.map((s) => s.trim()).filter(Boolean)) {
+    paths.add(p);
+  }
+  return paths.size;
 }
 
-// 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;
+// src/git/changes/count-working-tree-changed-files.ts
+async function countWorkingTreeChangedFilesForRepo(repoGitCwd) {
+  return runGitTask(async () => {
+    const g = cliSimpleGit(repoGitCwd);
+    const [nameStatusRaw, numstatRaw, untrackedRaw] = await Promise.all([
+      g.raw(["diff", "--name-status", "HEAD"]).catch(() => ""),
+      g.raw(["diff", "HEAD", "--numstat"]).catch(() => ""),
+      g.raw(["ls-files", "--others", "--exclude-standard"]).catch(() => "")
+    ]);
+    return workingTreeChangedPathCount(
+      String(nameStatusRaw).split("\n"),
+      String(numstatRaw).split("\n"),
+      String(untrackedRaw).split("\n")
+    );
+  });
 }
-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];
+
+// src/git/commits/remote-tracking/rev-parse-safe.ts
+async function revParseSafe(g, ref) {
+  try {
+    const v = (await g.raw(["rev-parse", "--verify", ref])).trim();
+    return v || null;
+  } catch {
+    return null;
   }
-  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/git/commits/remote-tracking/git-config.ts
+async function tryConfigGet(g, key) {
+  try {
+    const out = await g.raw(["config", "--get", key]);
+    const v = String(out).trim();
+    return v || null;
+  } catch {
+    return null;
+  }
 }
 
-// src/worktrees/prepare-new-session-worktrees.ts
-import * as fs23 from "node:fs";
-import * as path28 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/git/commits/remote-tracking/branch-remote-config.ts
+async function readBranchRemoteConfig(g) {
+  const branch = (await g.raw(["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+  if (!branch || branch === "HEAD") {
+    return { branch: null, remote: "origin", merge: null };
+  }
+  const [remote, merge2] = await Promise.all([
+    tryConfigGet(g, `branch.${branch}.remote`),
+    tryConfigGet(g, `branch.${branch}.merge`)
+  ]);
+  return { branch, remote: remote ?? "origin", merge: merge2 };
+}
+function trackingRefCandidates(config2) {
+  const candidates = ["HEAD@{upstream}", "@{u}"];
+  if (!config2.branch) return candidates;
+  if (config2.merge) {
+    candidates.push(
+      `refs/remotes/${config2.remote}/${config2.merge.replace(/^refs\/heads\//, "")}`
+    );
+  }
+  candidates.push(`refs/remotes/${config2.remote}/${config2.branch}`);
+  return candidates;
 }
 
-// src/worktrees/prepare-new-session-worktrees.ts
-function normalizeRepoRelPath(rel) {
-  return rel === "" ? "." : rel.replace(/\\/g, "/");
+// src/git/commits/remote-tracking/first-resolved-ref.ts
+async function firstResolvedSha(g, candidates) {
+  const resolved = await Promise.all(
+    candidates.map(async (ref) => ({ ref, sha: await revParseSafe(g, ref) }))
+  );
+  return resolved.find((entry) => entry.sha)?.sha ?? null;
 }
-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/git/commits/remote-tracking/resolve-default-remote-branch-ref.ts
+var DEFAULT_REMOTE_BRANCH_NAMES = ["main", "master", "trunk", "develop"];
+function defaultRemoteBranchNameRefs(remote) {
+  return DEFAULT_REMOTE_BRANCH_NAMES.map((name) => `refs/remotes/${remote}/${name}`);
 }
-async function prepareNewSessionWorktrees(options) {
-  const { worktreesRootPath, bridgeRoot, sessionId, layout, log: log2, worktreeBaseBranches } = options;
-  const bridgeResolved = path28.resolve(bridgeRoot);
-  const cwdKey = allocateDirNameForLauncherCwd(layout, bridgeResolved);
-  const bridgeKeyDir = path28.join(worktreesRootPath, cwdKey);
-  const sessionDir = path28.join(bridgeKeyDir, sessionId);
-  const repos = await discoverGitReposUnderRoot(bridgeResolved);
-  if (repos.length === 0) {
-    log2("[worktrees] No Git repositories under bridge root; skipping worktree creation.");
+async function resolveRemoteHeadSymbolicRef(g, remote) {
+  const headSym = `refs/remotes/${remote}/HEAD`;
+  try {
+    const out = await g.raw(["symbolic-ref", "-q", "--verify", headSym]);
+    const resolved = String(out).trim();
+    return resolved.startsWith("refs/remotes/") ? resolved : null;
+  } catch {
     return null;
   }
-  const branch = `session-${sessionId}`;
-  const worktreePaths = [];
-  fs23.mkdirSync(sessionDir, { recursive: true });
-  for (const repo of repos) {
-    let rel = path28.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path28.isAbsolute(rel)) continue;
-    const relNorm = normalizeRepoRelPath(rel === "" ? "." : rel);
-    const wtPath = relNorm === "." ? sessionDir : path28.join(sessionDir, relNorm);
-    if (relNorm !== ".") {
-      fs23.mkdirSync(path28.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)}`
-      );
-    }
+}
+async function resolveDefaultRemoteBranchSha(g, remote) {
+  const nameRefs = defaultRemoteBranchNameRefs(remote);
+  const [symRef, ...nameShas] = await Promise.all([
+    resolveRemoteHeadSymbolicRef(g, remote),
+    ...nameRefs.map((ref) => revParseSafe(g, ref))
+  ]);
+  if (symRef) return revParseSafe(g, symRef);
+  for (let i = 0; i < nameRefs.length; i++) {
+    if (nameShas[i]) return nameShas[i];
   }
-  if (worktreePaths.length === 0) return null;
-  return {
-    worktreePaths,
-    sessionParentPath: sessionDir,
-    workingTreeRelRoot: sessionDir
-  };
+  return null;
 }
 
-// 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 } : {}
+// src/git/commits/remote-tracking/resolve-base-sha-for-unpushed-commits.ts
+import * as path22 from "node:path";
+var BASE_SHA_CACHE_TTL_MS = 3e4;
+var baseShaCache = /* @__PURE__ */ new Map();
+async function resolveBaseShaForUnpushedCommitsUncached(g) {
+  const config2 = await readBranchRemoteConfig(g);
+  const trackingSha = await firstResolvedSha(g, trackingRefCandidates(config2));
+  if (trackingSha) return trackingSha;
+  return resolveDefaultRemoteBranchSha(g, config2.remote);
+}
+async function resolveBaseShaForUnpushedCommits(g, repoDir) {
+  if (repoDir) {
+    const key = path22.resolve(repoDir);
+    const now = Date.now();
+    const cached2 = baseShaCache.get(key);
+    if (cached2 && cached2.expiresAt > now) return cached2.baseSha;
+    const baseSha = await resolveBaseShaForUnpushedCommitsUncached(g);
+    baseShaCache.set(key, { baseSha, expiresAt: now + BASE_SHA_CACHE_TTL_MS });
+    return baseSha;
+  }
+  return resolveBaseShaForUnpushedCommitsUncached(g);
+}
+
+// src/git/commits/remote-tracking/commits-ahead-of-remote-tracking.ts
+async function commitsAheadOfRemoteTracking(repoDir) {
+  const g = cliSimpleGit(repoDir);
+  const headSha = await revParseSafe(g, "HEAD");
+  if (!headSha) return 0;
+  const baseSha = await resolveBaseShaForUnpushedCommits(g, repoDir);
+  if (!baseSha || baseSha === headSha) return 0;
+  try {
+    const out = await g.raw(["rev-list", "--count", `${baseSha}..${headSha}`]);
+    const n = parseInt(String(out).trim(), 10);
+    return Number.isNaN(n) ? 0 : n;
+  } catch {
+    return 0;
+  }
+}
+
+// src/git/status/working-tree-status.ts
+async function getRepoWorkingTreeStatus(repoDir) {
+  return runGitTask(async () => {
+    const uncommittedFileCount = await countWorkingTreeChangedFilesForRepo(repoDir);
+    const hasUncommittedChanges = uncommittedFileCount > 0;
+    const ahead = await commitsAheadOfRemoteTracking(repoDir);
+    return { hasUncommittedChanges, hasUnpushedCommits: ahead > 0, uncommittedFileCount };
   });
-  if (!prep) return void 0;
-  params.cache.remember(params.sessionId, {
-    sessionParentPath: prep.sessionParentPath,
-    workingTreeRelRoot: prep.workingTreeRelRoot,
-    repoCheckoutPaths: prep.worktreePaths
+}
+async function aggregateSessionPathsWorkingTreeStatus(paths) {
+  let hasUncommittedChanges = false;
+  let hasUnpushedCommits = false;
+  let uncommittedFileCount = 0;
+  await forEachWithGitYield(paths, async (p) => {
+    const s = await getRepoWorkingTreeStatus(p);
+    uncommittedFileCount += s.uncommittedFileCount;
+    if (s.hasUncommittedChanges) hasUncommittedChanges = true;
+    if (s.hasUnpushedCommits) hasUnpushedCommits = true;
   });
-  return params.cache.getSessionParentPath(params.sessionId);
+  return { hasUncommittedChanges, hasUnpushedCommits, uncommittedFileCount };
 }
-
-// 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;
+async function pushAheadOfUpstreamForPaths(paths) {
+  await forEachWithGitYield(paths, async (p) => {
+    const g = cliSimpleGit(p);
+    const ahead = await commitsAheadOfRemoteTracking(p);
+    if (ahead <= 0) return;
+    await g.push();
+  });
 }
 
-// src/worktrees/manager/resolve-explicit-session-parent-path.ts
-import * as path29 from "node:path";
-async function resolveExplicitSessionParentPath(params) {
-  const resolved = path29.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;
+// src/worktrees/manager/resolve-commit-targets.ts
+function bridgeRootBinding(bridgeRoot) {
+  return {
+    sessionParentPath: bridgeRoot,
+    workingTreeRelRoot: bridgeRoot,
+    repoCheckoutPaths: [bridgeRoot]
   };
-  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 = path29.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;
+async function resolveCommitTargetsAsync(sessionId, cache2, discover) {
   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));
+  const paths = cache2.getRepoCheckoutPathsRef(sid);
+  if (paths?.length) return paths;
+  const disc = await discover(sid);
+  if (disc?.repoCheckoutPaths.length) {
+    cache2.remember(sid, disc);
+    return disc.repoCheckoutPaths;
   }
-  return prepareAndRememberSessionWorktrees({
-    cache: cache2,
-    sessionId: sid,
-    worktreesRootPath,
-    layout,
-    log: log2
-  });
+  const bridgeRoot = getBridgeRoot();
+  cache2.remember(sid, bridgeRootBinding(bridgeRoot));
+  return [bridgeRoot];
+}
+
+// src/worktrees/manager/git/get-session-working-tree-status.ts
+async function getSessionWorkingTreeStatus(cache2, sessionId, discover) {
+  return aggregateSessionPathsWorkingTreeStatus(
+    await resolveCommitTargetsAsync(sessionId, cache2, discover)
+  );
 }
 
 // src/git/changes/types.ts
@@ -37477,108 +37420,13 @@ function formatRemoteDisplayLabel(remoteUrl) {
 }
 
 // src/git/changes/repo/get-working-tree-change-repo-details.ts
-import * as path34 from "node:path";
+import * as path29 from "node:path";
 
 // src/git/changes/repo/build-working-tree-change-repo-detail.ts
-import * as path33 from "node:path";
+import * as path28 from "node:path";
 
-// src/git/commits/resolve-remote-tracking.ts
-async function tryConfigGet(g, key) {
-  try {
-    const out = await g.raw(["config", "--get", key]);
-    const v = String(out).trim();
-    return v || null;
-  } catch {
-    return null;
-  }
-}
-async function revParseSafe(g, ref) {
-  try {
-    const v = (await g.raw(["rev-parse", ref])).trim();
-    return v || null;
-  } catch {
-    return null;
-  }
-}
-async function resolveRemoteTrackingRefForAhead(g) {
-  try {
-    await g.raw(["rev-parse", "--verify", "HEAD@{upstream}"]);
-    return "HEAD@{upstream}";
-  } catch {
-    try {
-      await g.raw(["rev-parse", "--verify", "@{u}"]);
-      return "@{u}";
-    } catch {
-    }
-  }
-  const branch = (await g.raw(["rev-parse", "--abbrev-ref", "HEAD"])).trim();
-  if (!branch || branch === "HEAD") return null;
-  const remote = await tryConfigGet(g, `branch.${branch}.remote`) ?? "origin";
-  const merge2 = await tryConfigGet(g, `branch.${branch}.merge`);
-  if (merge2) {
-    const upstreamBranch = merge2.replace(/^refs\/heads\//, "");
-    const ref = `refs/remotes/${remote}/${upstreamBranch}`;
-    try {
-      await g.raw(["rev-parse", "--verify", ref]);
-      return ref;
-    } catch {
-    }
-  }
-  const fallbackRef = `refs/remotes/${remote}/${branch}`;
-  try {
-    await g.raw(["rev-parse", "--verify", fallbackRef]);
-    return fallbackRef;
-  } catch {
-    return null;
-  }
-}
-async function remoteForCurrentBranch(g) {
-  const branch = (await g.raw(["rev-parse", "--abbrev-ref", "HEAD"])).trim();
-  if (!branch || branch === "HEAD") return "origin";
-  return await tryConfigGet(g, `branch.${branch}.remote`) ?? "origin";
-}
-async function resolveDefaultRemoteBranchRef(g, remote) {
-  const headSym = `refs/remotes/${remote}/HEAD`;
-  try {
-    const resolved = (await g.raw(["symbolic-ref", "-q", "--verify", headSym])).trim();
-    if (resolved.startsWith("refs/remotes/")) return resolved;
-  } catch {
-  }
-  for (const name of ["main", "master", "trunk", "develop"]) {
-    const r = `refs/remotes/${remote}/${name}`;
-    try {
-      await g.raw(["rev-parse", "--verify", r]);
-      return r;
-    } catch {
-    }
-  }
-  return null;
-}
-async function resolveBaseShaForUnpushedCommits(g) {
-  const trackingRef = await resolveRemoteTrackingRefForAhead(g);
-  if (trackingRef) {
-    const sha = await revParseSafe(g, trackingRef);
-    if (sha) return sha;
-  }
-  const remote = await remoteForCurrentBranch(g);
-  const defaultRef = await resolveDefaultRemoteBranchRef(g, remote);
-  if (!defaultRef) return null;
-  return revParseSafe(g, defaultRef);
-}
-async function commitsAheadOfRemoteTracking(repoDir) {
-  const g = cliSimpleGit(repoDir);
-  const headSha = await revParseSafe(g, "HEAD");
-  if (!headSha) return 0;
-  const baseSha = await resolveBaseShaForUnpushedCommits(g);
-  if (!baseSha || baseSha === headSha) return 0;
-  try {
-    const out = await g.raw(["rev-list", "--count", `${baseSha}..${headSha}`]);
-    const n = parseInt(String(out).trim(), 10);
-    return Number.isNaN(n) ? 0 : n;
-  } catch {
-    return 0;
-  }
-}
+// src/git/commits/list-unpushed-commits.ts
+import * as path23 from "node:path";
 
 // src/git/commits/lib/parse-log-lines.ts
 function parseLogShaDateSubjectLines(raw) {
@@ -37598,9 +37446,14 @@ function parseLogShaDateSubjectLines(raw) {
 }
 
 // src/git/commits/list-unpushed-commits.ts
+var UNPUSHED_CACHE_TTL_MS = 3e4;
+var unpushedCache = /* @__PURE__ */ new Map();
 async function gitLogNotReachableFromBase(g, baseSha, headSha) {
   if (baseSha === headSha) return [];
   try {
+    const countOut = await g.raw(["rev-list", "--count", `${baseSha}..${headSha}`]);
+    const count = parseInt(String(countOut).trim(), 10);
+    if (!Number.isFinite(count) || count <= 0) return [];
     const logOut = await g.raw(["log", "--format=%H	%cI	%s", `${baseSha}..${headSha}`]);
     return parseLogShaDateSubjectLines(logOut);
   } catch {
@@ -37608,12 +37461,22 @@ async function gitLogNotReachableFromBase(g, baseSha, headSha) {
   }
 }
 async function listUnpushedCommits(repoDir) {
+  const key = path23.resolve(repoDir);
+  const now = Date.now();
+  const cached2 = unpushedCache.get(key);
+  if (cached2 && cached2.expiresAt > now) return cached2.commits;
   const g = cliSimpleGit(repoDir);
-  const headSha = await revParseSafe(g, "HEAD");
-  if (!headSha) return [];
-  const baseSha = await resolveBaseShaForUnpushedCommits(g);
-  if (!baseSha) return [];
-  return gitLogNotReachableFromBase(g, baseSha, headSha);
+  const [headSha, baseSha] = await Promise.all([
+    revParseSafe(g, "HEAD"),
+    resolveBaseShaForUnpushedCommits(g, repoDir)
+  ]);
+  if (!headSha || !baseSha) {
+    unpushedCache.set(key, { commits: [], expiresAt: now + UNPUSHED_CACHE_TTL_MS });
+    return [];
+  }
+  const commits = await gitLogNotReachableFromBase(g, baseSha, headSha);
+  unpushedCache.set(key, { commits, expiresAt: now + UNPUSHED_CACHE_TTL_MS });
+  return commits;
 }
 
 // src/git/commits/lib/sanitize-recent-commits-limit.ts
@@ -37627,72 +37490,40 @@ function sanitizeRecentCommitsLimit(value) {
 }
 
 // src/git/commits/list-recent-commits.ts
-async function listRecentCommits(repoDir, limitInput) {
+async function listRecentCommitRefs(repoDir, limitInput) {
   const limit = sanitizeRecentCommitsLimit(limitInput);
   const g = cliSimpleGit(repoDir);
-  const headSha = await revParseSafe(g, "HEAD");
-  if (!headSha) return { commits: [], hasMore: false };
-  const unpushedSet = new Set((await listUnpushedCommits(repoDir)).map((c) => c.sha));
   try {
-    const logOut = await g.raw(["log", "--format=%H	%cI	%s", `-n`, String(limit), "HEAD"]);
-    const commits = parseLogShaDateSubjectLines(logOut).map((c) => ({
-      ...c,
-      needsPush: unpushedSet.has(c.sha)
-    }));
-    let hasMore = false;
-    if (commits.length === limit) {
-      const nextOut = await g.raw(["log", "-n", "1", `--skip=${limit}`, "--format=%H", "HEAD"]);
-      hasMore = /^[0-9a-f]{7,40}$/i.test(String(nextOut).trim());
-    }
+    const logOut = await g.raw(["log", "--format=%H	%cI	%s", `-n`, String(limit + 1), "HEAD"]);
+    const parsed = parseLogShaDateSubjectLines(logOut);
+    const hasMore = parsed.length > limit;
+    const commits = parsed.slice(0, limit);
     return { commits, hasMore };
   } catch {
     return { commits: [], hasMore: false };
   }
 }
 
-// src/git/changes/parse/normalize-git-diff-path.ts
-function normalizeGitDiffPath(path55) {
-  return path55.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
-}
-
-// src/git/changes/parse/expand-git-rename-numstat-path.ts
-function expandGitRenameNumstatPath(rawPath) {
-  const open2 = rawPath.indexOf("{");
-  const arrow = rawPath.indexOf("=>");
-  const close = rawPath.lastIndexOf("}");
-  if (open2 === -1 || arrow === -1 || close === -1 || open2 > arrow || arrow > close) {
-    return null;
-  }
-  const prefix = rawPath.slice(0, open2);
-  const suffix = rawPath.slice(close + 1);
-  const oldPart = rawPath.slice(open2 + 1, arrow).trim();
-  const newPart = rawPath.slice(arrow + 2, close).trim();
-  return {
-    oldPath: normalizeGitDiffPath(`${prefix}${oldPart}${suffix}`),
-    newPath: normalizeGitDiffPath(`${prefix}${newPart}${suffix}`)
-  };
-}
-function isGitRenameNumstatPath(rawPath) {
-  return expandGitRenameNumstatPath(rawPath) != null;
-}
+// src/git/changes/listing/list-changed-files-for-commit.ts
+import * as path25 from "node:path";
 
 // src/git/changes/rows/build-changed-file-row.ts
 function buildChangedFileRow(options) {
   const pathInRepo = normalizeGitDiffPath(options.pathInRepo);
-  const relLauncher = posixJoinDirFile(options.repoRelPath, pathInRepo);
+  const workspaceRelPath = posixJoinDirFile(options.repoRelPath, pathInRepo);
   const additions = options.numEntry?.additions ?? 0;
   const deletions = options.numEntry?.deletions ?? 0;
   let change = options.nameEntry?.change ?? "modified";
-  let movedFromPathRelLauncher;
+  let movedFromWorkspaceRelPath;
   let movedFromPathInRepo;
   const oldPathInRepo = options.nameEntry?.oldPathInRepo ?? options.numEntry?.oldPathInRepo;
   if (change === "moved" && oldPathInRepo) {
     movedFromPathInRepo = normalizeGitDiffPath(oldPathInRepo);
-    movedFromPathRelLauncher = posixJoinDirFile(options.repoRelPath, movedFromPathInRepo);
+    movedFromWorkspaceRelPath = posixJoinDirFile(options.repoRelPath, movedFromPathInRepo);
   } else if (oldPathInRepo && change === "modified") {
     change = "moved";
     movedFromPathInRepo = normalizeGitDiffPath(oldPathInRepo);
-    movedFromPathRelLauncher = posixJoinDirFile(options.repoRelPath, movedFromPathInRepo);
+    movedFromWorkspaceRelPath = posixJoinDirFile(options.repoRelPath, movedFromPathInRepo);
   }
   if (options.untracked && !options.nameEntry) {
     change = "added";
@@ -37702,11 +37533,11 @@ function buildChangedFileRow(options) {
     else change = "modified";
   }
   return {
-    pathRelLauncher: relLauncher,
+    workspaceRelPath,
     additions,
     deletions,
     change,
-    ...movedFromPathRelLauncher ? { movedFromPathRelLauncher } : {},
+    ...movedFromWorkspaceRelPath ? { movedFromWorkspaceRelPath } : {},
     ...movedFromPathInRepo ? { movedFromPathInRepo } : {}
   };
 }
@@ -37765,8 +37596,8 @@ async function unifiedDiffForFileInRange(repoCwd, range, pathInRepo, change, mov
 }
 
 // src/git/changes/total-lines/resolve-changed-file-total-lines.ts
-import * as fs24 from "node:fs";
-import * as path30 from "node:path";
+import * as fs18 from "node:fs";
+import * as path24 from "node:path";
 
 // src/git/changes/lines/count-lines.ts
 import { createReadStream } from "node:fs";
@@ -37812,13 +37643,13 @@ async function countLinesInGitRef(repoGitCwd, ref, pathInRepo) {
 }
 async function resolveWorkingTreeFileTotalLines(options) {
   if (options.isBinary) return null;
-  const filePath = path30.join(options.repoGitCwd, options.pathInRepo);
+  const filePath = path24.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 fs24.promises.stat(filePath);
+      const st = await fs18.promises.stat(filePath);
       if (!st.isFile()) return null;
       return await countTextFileLines(filePath);
     } catch {
@@ -37838,23 +37669,23 @@ async function resolveCommitFileTotalLines(options) {
   return null;
 }
 
-// src/git/changes/listing/path-in-repo-from-launcher.ts
-function pathInRepoFromLauncher(pathRelLauncher, repoRelPath) {
+// src/git/changes/listing/path-in-repo-from-workspace.ts
+function pathInRepoFromWorkspace(workspaceRelPath, repoRelPath) {
   const normRel = repoRelPath === "." || repoRelPath === "" ? "." : repoRelPath;
-  if (normRel === ".") return pathRelLauncher;
-  if (pathRelLauncher.startsWith(`${normRel}/`)) {
-    return pathRelLauncher.slice(normRel.length + 1);
+  if (normRel === ".") return workspaceRelPath;
+  if (workspaceRelPath.startsWith(`${normRel}/`)) {
+    return workspaceRelPath.slice(normRel.length + 1);
   }
-  return pathRelLauncher;
+  return workspaceRelPath;
 }
-function normalizeRepoRelPath2(repoRelPath) {
+function normalizeRepoRelPath(repoRelPath) {
   return repoRelPath === "." || repoRelPath === "" ? "." : repoRelPath;
 }
 
 // src/git/changes/listing/enrich-commit-file-rows.ts
 async function enrichCommitFileRows(options) {
   await forEachWithGitYield(options.rows, async (row) => {
-    const pathInRepo = pathInRepoFromLauncher(row.pathRelLauncher, options.repoRelPath);
+    const pathInRepo = pathInRepoFromWorkspace(row.workspaceRelPath, options.repoRelPath);
     row.patchContent = await unifiedDiffForFileInRange(
       options.repoGitCwd,
       options.range,
@@ -37873,102 +37704,6 @@ async function enrichCommitFileRows(options) {
   });
 }
 
-// src/git/changes/parse/parse-name-status-entries.ts
-function parseNameStatusEntries(lines) {
-  const entries = [];
-  for (const line of lines) {
-    if (!line.trim()) continue;
-    const tabParts = line.split("	");
-    if (tabParts.length < 2) continue;
-    const status = tabParts[0].trim();
-    const code = status[0];
-    if (code === "A") {
-      entries.push({ pathInRepo: normalizeGitDiffPath(tabParts[tabParts.length - 1]), change: "added" });
-    } else if (code === "D") {
-      entries.push({ pathInRepo: normalizeGitDiffPath(tabParts[tabParts.length - 1]), change: "removed" });
-    } else if (code === "R" || code === "C") {
-      if (tabParts.length >= 3) {
-        entries.push({
-          pathInRepo: normalizeGitDiffPath(tabParts[tabParts.length - 1]),
-          oldPathInRepo: normalizeGitDiffPath(tabParts[tabParts.length - 2]),
-          change: "moved"
-        });
-      }
-    } else if (code === "M" || code === "U" || code === "T") {
-      entries.push({ pathInRepo: normalizeGitDiffPath(tabParts[tabParts.length - 1]), change: "modified" });
-    }
-  }
-  return entries;
-}
-function parseNameStatusLines(lines) {
-  const m = /* @__PURE__ */ new Map();
-  for (const entry of parseNameStatusEntries(lines)) {
-    m.set(entry.pathInRepo, entry.change);
-  }
-  return m;
-}
-
-// src/git/changes/parse/parse-numstat-entries.ts
-function parseNumstatCounts(parts) {
-  const [a, d] = parts;
-  return {
-    additions: a === "-" ? 0 : parseInt(String(a), 10) || 0,
-    deletions: d === "-" ? 0 : parseInt(String(d), 10) || 0
-  };
-}
-function parseNumstatLine(line) {
-  const parts = line.split("	");
-  if (parts.length < 3) return null;
-  const rawPath = parts[parts.length - 1];
-  const { additions, deletions } = parseNumstatCounts(parts);
-  const expanded = expandGitRenameNumstatPath(rawPath);
-  const pathInRepo = normalizeGitDiffPath(expanded?.newPath ?? rawPath);
-  return {
-    pathInRepo,
-    additions,
-    deletions,
-    ...expanded ? { oldPathInRepo: expanded.oldPath } : {}
-  };
-}
-function parseNumstatEntries(lines) {
-  const m = /* @__PURE__ */ new Map();
-  for (const line of lines) {
-    if (!line.trim()) continue;
-    const parts = line.split("	");
-    if (parts.length < 3) continue;
-    const rawPath = parts[parts.length - 1];
-    const expanded = expandGitRenameNumstatPath(rawPath);
-    const entry = parseNumstatLine(line);
-    if (!entry) continue;
-    const existing = m.get(entry.pathInRepo);
-    if (!existing || expanded) {
-      m.set(entry.pathInRepo, entry);
-    }
-  }
-  return m;
-}
-function parseNumstat(lines) {
-  const m = /* @__PURE__ */ new Map();
-  for (const [path55, entry] of parseNumstatEntries(lines)) {
-    m.set(path55, { additions: entry.additions, deletions: entry.deletions });
-  }
-  return m;
-}
-
-// src/git/changes/parse/numstat-from-git-no-index.ts
-async function numstatFromGitNoIndex(g, pathInRepo) {
-  const devNull = process.platform === "win32" ? "NUL" : "/dev/null";
-  try {
-    const out = await g.raw(["diff", "--numstat", "--no-index", "--", devNull, pathInRepo]);
-    const first2 = String(out).split("\n").find((l) => l.trim()) ?? "";
-    const parsed = parseNumstatLine(first2);
-    if (!parsed) return null;
-    return { additions: parsed.additions, deletions: parsed.deletions };
-  } catch {
-    return null;
-  }
-}
-
 // src/git/changes/rows/collect-moved-source-paths.ts
 function collectMovedSourcePaths(nameEntries, numByPath) {
   const sources = /* @__PURE__ */ new Set();
@@ -38048,8 +37783,8 @@ function pickPreferredChangedFileRow(a, b) {
   const aHasPatch = Boolean(a.patchContent?.trim());
   const bHasPatch = Boolean(b.patchContent?.trim());
   if (aHasPatch !== bHasPatch) return aHasPatch ? a : b;
-  const aHasMoveMeta = Boolean(a.movedFromPathInRepo || a.movedFromPathRelLauncher);
-  const bHasMoveMeta = Boolean(b.movedFromPathInRepo || b.movedFromPathRelLauncher);
+  const aHasMoveMeta = Boolean(a.movedFromPathInRepo || a.movedFromWorkspaceRelPath);
+  const bHasMoveMeta = Boolean(b.movedFromPathInRepo || b.movedFromWorkspaceRelPath);
   if (aHasMoveMeta !== bHasMoveMeta) return aHasMoveMeta ? a : b;
   return a;
 }
@@ -38058,30 +37793,39 @@ function pickPreferredChangedFileRow(a, b) {
 function dedupeChangedFileRows(rows) {
   const byPath = /* @__PURE__ */ new Map();
   for (const row of rows) {
-    const key = normalizeGitDiffPath(row.pathRelLauncher);
-    const normalizedRow = key === row.pathRelLauncher ? row : { ...row, pathRelLauncher: key };
+    const key = normalizeGitDiffPath(row.workspaceRelPath);
+    const normalizedRow = key === row.workspaceRelPath ? row : { ...row, workspaceRelPath: key };
     const existing = byPath.get(key);
     if (!existing) {
       byPath.set(key, normalizedRow);
       continue;
     }
     const preferRow = pickPreferredChangedFileRow(existing, normalizedRow);
-    byPath.set(key, { ...preferRow, pathRelLauncher: key });
+    byPath.set(key, { ...preferRow, workspaceRelPath: key });
   }
   return [...byPath.values()];
 }
 
 // src/git/changes/listing/list-changed-files-for-commit.ts
-async function listChangedFilesForCommit(repoGitCwd, repoRelPath, commitSha) {
+var COMMIT_FILES_CACHE_TTL_MS = 5 * 6e4;
+var commitFilesCache = /* @__PURE__ */ new Map();
+function commitFilesCacheKey(repoGitCwd, commitSha) {
+  return `${path25.resolve(repoGitCwd)}:${commitSha}`;
+}
+async function listChangedFilesForCommit(repoGitCwd, repoRelPath, commitSha, options = {}) {
+  const cacheKey = commitFilesCacheKey(repoGitCwd, commitSha);
+  if (!options.includeFilePatches) {
+    const now = Date.now();
+    const cached2 = commitFilesCache.get(cacheKey);
+    if (cached2 && cached2.expiresAt > now) return cached2.rows;
+  }
   const g = cliSimpleGit(repoGitCwd);
-  const parent = await parentForCommitDiff(g, commitSha);
-  const range = `${parent}..${commitSha}`;
+  const normRel = normalizeRepoRelPath(repoRelPath);
   const [nameStatusRaw, numstatRaw] = await Promise.all([
-    g.raw(["diff", ...RENAME_DIFF_ARGS, "--name-status", range]).catch(() => ""),
-    g.raw(["diff", ...RENAME_DIFF_ARGS, "--numstat", range]).catch(() => "")
+    g.raw(["diff-tree", "--no-commit-id", "--name-status", "-r", ...RENAME_DIFF_ARGS, commitSha]).catch(() => ""),
+    g.raw(["show", "--numstat", "--format=format:", commitSha]).catch(() => "")
   ]);
   const parsed = parseDiffOutput(String(nameStatusRaw), String(numstatRaw));
-  const normRel = normalizeRepoRelPath2(repoRelPath);
   const paths = collectChangedPaths({
     nameEntries: parsed.nameEntries,
     numByPath: parsed.numByPath
@@ -38094,29 +37838,39 @@ async function listChangedFilesForCommit(repoGitCwd, repoRelPath, commitSha) {
     movedSourcePaths: parsed.movedSourcePaths
   });
   rows = dedupeChangedFileRows(rows);
-  await enrichCommitFileRows({
-    rows,
-    repoGitCwd,
-    repoRelPath: normRel,
-    range,
-    commitSha,
-    parentSha: parent,
-    binaryByPath: parsed.binaryByPath
-  });
+  if (options.includeFilePatches) {
+    const parent = await parentForCommitDiff(g, commitSha);
+    const range = `${parent}..${commitSha}`;
+    await enrichCommitFileRows({
+      rows,
+      repoGitCwd,
+      repoRelPath: normRel,
+      range,
+      commitSha,
+      parentSha: parent,
+      binaryByPath: parsed.binaryByPath
+    });
+  }
   const finalRows = dedupeChangedFileRows(rows);
-  finalRows.sort((a, b) => a.pathRelLauncher.localeCompare(b.pathRelLauncher));
+  finalRows.sort((a, b) => a.workspaceRelPath.localeCompare(b.workspaceRelPath));
+  if (!options.includeFilePatches) {
+    commitFilesCache.set(cacheKey, {
+      rows: finalRows,
+      expiresAt: Date.now() + COMMIT_FILES_CACHE_TTL_MS
+    });
+  }
   return finalRows;
 }
 
 // src/git/changes/listing/apply-untracked-file-stats.ts
-import * as fs25 from "node:fs";
-import * as path31 from "node:path";
+import * as fs19 from "node:fs";
+import * as path26 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 = path31.join(options.repoGitCwd, pathInRepo);
+    const repoFilePath = path26.join(options.repoGitCwd, pathInRepo);
     const fromGit = await numstatFromGitNoIndex(options.g, pathInRepo);
     if (fromGit) {
       row.additions = fromGit.additions;
@@ -38124,7 +37878,7 @@ function createUntrackedStatsApplier(options) {
       return;
     }
     try {
-      const st = await fs25.promises.stat(repoFilePath);
+      const st = await fs19.promises.stat(repoFilePath);
       row.additions = st.isFile() ? await countTextFileLines(repoFilePath) : 0;
     } catch {
       row.additions = 0;
@@ -38134,7 +37888,7 @@ function createUntrackedStatsApplier(options) {
 }
 
 // src/git/changes/listing/enrich-working-tree-file-rows.ts
-import * as path32 from "node:path";
+import * as path27 from "node:path";
 
 // src/git/changes/patch/hydrate/append-injected-context-lines.ts
 async function appendInjectedContextLines(out, inject, maybeYield, injectedTotal) {
@@ -38214,10 +37968,10 @@ async function readGitBlobLines(repoCwd, pathInRepo) {
 }
 
 // src/git/changes/patch/hydrate/read-worktree-file-lines.ts
-import * as fs26 from "node:fs";
+import * as fs20 from "node:fs";
 async function readWorktreeFileLines(filePath) {
   try {
-    const raw = await fs26.promises.readFile(filePath, "utf8");
+    const raw = await fs20.promises.readFile(filePath, "utf8");
     return raw.split(/\r?\n/);
   } catch {
     return null;
@@ -38313,8 +38067,8 @@ async function hydrateUnifiedPatchWithFileContext(patch, filePath, repoGitCwd, p
 // src/git/changes/listing/enrich-working-tree-file-rows.ts
 async function enrichWorkingTreeFileRows(options) {
   await forEachWithGitYield(options.rows, async (row) => {
-    const pathInRepo = pathInRepoFromLauncher(row.pathRelLauncher, options.repoRelPath);
-    const filePath = path32.join(options.repoGitCwd, pathInRepo);
+    const pathInRepo = pathInRepoFromWorkspace(row.workspaceRelPath, options.repoRelPath);
+    const filePath = path27.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) {
@@ -38337,7 +38091,7 @@ async function enrichWorkingTreeFileRows(options) {
 }
 
 // src/git/changes/listing/list-changed-files-for-repo.ts
-async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
+async function listChangedFilesForRepo(repoGitCwd, repoRelPath, options = {}) {
   const g = cliSimpleGit(repoGitCwd);
   const [nameStatusRaw, numstatRaw, untrackedRaw] = await Promise.all([
     g.raw(["diff", ...RENAME_DIFF_ARGS, "--name-status", "HEAD"]).catch(() => ""),
@@ -38367,12 +38121,14 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
     })
   });
   rows = dedupeChangedFileRows(rows);
-  await enrichWorkingTreeFileRows({
-    rows,
-    repoGitCwd,
-    repoRelPath,
-    binaryByPath: parsed.binaryByPath
-  });
+  if (options.includeFilePatches) {
+    await enrichWorkingTreeFileRows({
+      rows,
+      repoGitCwd,
+      repoRelPath,
+      binaryByPath: parsed.binaryByPath
+    });
+  }
   return dedupeChangedFileRows(rows);
 }
 
@@ -38383,48 +38139,62 @@ function normRepoRel(p) {
 }
 
 // src/git/changes/repo/build-working-tree-change-repo-detail.ts
+async function loadRecentAndUnpushedCommits(repoDir, recentCommitsLimit) {
+  const [unpushedCommits, recentCommitList] = await Promise.all([
+    listUnpushedCommits(repoDir),
+    listRecentCommitRefs(repoDir, recentCommitsLimit)
+  ]);
+  const unpushedSet = new Set(unpushedCommits.map((c) => c.sha));
+  return {
+    unpushedCommits,
+    recentCommits: recentCommitList.commits.map((c) => ({
+      ...c,
+      needsPush: unpushedSet.has(c.sha)
+    })),
+    recentCommitsHasMore: recentCommitList.hasMore
+  };
+}
 async function buildWorkingTreeChangeRepoDetail(options) {
-  const t = path33.resolve(options.targetPath);
+  const t = path28.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";
-  }
+  const isCommitView = options.basis.kind === "commit";
+  const sessionWtRoot = options.sessionWorktreeRootPath ? path28.resolve(options.sessionWorktreeRootPath) : null;
+  const legacyNested = options.legacyRepoNestedSessionLayout;
   await yieldToEventLoop2();
-  const remoteUrl = await getRemoteOriginUrl(t);
+  const branchPromise = g.raw(["rev-parse", "--abbrev-ref", "HEAD"]).then((out) => out.trim() || "HEAD").catch(() => "HEAD");
+  const remoteUrlPromise = getRemoteOriginUrl(t);
+  const topLevelPromise = sessionWtRoot ? Promise.resolve(t) : g.raw(["rev-parse", "--show-toplevel"]).then((out) => out.trim()).catch(() => t);
+  const [branch, remoteUrl, topOrT] = await Promise.all([
+    branchPromise,
+    remoteUrlPromise,
+    topLevelPromise
+  ]);
   const remoteDisplay = formatRemoteDisplayLabel(remoteUrl);
-  const sessionWtRoot = options.sessionWorktreeRootPath ? path33.resolve(options.sessionWorktreeRootPath) : null;
-  const legacyNested = options.legacyRepoNestedSessionLayout;
   let repoRelPath;
   if (sessionWtRoot) {
-    const anchor = legacyNested ? path33.dirname(t) : t;
-    const relNorm = path33.relative(sessionWtRoot, anchor);
+    const anchor = legacyNested ? path28.dirname(t) : t;
+    const relNorm = path28.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 = path33.relative(options.bridgeRoot, path33.resolve(top)).replace(/\\/g, "/") || ".";
-    repoRelPath = rel.startsWith("..") ? path33.basename(path33.resolve(top)) : rel;
+    const top = topOrT;
+    const rel = path28.relative(options.bridgeRoot, path28.resolve(top)).replace(/\\/g, "/") || ".";
+    repoRelPath = rel.startsWith("..") ? path28.basename(path28.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)
+  const commitSha = isCommitView ? options.basis.sha.trim() : null;
+  const filesPromise = isCommitView && commitSha ? listChangedFilesForCommit(t, relForList, commitSha, {
+    includeFilePatches: options.includeFilePatches
+  }) : listChangedFilesForRepo(t, relForList, { includeFilePatches: options.includeFilePatches });
+  const statusPromise = isCommitView ? Promise.resolve(false) : g.status().then((st) => (st.files?.length ?? 0) > 0);
+  const commitsPromise = isCommitView ? Promise.resolve(null) : loadRecentAndUnpushedCommits(t, options.recentCommitsLimit);
+  const [files, hasUncommittedChanges, commitData] = await Promise.all([
+    filesPromise,
+    statusPromise,
+    commitsPromise
   ]);
   return {
     repoRelPath: norm,
@@ -38434,18 +38204,18 @@ async function buildWorkingTreeChangeRepoDetail(options) {
     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
+    unpushedCommits: commitData?.unpushedCommits ?? [],
+    recentCommits: commitData?.recentCommits ?? [],
+    recentCommitsHasMore: commitData?.recentCommitsHasMore ?? false,
+    changesView: isCommitView ? "commit" : "working",
+    changesCommitSha: commitSha
   };
 }
 
 // src/git/changes/repo/get-working-tree-change-repo-details.ts
 async function getWorkingTreeChangeRepoDetails(options) {
-  const bridgeRoot = path34.resolve(getBridgeRoot());
-  const sessionWtRoot = options.sessionWorktreeRootPath ? path34.resolve(options.sessionWorktreeRootPath) : null;
+  const bridgeRoot = path29.resolve(getBridgeRoot());
+  const sessionWtRoot = options.sessionWorktreeRootPath ? path29.resolve(options.sessionWorktreeRootPath) : null;
   const legacyNested = options.legacyRepoNestedSessionLayout === true;
   const out = [];
   const filter = options.repoFilterRelPath != null ? normRepoRel(options.repoFilterRelPath) : null;
@@ -38459,14 +38229,16 @@ async function getWorkingTreeChangeRepoDetails(options) {
   const basis = filter == null && basisInput.kind === "commit" ? { kind: "working" } : basisInput;
   for (let i = 0; i < options.commitTargetPaths.length; i++) {
     await yieldToEventLoop2();
+    const targetPath = options.commitTargetPaths[i];
     const detail = await buildWorkingTreeChangeRepoDetail({
-      targetPath: options.commitTargetPaths[i],
+      targetPath,
       bridgeRoot,
       sessionWorktreeRootPath: sessionWtRoot,
       legacyRepoNestedSessionLayout: legacyNested,
       repoFilterRelPath: filter,
       basis,
-      recentCommitsLimit: options.recentCommitsLimit
+      recentCommitsLimit: options.recentCommitsLimit,
+      includeFilePatches: options.includeFilePatches
     });
     if (!detail) continue;
     out.push(detail);
@@ -38475,94 +38247,148 @@ async function getWorkingTreeChangeRepoDetails(options) {
   return out;
 }
 
-// src/git/changes/status/working-tree-changed-path-count.ts
-function workingTreeChangedPathCount(nameStatusLines, numstatLines, untrackedLines) {
-  const kindByPath = parseNameStatusLines(nameStatusLines);
-  const numByPath = parseNumstat(numstatLines);
-  const paths = /* @__PURE__ */ new Set([...kindByPath.keys(), ...numByPath.keys()]);
-  for (const p of untrackedLines.map((s) => s.trim()).filter(Boolean)) {
-    paths.add(p);
-  }
-  return paths.size;
-}
-
-// src/git/changes/count-working-tree-changed-files.ts
-async function countWorkingTreeChangedFilesForRepo(repoGitCwd) {
-  return runGitTask(async () => {
+// src/git/changes/repo/get-working-tree-change-file-patch.ts
+import * as path30 from "node:path";
+async function getWorkingTreeChangeFilePatch(options) {
+  const repoGitCwd = path30.resolve(options.repoGitCwd);
+  if (!await isGitRepoDirectory(repoGitCwd)) {
+    throw new Error("Not a git repository");
+  }
+  const normRel = options.repoRelPath === "." || options.repoRelPath === "" ? "." : options.repoRelPath;
+  const pathInRepo = pathInRepoFromWorkspace(options.workspaceRelPath, normRel);
+  const movedFromPathInRepo = options.change === "moved" && options.movedFromWorkspaceRelPath ? pathInRepoFromWorkspace(options.movedFromWorkspaceRelPath, normRel) : void 0;
+  if (options.basis.kind === "commit") {
+    const commitSha = options.basis.sha.trim();
+    if (!commitSha) throw new Error("commit sha is required for commit file patch");
     const g = cliSimpleGit(repoGitCwd);
-    const [nameStatusRaw, numstatRaw, untrackedRaw] = await Promise.all([
-      g.raw(["diff", "--name-status", "HEAD"]).catch(() => ""),
-      g.raw(["diff", "HEAD", "--numstat"]).catch(() => ""),
-      g.raw(["ls-files", "--others", "--exclude-standard"]).catch(() => "")
-    ]);
-    return workingTreeChangedPathCount(
-      String(nameStatusRaw).split("\n"),
-      String(numstatRaw).split("\n"),
-      String(untrackedRaw).split("\n")
+    const parentSha = await parentForCommitDiff(g, commitSha);
+    const range = `${parentSha}..${commitSha}`;
+    const patchContent2 = await unifiedDiffForFileInRange(
+      repoGitCwd,
+      range,
+      pathInRepo,
+      options.change,
+      movedFromPathInRepo
     );
+    const isBinary = Boolean(patchContent2?.includes("Binary files"));
+    const totalLines2 = await resolveCommitFileTotalLines({
+      repoGitCwd,
+      pathInRepo,
+      change: options.change,
+      commitSha,
+      parentSha,
+      isBinary
+    });
+    return { patchContent: patchContent2, totalLines: totalLines2 };
+  }
+  const filePath = path30.join(repoGitCwd, pathInRepo);
+  const hydrateKind = options.change === "moved" ? "modified" : options.change;
+  let patchContent = await unifiedDiffForFile(
+    repoGitCwd,
+    pathInRepo,
+    options.change,
+    movedFromPathInRepo
+  );
+  if (patchContent) {
+    patchContent = await hydrateUnifiedPatchWithFileContext(
+      patchContent,
+      filePath,
+      repoGitCwd,
+      pathInRepo,
+      hydrateKind
+    );
+  }
+  const totalLines = await resolveWorkingTreeFileTotalLines({
+    repoGitCwd,
+    pathInRepo,
+    change: options.change,
+    isBinary: Boolean(patchContent?.includes("Binary files"))
   });
+  return { patchContent, totalLines };
 }
 
-// src/git/status/working-tree-status.ts
-async function getRepoWorkingTreeStatus(repoDir) {
-  return runGitTask(async () => {
-    const uncommittedFileCount = await countWorkingTreeChangedFilesForRepo(repoDir);
-    const hasUncommittedChanges = uncommittedFileCount > 0;
-    const ahead = await commitsAheadOfRemoteTracking(repoDir);
-    return { hasUncommittedChanges, hasUnpushedCommits: ahead > 0, uncommittedFileCount };
-  });
-}
-async function aggregateSessionPathsWorkingTreeStatus(paths) {
-  let hasUncommittedChanges = false;
-  let hasUnpushedCommits = false;
-  let uncommittedFileCount = 0;
-  await forEachWithGitYield(paths, async (p) => {
-    const s = await getRepoWorkingTreeStatus(p);
-    uncommittedFileCount += s.uncommittedFileCount;
-    if (s.hasUncommittedChanges) hasUncommittedChanges = true;
-    if (s.hasUnpushedCommits) hasUnpushedCommits = true;
+// src/worktrees/manager/git/get-session-working-tree-change-details.ts
+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() ? normRepoRel(opts.repoRelPath.trim()) : null,
+    basis: opts?.basis,
+    recentCommitsLimit: opts?.recentCommitsLimit,
+    includeFilePatches: false
   });
-  return { hasUncommittedChanges, hasUnpushedCommits, uncommittedFileCount };
 }
-async function pushAheadOfUpstreamForPaths(paths) {
-  await forEachWithGitYield(paths, async (p) => {
-    const g = cliSimpleGit(p);
-    const ahead = await commitsAheadOfRemoteTracking(p);
-    if (ahead <= 0) return;
-    await g.push();
-  });
+
+// src/worktrees/manager/git/parse-working-tree-change-kind.ts
+function parseWorkingTreeChangeKind(value) {
+  if (value === "added" || value === "removed" || value === "modified" || value === "moved") return value;
+  return null;
 }
 
-// src/git/branches/commit-and-push.ts
-async function gitCommitAllIfDirty(repoDir, message, options) {
-  const g = cliSimpleGit(repoDir);
-  const st = await g.status();
-  if (!st.files?.length) return;
-  const branch = options.branch.trim();
-  if (!branch) {
-    throw new Error("Branch name is required");
-  }
-  const branches = await g.branchLocal();
-  const localNames = new Set(branches.all.map((b) => b.replace(/^\*\s*/, "").trim()));
-  if (!localNames.has(branch)) {
-    await g.checkoutLocalBranch(branch);
+// src/worktrees/manager/git/get-session-working-tree-change-file-patch.ts
+import * as path32 from "node:path";
+
+// src/git/changes/repo/resolve-checkout-repo-rel-path.ts
+import * as path31 from "node:path";
+async function resolveCheckoutRepoRelPath(options) {
+  const t = path31.resolve(options.checkoutPath);
+  const g = cliSimpleGit(t);
+  const sessionWtRoot = options.sessionWorktreeRootPath ? path31.resolve(options.sessionWorktreeRootPath) : null;
+  const legacyNested = options.legacyRepoNestedSessionLayout;
+  let repoRelPath;
+  if (sessionWtRoot) {
+    const anchor = legacyNested ? path31.dirname(t) : t;
+    const relNorm = path31.relative(sessionWtRoot, anchor);
+    repoRelPath = relNorm === "" ? "." : relNorm.replace(/\\/g, "/");
   } else {
-    await g.checkout(branch);
+    let top = t;
+    try {
+      await yieldToEventLoop2();
+      top = (await g.raw(["rev-parse", "--show-toplevel"])).trim();
+    } catch {
+      top = t;
+    }
+    const rel = path31.relative(options.bridgeRoot, path31.resolve(top)).replace(/\\/g, "/") || ".";
+    repoRelPath = rel.startsWith("..") ? path31.basename(path31.resolve(top)) : rel;
   }
-  await g.add(".");
-  await g.commit(message);
-  if (options.push) {
-    await g.push(["-u", "origin", branch]);
+  return normRepoRel(repoRelPath === "" ? "." : repoRelPath);
+}
+
+// src/worktrees/manager/git/get-session-working-tree-change-file-patch.ts
+async function getSessionWorkingTreeChangeFilePatch(cache2, sessionId, discover, opts) {
+  const targets = await resolveCommitTargetsAsync(sessionId, cache2, discover);
+  const bridgeRoot = path32.resolve(getBridgeRoot());
+  const sessionWtRoot = cache2.getWorkingTreeRelRoot(sessionId) ? path32.resolve(cache2.getWorkingTreeRelRoot(sessionId)) : null;
+  const legacyNested = cache2.isLegacyNestedLayout(sessionId);
+  const filter = normRepoRel(opts.repoRelPath.trim());
+  for (const targetPath of targets) {
+    const checkoutPath = path32.resolve(targetPath);
+    if (!await isGitRepoDirectory(checkoutPath)) continue;
+    const repoRelPath = await resolveCheckoutRepoRelPath({
+      checkoutPath,
+      bridgeRoot,
+      sessionWorktreeRootPath: sessionWtRoot,
+      legacyRepoNestedSessionLayout: legacyNested
+    });
+    if (repoRelPath !== filter) continue;
+    return getWorkingTreeChangeFilePatch({
+      repoGitCwd: checkoutPath,
+      repoRelPath: filter,
+      workspaceRelPath: opts.workspaceRelPath.trim(),
+      change: opts.change,
+      movedFromWorkspaceRelPath: opts.movedFromWorkspaceRelPath?.trim() || null,
+      basis: opts.basis
+    });
   }
+  throw new Error(`Repository not found: ${filter}`);
 }
 
-// src/worktrees/commit-session-worktrees.ts
-async function commitSessionWorktrees(options) {
-  const { paths, branch, message, push } = options;
+// src/worktrees/manager/git/push-session-upstream.ts
+async function pushSessionUpstream(cache2, sessionId, discover) {
   try {
-    for (const wt of paths) {
-      await gitCommitAllIfDirty(wt, message, { push, branch });
-    }
+    await pushAheadOfUpstreamForPaths(await resolveCommitTargetsAsync(sessionId, cache2, discover));
     return { ok: true };
   } catch (e) {
     const err = e instanceof Error ? e.message : String(e);
@@ -38571,23 +38397,23 @@ async function commitSessionWorktrees(options) {
 }
 
 // src/worktrees/remove-session-worktrees.ts
-import * as fs29 from "node:fs";
+import * as fs23 from "node:fs";
 
 // src/git/worktrees/worktree-remove.ts
-import * as fs28 from "node:fs";
+import * as fs22 from "node:fs";
 
 // src/git/worktrees/resolve-main-repo-from-git-file.ts
-import * as fs27 from "node:fs";
-import * as path35 from "node:path";
+import * as fs21 from "node:fs";
+import * as path33 from "node:path";
 function resolveMainRepoFromWorktreeGitFile(wt) {
-  const gitDirFile = path35.join(wt, ".git");
-  if (!fs27.existsSync(gitDirFile) || !fs27.statSync(gitDirFile).isFile()) return "";
-  const first2 = fs27.readFileSync(gitDirFile, "utf8").trim();
+  const gitDirFile = path33.join(wt, ".git");
+  if (!fs21.existsSync(gitDirFile) || !fs21.statSync(gitDirFile).isFile()) return "";
+  const first2 = fs21.readFileSync(gitDirFile, "utf8").trim();
   const m = first2.match(/^gitdir:\s*(.+)$/im);
   if (!m) return "";
-  const gitWorktreePath = path35.resolve(wt, m[1].trim());
-  const gitDir = path35.dirname(path35.dirname(gitWorktreePath));
-  return path35.dirname(gitDir);
+  const gitWorktreePath = path33.resolve(wt, m[1].trim());
+  const gitDir = path33.dirname(path33.dirname(gitWorktreePath));
+  return path33.dirname(gitDir);
 }
 
 // src/git/worktrees/worktree-remove.ts
@@ -38596,7 +38422,7 @@ async function gitWorktreeRemoveForce(worktreePath) {
   if (mainRepo) {
     await cliSimpleGit(mainRepo).raw(["worktree", "remove", "--force", worktreePath]);
   } else {
-    fs28.rmSync(worktreePath, { recursive: true, force: true });
+    fs22.rmSync(worktreePath, { recursive: true, force: true });
   }
 }
 
@@ -38609,13 +38435,20 @@ async function removeSessionWorktrees(paths, log2) {
     } catch (e) {
       log2(`[worktrees] Remove failed for ${wt}: ${e instanceof Error ? e.message : String(e)}`);
       try {
-        fs29.rmSync(wt, { recursive: true, force: true });
+        fs23.rmSync(wt, { recursive: true, force: true });
       } catch {
       }
     }
   }
 }
 
+// src/worktrees/manager/git/remove-session-worktree-checkouts.ts
+async function removeSessionWorktreeCheckouts(cache2, sessionId, log2) {
+  const paths = cache2.clearSession(sessionId);
+  if (!paths?.length) return;
+  await removeSessionWorktrees(paths, log2);
+}
+
 // src/git/branches/rename-branch.ts
 async function gitRenameCurrentBranch(repoDir, newName) {
   const g = cliSimpleGit(repoDir);
@@ -38637,216 +38470,623 @@ async function renameSessionWorktreeBranches(paths, newBranch, log2) {
   }
 }
 
-// src/worktrees/manager/resolve-commit-targets.ts
-function bridgeRootBinding(bridgeRoot) {
-  return {
-    sessionParentPath: bridgeRoot,
-    workingTreeRelRoot: bridgeRoot,
-    repoCheckoutPaths: [bridgeRoot]
-  };
-}
-async function resolveCommitTargetsAsync(sessionId, cache2, discover) {
-  const sid = sessionId.trim();
-  const paths = cache2.getRepoCheckoutPathsRef(sid);
-  if (paths?.length) return paths;
-  const disc = await discover(sid);
-  if (disc?.repoCheckoutPaths.length) {
-    cache2.remember(sid, disc);
-    return disc.repoCheckoutPaths;
-  }
-  const bridgeRoot = getBridgeRoot();
-  cache2.remember(sid, bridgeRootBinding(bridgeRoot));
-  return [bridgeRoot];
+// src/worktrees/manager/git/rename-session-worktree-branch.ts
+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-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 getSessionWorkingTreeStatus(cache2, sessionId, discover) {
-  return aggregateSessionPathsWorkingTreeStatus(
-    await resolveCommitTargetsAsync(sessionId, cache2, discover)
-  );
+// src/worktrees/discovery/discover-session-worktree-on-disk.ts
+import * as fs27 from "node:fs";
+import * as path38 from "node:path";
+
+// src/worktrees/discovery/collect-worktree-paths.ts
+import * as fs25 from "node:fs";
+import * as path35 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);
 }
-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
-  });
+
+// src/worktrees/discovery/disk-walk-utils.ts
+import * as fs24 from "node:fs";
+import * as path34 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 pushSessionUpstream(cache2, sessionId, discover) {
+async function isGitDir(dirPath) {
   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 };
+    await fs24.promises.access(path34.join(dirPath, ".git"));
+    return true;
+  } catch {
+    return false;
   }
 }
-async function removeSessionWorktreeCheckouts(cache2, sessionId, log2) {
-  const paths = cache2.clearSession(sessionId);
-  if (!paths?.length) return;
-  await removeSessionWorktrees(paths, log2);
+
+// 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(path35.resolve(dir));
+      return;
+    }
+    let entries;
+    try {
+      entries = await fs25.promises.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (shouldSkipDiskWalkEntry(e.name)) continue;
+      const full = path35.join(dir, e.name);
+      if (!e.isDirectory()) continue;
+      await walk(full);
+    }
+  };
+  await walk(path35.resolve(rootPath));
+  return { paths: [...new Set(out)], entriesVisited: state.entries };
 }
-async function renameSessionWorktreeBranch(cache2, sessionId, newBranch, log2) {
-  const paths = cache2.getRepoCheckoutPathsRef(sessionId);
-  if (!paths?.length) return;
-  await renameSessionWorktreeBranches(paths, newBranch, log2);
+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 fs25.promises.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (shouldSkipDiskWalkEntry(e.name)) continue;
+      const full = path35.join(dir, e.name);
+      if (!e.isDirectory()) continue;
+      if (e.name === sessionId) {
+        if (await isGitDir(full)) out.push(path35.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/manager/session-worktree-cache.ts
+// src/worktrees/discovery/layout-keys-for-bridge-root.ts
 import * as path36 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) => path36.resolve(p));
-    this.sessionRepoCheckoutPaths.set(sessionId, paths);
-    this.sessionParentPathBySession.set(sessionId, path36.resolve(binding.sessionParentPath));
-    this.sessionWorkingTreeRelRootBySession.set(sessionId, path36.resolve(binding.workingTreeRelRoot));
-  }
-  clearSession(sessionId) {
-    const paths = this.sessionRepoCheckoutPaths.get(sessionId);
-    this.sessionRepoCheckoutPaths.delete(sessionId);
-    this.sessionParentPathBySession.delete(sessionId);
-    this.sessionWorkingTreeRelRootBySession.delete(sessionId);
-    return paths;
-  }
-  getSessionParentPath(sessionId) {
-    return this.sessionParentPathBySession.get(sessionId);
-  }
-  getWorkingTreeRelRoot(sessionId) {
-    return this.sessionWorkingTreeRelRootBySession.get(sessionId) ?? null;
+function layoutKeysForBridgeRoot(layout, bridgeRoot, keysOnDisk) {
+  const bridge = path36.resolve(bridgeRoot);
+  const preferred = getLauncherDirNameIfPresent(layout, bridgeRoot);
+  const relevant = layout.launcherCwds.filter((e) => {
+    const entry = path36.resolve(e.absolutePath);
+    return bridge === entry || bridge.startsWith(entry + path36.sep) || entry.startsWith(bridge + path36.sep);
+  }).sort((a, b) => path36.resolve(b.absolutePath).length - path36.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;
   }
-  hasSession(sessionId) {
-    return this.sessionParentPathBySession.has(sessionId);
+  for (const k of keysOnDisk) add(k);
+  return ordered;
+}
+
+// src/worktrees/discovery/try-binding-from-session-directory.ts
+import * as fs26 from "node:fs";
+import * as path37 from "node:path";
+async function tryBindingFromSessionDirectory(sessionDir) {
+  let st;
+  try {
+    st = await fs26.promises.stat(sessionDir);
+  } catch {
+    return null;
   }
-  getRepoCheckoutPaths(sessionId) {
-    const paths = this.sessionRepoCheckoutPaths.get(sessionId);
-    return paths?.length ? [...paths] : void 0;
+  if (!st.isDirectory()) return null;
+  const { paths: worktreePaths } = await collectGitRepoRootsUnderDirectory(sessionDir);
+  if (worktreePaths.length === 0) return null;
+  const abs = path37.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 fs27.promises.access(worktreesRootPath);
+  } catch {
+    return null;
   }
-  getRepoCheckoutPathsRef(sessionId) {
-    const paths = this.sessionRepoCheckoutPaths.get(sessionId);
-    return paths?.length ? paths : void 0;
+  const preferredKey = getLauncherDirNameIfPresent(layout, bridgeRoot);
+  const keysOnDisk = [];
+  if (preferredKey) keysOnDisk.push(preferredKey);
+  try {
+    for (const name of await fs27.promises.readdir(worktreesRootPath)) {
+      if (name.startsWith(".")) continue;
+      const p = path38.join(worktreesRootPath, name);
+      let st;
+      try {
+        st = await fs27.promises.stat(p);
+      } catch {
+        continue;
+      }
+      if (!st.isDirectory()) continue;
+      if (!keysOnDisk.includes(name)) keysOnDisk.push(name);
+    }
+  } catch {
+    return null;
   }
-  isLegacyNestedLayout(sessionId) {
-    const parent = this.sessionParentPathBySession.get(sessionId);
-    const relRoot = this.sessionWorkingTreeRelRootBySession.get(sessionId);
-    if (!parent || !relRoot) return false;
-    return path36.resolve(parent) !== path36.resolve(relRoot);
+  const keys = layoutKeysForBridgeRoot(layout, bridgeRoot, keysOnDisk);
+  for (const key of keys) {
+    if (isCliImmediateShutdownRequested()) return null;
+    await yieldToEventLoop();
+    const layoutRoot = path38.join(worktreesRootPath, key);
+    let layoutSt;
+    try {
+      layoutSt = await fs27.promises.stat(layoutRoot);
+    } catch {
+      continue;
+    }
+    if (!layoutSt.isDirectory()) continue;
+    const sessionDir = path38.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) ?? path38.resolve(legacy.paths[0]);
+      return {
+        sessionParentPath: path38.resolve(isolated),
+        workingTreeRelRoot: path38.resolve(layoutRoot),
+        repoCheckoutPaths: legacy.paths.map((p) => path38.resolve(p))
+      };
+    }
   }
-};
+  return null;
+}
 
-// src/worktrees/manager/manager.ts
-var SessionWorktreeManager = class {
-  worktreesRootPath;
-  log;
-  cache = new SessionWorktreeCache();
-  layout;
-  constructor(options) {
-    this.worktreesRootPath = options.worktreesRootPath;
-    this.log = options.log;
-    this.layout = loadWorktreeLayout();
+// src/worktrees/discovery/discover-session-worktrees-under-session-worktree-root.ts
+import * as fs28 from "node:fs";
+import * as path40 from "node:path";
+
+// src/worktrees/discovery/discover-legacy-binding-ascending-from-checkout.ts
+import * as path39 from "node:path";
+async function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
+  const sid = sessionId.trim();
+  if (!sid) return null;
+  const hintR = path39.resolve(checkoutPath);
+  let best = null;
+  let cur = path39.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) => path39.resolve(p) === hintR)) {
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths.paths) ?? path39.resolve(paths.paths[0]);
+      best = {
+        sessionParentPath: path39.resolve(isolated),
+        workingTreeRelRoot: path39.resolve(cur),
+        repoCheckoutPaths: paths.paths.map((p) => path39.resolve(p))
+      };
+    }
+    const next = path39.dirname(cur);
+    if (next === cur) break;
+    cur = next;
   }
-  discoverAsync(sessionId) {
-    return discoverSessionBindingAsync({
-      sessionId,
-      worktreesRootPath: this.worktreesRootPath,
-      layout: this.layout
-    });
+  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 = path40.resolve(sessionWorktreeRootPathOrHint);
+  const underHint = await tryBindingFromSessionDirectory(path40.join(hint, sid));
+  if (underHint) return underHint;
+  const direct = await tryBindingFromSessionDirectory(hint);
+  if (direct) {
+    if (path40.basename(hint) === sid && await isGitDir(hint)) {
+      const legacyFromCheckout = await discoverLegacyBindingAscendingFromCheckout(sid, hint);
+      if (legacyFromCheckout && legacyFromCheckout.repoCheckoutPaths.length > direct.repoCheckoutPaths.length) {
+        return legacyFromCheckout;
+      }
+    }
+    return direct;
   }
-  getIsolatedSessionParentPathForSession(sessionId) {
-    return resolveIsolatedSessionParentPath(
-      sessionId,
-      this.cache,
-      (sid) => this.ensureRepoCheckoutPathsForSession(sid)
-    );
+  if (path40.basename(hint) === sid && await isGitDir(hint)) {
+    const legacyFromCheckout = await discoverLegacyBindingAscendingFromCheckout(sid, hint);
+    if (legacyFromCheckout) return legacyFromCheckout;
   }
-  resolveSessionParentPathForPrompt(sessionId, opts) {
-    return resolveSessionParentPathForPrompt({
-      sessionId,
-      cache: this.cache,
-      worktreesRootPath: this.worktreesRootPath,
-      layout: this.layout,
-      log: this.log,
-      discover: (sid) => this.discoverAsync(sid),
-      opts
-    });
+  let st;
+  try {
+    st = await fs28.promises.stat(hint);
+  } catch {
+    return null;
   }
-  async renameSessionBranch(sessionId, newBranch) {
-    await renameSessionWorktreeBranch(this.cache, sessionId, newBranch, this.log);
+  if (!st.isDirectory()) return null;
+  const legacyPaths = await collectWorktreeRootsNamed(hint, sid);
+  if (legacyPaths.paths.length === 0) return null;
+  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths.paths) ?? path40.resolve(legacyPaths.paths[0]);
+  return {
+    sessionParentPath: path40.resolve(isolated),
+    workingTreeRelRoot: hint,
+    repoCheckoutPaths: legacyPaths.paths.map((p) => path40.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];
   }
-  usesWorktreeSession(sessionId) {
-    if (!sessionId) return false;
-    return this.cache.hasSession(sessionId);
+  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 fs29 from "node:fs";
+import * as path41 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";
+}
+async function prepareNewSessionWorktrees(options) {
+  const { worktreesRootPath, bridgeRoot, sessionId, layout, log: log2, worktreeBaseBranches } = options;
+  const bridgeResolved = path41.resolve(bridgeRoot);
+  const cwdKey = allocateDirNameForLauncherCwd(layout, bridgeResolved);
+  const bridgeKeyDir = path41.join(worktreesRootPath, cwdKey);
+  const sessionDir = path41.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;
   }
-  getRepoCheckoutPathsForSession(sessionId) {
-    if (!sessionId) return void 0;
-    return this.cache.getRepoCheckoutPaths(sessionId);
+  const branch = `session-${sessionId}`;
+  const worktreePaths = [];
+  fs29.mkdirSync(sessionDir, { recursive: true });
+  for (const repo of repos) {
+    let rel = path41.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path41.isAbsolute(rel)) continue;
+    const relNorm = normalizeRepoRelPath2(rel === "" ? "." : rel);
+    const wtPath = relNorm === "." ? sessionDir : path41.join(sessionDir, relNorm);
+    if (relNorm !== ".") {
+      fs29.mkdirSync(path41.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)}`
+      );
+    }
   }
-  ensureRepoCheckoutPathsForSession(sessionId) {
-    return ensureRepoCheckoutPathsForSession(sessionId, this.cache);
+  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);
   }
-  async ensureRepoCheckoutPathsForSessionAsync(sessionId) {
-    return ensureRepoCheckoutPathsForSessionAsync(sessionId, this.cache, (sid) => this.discoverAsync(sid));
+  return void 0;
+}
+
+// src/worktrees/manager/resolve-explicit-session-parent-path.ts
+import * as path42 from "node:path";
+async function resolveExplicitSessionParentPath(params) {
+  const resolved = path42.resolve(params.parentPathRaw);
+  if (parseSessionParent(params.sessionParent) !== "worktrees_root") {
+    return resolved;
   }
-  getSessionWorktreeRootForSession(sessionId) {
-    return this.getIsolatedSessionParentPathForSession(sessionId);
+  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 = path42.dirname(cur);
+    if (next === cur) break;
+    cur = next;
   }
-  async removeSessionWorktrees(sessionId) {
-    await removeSessionWorktreeCheckouts(this.cache, sessionId, this.log);
+  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)
+    });
   }
-  async commitSession(params) {
-    return commitSessionWorktree(this.cache, params);
+  const parentKind = parseSessionParent(opts.sessionParent);
+  if (parentKind === "bridge_root") {
+    return void 0;
   }
-  async getSessionWorkingTreeStatus(sessionId) {
-    return getSessionWorkingTreeStatus(this.cache, sessionId, (sid) => this.discoverAsync(sid));
+  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 } : {}
+    });
   }
-  async getSessionWorkingTreeChangeDetails(sessionId, opts) {
-    return getSessionWorkingTreeChangeDetails(this.cache, sessionId, (sid) => this.discoverAsync(sid), opts);
+  if (!opts.isNewSession) {
+    return resolveExistingSessionParentPath(sid, cache2, () => discover(sid));
   }
-  async pushSessionUpstream(sessionId) {
-    return pushSessionUpstream(this.cache, sessionId, (sid) => this.discoverAsync(sid));
+  return prepareAndRememberSessionWorktrees({
+    cache: cache2,
+    sessionId: sid,
+    worktreesRootPath,
+    layout,
+    log: log2
+  });
+}
+
+// src/worktrees/manager/session-worktree-paths.ts
+function createSessionWorktreePathsApi(ctx) {
+  const discoverAsync = (sessionId) => discoverSessionBindingAsync({
+    sessionId,
+    worktreesRootPath: ctx.worktreesRootPath,
+    layout: ctx.layout
+  });
+  return {
+    discoverAsync,
+    getIsolatedSessionParentPathForSession(sessionId) {
+      return resolveIsolatedSessionParentPath(
+        sessionId,
+        ctx.cache,
+        (sid) => ensureRepoCheckoutPathsForSession(sid, ctx.cache)
+      );
+    },
+    resolveSessionParentPathForPrompt(sessionId, opts) {
+      return resolveSessionParentPathForPrompt({
+        sessionId,
+        cache: ctx.cache,
+        worktreesRootPath: ctx.worktreesRootPath,
+        layout: ctx.layout,
+        log: ctx.log,
+        discover: (sid) => discoverAsync(sid),
+        opts
+      });
+    },
+    usesWorktreeSession(sessionId) {
+      if (!sessionId) return false;
+      return ctx.cache.hasSession(sessionId);
+    },
+    getRepoCheckoutPathsForSession(sessionId) {
+      if (!sessionId) return void 0;
+      return ctx.cache.getRepoCheckoutPaths(sessionId);
+    },
+    ensureRepoCheckoutPathsForSession(sessionId) {
+      return ensureRepoCheckoutPathsForSession(sessionId, ctx.cache);
+    },
+    async ensureRepoCheckoutPathsForSessionAsync(sessionId) {
+      return ensureRepoCheckoutPathsForSessionAsync(sessionId, ctx.cache, (sid) => discoverAsync(sid));
+    },
+    getSessionWorktreeRootForSession(sessionId) {
+      return resolveIsolatedSessionParentPath(
+        sessionId,
+        ctx.cache,
+        (sid) => ensureRepoCheckoutPathsForSession(sid, ctx.cache)
+      );
+    }
+  };
+}
+
+// src/worktrees/manager/session-worktree-git.ts
+function createSessionWorktreeGitApi(ctx) {
+  const paths = createSessionWorktreePathsApi(ctx);
+  return {
+    async renameSessionBranch(sessionId, newBranch) {
+      await renameSessionWorktreeBranch(ctx.cache, sessionId, newBranch, ctx.log);
+    },
+    async removeSessionWorktrees(sessionId) {
+      await removeSessionWorktreeCheckouts(ctx.cache, sessionId, ctx.log);
+    },
+    async commitSession(params) {
+      return commitSessionWorktree(ctx.cache, params);
+    },
+    async getSessionWorkingTreeStatus(sessionId) {
+      return getSessionWorkingTreeStatus(ctx.cache, sessionId, (sid) => paths.discoverAsync(sid));
+    },
+    async getSessionWorkingTreeChangeDetails(sessionId, opts) {
+      return getSessionWorkingTreeChangeDetails(ctx.cache, sessionId, (sid) => paths.discoverAsync(sid), opts);
+    },
+    async getSessionWorkingTreeChangeFilePatch(sessionId, opts) {
+      return getSessionWorkingTreeChangeFilePatch(ctx.cache, sessionId, (sid) => paths.discoverAsync(sid), opts);
+    },
+    async pushSessionUpstream(sessionId) {
+      return pushSessionUpstream(ctx.cache, sessionId, (sid) => paths.discoverAsync(sid));
+    }
+  };
+}
+
+// src/worktrees/manager/session-worktree-manager.ts
+var SessionWorktreeManager = class {
+  constructor(options) {
+    const ctx = createSessionWorktreeManagerContext(options);
+    Object.assign(this, createSessionWorktreePathsApi(ctx), createSessionWorktreeGitApi(ctx));
   }
 };
 
 // src/worktrees/manager/default-worktrees-root-path.ts
-import * as path37 from "node:path";
+import * as path43 from "node:path";
 import os8 from "node:os";
 function defaultWorktreesRootPath() {
-  return path37.join(os8.homedir(), ".buildautomaton", "worktrees");
+  return path43.join(os8.homedir(), ".buildautomaton", "worktrees");
 }
 
 // src/files/watch-file-index.ts
 import { watch } from "node:fs";
-import path42 from "node:path";
+import path48 from "node:path";
 
 // src/files/index/paths.ts
-import path38 from "node:path";
+import path44 from "node:path";
 import crypto2 from "node:crypto";
 function getCwdHashForFileIndex(resolvedCwd) {
-  return crypto2.createHash("sha256").update(path38.resolve(resolvedCwd)).digest("hex").slice(0, INDEX_HASH_LEN);
+  return crypto2.createHash("sha256").update(path44.resolve(resolvedCwd)).digest("hex").slice(0, INDEX_HASH_LEN);
 }
 
 // src/files/index/build-file-index.ts
-import path40 from "node:path";
+import path46 from "node:path";
 
 // src/files/index/walk-workspace-tree.ts
 import fs30 from "node:fs";
-import path39 from "node:path";
+import path45 from "node:path";
 var DEPENDENCY_INSTALL_DIR_NAMES = /* @__PURE__ */ new Set([
   "node_modules",
   "bower_components",
@@ -38875,18 +39115,18 @@ async function walkWorkspaceTreeAsync(dir, baseDir, onFile, state) {
       if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
     }
     state.n++;
-    const full = path39.join(dir, name);
+    const full = path45.join(dir, name);
     let stat3;
     try {
       stat3 = await fs30.promises.stat(full);
     } catch {
       continue;
     }
-    const relative6 = path39.relative(baseDir, full).replace(/\\/g, "/");
+    const relative7 = path45.relative(baseDir, full).replace(/\\/g, "/");
     if (stat3.isDirectory()) {
       await walkWorkspaceTreeAsync(full, baseDir, onFile, state);
     } else if (stat3.isFile()) {
-      onFile(relative6);
+      onFile(relative7);
     }
   }
 }
@@ -38984,7 +39224,7 @@ async function collectWorkspacePathsAsync(resolved) {
 }
 async function buildFileIndexAsync(cwd) {
   return withFileIndexSqliteLock(async () => {
-    const resolved = path40.resolve(cwd);
+    const resolved = path46.resolve(cwd);
     await yieldToEventLoop();
     assertNotShutdown();
     const paths = await collectWorkspacePathsAsync(resolved);
@@ -38996,7 +39236,7 @@ async function buildFileIndexAsync(cwd) {
 }
 
 // src/files/index/ensure-file-index.ts
-import path41 from "node:path";
+import path47 from "node:path";
 
 // src/files/index/search-file-index.ts
 function escapeLikePattern(fragment) {
@@ -39048,7 +39288,7 @@ async function searchBridgeFilePathsAsync(resolvedCwd, query, limit = 100) {
 
 // src/files/index/ensure-file-index.ts
 async function ensureFileIndexAsync(cwd) {
-  const resolved = path41.resolve(cwd);
+  const resolved = path47.resolve(cwd);
   if (await bridgeFileIndexIsPopulated(resolved)) {
     return { fromCache: true, pathCount: await bridgeFileIndexPathCount(resolved) };
   }
@@ -39092,7 +39332,7 @@ function createFsWatcher(resolved, schedule) {
   }
 }
 function startFileIndexWatcher(cwd = getBridgeRoot()) {
-  const resolved = path42.resolve(cwd);
+  const resolved = path48.resolve(cwd);
   void buildFileIndexAsync(resolved).catch((e) => {
     if (e instanceof CliSqliteInterrupted) return;
     console.error("[file-index] Initial index build failed:", e);
@@ -39122,7 +39362,7 @@ function startFileIndexWatcher(cwd = getBridgeRoot()) {
 }
 
 // src/connection/create-bridge-connection.ts
-import * as path53 from "node:path";
+import * as path60 from "node:path";
 
 // src/dev-servers/manager/dev-server-manager.ts
 import { rm as rm2 } from "node:fs/promises";
@@ -39144,15 +39384,15 @@ function sendDevServerStatus(getWs, serverId, status, options) {
 
 // src/dev-servers/process/terminate-child-process.ts
 async function sigtermAndWaitForExit(proc, graceMs, log2, shortId) {
-  const exited = new Promise((resolve28) => {
-    proc.once("exit", () => resolve28());
+  const exited = new Promise((resolve34) => {
+    proc.once("exit", () => resolve34());
   });
   log2(`[dev-server] Sending SIGTERM to ${shortId} (pid=${proc.pid ?? "?"}).`);
   try {
     proc.kill("SIGTERM");
   } catch {
   }
-  await Promise.race([exited, new Promise((resolve28) => setTimeout(resolve28, graceMs))]);
+  await Promise.race([exited, new Promise((resolve34) => setTimeout(resolve34, graceMs))]);
 }
 function forceKillChild(proc, log2, shortId, graceMs) {
   log2(
@@ -39432,10 +39672,10 @@ function trySpawnShellTruePiped(command, env, cwd, devNullFd, signal) {
 import { spawn as spawn7 } from "node:child_process";
 import fs34 from "node:fs";
 import { tmpdir } from "node:os";
-import path43 from "node:path";
+import path49 from "node:path";
 function trySpawnMergedLogFile(command, env, cwd, signal) {
-  const tmpRoot = fs34.mkdtempSync(path43.join(tmpdir(), "ba-devsrv-log-"));
-  const logPath = path43.join(tmpRoot, "combined.log");
+  const tmpRoot = fs34.mkdtempSync(path49.join(tmpdir(), "ba-devsrv-log-"));
+  const logPath = path49.join(tmpRoot, "combined.log");
   let logFd;
   try {
     logFd = fs34.openSync(logPath, "a");
@@ -39479,15 +39719,15 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
 import { spawn as spawn8 } from "node:child_process";
 import fs35 from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path44 from "node:path";
+import path50 from "node:path";
 function shSingleQuote(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 function trySpawnShellScriptLogRedirectUnix(command, env, cwd, signal) {
-  const tmpRoot = fs35.mkdtempSync(path44.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path44.join(tmpRoot, "combined.log");
-  const innerPath = path44.join(tmpRoot, "_cmd.sh");
-  const runnerPath = path44.join(tmpRoot, "_run.sh");
+  const tmpRoot = fs35.mkdtempSync(path50.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path50.join(tmpRoot, "combined.log");
+  const innerPath = path50.join(tmpRoot, "_cmd.sh");
+  const runnerPath = path50.join(tmpRoot, "_run.sh");
   try {
     fs35.writeFileSync(innerPath, `#!/bin/sh
 ${command}
@@ -39518,9 +39758,9 @@ cd ${shSingleQuote(cwd)}
   }
 }
 function trySpawnShellScriptLogRedirectWin(command, env, cwd, signal) {
-  const tmpRoot = fs35.mkdtempSync(path44.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path44.join(tmpRoot, "combined.log");
-  const runnerPath = path44.join(tmpRoot, "_run.bat");
+  const tmpRoot = fs35.mkdtempSync(path50.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path50.join(tmpRoot, "combined.log");
+  const runnerPath = path50.join(tmpRoot, "_run.bat");
   const q = (p) => `"${p.replace(/"/g, '""')}"`;
   const com = process.env.ComSpec || "cmd.exe";
   try {
@@ -40033,7 +40273,7 @@ async function proxyToLocal(request) {
   };
   const maxAttempts = isIdempotentProxyMethod(request.method) ? LOCAL_PREVIEW_FETCH_RETRY_DELAYS_MS.length + 1 : 1;
   for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-    const once = await new Promise((resolve28) => {
+    const once = await new Promise((resolve34) => {
       const req = mod.request(opts, (res) => {
         const chunks = [];
         res.on("data", (c) => chunks.push(c));
@@ -40044,7 +40284,7 @@ async function proxyToLocal(request) {
             if (typeof v === "string") headers[k] = v;
             else if (Array.isArray(v) && v[0]) headers[k] = v[0];
           }
-          resolve28({
+          resolve34({
             id: request.id,
             statusCode: res.statusCode ?? 0,
             headers,
@@ -40053,7 +40293,7 @@ async function proxyToLocal(request) {
         });
       });
       req.on("error", (err) => {
-        resolve28({
+        resolve34({
           id: request.id,
           statusCode: 0,
           headers: {},
@@ -40460,15 +40700,38 @@ function createOnBridgeIdentified(opts) {
   };
 }
 
-// src/skills/discover-local-agent-skills.ts
-import fs36 from "node:fs";
-import path45 from "node:path";
+// src/skills/discovery/skill-discovery-roots.ts
 var SKILL_DISCOVERY_ROOTS = [".agents/skills", ".claude/skills", ".cursor/skills", "skills"];
-function discoverLocalSkills(cwd) {
+async function yieldSkillDiscoveryWork(entryCount) {
+  if (entryCount > 0 && entryCount % INDEX_WORK_YIELD_EVERY === 0) {
+    await yieldToEventLoop();
+  }
+}
+
+// src/skills/discovery/discover-local-skills.ts
+import fs36 from "node:fs";
+import path51 from "node:path";
+function collectSkillFromDir(rel, base, name, seenKeys, out) {
+  const dir = path51.join(base, name);
+  try {
+    if (!fs36.statSync(dir).isDirectory()) return;
+  } catch {
+    return;
+  }
+  const skillMd = path51.join(dir, "SKILL.md");
+  if (!fs36.existsSync(skillMd)) return;
+  const key = `${rel}/${name}`;
+  if (seenKeys.has(key)) return;
+  seenKeys.add(key);
+  out.push({ skillKey: name, path: `${rel}/${name}`.replace(/\\/g, "/") });
+}
+async function discoverLocalSkillsAsync(cwd) {
   const out = [];
   const seenKeys = /* @__PURE__ */ new Set();
+  let work = 0;
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path45.join(cwd, rel);
+    await yieldSkillDiscoveryWork(++work);
+    const base = path51.join(cwd, rel);
     if (!fs36.existsSync(base) || !fs36.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
@@ -40476,45 +40739,45 @@ function discoverLocalSkills(cwd) {
     } catch {
       continue;
     }
-    for (const name of entries) {
-      const dir = path45.join(base, name);
-      try {
-        if (!fs36.statSync(dir).isDirectory()) continue;
-      } catch {
-        continue;
-      }
-      const skillMd = path45.join(dir, "SKILL.md");
-      if (!fs36.existsSync(skillMd)) continue;
-      const key = `${rel}/${name}`;
-      if (seenKeys.has(key)) continue;
-      seenKeys.add(key);
-      out.push({ skillKey: name, path: `${rel}/${name}`.replace(/\\/g, "/") });
+    for (let i = 0; i < entries.length; i++) {
+      await yieldSkillDiscoveryWork(++work);
+      collectSkillFromDir(rel, base, entries[i], seenKeys, out);
     }
   }
   return out;
 }
-function discoverSkillLayoutRoots(cwd) {
+
+// src/skills/discovery/discover-skill-layout-roots.ts
+import fs37 from "node:fs";
+import path52 from "node:path";
+function collectLayoutSkill(rel, base, name, skills2) {
+  const dir = path52.join(base, name);
+  try {
+    if (!fs37.statSync(dir).isDirectory()) return;
+  } catch {
+    return;
+  }
+  if (!fs37.existsSync(path52.join(dir, "SKILL.md"))) return;
+  const relPath = `${rel}/${name}`.replace(/\\/g, "/");
+  skills2.push({ name, relPath });
+}
+async function discoverSkillLayoutRootsAsync(cwd) {
   const roots = [];
+  let work = 0;
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path45.join(cwd, rel);
-    if (!fs36.existsSync(base) || !fs36.statSync(base).isDirectory()) continue;
+    await yieldSkillDiscoveryWork(++work);
+    const base = path52.join(cwd, rel);
+    if (!fs37.existsSync(base) || !fs37.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs36.readdirSync(base);
+      entries = fs37.readdirSync(base);
     } catch {
       continue;
     }
     const skills2 = [];
-    for (const name of entries) {
-      const dir = path45.join(base, name);
-      try {
-        if (!fs36.statSync(dir).isDirectory()) continue;
-      } catch {
-        continue;
-      }
-      if (!fs36.existsSync(path45.join(dir, "SKILL.md"))) continue;
-      const relPath = `${rel}/${name}`.replace(/\\/g, "/");
-      skills2.push({ name, relPath });
+    for (let i = 0; i < entries.length; i++) {
+      await yieldSkillDiscoveryWork(++work);
+      collectLayoutSkill(rel, base, entries[i], skills2);
     }
     if (skills2.length > 0) {
       roots.push({ path: rel.replace(/\\/g, "/"), skills: skills2 });
@@ -40556,16 +40819,18 @@ async function detectLocalAgentTypes() {
 function createSendLocalSkillsReport(getWs, logFn) {
   return () => {
     setImmediate(() => {
-      try {
-        const socket = getWs();
-        if (!socket || socket.readyState !== wrapper_default.OPEN) return;
-        const skills2 = discoverLocalSkills(getBridgeRoot());
-        sendWsMessage(socket, { type: "local_skills", skills: skills2 });
-      } catch (e) {
-        logFn(
-          `[Bridge service] Local skills report failed: ${e instanceof Error ? e.message : String(e)}`
-        );
-      }
+      void (async () => {
+        try {
+          const socket = getWs();
+          if (!socket || socket.readyState !== wrapper_default.OPEN) return;
+          const skills2 = await discoverLocalSkillsAsync(getBridgeRoot());
+          sendWsMessage(socket, { type: "local_skills", skills: skills2 });
+        } catch (e) {
+          logFn(
+            `[Bridge service] Local skills report failed: ${e instanceof Error ? e.message : String(e)}`
+          );
+        }
+      })();
     });
   };
 }
@@ -40868,7 +41133,7 @@ function syncRunningTurnQueueKeys(turns, queueKey) {
 }
 
 // src/prompt-turn-queue/runner/run-local-revert-before-queued-prompt.ts
-import fs37 from "node:fs";
+import fs38 from "node:fs";
 async function runLocalRevertBeforeQueuedPrompt(next, deps) {
   if (next.serverState !== "requeued_with_revert") return true;
   const sid = next.sessionId;
@@ -40877,7 +41142,7 @@ async function runLocalRevertBeforeQueuedPrompt(next, deps) {
   const agentBase = deps.sessionWorktreeManager.getSessionWorktreeRootForSession(sid) ?? getBridgeRoot();
   const file2 = snapshotFilePath(agentBase, tid);
   try {
-    await fs37.promises.access(file2, fs37.constants.F_OK);
+    await fs38.promises.access(file2, fs38.constants.F_OK);
   } catch {
     deps.log(
       `[Queue] requeued_with_revert: no pre-turn snapshot for ${tid.slice(0, 8)}\u2026; continuing without revert.`
@@ -41165,9 +41430,9 @@ function parseChangeSummarySnapshots(raw) {
   for (const item of raw) {
     if (!item || typeof item !== "object") continue;
     const o = item;
-    const path55 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
-    if (!path55) continue;
-    const row = { path: path55 };
+    const path62 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
+    if (!path62) continue;
+    const row = { path: path62 };
     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;
@@ -41377,8 +41642,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path55, body) {
-  const url2 = `http://127.0.0.1:${port}${path55}`;
+async function requestPreviewApi(port, secret, method, path62, body) {
+  const url2 = `http://127.0.0.1:${port}${path62}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -41390,7 +41655,7 @@ async function requestPreviewApi(port, secret, method, path55, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path55}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path62}: ${res.status}`);
   }
   return data;
 }
@@ -41555,14 +41820,14 @@ var handleSkillCallMessage = (msg, { getWs, log: log2 }) => {
 };
 
 // src/files/list-dir/index.ts
-import fs39 from "node:fs";
+import fs40 from "node:fs";
 
 // src/files/ensure-under-cwd.ts
-import path46 from "node:path";
+import path53 from "node:path";
 function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
-  const normalized = path46.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path46.resolve(cwd, normalized);
-  if (!resolved.startsWith(cwd + path46.sep) && resolved !== cwd) {
+  const normalized = path53.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path53.resolve(cwd, normalized);
+  if (!resolved.startsWith(cwd + path53.sep) && resolved !== cwd) {
     return null;
   }
   return resolved;
@@ -41572,15 +41837,15 @@ function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
 var LIST_DIR_YIELD_EVERY = 256;
 
 // src/files/list-dir/map-dir-entry.ts
-import path47 from "node:path";
-import fs38 from "node:fs";
+import path54 from "node:path";
+import fs39 from "node:fs";
 async function mapDirEntry(d, relativePath, resolved) {
-  const entryPath = path47.join(relativePath || ".", d.name).replace(/\\/g, "/");
-  const fullPath = path47.join(resolved, d.name);
+  const entryPath = path54.join(relativePath || ".", d.name).replace(/\\/g, "/");
+  const fullPath = path54.join(resolved, d.name);
   let isDir = d.isDirectory();
   if (d.isSymbolicLink()) {
     try {
-      const targetStat = await fs38.promises.stat(fullPath);
+      const targetStat = await fs39.promises.stat(fullPath);
       isDir = targetStat.isDirectory();
     } catch {
       isDir = false;
@@ -41610,7 +41875,7 @@ async function listDirAsync(relativePath, sessionParentPath = getBridgeRoot()) {
     return { error: "Path is outside working directory" };
   }
   try {
-    const names = await fs39.promises.readdir(resolved, { withFileTypes: true });
+    const names = await fs40.promises.readdir(resolved, { withFileTypes: true });
     const entries = [];
     for (let i = 0; i < names.length; i++) {
       if (i > 0 && i % LIST_DIR_YIELD_EVERY === 0) {
@@ -41630,18 +41895,18 @@ var LINE_CHUNK_SIZE = 64 * 1024;
 var READ_RANGE_YIELD_EVERY_BYTES = 256 * 1024;
 
 // src/files/read-file/resolve-file-path.ts
-import fs40 from "node:fs";
+import fs41 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 fs40.promises.realpath(resolved);
+    real = await fs41.promises.realpath(resolved);
   } catch {
     real = resolved;
   }
   try {
-    const stat3 = await fs40.promises.stat(real);
+    const stat3 = await fs41.promises.stat(real);
     if (!stat3.isFile()) return { error: "Not a file" };
     return real;
   } catch (err) {
@@ -41650,11 +41915,11 @@ async function resolveFilePathAsync(relativePath, sessionParentPath = getBridgeR
 }
 
 // src/files/read-file/read-file-range-async.ts
-import fs41 from "node:fs";
+import fs42 from "node:fs";
 import { StringDecoder } from "node:string_decoder";
 async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
-  const fileSize = (await fs41.promises.stat(filePath)).size;
-  const fd = await fs41.promises.open(filePath, "r");
+  const fileSize = (await fs42.promises.stat(filePath)).size;
+  const fd = await fs42.promises.open(filePath, "r");
   const bufSize = 64 * 1024;
   const buf = Buffer.alloc(bufSize);
   const decoder = new StringDecoder("utf8");
@@ -41816,11 +42081,11 @@ async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, li
 }
 
 // src/files/read-file/read-file-buffer-full-async.ts
-import fs42 from "node:fs";
+import fs43 from "node:fs";
 var READ_CHUNK_BYTES = 256 * 1024;
 async function readFileBufferFullAsync(filePath) {
-  const stat3 = await fs42.promises.stat(filePath);
-  const fd = await fs42.promises.open(filePath, "r");
+  const stat3 = await fs43.promises.stat(filePath);
+  const fd = await fs43.promises.open(filePath, "r");
   const chunks = [];
   let position = 0;
   let bytesSinceYield = 0;
@@ -41927,13 +42192,13 @@ async function resolveFileBrowserSessionParent(sessionWorktreeManager, sessionId
 }
 
 // src/files/handle-file-browser-search.ts
-import path48 from "node:path";
+import path55 from "node:path";
 var SEARCH_LIMIT = 100;
 function handleFileBrowserSearch(msg, socket, e2ee, sessionWorktreeManager) {
   void (async () => {
     await yieldToEventLoop();
     const q = typeof msg.q === "string" ? msg.q : "";
-    const sessionParentPath = path48.resolve(
+    const sessionParentPath = path55.resolve(
       sessionWorktreeManager != null ? await resolveFileBrowserSessionParent(sessionWorktreeManager, msg.sessionId) : getBridgeRoot()
     );
     if (!await bridgeFileIndexIsPopulated(sessionParentPath)) {
@@ -42043,37 +42308,56 @@ function handleFileBrowserSearchMessage(msg, { getWs, e2ee, sessionWorktreeManag
 
 // src/routing/handlers/skill-layout-request.ts
 function handleSkillLayoutRequest(msg, deps) {
-  const socket = deps.getWs();
   const id = typeof msg.id === "string" ? msg.id : "";
-  const roots = discoverSkillLayoutRoots(getBridgeRoot());
-  if (socket) {
-    sendWsMessage(socket, { type: "skill_layout_response", id, roots });
-  }
+  void (async () => {
+    const socket = deps.getWs();
+    const roots = await discoverSkillLayoutRootsAsync(getBridgeRoot());
+    if (socket) {
+      sendWsMessage(socket, { type: "skill_layout_response", id, roots });
+    }
+  })();
 }
 
-// src/skills/install-remote-skills.ts
-import fs43 from "node:fs";
-import path49 from "node:path";
-function installRemoteSkills(cwd, targetDir, items) {
+// src/skills/install/is-valid-install-item.ts
+function isValidRemoteSkillInstallItem(item) {
+  if (item === null || typeof item !== "object") return false;
+  const o = item;
+  return typeof o.sourceId === "string" && typeof o.skillName === "string" && typeof o.versionHash === "string" && Array.isArray(o.files);
+}
+
+// src/skills/install/install-remote-skills-async.ts
+import fs44 from "node:fs";
+import path56 from "node:path";
+
+// src/skills/install/constants.ts
+var INSTALL_SKILLS_YIELD_EVERY = 16;
+
+// src/skills/install/install-remote-skills-async.ts
+async function writeInstallFileAsync(skillDir, f, filesWritten) {
+  if (typeof f.path !== "string" || !f.text && !f.base64) return;
+  if (++filesWritten.count % INSTALL_SKILLS_YIELD_EVERY === 0) {
+    await yieldToEventLoop();
+  }
+  const dest = path56.join(skillDir, f.path);
+  await fs44.promises.mkdir(path56.dirname(dest), { recursive: true });
+  if (f.text !== void 0) {
+    await fs44.promises.writeFile(dest, f.text, "utf8");
+  } else if (f.base64) {
+    await fs44.promises.writeFile(dest, Buffer.from(f.base64, "base64"));
+  }
+}
+async function installRemoteSkillsAsync(cwd, targetDir, items) {
   const installed2 = [];
   if (!Array.isArray(items)) {
     return { success: false, error: "Invalid items" };
   }
+  const filesWritten = { count: 0 };
   try {
     for (const item of items) {
-      if (typeof item.sourceId !== "string" || typeof item.skillName !== "string" || typeof item.versionHash !== "string" || !Array.isArray(item.files)) {
-        continue;
-      }
-      const skillDir = path49.join(cwd, targetDir, item.skillName);
+      if (!isValidRemoteSkillInstallItem(item)) continue;
+      const skillDir = path56.join(cwd, targetDir, item.skillName);
       for (const f of item.files) {
-        if (typeof f.path !== "string" || !f.text && !f.base64) continue;
-        const dest = path49.join(skillDir, f.path);
-        fs43.mkdirSync(path49.dirname(dest), { recursive: true });
-        if (f.text !== void 0) {
-          fs43.writeFileSync(dest, f.text, "utf8");
-        } else if (f.base64) {
-          fs43.writeFileSync(dest, Buffer.from(f.base64, "base64"));
-        }
+        await writeInstallFileAsync(skillDir, f, filesWritten);
       }
       installed2.push({
         sourceId: item.sourceId,
@@ -42089,28 +42373,32 @@ function installRemoteSkills(cwd, targetDir, items) {
 
 // src/routing/handlers/install-skills.ts
 var handleInstallSkillsMessage = (msg, deps) => {
-  const socket = deps.getWs();
   const id = typeof msg.id === "string" ? msg.id : "";
   const targetDir = typeof msg.targetDir === "string" && msg.targetDir.trim() ? msg.targetDir.trim() : ".agents/skills";
   const rawItems = msg.items;
   const cwd = getBridgeRoot();
-  const result = installRemoteSkills(cwd, targetDir, rawItems);
-  if (!result.success) {
-    const err = result.error ?? "Invalid items";
-    deps.log(`[Bridge service] Install skills failed: ${err}`);
+  void (async () => {
+    const socket = deps.getWs();
+    const result = await installRemoteSkillsAsync(cwd, targetDir, rawItems);
+    if (!result.success) {
+      const err = result.error ?? "Invalid items";
+      deps.log(`[Bridge service] Install skills failed: ${err}`);
+      if (socket) {
+        sendWsMessage(socket, { type: "install_skills_result", id, success: false, error: err });
+      }
+      return;
+    }
     if (socket) {
-      sendWsMessage(socket, { type: "install_skills_result", id, success: false, error: err });
+      sendWsMessage(socket, { type: "install_skills_result", id, success: true, installed: result.installed });
     }
-    return;
-  }
-  if (socket) {
-    sendWsMessage(socket, { type: "install_skills_result", id, success: true, installed: result.installed });
-  }
+  })();
 };
 
 // src/routing/handlers/refresh-local-skills.ts
 var handleRefreshLocalSkills = (_msg, deps) => {
-  deps.sendLocalSkillsReport?.();
+  setImmediate(() => {
+    deps.sendLocalSkillsReport?.();
+  });
 };
 
 // src/routing/handlers/git/handle-session-git-commit.ts
@@ -42141,13 +42429,78 @@ async function handleSessionGitCommitAction(deps, sessionId, msg, reply) {
   });
 }
 
+// src/routing/handlers/git/session-git-changes-params.ts
+function readString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function readChangesObject(msg) {
+  const changes = msg.changes;
+  if (!changes || typeof changes !== "object" || Array.isArray(changes)) return null;
+  return changes;
+}
+function parseSessionGitChangesParams(msg) {
+  const nested = readChangesObject(msg);
+  const file2 = nested?.file && typeof nested.file === "object" && !Array.isArray(nested.file) ? nested.file : null;
+  const repoRelPath = readString(nested?.repoRelPath) || readString(msg.changesRepoRelPath);
+  const viewRaw = nested?.view ?? msg.changesView;
+  const view = viewRaw === "commit" ? "commit" : "working";
+  const commitSha = readString(nested?.commitSha) || readString(msg.changesCommitSha);
+  const recentCommitsLimit = nested?.recentCommitsLimit ?? msg.changesRecentCommitsLimit;
+  return {
+    repoRelPath,
+    view,
+    commitSha,
+    recentCommitsLimit: typeof recentCommitsLimit === "number" || typeof recentCommitsLimit === "string" ? recentCommitsLimit : void 0,
+    fileWorkspaceRelPath: readString(file2?.workspaceRelPath),
+    fileChange: readString(file2?.change),
+    fileMovedFromWorkspaceRelPath: readString(file2?.movedFromWorkspaceRelPath)
+  };
+}
+
+// src/routing/handlers/git/handle-session-git-get-change-file-patch.ts
+async function handleSessionGitGetChangeFilePatchAction(deps, msg, reply) {
+  const changes = parseSessionGitChangesParams(msg);
+  const { repoRelPath: repoRel, view, commitSha, fileWorkspaceRelPath, fileChange, fileMovedFromWorkspaceRelPath } = changes;
+  const change = parseWorkingTreeChangeKind(fileChange);
+  if (!repoRel || !fileWorkspaceRelPath || !change) {
+    reply({
+      ok: false,
+      error: "changes.repoRelPath, changes.file.workspaceRelPath, and changes.file.change are required"
+    });
+    return;
+  }
+  if (view === "commit" && !commitSha) {
+    reply({ ok: false, error: "changes.commitSha is required for commit file patch" });
+    return;
+  }
+  const patch = await deps.sessionWorktreeManager.getSessionWorkingTreeChangeFilePatch(msg.sessionId, {
+    repoRelPath: repoRel,
+    workspaceRelPath: fileWorkspaceRelPath,
+    change,
+    movedFromWorkspaceRelPath: fileMovedFromWorkspaceRelPath || null,
+    basis: view === "commit" ? { kind: "commit", sha: commitSha } : { kind: "working" }
+  });
+  reply(
+    {
+      ok: true,
+      patchContent: patch.patchContent ?? null,
+      totalLines: patch.totalLines
+    },
+    ["patchContent"]
+  );
+}
+
 // src/routing/handlers/git/coalesce-list-changes.ts
 var listChangesInflight = /* @__PURE__ */ new Map();
+function normalizeListChangesRepoRel(repoRelPath) {
+  if (!repoRelPath?.trim()) return "";
+  return normRepoRel(repoRelPath.trim());
+}
 function listChangesInflightKey(sessionId, opts) {
   const basis = opts?.basis;
   return [
     sessionId,
-    opts?.repoRelPath ?? "",
+    normalizeListChangesRepoRel(opts?.repoRelPath),
     basis?.kind === "commit" ? `commit:${basis.sha}` : "working",
     String(opts?.recentCommitsLimit ?? "")
   ].join("|");
@@ -42165,16 +42518,17 @@ function getSessionWorkingTreeChangeDetailsCoalesced(sessionWorktreeManager, ses
 
 // 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() : "";
+  const changes = parseSessionGitChangesParams(msg);
+  const { repoRelPath: repoRel, view, commitSha, recentCommitsLimit } = changes;
   if (view === "commit") {
     if (!repoRel || !commitSha) {
-      reply({ ok: false, error: "changesRepoRelPath and changesCommitSha are required for commit view" });
+      reply({
+        ok: false,
+        error: "changes.repoRelPath and changes.commitSha 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 },
@@ -42219,7 +42573,11 @@ async function handleSessionGitStatusAction(deps, sessionId, reply) {
 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);
+  let wire = message;
+  if (e2ee && encryptedFields.length > 0) {
+    wire = e2ee.encryptFields(message, encryptedFields);
+  }
+  sendWsMessage(ws, wire);
 }
 
 // src/routing/handlers/git/session-git-request.ts
@@ -42227,7 +42585,7 @@ var handleSessionGitRequestMessage = (msg, deps) => {
   if (typeof msg.id !== "string") return;
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
   const action = msg.action;
-  if (!sessionId || action !== "status" && action !== "push" && action !== "commit" && action !== "list_changes")
+  if (!sessionId || action !== "status" && action !== "push" && action !== "commit" && action !== "list_changes" && action !== "file_diff")
     return;
   void (async () => {
     const ws = deps.getWs();
@@ -42241,6 +42599,10 @@ var handleSessionGitRequestMessage = (msg, deps) => {
         await handleSessionGitListChangesAction(deps, { ...msg, sessionId }, reply);
         return;
       }
+      if (action === "file_diff") {
+        await handleSessionGitGetChangeFilePatchAction(deps, { ...msg, sessionId }, reply);
+        return;
+      }
       if (action === "push") {
         await handleSessionGitPushAction(deps, sessionId, reply);
         return;
@@ -42275,7 +42637,7 @@ var handleSessionDiscardedMessage = (msg, deps) => {
 };
 
 // src/routing/handlers/revert-turn-snapshot.ts
-import * as fs44 from "node:fs";
+import * as fs45 from "node:fs";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
@@ -42288,7 +42650,7 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
     const agentBase = sessionWorktreeManager.getSessionWorktreeRootForSession(sessionId) ?? getBridgeRoot();
     const file2 = snapshotFilePath(agentBase, turnId);
     try {
-      await fs44.promises.access(file2, fs44.constants.F_OK);
+      await fs45.promises.access(file2, fs45.constants.F_OK);
     } catch {
       sendWsMessage(s, {
         type: "revert_turn_snapshot_result",
@@ -42326,11 +42688,13 @@ var handleDevServerControl = (msg, deps) => {
 // src/routing/handlers/dev-servers-config.ts
 var handleDevServersConfig = (msg, deps) => {
   const devServers = msg.devServers;
-  deps.devServerManager?.applyConfig(devServers ?? []);
+  setImmediate(() => {
+    deps.devServerManager?.applyConfig(devServers ?? []);
+  });
 };
 
 // src/git/bridge-git-context.ts
-import * as path50 from "node:path";
+import * as path57 from "node:path";
 
 // src/git/branches/get-current-branch.ts
 async function getCurrentBranch(repoPath) {
@@ -42380,12 +42744,12 @@ async function listRepoBranchRefs(repoPath) {
 // src/git/bridge-git-context.ts
 function folderNameForRelPath(relPath, bridgeRoot) {
   if (relPath === "." || relPath === "") {
-    return path50.basename(path50.resolve(bridgeRoot)) || "repo";
+    return path57.basename(path57.resolve(bridgeRoot)) || "repo";
   }
-  return path50.basename(relPath) || relPath;
+  return path57.basename(relPath) || relPath;
 }
 async function discoverGitReposForBridgeContext(bridgeRoot) {
-  const root = path50.resolve(bridgeRoot);
+  const root = path57.resolve(bridgeRoot);
   if (await isGitRepoDirectory(root)) {
     const remoteUrl = await getRemoteOriginUrl(root);
     return [{ absolutePath: root, remoteUrl }];
@@ -42393,17 +42757,19 @@ async function discoverGitReposForBridgeContext(bridgeRoot) {
   const [deep, shallow] = await Promise.all([discoverGitReposUnderRoot(root), discoverGitRepos(root)]);
   const byPath = /* @__PURE__ */ new Map();
   for (const repo of [...deep, ...shallow]) {
-    byPath.set(path50.resolve(repo.absolutePath), repo);
+    byPath.set(path57.resolve(repo.absolutePath), repo);
   }
   return [...byPath.values()];
 }
 async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path50.resolve(bridgeRoot);
+  const bridgeResolved = path57.resolve(bridgeRoot);
   const repos = await discoverGitReposForBridgeContext(bridgeResolved);
   const rows = [];
-  for (const repo of repos) {
-    let rel = path50.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path50.isAbsolute(rel)) continue;
+  for (let i = 0; i < repos.length; i++) {
+    if (i > 0) await yieldToEventLoop();
+    const repo = repos[i];
+    let rel = path57.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path57.isAbsolute(rel)) continue;
     const relPath = rel === "" ? "." : rel.replace(/\\/g, "/");
     const currentBranch = await getCurrentBranch(repo.absolutePath);
     const remoteUrl = repo.remoteUrl.trim() || null;
@@ -42418,11 +42784,11 @@ async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
   return rows;
 }
 async function listRepoBranchesForBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path50.resolve(bridgeRoot);
+  const bridgeResolved = path57.resolve(bridgeRoot);
   const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
-  const repoPath = rel === "" ? bridgeResolved : path50.join(bridgeResolved, rel);
-  const resolved = path50.resolve(repoPath);
-  if (!resolved.startsWith(bridgeResolved + path50.sep) && resolved !== bridgeResolved) {
+  const repoPath = rel === "" ? bridgeResolved : path57.join(bridgeResolved, rel);
+  const resolved = path57.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path57.sep) && resolved !== bridgeResolved) {
     return [];
   }
   return listRepoBranchRefs(resolved);
@@ -42927,10 +43293,10 @@ function listCliAgentCapabilityCacheForWorkspace(db, workspaceId) {
 }
 
 // src/agents/capabilities/warmup-agent-capabilities-on-connect.ts
-import * as path52 from "node:path";
+import * as path59 from "node:path";
 
 // src/agents/capabilities/probe-one-agent-type-for-capabilities.ts
-import * as path51 from "node:path";
+import * as path58 from "node:path";
 async function probeOneAgentTypeForCapabilities(params) {
   const { agentType, cwd, workspaceId, log: log2, reportAgentCapabilities, bridgeReport = true, shouldContinue } = params;
   const canContinue = () => shouldContinue?.() !== false;
@@ -42968,7 +43334,7 @@ async function probeOneAgentTypeForCapabilities(params) {
     if (!canContinue()) return false;
     handle = await resolved.createClient({
       command: resolved.command,
-      cwd: path51.resolve(cwd),
+      cwd: path58.resolve(cwd),
       backendAgentType: agentType,
       sessionMode: "agent",
       persistedAcpSessionId: null,
@@ -43046,7 +43412,7 @@ async function warmupAgentCapabilitiesOnConnect(params) {
   const { workspaceId, log: log2, getWs } = params;
   const isCurrent = beginAgentCapabilityWarmupRun();
   if (!isCurrent()) return;
-  const cwd = path52.resolve(getBridgeRoot());
+  const cwd = path59.resolve(getBridgeRoot());
   async function sendBatchFromCache() {
     if (!isCurrent()) return;
     const socket = getWs();
@@ -43392,18 +43758,18 @@ import * as http from "node:http";
 
 // src/mcp/bridge-access/read-json-body.ts
 function readJsonBody(req) {
-  return new Promise((resolve28, reject) => {
+  return new Promise((resolve34, 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) {
-          resolve28({});
+          resolve34({});
           return;
         }
         const parsed = JSON.parse(raw);
-        resolve28(parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {});
+        resolve34(parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {});
       } catch (e) {
         reject(e);
       }
@@ -43461,7 +43827,7 @@ function createBridgeAccessRequestHandler(registry2) {
 // src/mcp/bridge-access/start-server.ts
 function startBridgeAccessServer(registry2) {
   const server = http.createServer(createBridgeAccessRequestHandler(registry2));
-  return new Promise((resolve28, reject) => {
+  return new Promise((resolve34, reject) => {
     server.once("error", reject);
     server.listen(0, "127.0.0.1", () => {
       const addr = server.address();
@@ -43469,7 +43835,7 @@ function startBridgeAccessServer(registry2) {
         reject(new Error("Bridge access server did not bind"));
         return;
       }
-      resolve28({
+      resolve34({
         port: addr.port,
         close: () => new Promise((closeResolve, closeReject) => {
           server.close((err) => err ? closeReject(err) : closeResolve());
@@ -43609,8 +43975,8 @@ async function createBridgeConnection(options) {
     getCloudAccessToken: () => tokens.accessToken
   };
   const identifyReportedPaths = {
-    bridgeRootPath: path53.resolve(getBridgeRoot()),
-    worktreesRootPath: path53.resolve(worktreesRootPath)
+    bridgeRootPath: path60.resolve(getBridgeRoot()),
+    worktreesRootPath: path60.resolve(worktreesRootPath)
   };
   const { connect } = createMainBridgeWebSocketLifecycle({
     state,
@@ -43865,9 +44231,9 @@ async function runCliAction(program2, opts) {
   const firehoseServerUrl = opts.firehoseUrl ?? opts.proxyUrl ?? process.env.BUILDAUTOMATON_FIREHOSE_URL ?? process.env.BUILDAUTOMATON_PROXY_URL ?? DEFAULT_FIREHOSE_URL;
   const bridgeRootOpt = (opts.bridgeRoot && typeof opts.bridgeRoot === "string" && opts.bridgeRoot.trim() ? opts.bridgeRoot.trim() : null) ?? (opts.cwd && typeof opts.cwd === "string" && opts.cwd.trim() ? opts.cwd.trim() : null);
   if (bridgeRootOpt) {
-    const resolvedBridgeRoot = path54.resolve(process.cwd(), bridgeRootOpt);
+    const resolvedBridgeRoot = path61.resolve(process.cwd(), bridgeRootOpt);
     try {
-      const st = fs45.statSync(resolvedBridgeRoot);
+      const st = fs46.statSync(resolvedBridgeRoot);
       if (!st.isDirectory()) {
         console.error(`Bridge root is not a directory: ${resolvedBridgeRoot}`);
         process.exit(1);
@@ -43887,7 +44253,7 @@ async function runCliAction(program2, opts) {
   );
   let worktreesRootPath;
   if (opts.worktreesRoot && opts.worktreesRoot.trim()) {
-    worktreesRootPath = path54.resolve(opts.worktreesRoot.trim());
+    worktreesRootPath = path61.resolve(opts.worktreesRoot.trim());
   }
   const e2eCertificates = opts.e2eeCertificatesDir?.trim() ? await loadOrCreateE2eCertificates(opts.e2eeCertificatesDir.trim()) : void 0;
   if (e2eCertificates) {