@buildautomaton/cli 0.1.73 → 0.1.75

package/dist/index.js

@@ -4208,8 +4208,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path82, errorMaps, issueData } = params;
-      const fullPath = [...path82, ...issueData.path || []];
+      const { data, path: path84, errorMaps, issueData } = params;
+      const fullPath = [...path84, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -4517,11 +4517,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path82, key) {
+      constructor(parent, value, path84, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path82;
+        this._path = path84;
         this._key = key;
       }
       get path() {
@@ -8182,15 +8182,15 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path82) {
-  if (!path82)
+function getElementAtPath(obj, path84) {
+  if (!path84)
     return obj;
-  return path82.reduce((acc, key) => acc?.[key], obj);
+  return path84.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
-  const promises12 = keys.map((key) => promisesObj[key]);
-  return Promise.all(promises12).then((results) => {
+  const promises13 = keys.map((key) => promisesObj[key]);
+  return Promise.all(promises13).then((results) => {
     const resolvedObj = {};
     for (let i = 0; i < keys.length; i++) {
       resolvedObj[keys[i]] = results[i];
@@ -8434,11 +8434,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path82, issues) {
+function prefixIssues(path84, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path82);
+    iss.path.unshift(path84);
     return iss;
   });
 }
@@ -8627,7 +8627,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path82 = []) => {
+  const processError = (error41, path84 = []) => {
     var _a2, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -8637,7 +8637,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path82, ...issue2.path];
+        const fullpath = [...path84, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -8667,9 +8667,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path82) {
+function toDotPath(path84) {
   const segs = [];
-  for (const seg of path82) {
+  for (const seg of path84) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -22376,7 +22376,7 @@ function readMigrationSql(filename, ...searchSubdirs) {
     join2(moduleDir, "..", sub, filename),
     join2(moduleDir, "..", "..", "dist", sub, filename)
   ]);
-  const resolved = candidates.find((path82) => existsSync(path82));
+  const resolved = candidates.find((path84) => existsSync(path84));
   if (!resolved) {
     throw new Error(`Missing SQLite migration SQL: ${filename} (searched ${searchSubdirs.join(", ")})`);
   }
@@ -23447,7 +23447,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path82, checkUnignored, mode) {
+      test(path84, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -23456,7 +23456,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path82);
+          const matched = rule[mode].test(path84);
           if (!matched) {
             return;
           }
@@ -23477,17 +23477,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path82, originalPath, doThrow) => {
-      if (!isString(path82)) {
+    var checkPath = (path84, originalPath, doThrow) => {
+      if (!isString(path84)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path82) {
+      if (!path84) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path82)) {
+      if (checkPath.isNotRelative(path84)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -23496,7 +23496,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path82) => REGEX_TEST_INVALID_PATH.test(path82);
+    var isNotRelative = (path84) => REGEX_TEST_INVALID_PATH.test(path84);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -23526,19 +23526,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache2, checkUnignored, slices) {
-        const path82 = originalPath && checkPath.convert(originalPath);
+        const path84 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path82,
+          path84,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path82, cache2, checkUnignored, slices);
+        return this._t(path84, cache2, checkUnignored, slices);
       }
-      checkIgnore(path82) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path82)) {
-          return this.test(path82);
+      checkIgnore(path84) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path84)) {
+          return this.test(path84);
         }
-        const slices = path82.split(SLASH).filter(Boolean);
+        const slices = path84.split(SLASH).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -23551,18 +23551,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path82, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path84, false, MODE_CHECK_IGNORE);
       }
-      _t(path82, cache2, checkUnignored, slices) {
-        if (path82 in cache2) {
-          return cache2[path82];
+      _t(path84, cache2, checkUnignored, slices) {
+        if (path84 in cache2) {
+          return cache2[path84];
         }
         if (!slices) {
-          slices = path82.split(SLASH).filter(Boolean);
+          slices = path84.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache2[path82] = this._rules.test(path82, checkUnignored, MODE_IGNORE);
+          return cache2[path84] = this._rules.test(path84, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -23570,29 +23570,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache2[path82] = parent.ignored ? parent : this._rules.test(path82, checkUnignored, MODE_IGNORE);
+        return cache2[path84] = parent.ignored ? parent : this._rules.test(path84, checkUnignored, MODE_IGNORE);
       }
-      ignores(path82) {
-        return this._test(path82, this._ignoreCache, false).ignored;
+      ignores(path84) {
+        return this._test(path84, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path82) => !this.ignores(path82);
+        return (path84) => !this.ignores(path84);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path82) {
-        return this._test(path82, this._testCache, true);
+      test(path84) {
+        return this._test(path84, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path82) => checkPath(path82 && checkPath.convert(path82), path82, RETURN_FALSE);
+    var isPathValid = (path84) => checkPath(path84 && checkPath.convert(path84), path84, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path82) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path82) || isNotRelative(path82);
+      checkPath.isNotRelative = (path84) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path84) || isNotRelative(path84);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -26497,8 +26497,8 @@ var init_task_queue_types = __esm({
 });
 
 // src/code-nav/symbol-index/scheduler/task-queue-store.ts
-function setSymbolIndexWorkerRunning(running) {
-  symbolIndexWorkerRunning = running;
+function setSymbolIndexWorkerRunning(running2) {
+  symbolIndexWorkerRunning = running2;
 }
 function taskMatchesCurrentPending(task) {
   const current = pendingSymbolIndexTasks.get(symbolIndexTaskKey(task.parentPath, task.filePath));
@@ -27960,10 +27960,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(path82, isFile, isDirectory) {
-      log2(`checking %s`, path82);
+    function check2(path84, isFile, isDirectory) {
+      log2(`checking %s`, path84);
       try {
-        const stat2 = fs_1.statSync(path82);
+        const stat2 = fs_1.statSync(path84);
         if (stat2.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -27983,8 +27983,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path82, type = exports.READABLE) {
-      return check2(path82, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path84, type = exports.READABLE) {
+      return check2(path84, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -30370,8 +30370,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path82, body) {
-  const url2 = `http://127.0.0.1:${port}${path82}`;
+async function requestPreviewApi(port, secret, method, path84, body) {
+  const url2 = `http://127.0.0.1:${port}${path84}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -30383,7 +30383,7 @@ async function requestPreviewApi(port, secret, method, path82, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path82}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path84}: ${res.status}`);
   }
   return data;
 }
@@ -30606,7 +30606,7 @@ function installBridgeProcessResilience() {
 }
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.73".length > 0 ? "0.1.73" : "0.0.0-dev";
+var CLI_VERSION = "0.1.75".length > 0 ? "0.1.75" : "0.0.0-dev";
 
 // src/connection/heartbeat/constants.ts
 var BRIDGE_APP_HEARTBEAT_INTERVAL_MS = 1e4;
@@ -34524,6 +34524,7 @@ function extractSessionUpdateMessageText(params) {
 }
 
 // src/agents/planning/planning-session-turn-buffer.ts
+var MAX_PLANNING_BUFFER_CHARS = 512 * 1024;
 var buffersByRunId = /* @__PURE__ */ new Map();
 function registerPlanningSessionTurn(runId) {
   buffersByRunId.set(runId, { messageBuffer: "" });
@@ -34541,7 +34542,10 @@ function capturePlanningSessionUpdate(params) {
   });
   if (bucket !== "message") return false;
   const text = extractSessionUpdateMessageText(params.payload);
-  if (text) state.messageBuffer += text;
+  if (text && state.messageBuffer.length < MAX_PLANNING_BUFFER_CHARS) {
+    const room = MAX_PLANNING_BUFFER_CHARS - state.messageBuffer.length;
+    state.messageBuffer += room >= text.length ? text : text.slice(0, room);
+  }
   return true;
 }
 function getPlanningSessionTurnOutput(runId) {
@@ -35080,8 +35084,8 @@ async function execGitFile(args, options) {
 }
 
 // src/git/changes/parse/normalize-git-diff-path.ts
-function normalizeGitDiffPath(path82) {
-  return path82.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
+function normalizeGitDiffPath(path84) {
+  return path84.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
 }
 
 // src/git/changes/parse/parse-name-status-entries.ts
@@ -36606,11 +36610,30 @@ function closeHttpServer(server) {
 }
 
 // src/mcp/bridge-access/read-json-body.ts
+var MAX_JSON_BODY_BYTES = 1024 * 1024;
+var RequestBodyTooLargeError = class extends Error {
+  constructor() {
+    super(`Request body exceeds ${MAX_JSON_BODY_BYTES} bytes`);
+  }
+};
 function readJsonBody(req) {
   return new Promise((resolve35, reject) => {
     const chunks = [];
-    req.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+    let total = 0;
+    let tooLarge = false;
+    req.on("data", (chunk) => {
+      if (tooLarge) return;
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      total += buf.length;
+      if (total > MAX_JSON_BODY_BYTES) {
+        tooLarge = true;
+        reject(new RequestBodyTooLargeError());
+        return;
+      }
+      chunks.push(buf);
+    });
     req.on("end", () => {
+      if (tooLarge) return;
       try {
         const raw = Buffer.concat(chunks).toString("utf8").trim();
         if (!raw) {
@@ -36667,7 +36690,7 @@ function createBridgeAccessRequestHandler(registry2) {
         sendJsonResponse(res, 404, { ok: false, error: "Not found" });
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        sendJsonResponse(res, 500, { ok: false, error: message });
+        sendJsonResponse(res, err instanceof RequestBodyTooLargeError ? 413 : 500, { ok: false, error: message });
       }
     })();
   };
@@ -39291,8 +39314,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path82) {
-  return path82 instanceof String && cache.has(path82);
+function isPathSpec(path84) {
+  return path84 instanceof String && cache.has(path84);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -39381,8 +39404,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path82) {
-  return (0, import_file_exists.exists)(path82, import_file_exists.FOLDER);
+function folderExists(path84) {
+  return (0, import_file_exists.exists)(path84, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -39786,8 +39809,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path82) {
-      return /^\.(git)?$/.test(path82.trim());
+    parser(path84) {
+      return /^\.(git)?$/.test(path84.trim());
     }
   };
 }
@@ -40221,11 +40244,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path82, line, preview] = input.split(NULL);
-    paths.add(path82);
-    (results[path82] = results[path82] || []).push({
+    const [path84, line, preview] = input.split(NULL);
+    paths.add(path84);
+    (results[path84] = results[path84] || []).push({
       line: asNumber(line),
-      path: path82,
+      path: path84,
       preview
     });
   });
@@ -40990,14 +41013,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path82, text) {
+function parseInit(bare, path84, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path82, false, result[1]);
+    return new InitSummary(bare, path84, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path82, true, result[1]);
+    return new InitSummary(bare, path84, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -41008,7 +41031,7 @@ function parseInit(bare, path82, text) {
       break;
     }
   }
-  return new InitSummary(bare, path82, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path84, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -41017,9 +41040,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path82, existing, gitDir) {
+      constructor(bare, path84, existing, gitDir) {
         this.bare = bare;
-        this.path = path82;
+        this.path = path84;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -41031,7 +41054,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path82, customArgs) {
+function initTask(bare = false, path84, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -41040,7 +41063,7 @@ function initTask(bare = false, path82, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path82, text);
+      return parseInit(commands.includes("--bare"), path84, text);
     }
   };
 }
@@ -41856,12 +41879,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path82, index, working_dir) {
-        this.path = path82;
+      constructor(path84, index, working_dir) {
+        this.path = path84;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path82) || [null, path82, path82];
+          const detail = fromPathRegex.exec(path84) || [null, path84, path84];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -41892,14 +41915,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path82) {
+  function data(index, workingDir, path84) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path82);
+      handler(result, path84);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path82, index, workingDir));
+      result.files.push(new FileStatusSummary(path84, index, workingDir));
     }
   }
 }
@@ -42208,9 +42231,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path82, write) {
+      hashObject(path84, write) {
         return this._runTask(
-          hashObjectTask(path82, write === true),
+          hashObjectTask(path84, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -42563,8 +42586,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path82 = input.trim().replace(/^["']|["']$/g, "");
-  return path82 && normalize3(path82);
+  const path84 = input.trim().replace(/^["']|["']$/g, "");
+  return path84 && normalize3(path84);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -42878,8 +42901,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path82) {
-  return subModuleTask(["add", repo, path82]);
+function addSubModuleTask(repo, path84) {
+  return subModuleTask(["add", repo, path84]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -43212,8 +43235,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path82, then) {
-      return this._runTask(addSubModuleTask2(repo, path82), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path84, then) {
+      return this._runTask(addSubModuleTask2(repo, path84), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -43952,8 +43975,8 @@ function parseNumstatEntries(lines) {
 }
 function parseNumstat(lines) {
   const m = /* @__PURE__ */ new Map();
-  for (const [path82, entry] of parseNumstatEntries(lines)) {
-    m.set(path82, { additions: entry.additions, deletions: entry.deletions });
+  for (const [path84, entry] of parseNumstatEntries(lines)) {
+    m.set(path84, { additions: entry.additions, deletions: entry.deletions });
   }
   return m;
 }
@@ -44236,23 +44259,26 @@ function formatRemoteDisplayLabel(remoteUrl) {
 }
 
 // src/git/changes/repo/get-working-tree-change-repo-details.ts
-import * as path51 from "node:path";
+import * as path52 from "node:path";
 
 // src/git/changes/repo/build-working-tree-change-repo-detail.ts
-import * as path50 from "node:path";
+import * as path51 from "node:path";
 
 // src/git/is-git-repo.ts
+import * as fs32 from "node:fs";
+import * as path43 from "node:path";
 async function isGitRepoDirectory(dirPath) {
   try {
-    return await cliSimpleGit(dirPath).checkIsRepo();
+    await fs32.promises.access(path43.join(dirPath, ".git"));
+    return true;
   } catch {
     return false;
   }
 }
 
 // src/git/changes/listing/apply-untracked-file-stats.ts
-import * as fs32 from "node:fs";
-import * as path43 from "node:path";
+import * as fs33 from "node:fs";
+import * as path44 from "node:path";
 
 // src/git/changes/lines/count-lines.ts
 import { createReadStream } from "node:fs";
@@ -44284,7 +44310,7 @@ function createUntrackedStatsApplier(options) {
     if (!options.untrackedSet.has(pathInRepo)) return;
     if (options.nameByPath.has(pathInRepo)) return;
     if (row.change === "moved") return;
-    const repoFilePath = path43.join(options.repoGitCwd, pathInRepo);
+    const repoFilePath = path44.join(options.repoGitCwd, pathInRepo);
     const fromGit = await numstatFromGitNoIndex(options.g, pathInRepo);
     if (fromGit) {
       row.additions = fromGit.additions;
@@ -44292,7 +44318,7 @@ function createUntrackedStatsApplier(options) {
       return;
     }
     try {
-      const st = await fs32.promises.stat(repoFilePath);
+      const st = await fs33.promises.stat(repoFilePath);
       row.additions = st.isFile() ? await countTextFileLines(repoFilePath) : 0;
     } catch {
       row.additions = 0;
@@ -44369,7 +44395,7 @@ async function buildChangedFileRowsFromPaths(options) {
 }
 
 // src/git/changes/listing/enrich-working-tree-file-rows.ts
-import * as path45 from "node:path";
+import * as path46 from "node:path";
 
 // src/git/changes/patch/patch-truncate.ts
 function truncatePatch(s) {
@@ -44457,10 +44483,10 @@ async function readGitBlobLines(repoCwd, pathInRepo) {
 }
 
 // src/git/changes/patch/hydrate/read-worktree-file-lines.ts
-import * as fs33 from "node:fs";
+import * as fs34 from "node:fs";
 async function readWorktreeFileLines(filePath) {
   try {
-    const raw = await fs33.promises.readFile(filePath, "utf8");
+    const raw = await fs34.promises.readFile(filePath, "utf8");
     return raw.split(/\r?\n/);
   } catch {
     return null;
@@ -44598,8 +44624,8 @@ async function unifiedDiffForFileInRange(repoCwd, range, pathInRepo, change, mov
 }
 
 // src/git/changes/total-lines/resolve-changed-file-total-lines.ts
-import * as fs34 from "node:fs";
-import * as path44 from "node:path";
+import * as fs35 from "node:fs";
+import * as path45 from "node:path";
 var MAX_BYTES = 512e3;
 async function countLinesInGitRef(repoGitCwd, ref, pathInRepo) {
   const spec = `${ref}:${pathInRepo}`;
@@ -44619,13 +44645,13 @@ async function countLinesInGitRef(repoGitCwd, ref, pathInRepo) {
 }
 async function resolveWorkingTreeFileTotalLines(options) {
   if (options.isBinary) return null;
-  const filePath = path44.join(options.repoGitCwd, options.pathInRepo);
+  const filePath = path45.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 fs34.promises.stat(filePath);
+      const st = await fs35.promises.stat(filePath);
       if (!st.isFile()) return null;
       return await countTextFileLines(filePath);
     } catch {
@@ -44668,7 +44694,7 @@ async function enrichWorkingTreeFileRows(options) {
       row.workspaceRelPath,
       options.repoPathRelativeToWorkspaceRoot
     );
-    const filePath = path45.join(options.repoGitCwd, filePathRelativeToRepoRoot);
+    const filePath = path46.join(options.repoGitCwd, filePathRelativeToRepoRoot);
     const hydrateKind = row.change === "moved" ? "modified" : row.change;
     let patch = await unifiedDiffForFile(
       options.repoGitCwd,
@@ -44826,7 +44852,7 @@ async function listChangedFilesForRepo(repoGitCwd, repoPathRelativeToWorkspaceRo
 }
 
 // src/git/changes/listing/list-changed-files-for-commit.ts
-import * as path46 from "node:path";
+import * as path47 from "node:path";
 
 // src/git/changes/listing/enrich-commit-file-rows.ts
 async function enrichCommitFileRows(options) {
@@ -44871,7 +44897,7 @@ async function parentForCommitDiff(g, sha) {
 var COMMIT_FILES_CACHE_TTL_MS = 5 * 6e4;
 var commitFilesCache = /* @__PURE__ */ new Map();
 function commitFilesCacheKey(repoGitCwd, commitSha) {
-  return `${path46.resolve(repoGitCwd)}:${commitSha}`;
+  return `${path47.resolve(repoGitCwd)}:${commitSha}`;
 }
 async function listChangedFilesForCommit(repoGitCwd, repoPathRelativeToWorkspaceRoot, commitSha, options = {}) {
   const cacheKey = commitFilesCacheKey(repoGitCwd, commitSha);
@@ -44926,7 +44952,7 @@ async function listChangedFilesForCommit(repoGitCwd, repoPathRelativeToWorkspace
 }
 
 // src/git/commits/list-unpushed-commits.ts
-import * as path47 from "node:path";
+import * as path48 from "node:path";
 
 // src/git/commits/lib/parse-log-lines.ts
 function parseLogShaDateSubjectLines(raw) {
@@ -44961,7 +44987,7 @@ async function gitLogNotReachableFromBase(g, baseSha, headSha) {
   }
 }
 async function listUnpushedCommits(repoDir) {
-  const key = path47.resolve(repoDir);
+  const key = path48.resolve(repoDir);
   const now = Date.now();
   const cached2 = unpushedCache.get(key);
   if (cached2 && cached2.expiresAt > now) return cached2.commits;
@@ -45022,7 +45048,7 @@ async function loadRecentAndUnpushedCommitsForRepoDetail(repoDir, recentCommitsL
 }
 
 // src/git/changes/repo/load-working-tree-change-repo-git-info.ts
-import * as path48 from "node:path";
+import * as path49 from "node:path";
 
 // src/git/remote-origin-url.ts
 async function getRemoteOriginUrl(gitDir) {
@@ -45037,7 +45063,7 @@ async function getRemoteOriginUrl(gitDir) {
 
 // src/git/changes/repo/load-working-tree-change-repo-git-info.ts
 async function loadWorkingTreeChangeRepoGitInfo(checkoutPath) {
-  const resolvedCheckoutPath = path48.resolve(checkoutPath);
+  const resolvedCheckoutPath = path49.resolve(checkoutPath);
   const git = cliSimpleGit(resolvedCheckoutPath);
   await yieldToEventLoop2();
   const [branch, remoteUrl] = await Promise.all([
@@ -45052,14 +45078,14 @@ async function loadWorkingTreeChangeRepoGitInfo(checkoutPath) {
 }
 
 // src/git/changes/repo/resolve-repo-path-relative-to-workspace-root.ts
-import * as path49 from "node:path";
+import * as path50 from "node:path";
 async function resolveRepoPathRelativeToWorkspaceRoot(options) {
-  const checkoutPath = path49.resolve(options.checkoutPath);
+  const checkoutPath = path50.resolve(options.checkoutPath);
   const git = cliSimpleGit(checkoutPath);
-  const sessionParentPath = options.sessionParentPath ? path49.resolve(options.sessionParentPath) : null;
+  const sessionParentPath = options.sessionParentPath ? path50.resolve(options.sessionParentPath) : null;
   let repoPathRelativeToWorkspaceRoot;
   if (sessionParentPath) {
-    const checkoutPathRelativeToSessionParent = path49.relative(sessionParentPath, checkoutPath);
+    const checkoutPathRelativeToSessionParent = path50.relative(sessionParentPath, checkoutPath);
     repoPathRelativeToWorkspaceRoot = checkoutPathRelativeToSessionParent === "" ? "." : checkoutPathRelativeToSessionParent.replace(/\\/g, "/");
   } else {
     let gitTopLevel = checkoutPath;
@@ -45069,8 +45095,8 @@ async function resolveRepoPathRelativeToWorkspaceRoot(options) {
     } catch {
       gitTopLevel = checkoutPath;
     }
-    const gitTopLevelRelativeToBridgeRoot = path49.relative(options.bridgeRoot, path49.resolve(gitTopLevel)).replace(/\\/g, "/") || ".";
-    repoPathRelativeToWorkspaceRoot = gitTopLevelRelativeToBridgeRoot.startsWith("..") ? path49.basename(path49.resolve(gitTopLevel)) : gitTopLevelRelativeToBridgeRoot;
+    const gitTopLevelRelativeToBridgeRoot = path50.relative(options.bridgeRoot, path50.resolve(gitTopLevel)).replace(/\\/g, "/") || ".";
+    repoPathRelativeToWorkspaceRoot = gitTopLevelRelativeToBridgeRoot.startsWith("..") ? path50.basename(path50.resolve(gitTopLevel)) : gitTopLevelRelativeToBridgeRoot;
   }
   return normalizeRepoPathRelativeToWorkspaceRoot(
     repoPathRelativeToWorkspaceRoot === "" ? "." : repoPathRelativeToWorkspaceRoot
@@ -45079,10 +45105,10 @@ async function resolveRepoPathRelativeToWorkspaceRoot(options) {
 
 // src/git/changes/repo/build-working-tree-change-repo-detail.ts
 async function buildWorkingTreeChangeRepoDetail(options) {
-  const checkoutPath = path50.resolve(options.targetPath);
+  const checkoutPath = path51.resolve(options.targetPath);
   if (!await isGitRepoDirectory(checkoutPath)) return null;
   const isCommitView = options.basis.kind === "commit";
-  const sessionParentPath = options.sessionParentPath ? path50.resolve(options.sessionParentPath) : null;
+  const sessionParentPath = options.sessionParentPath ? path51.resolve(options.sessionParentPath) : null;
   const git = cliSimpleGit(checkoutPath);
   const repoPathRelativeToWorkspaceRoot = await resolveRepoPathRelativeToWorkspaceRoot({
     checkoutPath,
@@ -45130,8 +45156,8 @@ async function buildWorkingTreeChangeRepoDetail(options) {
 
 // src/git/changes/repo/get-working-tree-change-repo-details.ts
 async function getWorkingTreeChangeRepoDetails(options) {
-  const bridgeRoot = path51.resolve(getBridgeRoot());
-  const sessionParentPath = options.sessionParentPath ? path51.resolve(options.sessionParentPath) : null;
+  const bridgeRoot = path52.resolve(getBridgeRoot());
+  const sessionParentPath = options.sessionParentPath ? path52.resolve(options.sessionParentPath) : null;
   const out = [];
   const filter = options.repoFilterRelPath != null ? normalizeRepoPathRelativeToWorkspaceRoot(options.repoFilterRelPath) : null;
   const basisInput = options.basis ?? { kind: "working" };
@@ -45162,9 +45188,9 @@ async function getWorkingTreeChangeRepoDetails(options) {
 }
 
 // src/git/changes/repo/get-working-tree-change-file-patch.ts
-import * as path52 from "node:path";
+import * as path53 from "node:path";
 async function getWorkingTreeChangeFilePatch(options) {
-  const repoGitCwd = path52.resolve(options.repoGitCwd);
+  const repoGitCwd = path53.resolve(options.repoGitCwd);
   if (!await isGitRepoDirectory(repoGitCwd)) {
     throw new Error("Not a git repository");
   }
@@ -45203,7 +45229,7 @@ async function getWorkingTreeChangeFilePatch(options) {
     });
     return { patchContent: patchContent2, totalLines: totalLines2 };
   }
-  const filePath = path52.join(repoGitCwd, filePathRelativeToRepoRoot);
+  const filePath = path53.join(repoGitCwd, filePathRelativeToRepoRoot);
   const hydrateKind = options.change === "moved" ? "modified" : options.change;
   let patchContent = await unifiedDiffForFile(
     repoGitCwd,
@@ -45249,18 +45275,18 @@ function parseWorkingTreeChangeKind(value) {
 }
 
 // src/worktrees/manager/git/get-session-working-tree-change-file-patch.ts
-import * as path53 from "node:path";
+import * as path54 from "node:path";
 async function getSessionWorkingTreeChangeFilePatch(cache2, sessionId, discover, opts) {
   const targets = await resolveCommitTargetsAsync(sessionId, cache2, discover);
-  const bridgeRoot = path53.resolve(getBridgeRoot());
-  const sessionParentPath = cache2.getSessionParentPath(sessionId) ? path53.resolve(cache2.getSessionParentPath(sessionId)) : null;
+  const bridgeRoot = path54.resolve(getBridgeRoot());
+  const sessionParentPath = cache2.getSessionParentPath(sessionId) ? path54.resolve(cache2.getSessionParentPath(sessionId)) : null;
   const repoPathRelativeToWorkspaceRootFilter = normalizeRepoPathRelativeToWorkspaceRoot(
     opts.repoRelPath.trim()
   );
   let result = null;
   await forEachWithGitYield(targets, async (targetPath) => {
     if (result) return;
-    const checkoutPath = path53.resolve(targetPath);
+    const checkoutPath = path54.resolve(targetPath);
     if (!await isGitRepoDirectory(checkoutPath)) return;
     const repoPathRelativeToWorkspaceRoot = await resolveRepoPathRelativeToWorkspaceRoot({
       checkoutPath,
@@ -45293,13 +45319,13 @@ async function pushSessionUpstream(cache2, sessionId, discover) {
 }
 
 // src/worktrees/remove-session-worktrees.ts
-import * as fs37 from "node:fs";
+import * as fs38 from "node:fs";
 
 // src/git/worktrees/worktree-remove.ts
-import * as fs36 from "node:fs";
+import * as fs37 from "node:fs";
 
 // src/worktrees/is-removable-session-worktree-checkout-path.ts
-import path54 from "node:path";
+import path55 from "node:path";
 init_normalize_resolved_path();
 function isBridgeRootCheckoutPath(checkoutPath) {
   return normalizeResolvedPath(checkoutPath) === normalizeResolvedPath(getBridgeRoot());
@@ -45308,23 +45334,23 @@ function isRemovableSessionWorktreeCheckoutPath(checkoutPath, worktreesRootPath)
   if (isBridgeRootCheckoutPath(checkoutPath)) return false;
   const normalized = normalizeResolvedPath(checkoutPath);
   const worktreesRoot = normalizeResolvedPath(worktreesRootPath);
-  const rel = path54.relative(worktreesRoot, normalized);
-  if (rel === "" || rel.startsWith("..") || path54.isAbsolute(rel)) return false;
+  const rel = path55.relative(worktreesRoot, normalized);
+  if (rel === "" || rel.startsWith("..") || path55.isAbsolute(rel)) return false;
   return true;
 }
 
 // src/git/worktrees/resolve-main-repo-from-git-file.ts
-import * as fs35 from "node:fs";
-import * as path55 from "node:path";
+import * as fs36 from "node:fs";
+import * as path56 from "node:path";
 function resolveMainRepoFromWorktreeGitFile(wt) {
-  const gitDirFile = path55.join(wt, ".git");
-  if (!fs35.existsSync(gitDirFile) || !fs35.statSync(gitDirFile).isFile()) return "";
-  const first2 = fs35.readFileSync(gitDirFile, "utf8").trim();
+  const gitDirFile = path56.join(wt, ".git");
+  if (!fs36.existsSync(gitDirFile) || !fs36.statSync(gitDirFile).isFile()) return "";
+  const first2 = fs36.readFileSync(gitDirFile, "utf8").trim();
   const m = first2.match(/^gitdir:\s*(.+)$/im);
   if (!m) return "";
-  const gitWorktreePath = path55.resolve(wt, m[1].trim());
-  const gitDir = path55.dirname(path55.dirname(gitWorktreePath));
-  return path55.dirname(gitDir);
+  const gitWorktreePath = path56.resolve(wt, m[1].trim());
+  const gitDir = path56.dirname(path56.dirname(gitWorktreePath));
+  return path56.dirname(gitDir);
 }
 
 // src/git/worktrees/worktree-remove.ts
@@ -45335,7 +45361,7 @@ async function gitWorktreeRemoveForce(worktreePath) {
     return true;
   }
   if (isBridgeRootCheckoutPath(worktreePath)) return false;
-  fs36.rmSync(worktreePath, { recursive: true, force: true });
+  fs37.rmSync(worktreePath, { recursive: true, force: true });
   return true;
 }
 
@@ -45357,7 +45383,7 @@ async function removeSessionWorktrees(paths, worktreesRootPath, log2) {
       log2(`[worktrees] Remove failed for ${wt}: ${e instanceof Error ? e.message : String(e)}`);
       if (isRemovableSessionWorktreeCheckoutPath(wt, worktreesRootPath)) {
         try {
-          fs37.rmSync(wt, { recursive: true, force: true });
+          fs38.rmSync(wt, { recursive: true, force: true });
         } catch {
         }
       }
@@ -45382,6 +45408,7 @@ async function gitRenameCurrentBranch(repoDir, newName) {
 async function renameSessionWorktreeBranches(paths, newBranch, log2) {
   const safe = newBranch.replace(/[^a-zA-Z0-9/_-]+/g, "-").slice(0, 80) || "session-branch";
   await forEachWithGitYield(paths, async (wt) => {
+    if (!await isGitRepoDirectory(wt)) return;
     try {
       await gitRenameCurrentBranch(wt, safe);
       log2(`[worktrees] Renamed branch in ${wt} \u2192 ${safe}`);
@@ -45403,12 +45430,12 @@ async function renameSessionWorktreeBranch(cache2, sessionId, newBranch, log2) {
 // src/worktrees/discovery/discover-session-worktree-on-disk.ts
 init_cli_process_interrupt();
 init_yield_to_event_loop();
-import * as fs41 from "node:fs";
-import * as path60 from "node:path";
+import * as fs42 from "node:fs";
+import * as path61 from "node:path";
 
 // src/worktrees/discovery/collect-worktree-paths.ts
-import * as fs39 from "node:fs";
-import * as path57 from "node:path";
+import * as fs40 from "node:fs";
+import * as path58 from "node:path";
 
 // src/worktrees/discovery/disk-walk-constants.ts
 var DISK_WALK_YIELD_EVERY = 64;
@@ -45438,8 +45465,8 @@ function shouldSkipDiskWalkEntry(name) {
 // src/worktrees/discovery/disk-walk-utils.ts
 init_cli_process_interrupt();
 init_yield_to_event_loop();
-import * as fs38 from "node:fs";
-import * as path56 from "node:path";
+import * as fs39 from "node:fs";
+import * as path57 from "node:path";
 async function yieldDuringDiskWalk(state) {
   state.entries++;
   if (state.entries % DISK_WALK_YIELD_EVERY !== 0) return true;
@@ -45449,7 +45476,7 @@ async function yieldDuringDiskWalk(state) {
 }
 async function isGitDir(dirPath) {
   try {
-    await fs38.promises.access(path56.join(dirPath, ".git"));
+    await fs39.promises.access(path57.join(dirPath, ".git"));
     return true;
   } catch {
     return false;
@@ -45463,23 +45490,23 @@ async function collectGitRepoRootsUnderDirectory(rootPath) {
   const walk = async (dir) => {
     if (!await yieldDuringDiskWalk(state)) return;
     if (await isGitDir(dir)) {
-      out.push(path57.resolve(dir));
+      out.push(path58.resolve(dir));
       return;
     }
     let entries;
     try {
-      entries = await fs39.promises.readdir(dir, { withFileTypes: true });
+      entries = await fs40.promises.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (shouldSkipDiskWalkEntry(e.name)) continue;
-      const full = path57.join(dir, e.name);
+      const full = path58.join(dir, e.name);
       if (!e.isDirectory()) continue;
       await walk(full);
     }
   };
-  await walk(path57.resolve(rootPath));
+  await walk(path58.resolve(rootPath));
   return { paths: [...new Set(out)], entriesVisited: state.entries };
 }
 async function collectWorktreeRootsNamed(root, sessionId, maxDepth = LEGACY_WALK_MAX_DEPTH) {
@@ -45490,16 +45517,16 @@ async function collectWorktreeRootsNamed(root, sessionId, maxDepth = LEGACY_WALK
     if (!await yieldDuringDiskWalk(state)) return;
     let entries;
     try {
-      entries = await fs39.promises.readdir(dir, { withFileTypes: true });
+      entries = await fs40.promises.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (shouldSkipDiskWalkEntry(e.name)) continue;
-      const full = path57.join(dir, e.name);
+      const full = path58.join(dir, e.name);
       if (!e.isDirectory()) continue;
       if (e.name === sessionId) {
-        if (await isGitDir(full)) out.push(path57.resolve(full));
+        if (await isGitDir(full)) out.push(path58.resolve(full));
         continue;
       }
       if (await isGitDir(full)) continue;
@@ -45511,14 +45538,14 @@ async function collectWorktreeRootsNamed(root, sessionId, maxDepth = LEGACY_WALK
 }
 
 // src/worktrees/discovery/layout-keys-for-bridge-root.ts
-import * as path58 from "node:path";
+import * as path59 from "node:path";
 function layoutKeysForBridgeRoot(layout, bridgeRoot, keysOnDisk) {
-  const bridge = path58.resolve(bridgeRoot);
+  const bridge = path59.resolve(bridgeRoot);
   const preferred = getLauncherDirNameIfPresent(layout, bridgeRoot);
   const relevant = layout.launcherCwds.filter((e) => {
-    const entry = path58.resolve(e.absolutePath);
-    return bridge === entry || bridge.startsWith(entry + path58.sep) || entry.startsWith(bridge + path58.sep);
-  }).sort((a, b) => path58.resolve(b.absolutePath).length - path58.resolve(a.absolutePath).length).map((e) => e.dirName).filter((name) => keysOnDisk.includes(name));
+    const entry = path59.resolve(e.absolutePath);
+    return bridge === entry || bridge.startsWith(entry + path59.sep) || entry.startsWith(bridge + path59.sep);
+  }).sort((a, b) => path59.resolve(b.absolutePath).length - path59.resolve(a.absolutePath).length).map((e) => e.dirName).filter((name) => keysOnDisk.includes(name));
   const ordered = [];
   const seen = /* @__PURE__ */ new Set();
   const add = (k) => {
@@ -45536,19 +45563,19 @@ function layoutKeysForBridgeRoot(layout, bridgeRoot, keysOnDisk) {
 }
 
 // src/worktrees/discovery/try-binding-from-isolated-directory.ts
-import * as fs40 from "node:fs";
-import * as path59 from "node:path";
+import * as fs41 from "node:fs";
+import * as path60 from "node:path";
 async function tryBindingFromIsolatedDirectory(scopeDir) {
   let st;
   try {
-    st = await fs40.promises.stat(scopeDir);
+    st = await fs41.promises.stat(scopeDir);
   } catch {
     return null;
   }
   if (!st.isDirectory()) return null;
   const { paths: worktreePaths } = await collectGitRepoRootsUnderDirectory(scopeDir);
   if (worktreePaths.length === 0) return null;
-  const abs = path59.resolve(scopeDir);
+  const abs = path60.resolve(scopeDir);
   return {
     parentPath: abs,
     repoCheckoutPaths: worktreePaths
@@ -45571,7 +45598,7 @@ async function discoverSessionWorktreeOnDisk(options) {
   const sid = sessionId.trim();
   if (!sid) return null;
   try {
-    await fs41.promises.access(worktreesRootPath);
+    await fs42.promises.access(worktreesRootPath);
   } catch {
     return null;
   }
@@ -45580,13 +45607,13 @@ async function discoverSessionWorktreeOnDisk(options) {
   if (preferredKey) keysOnDisk.push(preferredKey);
   const scanState = { entries: 0 };
   try {
-    for (const name of await fs41.promises.readdir(worktreesRootPath)) {
+    for (const name of await fs42.promises.readdir(worktreesRootPath)) {
       if (!await yieldDuringDiskWalk(scanState)) break;
       if (name.startsWith(".")) continue;
-      const p = path60.join(worktreesRootPath, name);
+      const p = path61.join(worktreesRootPath, name);
       let st;
       try {
-        st = await fs41.promises.stat(p);
+        st = await fs42.promises.stat(p);
       } catch {
         continue;
       }
@@ -45600,23 +45627,23 @@ async function discoverSessionWorktreeOnDisk(options) {
   for (const key of keys) {
     if (isCliImmediateShutdownRequested()) return null;
     await yieldToEventLoop();
-    const layoutRoot = path60.join(worktreesRootPath, key);
+    const layoutRoot = path61.join(worktreesRootPath, key);
     let layoutSt;
     try {
-      layoutSt = await fs41.promises.stat(layoutRoot);
+      layoutSt = await fs42.promises.stat(layoutRoot);
     } catch {
       continue;
     }
     if (!layoutSt.isDirectory()) continue;
-    const sessionDir = path60.join(layoutRoot, sid);
+    const sessionDir = path61.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) ?? path60.resolve(legacy.paths[0]);
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacy.paths) ?? path61.resolve(legacy.paths[0]);
       return {
-        sessionParentPath: path60.resolve(isolated),
-        repoCheckoutPaths: legacy.paths.map((p) => path60.resolve(p))
+        sessionParentPath: path61.resolve(isolated),
+        repoCheckoutPaths: legacy.paths.map((p) => path61.resolve(p))
       };
     }
   }
@@ -45624,31 +45651,31 @@ async function discoverSessionWorktreeOnDisk(options) {
 }
 
 // src/worktrees/discovery/discover-session-worktrees-under-session-worktree-root.ts
-import * as fs42 from "node:fs";
-import * as path62 from "node:path";
+import * as fs43 from "node:fs";
+import * as path63 from "node:path";
 
 // src/worktrees/discovery/discover-legacy-binding-ascending-from-checkout.ts
 init_cli_process_interrupt();
 init_yield_to_event_loop();
-import * as path61 from "node:path";
+import * as path62 from "node:path";
 async function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hintR = path61.resolve(checkoutPath);
+  const hintR = path62.resolve(checkoutPath);
   let best = null;
-  let cur = path61.dirname(hintR);
+  let cur = path62.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) => path61.resolve(p) === hintR)) {
-      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths.paths) ?? path61.resolve(paths.paths[0]);
+    if (paths.paths.some((p) => path62.resolve(p) === hintR)) {
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths.paths) ?? path62.resolve(paths.paths[0]);
       best = {
-        sessionParentPath: path61.resolve(isolated),
-        repoCheckoutPaths: paths.paths.map((p) => path61.resolve(p))
+        sessionParentPath: path62.resolve(isolated),
+        repoCheckoutPaths: paths.paths.map((p) => path62.resolve(p))
       };
     }
-    const next = path61.dirname(cur);
+    const next = path62.dirname(cur);
     if (next === cur) break;
     cur = next;
   }
@@ -45659,12 +45686,12 @@ async function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPat
 async function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionParentPathOrHint, sessionId) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hint = path62.resolve(sessionParentPathOrHint);
-  const underHint = await tryBindingFromSessionDirectory(path62.join(hint, sid));
+  const hint = path63.resolve(sessionParentPathOrHint);
+  const underHint = await tryBindingFromSessionDirectory(path63.join(hint, sid));
   if (underHint) return underHint;
   const direct = await tryBindingFromSessionDirectory(hint);
   if (direct) {
-    if (path62.basename(hint) === sid && await isGitDir(hint)) {
+    if (path63.basename(hint) === sid && await isGitDir(hint)) {
       const legacyFromCheckout = await discoverLegacyBindingAscendingFromCheckout(sid, hint);
       if (legacyFromCheckout && legacyFromCheckout.repoCheckoutPaths.length > direct.repoCheckoutPaths.length) {
         return legacyFromCheckout;
@@ -45672,23 +45699,23 @@ async function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionParentPat
     }
     return direct;
   }
-  if (path62.basename(hint) === sid && await isGitDir(hint)) {
+  if (path63.basename(hint) === sid && await isGitDir(hint)) {
     const legacyFromCheckout = await discoverLegacyBindingAscendingFromCheckout(sid, hint);
     if (legacyFromCheckout) return legacyFromCheckout;
   }
   let st;
   try {
-    st = await fs42.promises.stat(hint);
+    st = await fs43.promises.stat(hint);
   } catch {
     return null;
   }
   if (!st.isDirectory()) return null;
   const legacyPaths = await collectWorktreeRootsNamed(hint, sid);
   if (legacyPaths.paths.length === 0) return null;
-  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths.paths) ?? path62.resolve(legacyPaths.paths[0]);
+  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths.paths) ?? path63.resolve(legacyPaths.paths[0]);
   return {
-    sessionParentPath: path62.resolve(isolated),
-    repoCheckoutPaths: legacyPaths.paths.map((p) => path62.resolve(p))
+    sessionParentPath: path63.resolve(isolated),
+    repoCheckoutPaths: legacyPaths.paths.map((p) => path63.resolve(p))
   };
 }
 
@@ -45749,11 +45776,11 @@ function parseSessionParent(v) {
 }
 
 // src/worktrees/prepare/prepare-new-isolated-worktrees.ts
-import * as fs46 from "node:fs";
+import * as fs47 from "node:fs";
 
 // src/git/discover-repos.ts
-import * as fs43 from "node:fs";
-import * as path63 from "node:path";
+import * as fs44 from "node:fs";
+import * as path64 from "node:path";
 init_yield_to_event_loop();
 var GIT_DISCOVER_YIELD_EVERY = 32;
 async function yieldGitDiscoverWork(entryCount) {
@@ -45763,14 +45790,14 @@ async function yieldGitDiscoverWork(entryCount) {
 }
 async function discoverGitRepos(cwd = getBridgeRoot()) {
   const result = [];
-  const cwdResolved = path63.resolve(cwd);
+  const cwdResolved = path64.resolve(cwd);
   if (await isGitRepoDirectory(cwdResolved)) {
     const remoteUrl = await getRemoteOriginUrl(cwdResolved);
     result.push({ absolutePath: cwdResolved, remoteUrl });
   }
   let entries;
   try {
-    entries = fs43.readdirSync(cwdResolved, { withFileTypes: true });
+    entries = fs44.readdirSync(cwdResolved, { withFileTypes: true });
   } catch {
     return result;
   }
@@ -45778,7 +45805,7 @@ async function discoverGitRepos(cwd = getBridgeRoot()) {
     await yieldGitDiscoverWork(i + 1);
     const ent = entries[i];
     if (!ent.isDirectory()) continue;
-    const childPath2 = path63.join(cwdResolved, ent.name);
+    const childPath2 = path64.join(cwdResolved, ent.name);
     if (await isGitRepoDirectory(childPath2)) {
       const remoteUrl = await getRemoteOriginUrl(childPath2);
       result.push({ absolutePath: childPath2, remoteUrl });
@@ -45787,17 +45814,17 @@ async function discoverGitRepos(cwd = getBridgeRoot()) {
   return result;
 }
 async function discoverGitReposUnderRoot(rootPath) {
-  const root = path63.resolve(rootPath);
+  const root = path64.resolve(rootPath);
   const roots = [];
   let walkEntries = 0;
   async function walk(dir) {
     if (await isGitRepoDirectory(dir)) {
-      roots.push(path63.resolve(dir));
+      roots.push(path64.resolve(dir));
       return;
     }
     let entries;
     try {
-      entries = fs43.readdirSync(dir, { withFileTypes: true });
+      entries = fs44.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -45805,7 +45832,7 @@ async function discoverGitReposUnderRoot(rootPath) {
       await yieldGitDiscoverWork(++walkEntries);
       const ent = entries[i];
       if (!ent.isDirectory() || ent.name === ".git") continue;
-      await walk(path63.join(dir, ent.name));
+      await walk(path64.join(dir, ent.name));
     }
   }
   await walk(root);
@@ -45821,8 +45848,8 @@ async function discoverGitReposUnderRoot(rootPath) {
 }
 
 // src/worktrees/prepare/add-isolated-repo-worktree.ts
-import * as fs45 from "node:fs";
-import * as path65 from "node:path";
+import * as fs46 from "node:fs";
+import * as path66 from "node:path";
 
 // src/git/worktrees/worktree-add.ts
 async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch, baseRef = "HEAD") {
@@ -45838,8 +45865,8 @@ async function gitWorktreeAddExistingBranch(mainRepoPath, worktreePath, branch)
 }
 
 // src/worktrees/prepare/copy-bridge-files-along-worktree-path.ts
-import * as fs44 from "node:fs";
-import * as path64 from "node:path";
+import * as fs45 from "node:fs";
+import * as path65 from "node:path";
 var BRIDGE_FILES_ALONG_WORKTREE_PATH = ["AGENTS.md"];
 function copyBridgeFilesAlongWorktreePath(options) {
   const { bridgeRoot, scopeDir, repoPathRelativeToBridgeRoot, log: log2 } = options;
@@ -45848,19 +45875,19 @@ function copyBridgeFilesAlongWorktreePath(options) {
   const segments = repoPathRelativeToBridgeRoot.split("/").filter(Boolean);
   for (let i = 0; i < segments.length; i++) {
     const prefix = segments.slice(0, i).join("/");
-    const bridgeDir = prefix ? path64.join(bridgeRoot, prefix) : bridgeRoot;
-    const destDir = prefix ? path64.join(scopeDir, prefix) : scopeDir;
+    const bridgeDir = prefix ? path65.join(bridgeRoot, prefix) : bridgeRoot;
+    const destDir = prefix ? path65.join(scopeDir, prefix) : scopeDir;
     for (const fileName of fileNames) {
       copyFileIfPresent(bridgeDir, destDir, fileName, log2);
     }
   }
 }
 function copyFileIfPresent(srcDir, destDir, fileName, log2) {
-  const src = path64.join(srcDir, fileName);
-  if (!fs44.existsSync(src)) return;
-  const dest = path64.join(destDir, fileName);
+  const src = path65.join(srcDir, fileName);
+  if (!fs45.existsSync(src)) return;
+  const dest = path65.join(destDir, fileName);
   try {
-    fs44.copyFileSync(src, dest);
+    fs45.copyFileSync(src, dest);
     log2?.(`[worktrees] Copied ${fileName} to ${dest}`);
   } catch (e) {
     log2?.(
@@ -45892,16 +45919,16 @@ async function addIsolatedRepoWorktree(options) {
     worktreeBaseBranches,
     log: log2
   } = options;
-  const repoPathRelativeToBridgeRootRaw = path65.relative(bridgeResolved, repoAbsolutePath);
-  if (repoPathRelativeToBridgeRootRaw.startsWith("..") || path65.isAbsolute(repoPathRelativeToBridgeRootRaw)) {
+  const repoPathRelativeToBridgeRootRaw = path66.relative(bridgeResolved, repoAbsolutePath);
+  if (repoPathRelativeToBridgeRootRaw.startsWith("..") || path66.isAbsolute(repoPathRelativeToBridgeRootRaw)) {
     return null;
   }
   const repoPathRelativeToBridgeRoot = normalizeRepoPathRelativeToWorkspaceRoot(
     repoPathRelativeToBridgeRootRaw === "" ? "." : repoPathRelativeToBridgeRootRaw
   );
-  const worktreePath = repoPathRelativeToBridgeRoot === "." ? scopeDir : path65.join(scopeDir, repoPathRelativeToBridgeRoot);
+  const worktreePath = repoPathRelativeToBridgeRoot === "." ? scopeDir : path66.join(scopeDir, repoPathRelativeToBridgeRoot);
   if (repoPathRelativeToBridgeRoot !== ".") {
-    fs45.mkdirSync(path65.dirname(worktreePath), { recursive: true });
+    fs46.mkdirSync(path66.dirname(worktreePath), { recursive: true });
     copyBridgeFilesAlongWorktreePath({
       bridgeRoot: bridgeResolved,
       scopeDir,
@@ -45929,7 +45956,7 @@ async function addIsolatedRepoWorktree(options) {
 }
 
 // src/worktrees/prepare/resolve-isolated-scope-dir.ts
-import * as path66 from "node:path";
+import * as path67 from "node:path";
 
 // src/worktrees/worktree-layout-kind.ts
 function sanitizeWorktreeBranchSegment(value) {
@@ -45959,10 +45986,10 @@ function previewDeployBranchName(environmentId) {
 
 // src/worktrees/prepare/resolve-isolated-scope-dir.ts
 function resolveIsolatedScopeDir(options) {
-  const bridgeResolved = path66.resolve(options.bridgeRoot);
+  const bridgeResolved = path67.resolve(options.bridgeRoot);
   const cwdKey = allocateDirNameForLauncherCwd(options.layout, bridgeResolved);
-  const bridgeKeyDir = path66.join(options.worktreesRootPath, cwdKey);
-  const scopeDir = path66.join(bridgeKeyDir, ...layoutDirSegments(options.kind, options.scopeId));
+  const bridgeKeyDir = path67.join(options.worktreesRootPath, cwdKey);
+  const scopeDir = path67.join(bridgeKeyDir, ...layoutDirSegments(options.kind, options.scopeId));
   return { bridgeResolved, scopeDir };
 }
 
@@ -45992,7 +46019,7 @@ async function prepareNewIsolatedWorktrees(options) {
     return null;
   }
   const worktreePaths = [];
-  fs46.mkdirSync(scopeDir, { recursive: true });
+  fs47.mkdirSync(scopeDir, { recursive: true });
   await forEachWithGitYield(repos, async (repo) => {
     const worktreePath = await addIsolatedRepoWorktree({
       kind,
@@ -46064,10 +46091,10 @@ async function resolveExistingSessionParentPath(sessionId, cache2, discover) {
 }
 
 // src/worktrees/manager/resolve-explicit-session-parent-path.ts
-import * as path67 from "node:path";
+import * as path68 from "node:path";
 init_yield_to_event_loop();
 async function resolveExplicitSessionParentPath(params) {
-  const resolved = path67.resolve(params.parentPathRaw);
+  const resolved = path68.resolve(params.parentPathRaw);
   if (parseSessionParent(params.sessionParent) !== "worktrees_root") {
     return resolved;
   }
@@ -46084,7 +46111,7 @@ async function resolveExplicitSessionParentPath(params) {
     await yieldToEventLoop();
     const tryRoot = await discoverSessionWorktreesUnderSessionWorktreeRoot(cur, params.sessionId);
     if (tryRoot) return rememberAndReturn(tryRoot);
-    const next = path67.dirname(cur);
+    const next = path68.dirname(cur);
     if (next === cur) break;
     cur = next;
   }
@@ -46232,15 +46259,15 @@ var SessionWorktreeManager = class {
 };
 
 // src/worktrees/discovery/discover-preview-worktree-on-disk.ts
-import * as fs47 from "node:fs";
-import * as path68 from "node:path";
+import * as fs48 from "node:fs";
+import * as path69 from "node:path";
 init_yield_to_event_loop();
 async function discoverPreviewWorktreeOnDisk(options) {
   const { environmentId, worktreesRootPath, layout, bridgeRoot } = options;
   const eid = environmentId.trim();
   if (!eid) return null;
   try {
-    await fs47.promises.access(worktreesRootPath);
+    await fs48.promises.access(worktreesRootPath);
   } catch {
     return null;
   }
@@ -46249,13 +46276,13 @@ async function discoverPreviewWorktreeOnDisk(options) {
   if (preferredKey) keysOnDisk.push(preferredKey);
   const scanState = { entries: 0 };
   try {
-    for (const name of await fs47.promises.readdir(worktreesRootPath)) {
+    for (const name of await fs48.promises.readdir(worktreesRootPath)) {
       if (!await yieldDuringDiskWalk(scanState)) break;
       if (name.startsWith(".")) continue;
-      const p = path68.join(worktreesRootPath, name);
+      const p = path69.join(worktreesRootPath, name);
       let st;
       try {
-        st = await fs47.promises.stat(p);
+        st = await fs48.promises.stat(p);
       } catch {
         continue;
       }
@@ -46269,7 +46296,7 @@ async function discoverPreviewWorktreeOnDisk(options) {
   const previewDirRel = layoutDirSegments("preview_environment", eid);
   for (const key of keys) {
     await yieldToEventLoop();
-    const previewDir = path68.join(worktreesRootPath, key, ...previewDirRel);
+    const previewDir = path69.join(worktreesRootPath, key, ...previewDirRel);
     const binding = await tryBindingFromIsolatedDirectory(previewDir);
     if (binding) return binding;
   }
@@ -46396,7 +46423,7 @@ var PreviewWorktreeManager = class {
 };
 
 // src/worktrees/deploy/deploy-session-to-preview-environment.ts
-import * as path72 from "node:path";
+import * as path73 from "node:path";
 
 // src/git/worktrees/reset-worktree-to-branch.ts
 async function gitResetWorktreeToBranch(worktreePath, branch) {
@@ -46407,8 +46434,8 @@ async function gitResetWorktreeToBranch(worktreePath, branch) {
 }
 
 // src/worktrees/deploy/capture-and-apply-wip.ts
-import * as fs48 from "node:fs";
-import * as path69 from "node:path";
+import * as fs49 from "node:fs";
+import * as path70 from "node:path";
 
 // src/git/snapshot/git.ts
 async function gitStashCreate(repoRoot, log2) {
@@ -46456,12 +46483,12 @@ async function applyWorkingTreeWip(targetRepoPath, sourceRepoPath, wip, log2) {
     if (!ap.ok) return ap;
   }
   await forEachWithGitYield(wip.untrackedPaths, async (rel) => {
-    const src = path69.join(sourceRepoPath, rel);
-    const dst = path69.join(targetRepoPath, rel);
+    const src = path70.join(sourceRepoPath, rel);
+    const dst = path70.join(targetRepoPath, rel);
     try {
-      if (!fs48.existsSync(src)) return;
-      fs48.mkdirSync(path69.dirname(dst), { recursive: true });
-      fs48.copyFileSync(src, dst);
+      if (!fs49.existsSync(src)) return;
+      fs49.mkdirSync(path70.dirname(dst), { recursive: true });
+      fs49.copyFileSync(src, dst);
     } catch (e) {
       log2(
         `[worktrees] Failed to copy untracked ${rel}: ${e instanceof Error ? e.message : String(e)}`
@@ -46472,14 +46499,14 @@ async function applyWorkingTreeWip(targetRepoPath, sourceRepoPath, wip, log2) {
 }
 
 // src/worktrees/deploy/resolve-isolated-checkout-for-repo-path-relative-to-workspace-root.ts
-import * as path70 from "node:path";
+import * as path71 from "node:path";
 async function resolveIsolatedCheckoutForRepoPathRelativeToWorkspaceRoot(options) {
   const { checkoutPaths, sessionParentPath, bridgeRoot, repoPathRelativeToWorkspaceRoot } = options;
-  const resolvedSessionParentPath = sessionParentPath ? path70.resolve(sessionParentPath) : null;
+  const resolvedSessionParentPath = sessionParentPath ? path71.resolve(sessionParentPath) : null;
   let match = null;
   await forEachWithGitYield(checkoutPaths, async (checkoutPath) => {
     if (match) return;
-    const resolvedCheckoutPath = path70.resolve(checkoutPath);
+    const resolvedCheckoutPath = path71.resolve(checkoutPath);
     if (!await isGitRepoDirectory(resolvedCheckoutPath)) return;
     const resolvedRepoPathRelativeToWorkspaceRoot = await resolveRepoPathRelativeToWorkspaceRoot({
       checkoutPath: resolvedCheckoutPath,
@@ -46533,7 +46560,7 @@ async function applySessionWipToPreviewCheckouts(options) {
 }
 
 // src/worktrees/deploy/collect-session-repo-deploy-states.ts
-import * as path71 from "node:path";
+import * as path72 from "node:path";
 
 // src/git/branches/create-or-update-branch.ts
 async function gitCreateOrUpdateBranch(repoPath, branch, startRef, options) {
@@ -46570,19 +46597,19 @@ async function collectSessionRepoDeployStates(options) {
   const sessionParentPath = sessionWorktreeManager.getSessionParentPath(sid);
   const states = [];
   await forEachWithGitYield(sessionTargets, async (sessionCheckout) => {
-    const checkoutPath = path71.resolve(sessionCheckout);
+    const checkoutPath = path72.resolve(sessionCheckout);
     if (!await isGitRepoDirectory(checkoutPath)) return;
     const repoPathRelativeToWorkspaceRoot = await resolveRepoPathRelativeToWorkspaceRoot({
       checkoutPath,
       bridgeRoot,
-      sessionParentPath: sessionParentPath ? path71.resolve(sessionParentPath) : null
+      sessionParentPath: sessionParentPath ? path72.resolve(sessionParentPath) : null
     });
     if (!repoPathRelativeToWorkspaceRoot) return;
     const mainRepoPath = resolveMainRepoPath(checkoutPath);
     const headSha = (await cliSimpleGit(checkoutPath).revparse(["HEAD"])).trim();
     const previewCheckout = previewCheckoutPaths.length > 0 ? await resolveIsolatedCheckoutForRepoPathRelativeToWorkspaceRoot({
       checkoutPaths: previewCheckoutPaths,
-      sessionParentPath: previewParentPath ? path71.resolve(previewParentPath) : null,
+      sessionParentPath: previewParentPath ? path72.resolve(previewParentPath) : null,
       bridgeRoot,
       repoPathRelativeToWorkspaceRoot
     }) : null;
@@ -46602,7 +46629,7 @@ async function deploySessionToPreviewEnvironment(options) {
   const eid = options.environmentId.trim();
   if (!sid || !eid) return { ok: false, error: "sessionId and environmentId are required" };
   const deployBranch = previewDeployBranchName(eid);
-  const bridgeRoot = path72.resolve(getBridgeRoot());
+  const bridgeRoot = path73.resolve(getBridgeRoot());
   await previewWorktreeManager.ensureCached(eid);
   const existingPreviewParentPath = previewWorktreeManager.getPreviewParentPath(eid) ?? null;
   const existingPreviewCheckoutPaths = previewWorktreeManager.getRepoCheckoutPaths(eid) ?? [];
@@ -46642,10 +46669,10 @@ async function deploySessionToPreviewEnvironment(options) {
 }
 
 // src/worktrees/manager/default-worktrees-root-path.ts
-import * as path73 from "node:path";
+import * as path74 from "node:path";
 import os9 from "node:os";
 function defaultWorktreesRootPath() {
-  return path73.join(os9.homedir(), ".buildautomaton", "worktrees");
+  return path74.join(os9.homedir(), ".buildautomaton", "worktrees");
 }
 
 // src/connection/create-bridge-worktree-managers.ts
@@ -46775,14 +46802,14 @@ function assertBridgeWorkspace(ctx) {
 }
 
 // src/files/list-dir/index.ts
-import fs50 from "node:fs";
+import fs51 from "node:fs";
 
 // src/files/ensure-under-cwd.ts
-import path74 from "node:path";
+import path75 from "node:path";
 function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
-  const normalized = path74.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path74.resolve(cwd, normalized);
-  if (!resolved.startsWith(cwd + path74.sep) && resolved !== cwd) {
+  const normalized = path75.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path75.resolve(cwd, normalized);
+  if (!resolved.startsWith(cwd + path75.sep) && resolved !== cwd) {
     return null;
   }
   return resolved;
@@ -46795,15 +46822,15 @@ init_yield_to_event_loop();
 var LIST_DIR_YIELD_EVERY = 256;
 
 // src/files/list-dir/map-dir-entry.ts
-import path75 from "node:path";
-import fs49 from "node:fs";
+import path76 from "node:path";
+import fs50 from "node:fs";
 async function mapDirEntry(d, relativePath, resolved) {
-  const entryPath = path75.join(relativePath || ".", d.name).replace(/\\/g, "/");
-  const fullPath = path75.join(resolved, d.name);
+  const entryPath = path76.join(relativePath || ".", d.name).replace(/\\/g, "/");
+  const fullPath = path76.join(resolved, d.name);
   let isDir = d.isDirectory();
   if (d.isSymbolicLink()) {
     try {
-      const targetStat = await fs49.promises.stat(fullPath);
+      const targetStat = await fs50.promises.stat(fullPath);
       isDir = targetStat.isDirectory();
     } catch {
       isDir = false;
@@ -46833,7 +46860,7 @@ async function listDirAsync(relativePath, sessionParentPath = getBridgeRoot()) {
     return { error: "Path is outside working directory" };
   }
   try {
-    const names = await fs50.promises.readdir(resolved, { withFileTypes: true });
+    const names = await fs51.promises.readdir(resolved, { withFileTypes: true });
     const entries = [];
     for (let i = 0; i < names.length; i++) {
       if (i > 0 && i % LIST_DIR_YIELD_EVERY === 0) {
@@ -46849,13 +46876,13 @@ async function listDirAsync(relativePath, sessionParentPath = getBridgeRoot()) {
 }
 
 // src/git/tree/resolve-repo-abs-path.ts
-import * as path76 from "node:path";
+import * as path77 from "node:path";
 function resolveRepoAbsPathFromBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path76.resolve(bridgeRoot);
+  const bridgeResolved = path77.resolve(bridgeRoot);
   const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
-  const repoPath = rel === "" ? bridgeResolved : path76.join(bridgeResolved, rel);
-  const resolved = path76.resolve(repoPath);
-  if (!resolved.startsWith(bridgeResolved + path76.sep) && resolved !== bridgeResolved) {
+  const repoPath = rel === "" ? bridgeResolved : path77.join(bridgeResolved, rel);
+  const resolved = path77.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path77.sep) && resolved !== bridgeResolved) {
     return null;
   }
   return resolved;
@@ -46941,7 +46968,7 @@ init_yield_to_event_loop();
 
 // src/files/read/types.ts
 var LINE_CHUNK_SIZE = 64 * 1024;
-var READ_RANGE_YIELD_EVERY_BYTES = 256 * 1024;
+var READ_RANGE_YIELD_EVERY_BYTES = 64 * 1024;
 
 // src/files/read/guess-mime-type.ts
 var MIME_BY_EXT = {
@@ -47336,25 +47363,25 @@ async function GET2(ctx) {
 init_in_flight();
 
 // src/files/read/read-file-async.ts
-import fs56 from "node:fs";
+import fs57 from "node:fs";
 init_yield_to_event_loop();
 
 // src/files/read/resolve-file-cache.ts
-import fs51 from "node:fs";
-import path77 from "node:path";
+import fs52 from "node:fs";
+import path78 from "node:path";
 var RESOLVE_CACHE_MAX = 4096;
 var resolveCache = /* @__PURE__ */ new Map();
 function resolveCacheKey(sessionParentPath, relativePath) {
   return `${sessionParentPath}\0${relativePath}`;
 }
 function pathStaysUnderParent(filePath, sessionParentPath) {
-  const parent = path77.resolve(sessionParentPath);
-  const resolved = path77.resolve(filePath);
-  return resolved === parent || resolved.startsWith(`${parent}${path77.sep}`);
+  const parent = path78.resolve(sessionParentPath);
+  const resolved = path78.resolve(filePath);
+  return resolved === parent || resolved.startsWith(`${parent}${path78.sep}`);
 }
 function statMatchesCacheSync(entry) {
   try {
-    const stat2 = fs51.statSync(entry.path);
+    const stat2 = fs52.statSync(entry.path);
     return stat2.isFile() && stat2.mtimeMs === entry.mtimeMs && stat2.size === entry.size;
   } catch {
     return false;
@@ -47387,7 +47414,7 @@ function joinInflightResolve(cacheKey, factory) {
 }
 
 // src/files/read/resolve-file-for-read-core.ts
-import fs52 from "node:fs";
+import fs53 from "node:fs";
 import { isMainThread as isMainThread4 } from "node:worker_threads";
 function resolveFileForReadImplSync(relativePath, sessionParentPath) {
   const cacheKey = resolveCacheKey(sessionParentPath, relativePath);
@@ -47397,13 +47424,13 @@ function resolveFileForReadImplSync(relativePath, sessionParentPath) {
   let size;
   let mtimeMs;
   try {
-    const lstat = fs52.lstatSync(resolved);
+    const lstat = fs53.lstatSync(resolved);
     if (lstat.isSymbolicLink()) {
-      real = fs52.realpathSync(resolved);
+      real = fs53.realpathSync(resolved);
       if (!pathStaysUnderParent(real, sessionParentPath)) {
         return { error: "Path is outside working directory" };
       }
-      const stat2 = fs52.statSync(real);
+      const stat2 = fs53.statSync(real);
       if (!stat2.isFile()) return { error: "Not a file" };
       size = stat2.size;
       mtimeMs = stat2.mtimeMs;
@@ -47431,13 +47458,13 @@ async function resolveFileForReadImpl(relativePath, sessionParentPath) {
   let size;
   let mtimeMs;
   try {
-    const lstat = await fs52.promises.lstat(resolved);
+    const lstat = await fs53.promises.lstat(resolved);
     if (lstat.isSymbolicLink()) {
-      real = await fs52.promises.realpath(resolved);
+      real = await fs53.promises.realpath(resolved);
       if (!pathStaysUnderParent(real, sessionParentPath)) {
         return { error: "Path is outside working directory" };
       }
-      const stat2 = await fs52.promises.stat(real);
+      const stat2 = await fs53.promises.stat(real);
       if (!stat2.isFile()) return { error: "Not a file" };
       size = stat2.size;
       mtimeMs = stat2.mtimeMs;
@@ -47486,7 +47513,7 @@ async function resolveFilePathAsync(relativePath, sessionParentPath = getBridgeR
 
 // src/files/read/read-file-range-async.ts
 init_yield_to_event_loop();
-import fs53 from "node:fs";
+import fs54 from "node:fs";
 import { StringDecoder as StringDecoder2 } from "node:string_decoder";
 
 // src/files/read/read-file-range-line-zero.ts
@@ -47600,8 +47627,8 @@ function finishLineZeroTail(state, tail, resultLines, fileSize, lineChunkSize, l
 
 // src/files/read/read-file-range-async.ts
 async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE, fileSizeIn) {
-  const fileSize = fileSizeIn ?? (await fs53.promises.stat(filePath)).size;
-  const fd = await fs53.promises.open(filePath, "r");
+  const fileSize = fileSizeIn ?? (await fs54.promises.stat(filePath)).size;
+  const fd = await fs54.promises.open(filePath, "r");
   const bufSize = 64 * 1024;
   const buf = Buffer.alloc(bufSize);
   const decoder = new StringDecoder2("utf8");
@@ -47702,7 +47729,7 @@ async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, li
 }
 
 // src/files/read/read-small-file-range-async.ts
-import fs54 from "node:fs";
+import fs55 from "node:fs";
 import { isMainThread as isMainThread5 } from "node:worker_threads";
 var SMALL_FILE_RANGE_MAX_BYTES = 512 * 1024;
 function sliceLineRange(lines, startLine, endLine, lineOffsetIn, lineChunkSize, fileSize) {
@@ -47732,7 +47759,7 @@ function sliceLineRange(lines, startLine, endLine, lineOffsetIn, lineChunkSize,
   };
 }
 function readSmallFileRangeSync(filePath, fileSize, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
-  const raw = fs54.readFileSync(filePath, "utf8");
+  const raw = fs55.readFileSync(filePath, "utf8");
   const lines = raw.split(/\r?\n/);
   return sliceLineRange(lines, startLine, endLine, lineOffsetIn, lineChunkSize, fileSize);
 }
@@ -47740,28 +47767,28 @@ async function readSmallFileRangeAsync(filePath, fileSize, startLine, endLine, l
   if (isMainThread5) {
     return readSmallFileRangeSync(filePath, fileSize, startLine, endLine, lineOffsetIn, lineChunkSize);
   }
-  const raw = await fs54.promises.readFile(filePath, "utf8");
+  const raw = await fs55.promises.readFile(filePath, "utf8");
   const lines = raw.split(/\r?\n/);
   return sliceLineRange(lines, startLine, endLine, lineOffsetIn, lineChunkSize, fileSize);
 }
 
 // src/files/read/read-file-buffer-full-async.ts
 init_yield_to_event_loop();
-import fs55 from "node:fs";
+import fs56 from "node:fs";
 import { isMainThread as isMainThread6 } from "node:worker_threads";
 var READ_CHUNK_BYTES = 256 * 1024;
 var MAIN_THREAD_SYNC_READ_MAX_BYTES = 512 * 1024;
 async function readFileBufferFullAsync(filePath, knownSize) {
   if (isMainThread6) {
-    const size2 = knownSize ?? fs55.statSync(filePath).size;
+    const size2 = knownSize ?? fs56.statSync(filePath).size;
     if (size2 <= MAIN_THREAD_SYNC_READ_MAX_BYTES) {
       await yieldToEventLoop();
-      const buffer = fs55.readFileSync(filePath);
+      const buffer = fs56.readFileSync(filePath);
       return { buffer, size: buffer.length };
     }
   }
-  const size = knownSize ?? (await fs55.promises.stat(filePath)).size;
-  const fd = await fs55.promises.open(filePath, "r");
+  const size = knownSize ?? (await fs56.promises.stat(filePath)).size;
+  const fd = await fs56.promises.open(filePath, "r");
   const chunks = [];
   let position = 0;
   let bytesSinceYield = 0;
@@ -47864,7 +47891,7 @@ async function readFileAsync(relativePath, startLine, endLine, lineOffset, lineC
     }
     if (hasRange) {
       if (fileSize == null) {
-        const stat2 = await fs56.promises.stat(resolvedPath);
+        const stat2 = await fs57.promises.stat(resolvedPath);
         fileSize = stat2.size;
       }
       const read2 = fileSize <= SMALL_FILE_RANGE_MAX_BYTES ? await readSmallFileRangeAsync(
@@ -48162,12 +48189,12 @@ function parseOptionalInt2(raw) {
   return Number.isInteger(parsed) ? parsed : void 0;
 }
 function parseCodeNavParams(url2) {
-  const path82 = url2.searchParams.get("path") ?? "";
+  const path84 = url2.searchParams.get("path") ?? "";
   const opRaw = url2.searchParams.get("op")?.trim();
   const op = opRaw === "references" ? "references" : opRaw === "symbols" ? "symbols" : opRaw === "definitions" ? "definitions" : "definition";
   const line = parseOptionalInt2(url2.searchParams.get("line")) ?? 1;
   const column = parseOptionalInt2(url2.searchParams.get("column")) ?? 0;
-  return { path: path82, op, line, column };
+  return { path: path84, op, line, column };
 }
 function parseCodeNavPath(url2) {
   const raw = url2.searchParams.get("path")?.trim();
@@ -48747,16 +48774,8 @@ var handleAgentConfigMessage = (msg, deps) => {
   handleBridgeAgentConfig(msg, deps);
 };
 
-// src/prompt-turn-queue/client-report.ts
-function sendPromptQueueClientReport(ws, queues) {
-  if (!ws) return false;
-  const wireQueues = {};
-  for (const [queueKey, rows] of Object.entries(queues)) {
-    wireQueues[queueKey] = rows.map((r) => ({ turnId: r.turnId, clientState: r.cliState }));
-  }
-  sendWsMessage(ws, { type: "prompt_queue_client_report", queues: wireQueues });
-  return true;
-}
+// src/prompt-turn-queue/runner/dispatch-started-prompt-queue-runs.ts
+init_yield_to_event_loop();
 
 // src/prompt-turn-queue/disk-store.ts
 init_cli_database();
@@ -48848,23 +48867,6 @@ function dispatchLocalPrompt(next, deps) {
   handleBridgePrompt(msg, deps);
 }
 
-// src/prompt-turn-queue/runner/queue-selection.ts
-function pickNextRunnableTurn(turns) {
-  for (const t of turns) {
-    if (t.bridgeServerState === "discarded" || t.bridgeServerState === "stopping") continue;
-    if (t.bridgeServerState === "cancel_requested") continue;
-    if (!isRunnableBridgePromptTurnServerState(t.bridgeServerState)) continue;
-    if (t.lastCliState === "running" || t.lastCliState === "stopped" || t.lastCliState === "failed" || t.lastCliState === "cancelled") {
-      continue;
-    }
-    return t;
-  }
-  return null;
-}
-function hasRunningTurn(turns) {
-  return turns.some((t) => t.lastCliState === "running");
-}
-
 // src/prompt-turn-queue/runner/run-id-queue-key-map.ts
 var runIdToQueueKey = /* @__PURE__ */ new Map();
 function getRunIdQueueKey(runId) {
@@ -48879,37 +48881,184 @@ function deleteRunIdQueueKey(runId) {
   return queueKey;
 }
 function syncRunningTurnQueueKeys(turns, queueKey) {
-  for (const running of turns.filter((t) => t.lastCliState === "running")) {
-    runIdToQueueKey.set(running.turnId, queueKey);
+  for (const running2 of turns.filter((t) => t.lastCliState === "running")) {
+    runIdToQueueKey.set(running2.turnId, queueKey);
   }
 }
 
+// src/prompt-turn-queue/runner/dispatch-started-prompt-queue-runs.ts
+async function dispatchStartedPromptQueueRuns(entries, started, deps) {
+  for (const [queueKey] of entries) {
+    const file2 = await readPersistedQueue(queueKey);
+    const running2 = file2?.turns.find((turn) => turn.lastCliState === "running");
+    if (running2 && started.has(running2.turnId) && getRunIdQueueKey(running2.turnId) === queueKey) {
+      dispatchLocalPrompt(running2, deps);
+    }
+    await yieldToEventLoop();
+  }
+}
+
+// src/prompt-turn-queue/runner/handle-prompt-queue-cancellations.ts
+init_yield_to_event_loop();
+
+// src/prompt-turn-queue/client-report.ts
+function sendPromptQueueClientReport(ws, queues) {
+  if (!ws) return false;
+  const wireQueues = {};
+  for (const [queueKey, rows] of Object.entries(queues)) {
+    wireQueues[queueKey] = rows.map((r) => ({ turnId: r.turnId, clientState: r.cliState }));
+  }
+  sendWsMessage(ws, { type: "prompt_queue_client_report", queues: wireQueues });
+  return true;
+}
+
+// src/prompt-turn-queue/runner/finalize-prompt-turn-on-bridge.ts
+async function finalizePromptTurnOnBridge(getWs, runId, success2, opts) {
+  if (!runId) return false;
+  const queueKey = deleteRunIdQueueKey(runId);
+  if (!queueKey) return false;
+  const f = await readPersistedQueue(queueKey);
+  if (!f) return false;
+  const t = f.turns.find((x) => x.turnId === runId);
+  if (!t) return false;
+  t.lastCliState = opts?.terminalCliState ?? (success2 ? "stopped" : "failed");
+  await writePersistedQueue(f);
+  sendPromptQueueClientReport(getWs(), { [queueKey]: [{ turnId: runId, cliState: t.lastCliState }] });
+  return true;
+}
+
+// src/prompt-turn-queue/runner/handle-prompt-queue-cancellations.ts
+async function handlePromptQueueCancellations(entries, deps) {
+  for (const [queueKey] of entries) {
+    const file2 = await readPersistedQueue(queueKey);
+    const turn = file2?.turns.find((row) => row.bridgeServerState === "cancel_requested" && row.lastCliState === "running");
+    if (!turn) {
+      await yieldToEventLoop();
+      continue;
+    }
+    deps.log(`[Queue] Cancellation request received for turn ${turn.turnId.slice(0, 8)}\u2026`);
+    if (await deps.acpManager.cancelRun(turn.turnId)) {
+      await yieldToEventLoop();
+      continue;
+    }
+    deps.log(`[Queue] cancel_requested for ${turn.turnId.slice(0, 8)}\u2026 with no local run; marking cancelled.`);
+    await finalizePromptTurnOnBridge(deps.getWs, turn.turnId, false, { terminalCliState: "cancelled" });
+    const ws = deps.getWs();
+    if (ws && turn.sessionId) {
+      sendWsMessage(ws, {
+        type: "prompt_result",
+        sessionId: turn.sessionId,
+        runId: turn.turnId,
+        success: false,
+        error: "Stopped by user",
+        stopReason: "cancelled"
+      });
+    }
+    await yieldToEventLoop();
+  }
+}
+
+// src/prompt-turn-queue/runner/persist-prompt-queue-snapshot.ts
+init_yield_to_event_loop();
+async function persistPromptQueueSnapshot(entries) {
+  for (const [queueKey, serverTurns] of entries) {
+    const file2 = await mergeBridgeServerQueueSnapshot(queueKey, serverTurns);
+    await writePersistedQueue(file2);
+    await yieldToEventLoop();
+  }
+  for (const [queueKey] of entries) {
+    const file2 = await readPersistedQueue(queueKey);
+    if (file2) syncRunningTurnQueueKeys(file2.turns, queueKey);
+    await yieldToEventLoop();
+  }
+}
+
+// src/prompt-turn-queue/runner/prompt-queue-snapshot-types.ts
+function promptQueueSnapshotEntries(queues) {
+  return Object.entries(queues).filter((entry) => Array.isArray(entry[1]));
+}
+
+// src/prompt-turn-queue/runner/start-prompt-queue-runs.ts
+init_yield_to_event_loop();
+
+// src/prompt-turn-queue/runner/queue-selection.ts
+function pickNextRunnableTurn(turns) {
+  for (const t of turns) {
+    if (t.bridgeServerState === "discarded" || t.bridgeServerState === "stopping") continue;
+    if (t.bridgeServerState === "cancel_requested") continue;
+    if (!isRunnableBridgePromptTurnServerState(t.bridgeServerState)) continue;
+    if (t.lastCliState === "running" || t.lastCliState === "stopped" || t.lastCliState === "failed" || t.lastCliState === "cancelled") {
+      continue;
+    }
+    return t;
+  }
+  return null;
+}
+function hasRunningTurn(turns) {
+  return turns.some((t) => t.lastCliState === "running");
+}
+
 // src/prompt-turn-queue/runner/run-local-revert-before-queued-prompt.ts
-import fs58 from "node:fs";
+import fs60 from "node:fs";
 
 // src/git/snapshot/capture.ts
-import * as fs57 from "node:fs";
-import * as path78 from "node:path";
+import * as fs59 from "node:fs";
+import * as path80 from "node:path";
+
+// src/git/snapshot/apply-pre-turn-snapshot.ts
+import * as fs58 from "node:fs";
+async function applyPreTurnSnapshot(filePath, log2) {
+  let data;
+  try {
+    data = JSON.parse(fs58.readFileSync(filePath, "utf8"));
+  } catch (error40) {
+    return { ok: false, error: error40 instanceof Error ? error40.message : String(error40) };
+  }
+  if (!Array.isArray(data.repos)) return { ok: false, error: "Invalid snapshot file" };
+  let applyError = null;
+  await forEachWithGitYield(data.repos, async (repo) => {
+    if (applyError || !repo.path) return;
+    const reset = await gitRun(repo.path, ["reset", "--hard", "HEAD"], log2, "reset --hard");
+    if (!reset.ok) {
+      applyError = reset;
+      return;
+    }
+    const clean = await gitRun(repo.path, ["clean", "-fd"], log2, "clean -fd");
+    if (!clean.ok) {
+      applyError = clean;
+      return;
+    }
+    if (repo.stashSha) {
+      const applied = await gitRun(repo.path, ["stash", "apply", repo.stashSha], log2, "stash apply");
+      if (!applied.ok) applyError = applied;
+    }
+  });
+  if (applyError) return applyError;
+  log2(`[snapshot] Restored pre-turn state for ${data.runId.slice(0, 8)}\u2026`);
+  return { ok: true };
+}
+
+// src/git/snapshot/resolve-repo-roots.ts
+import * as path79 from "node:path";
 async function resolveSnapshotRepoRoots(options) {
   const { worktreePaths, fallbackCwd, sessionId, log: log2 } = options;
   if (worktreePaths?.length) {
-    const uniq = [...new Set(worktreePaths.map((p) => path78.resolve(p)))];
-    return uniq;
+    const paths = [...new Set(worktreePaths.map((p) => path79.resolve(p)))];
+    return (await Promise.all(paths.map(async (p) => await isGitRepoDirectory(p) ? p : null))).filter((p) => p != null);
   }
   try {
-    const repos = await discoverGitReposUnderRoot(fallbackCwd);
-    const mapped = repos.map((r) => r.absolutePath);
+    const roots = (await discoverGitReposUnderRoot(fallbackCwd)).map((repo) => repo.absolutePath);
     const sid = sessionId?.trim();
-    if (sid) {
-      const filtered = mapped.filter((root) => path78.basename(root) === sid);
-      if (filtered.length > 0) return filtered;
-    }
-    return mapped;
-  } catch (e) {
-    log2(`[snapshot] Discover repositories failed: ${e instanceof Error ? e.message : String(e)}`);
+    if (!sid) return roots;
+    const sessionRoots = roots.filter((root) => path79.basename(root) === sid);
+    return sessionRoots.length > 0 ? sessionRoots : roots;
+  } catch (error40) {
+    log2(`[snapshot] Discover repositories failed: ${error40 instanceof Error ? error40.message : String(error40)}`);
     return [];
   }
 }
+
+// src/git/snapshot/capture.ts
 async function capturePreTurnSnapshot(options) {
   const { runId, repoRoots, agentCwd, log: log2 } = options;
   if (!runId || !repoRoots.length) {
@@ -48923,7 +49072,7 @@ async function capturePreTurnSnapshot(options) {
   });
   const dir = snapshotsDirForCwd(agentCwd);
   try {
-    fs57.mkdirSync(dir, { recursive: true });
+    fs59.mkdirSync(dir, { recursive: true });
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
   }
@@ -48932,9 +49081,9 @@ async function capturePreTurnSnapshot(options) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     repos
   };
-  const filePath = path78.join(dir, `${runId}.json`);
+  const filePath = path80.join(dir, `${runId}.json`);
   try {
-    fs57.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
+    fs59.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
   }
@@ -48944,39 +49093,6 @@ async function capturePreTurnSnapshot(options) {
   );
   return { ok: true, filePath, repos };
 }
-async function applyPreTurnSnapshot(filePath, log2) {
-  let data;
-  try {
-    const raw = fs57.readFileSync(filePath, "utf8");
-    data = JSON.parse(raw);
-  } catch (e) {
-    return { ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-  if (!Array.isArray(data.repos)) {
-    return { ok: false, error: "Invalid snapshot file" };
-  }
-  let applyError = null;
-  await forEachWithGitYield(data.repos, async (r) => {
-    if (applyError || !r.path) return;
-    const reset = await gitRun(r.path, ["reset", "--hard", "HEAD"], log2, "reset --hard");
-    if (!reset.ok) {
-      applyError = reset;
-      return;
-    }
-    const clean = await gitRun(r.path, ["clean", "-fd"], log2, "clean -fd");
-    if (!clean.ok) {
-      applyError = clean;
-      return;
-    }
-    if (r.stashSha) {
-      const ap = await gitRun(r.path, ["stash", "apply", r.stashSha], log2, "stash apply");
-      if (!ap.ok) applyError = ap;
-    }
-  });
-  if (applyError) return applyError;
-  log2(`[snapshot] Restored pre-turn state for ${data.runId.slice(0, 8)}\u2026`);
-  return { ok: true };
-}
 
 // src/prompt-turn-queue/runner/run-local-revert-before-queued-prompt.ts
 async function runLocalRevertBeforeQueuedPrompt(next, deps) {
@@ -48987,7 +49103,7 @@ async function runLocalRevertBeforeQueuedPrompt(next, deps) {
   const agentBase = deps.sessionWorktreeManager.getSessionWorktreeRootForSession(sid) ?? getBridgeRoot();
   const file2 = snapshotFilePath(agentBase, tid);
   try {
-    await fs58.promises.access(file2, fs58.constants.F_OK);
+    await fs60.promises.access(file2, fs60.constants.F_OK);
   } catch {
     deps.log(
       `[Queue] requeued_with_revert: no pre-turn snapshot for ${tid.slice(0, 8)}\u2026; continuing without revert.`
@@ -49001,96 +49117,41 @@ async function runLocalRevertBeforeQueuedPrompt(next, deps) {
   return res.ok;
 }
 
-// src/prompt-turn-queue/runner/finalize-prompt-turn-on-bridge.ts
-async function finalizePromptTurnOnBridge(getWs, runId, success2, opts) {
-  if (!runId) return false;
-  const queueKey = deleteRunIdQueueKey(runId);
-  if (!queueKey) return false;
-  const f = await readPersistedQueue(queueKey);
-  if (!f) return false;
-  const t = f.turns.find((x) => x.turnId === runId);
-  if (!t) return false;
-  t.lastCliState = opts?.terminalCliState ?? (success2 ? "stopped" : "failed");
-  await writePersistedQueue(f);
-  sendPromptQueueClientReport(getWs(), { [queueKey]: [{ turnId: runId, cliState: t.lastCliState }] });
-  return true;
-}
-
-// src/prompt-turn-queue/runner/apply-prompt-queue-state-from-server.ts
-async function applyPromptQueueStateFromServer(msg, deps) {
-  const raw = msg.queues;
-  if (!raw || typeof raw !== "object") return;
-  const getWs = deps.getWs;
-  for (const [queueKey, serverTurns] of Object.entries(raw)) {
-    if (!Array.isArray(serverTurns)) continue;
-    const file2 = await mergeBridgeServerQueueSnapshot(queueKey, serverTurns);
-    await writePersistedQueue(file2);
-  }
-  for (const [queueKey, serverTurns] of Object.entries(raw)) {
-    if (!Array.isArray(serverTurns)) continue;
-    const file2 = await readPersistedQueue(queueKey);
-    if (!file2) continue;
-    syncRunningTurnQueueKeys(file2.turns, queueKey);
-  }
-  for (const [queueKey, serverTurns] of Object.entries(raw)) {
-    if (!Array.isArray(serverTurns)) continue;
-    const file2 = await readPersistedQueue(queueKey);
-    if (!file2) continue;
-    const cancelRow = file2.turns.find((t) => t.bridgeServerState === "cancel_requested" && t.lastCliState === "running");
-    if (cancelRow) {
-      const localCancelHandled = await deps.acpManager.cancelRun(cancelRow.turnId);
-      if (!localCancelHandled) {
-        deps.log(
-          `[Queue] bridge server cancel_requested for ${cancelRow.turnId.slice(0, 8)}\u2026 but no local agent run is active (e.g. after CLI restart); marking cancelled and notifying bridge.`
-        );
-        await finalizePromptTurnOnBridge(deps.getWs, cancelRow.turnId, false, { terminalCliState: "cancelled" });
-        const ws = deps.getWs();
-        if (ws && cancelRow.sessionId) {
-          sendWsMessage(ws, {
-            type: "prompt_result",
-            sessionId: cancelRow.sessionId,
-            runId: cancelRow.turnId,
-            success: false,
-            error: "Stopped by user",
-            stopReason: "cancelled"
-          });
-        }
-      }
-    }
-  }
+// src/prompt-turn-queue/runner/start-prompt-queue-runs.ts
+async function startPromptQueueRuns(entries, deps) {
   const report = {};
-  const startedThisTick = /* @__PURE__ */ new Set();
-  for (const [queueKey, serverTurns] of Object.entries(raw)) {
-    if (!Array.isArray(serverTurns)) continue;
+  const started = /* @__PURE__ */ new Set();
+  for (const [queueKey] of entries) {
     const file2 = await readPersistedQueue(queueKey);
-    if (!file2) continue;
-    if (hasRunningTurn(file2.turns)) continue;
+    if (!file2 || hasRunningTurn(file2.turns)) continue;
     const next = pickNextRunnableTurn(file2.turns);
     if (!next) continue;
     if (!await runLocalRevertBeforeQueuedPrompt(next, deps)) {
       next.lastCliState = "failed";
       await writePersistedQueue(file2);
-      sendPromptQueueClientReport(getWs(), { [queueKey]: [{ turnId: next.turnId, cliState: "failed" }] });
+      sendPromptQueueClientReport(deps.getWs(), { [queueKey]: [{ turnId: next.turnId, cliState: "failed" }] });
       continue;
     }
     next.lastCliState = "running";
     await writePersistedQueue(file2);
     setRunIdQueueKey(next.turnId, queueKey);
-    startedThisTick.add(next.turnId);
+    started.add(next.turnId);
     report[queueKey] = [{ turnId: next.turnId, cliState: "running" }];
+    await yieldToEventLoop();
   }
-  if (Object.keys(report).length > 0) {
-    sendPromptQueueClientReport(getWs(), report);
-  }
-  for (const [queueKey, serverTurns] of Object.entries(raw)) {
-    if (!Array.isArray(serverTurns)) continue;
-    const file2 = await readPersistedQueue(queueKey);
-    if (!file2) continue;
-    const running = file2.turns.find((t) => t.lastCliState === "running");
-    if (!running || !startedThisTick.has(running.turnId)) continue;
-    if (getRunIdQueueKey(running.turnId) !== queueKey) continue;
-    dispatchLocalPrompt(running, deps);
-  }
+  if (Object.keys(report).length) sendPromptQueueClientReport(deps.getWs(), report);
+  return started;
+}
+
+// src/prompt-turn-queue/runner/apply-prompt-queue-state-from-server.ts
+async function applyPromptQueueStateFromServer(msg, deps) {
+  const raw = msg.queues;
+  if (!raw || typeof raw !== "object") return;
+  const entries = promptQueueSnapshotEntries(raw);
+  await persistPromptQueueSnapshot(entries);
+  await handlePromptQueueCancellations(entries, deps);
+  const started = await startPromptQueueRuns(entries, deps);
+  await dispatchStartedPromptQueueRuns(entries, started, deps);
 }
 
 // src/agents/acp/from-bridge/bridge-prompt-wiring.ts
@@ -49191,8 +49252,8 @@ async function runBridgePromptPreamble(params) {
     log: log2
   });
   if (s && sessionId) {
-    const cliGitBranch = await readGitBranch(effectiveCwd);
     const usesWt = sessionWorktreeManager.usesWorktreeSession(sessionId);
+    const cliGitBranch = repoRoots.length > 0 ? await readGitBranch(effectiveCwd) : null;
     const isolatedSessionParentPath = sessionWorktreeManager.getIsolatedSessionParentPathForSession(sessionId);
     sendWsMessage(s, {
       type: "session_git_context_report",
@@ -49356,10 +49417,34 @@ var handlePromptMessage = (msg, deps) => {
   handleBridgePrompt(msg, deps);
 };
 
+// src/prompt-turn-queue/runner/serial-prompt-queue-work.ts
+var running = false;
+var latestWork = null;
+async function drain() {
+  while (latestWork) {
+    const work = latestWork;
+    latestWork = null;
+    await work();
+  }
+}
+function enqueueLatestPromptQueueStateWork(work) {
+  latestWork = work;
+  if (running) return;
+  running = true;
+  void drain().finally(() => {
+    running = false;
+    if (latestWork) enqueueLatestPromptQueueStateWork(latestWork);
+  });
+}
+
 // src/routing/handlers/prompt-queue-state.ts
 var handlePromptQueueStateMessage = (msg, deps) => {
-  void applyPromptQueueStateFromServer(msg, deps).catch((err) => {
-    deps.log(`[Queue] applyPromptQueueStateFromServer failed: ${err instanceof Error ? err.message : String(err)}`);
+  enqueueLatestPromptQueueStateWork(async () => {
+    try {
+      await applyPromptQueueStateFromServer(msg, deps);
+    } catch (err) {
+      deps.log(`[Queue] applyPromptQueueStateFromServer failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
   });
 };
 
@@ -49610,7 +49695,7 @@ var handleSessionDiscardedMessage = (msg, deps) => {
 };
 
 // src/routing/handlers/revert-turn-snapshot.ts
-import * as fs59 from "node:fs";
+import * as fs61 from "node:fs";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
@@ -49623,7 +49708,7 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
     const agentBase = sessionWorktreeManager.getSessionWorktreeRootForSession(sessionId) ?? getBridgeRoot();
     const file2 = snapshotFilePath(agentBase, turnId);
     try {
-      await fs59.promises.access(file2, fs59.constants.F_OK);
+      await fs61.promises.access(file2, fs61.constants.F_OK);
     } catch {
       sendWsMessage(s, {
         type: "revert_turn_snapshot_result",
@@ -49721,8 +49806,8 @@ function isValidRemoteSkillInstallItem(item) {
 
 // src/skills/install/install-remote-skills-async.ts
 init_yield_to_event_loop();
-import fs60 from "node:fs";
-import path79 from "node:path";
+import fs62 from "node:fs";
+import path81 from "node:path";
 
 // src/skills/install/constants.ts
 var INSTALL_SKILLS_YIELD_EVERY = 16;
@@ -49733,12 +49818,12 @@ async function writeInstallFileAsync(skillDir, f, filesWritten) {
   if (++filesWritten.count % INSTALL_SKILLS_YIELD_EVERY === 0) {
     await yieldToEventLoop();
   }
-  const dest = path79.join(skillDir, f.path);
-  await fs60.promises.mkdir(path79.dirname(dest), { recursive: true });
+  const dest = path81.join(skillDir, f.path);
+  await fs62.promises.mkdir(path81.dirname(dest), { recursive: true });
   if (f.text !== void 0) {
-    await fs60.promises.writeFile(dest, f.text, "utf8");
+    await fs62.promises.writeFile(dest, f.text, "utf8");
   } else if (f.base64) {
-    await fs60.promises.writeFile(dest, Buffer.from(f.base64, "base64"));
+    await fs62.promises.writeFile(dest, Buffer.from(f.base64, "base64"));
   }
 }
 async function installRemoteSkillsAsync(cwd, targetDir, items) {
@@ -49750,7 +49835,7 @@ async function installRemoteSkillsAsync(cwd, targetDir, items) {
   try {
     for (const item of items) {
       if (!isValidRemoteSkillInstallItem(item)) continue;
-      const skillDir = path79.join(cwd, targetDir, item.skillName);
+      const skillDir = path81.join(cwd, targetDir, item.skillName);
       for (const f of item.files) {
         await writeInstallFileAsync(skillDir, f, filesWritten);
       }
@@ -50057,13 +50142,13 @@ function handleFileBrowserRequest(msg, socket, e2ee, sessionWorktreeManager) {
 
 // src/files/handle-file-browser-search.ts
 init_yield_to_event_loop();
-import path80 from "node:path";
+import path82 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 = path80.resolve(
+    const sessionParentPath = path82.resolve(
       sessionWorktreeManager != null ? await resolveFileBrowserSessionParent(sessionWorktreeManager, msg.sessionId) : getBridgeRoot()
     );
     if (!await bridgeFileIndexIsPopulated(sessionParentPath)) {
@@ -50161,7 +50246,7 @@ function handleFileBrowserCodeNavMessage(msg, { getWs, e2ee, sessionWorktreeMana
 }
 
 // src/git/bridge-git-context.ts
-import * as path81 from "node:path";
+import * as path83 from "node:path";
 init_yield_to_event_loop();
 
 // src/git/branches/get-current-branch.ts
@@ -50212,12 +50297,12 @@ async function listRepoBranchRefs(repoPath) {
 // src/git/bridge-git-context.ts
 function folderNameForRelPath(relPath, bridgeRoot) {
   if (relPath === "." || relPath === "") {
-    return path81.basename(path81.resolve(bridgeRoot)) || "repo";
+    return path83.basename(path83.resolve(bridgeRoot)) || "repo";
   }
-  return path81.basename(relPath) || relPath;
+  return path83.basename(relPath) || relPath;
 }
 async function discoverGitReposForBridgeContext(bridgeRoot) {
-  const root = path81.resolve(bridgeRoot);
+  const root = path83.resolve(bridgeRoot);
   if (await isGitRepoDirectory(root)) {
     const remoteUrl = await getRemoteOriginUrl(root);
     return [{ absolutePath: root, remoteUrl }];
@@ -50225,19 +50310,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(path81.resolve(repo.absolutePath), repo);
+    byPath.set(path83.resolve(repo.absolutePath), repo);
   }
   return [...byPath.values()];
 }
 async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path81.resolve(bridgeRoot);
+  const bridgeResolved = path83.resolve(bridgeRoot);
   const repos = await discoverGitReposForBridgeContext(bridgeResolved);
   const rows = [];
   for (let i = 0; i < repos.length; i++) {
     if (i > 0) await yieldToEventLoop();
     const repo = repos[i];
-    let rel = path81.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path81.isAbsolute(rel)) continue;
+    let rel = path83.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path83.isAbsolute(rel)) continue;
     const relPath = rel === "" ? "." : rel.replace(/\\/g, "/");
     const currentBranch = await getCurrentBranch(repo.absolutePath);
     const remoteUrl = repo.remoteUrl.trim() || null;
@@ -50252,11 +50337,11 @@ async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
   return rows;
 }
 async function listRepoBranchesForBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path81.resolve(bridgeRoot);
+  const bridgeResolved = path83.resolve(bridgeRoot);
   const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
-  const repoPath = rel === "" ? bridgeResolved : path81.join(bridgeResolved, rel);
-  const resolved = path81.resolve(repoPath);
-  if (!resolved.startsWith(bridgeResolved + path81.sep) && resolved !== bridgeResolved) {
+  const repoPath = rel === "" ? bridgeResolved : path83.join(bridgeResolved, rel);
+  const resolved = path83.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path83.sep) && resolved !== bridgeResolved) {
     return [];
   }
   return listRepoBranchRefs(resolved);