@buildautomaton/cli 0.1.85 → 0.1.86

package/dist/cli.js

@@ -973,8 +973,8 @@ var require_command = __commonJS({
   "../../node_modules/.pnpm/commander@12.1.0/node_modules/commander/lib/command.js"(exports) {
     var EventEmitter2 = __require("node:events").EventEmitter;
     var childProcess2 = __require("node:child_process");
-    var path88 = __require("node:path");
-    var fs67 = __require("node:fs");
+    var path90 = __require("node:path");
+    var fs69 = __require("node:fs");
     var process9 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1906,11 +1906,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path88.resolve(baseDir, baseName);
-          if (fs67.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path88.extname(baseName))) return void 0;
+          const localBin = path90.resolve(baseDir, baseName);
+          if (fs69.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path90.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs67.existsSync(`${localBin}${ext}`)
+            (ext) => fs69.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1922,21 +1922,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs67.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs69.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path88.resolve(
-            path88.dirname(resolvedScriptPath),
+          executableDir = path90.resolve(
+            path90.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path88.basename(
+            const legacyName = path90.basename(
               this._scriptPath,
-              path88.extname(this._scriptPath)
+              path90.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1947,7 +1947,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path88.extname(executableFile));
+        launchWithNode = sourceExt.includes(path90.extname(executableFile));
         let proc;
         if (process9.platform !== "win32") {
           if (launchWithNode) {
@@ -2787,7 +2787,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path88.basename(filename, path88.extname(filename));
+        this._name = path90.basename(filename, path90.extname(filename));
         return this;
       }
       /**
@@ -2801,9 +2801,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path89) {
-        if (path89 === void 0) return this._executableDir;
-        this._executableDir = path89;
+      executableDir(path91) {
+        if (path91 === void 0) return this._executableDir;
+        this._executableDir = path91;
         return this;
       }
       /**
@@ -7729,7 +7729,7 @@ function readMigrationSql(filename, ...searchSubdirs) {
     join3(moduleDir, "..", sub, filename),
     join3(moduleDir, "..", "..", "dist", sub, filename)
   ]);
-  const resolved = candidates.find((path88) => existsSync(path88));
+  const resolved = candidates.find((path90) => existsSync(path90));
   if (!resolved) {
     throw new Error(`Missing SQLite migration SQL: ${filename} (searched ${searchSubdirs.join(", ")})`);
   }
@@ -8807,7 +8807,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(path88, checkUnignored, mode) {
+      test(path90, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -8816,7 +8816,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path88);
+          const matched = rule[mode].test(path90);
           if (!matched) {
             return;
           }
@@ -8837,17 +8837,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path88, originalPath, doThrow) => {
-      if (!isString(path88)) {
+    var checkPath = (path90, originalPath, doThrow) => {
+      if (!isString(path90)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path88) {
+      if (!path90) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path88)) {
+      if (checkPath.isNotRelative(path90)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -8856,7 +8856,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path88) => REGEX_TEST_INVALID_PATH.test(path88);
+    var isNotRelative = (path90) => REGEX_TEST_INVALID_PATH.test(path90);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -8886,19 +8886,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache2, checkUnignored, slices) {
-        const path88 = originalPath && checkPath.convert(originalPath);
+        const path90 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path88,
+          path90,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path88, cache2, checkUnignored, slices);
+        return this._t(path90, cache2, checkUnignored, slices);
       }
-      checkIgnore(path88) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path88)) {
-          return this.test(path88);
+      checkIgnore(path90) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path90)) {
+          return this.test(path90);
         }
-        const slices = path88.split(SLASH).filter(Boolean);
+        const slices = path90.split(SLASH).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -8911,18 +8911,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path88, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path90, false, MODE_CHECK_IGNORE);
       }
-      _t(path88, cache2, checkUnignored, slices) {
-        if (path88 in cache2) {
-          return cache2[path88];
+      _t(path90, cache2, checkUnignored, slices) {
+        if (path90 in cache2) {
+          return cache2[path90];
         }
         if (!slices) {
-          slices = path88.split(SLASH).filter(Boolean);
+          slices = path90.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache2[path88] = this._rules.test(path88, checkUnignored, MODE_IGNORE);
+          return cache2[path90] = this._rules.test(path90, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -8930,29 +8930,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache2[path88] = parent.ignored ? parent : this._rules.test(path88, checkUnignored, MODE_IGNORE);
+        return cache2[path90] = parent.ignored ? parent : this._rules.test(path90, checkUnignored, MODE_IGNORE);
       }
-      ignores(path88) {
-        return this._test(path88, this._ignoreCache, false).ignored;
+      ignores(path90) {
+        return this._test(path90, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path88) => !this.ignores(path88);
+        return (path90) => !this.ignores(path90);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path88) {
-        return this._test(path88, this._testCache, true);
+      test(path90) {
+        return this._test(path90, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path88) => checkPath(path88 && checkPath.convert(path88), path88, RETURN_FALSE);
+    var isPathValid = (path90) => checkPath(path90 && checkPath.convert(path90), path90, 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 = (path88) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path88) || isNotRelative(path88);
+      checkPath.isNotRelative = (path90) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path90) || isNotRelative(path90);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -12913,10 +12913,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path88) {
-  if (!path88)
+function getElementAtPath(obj, path90) {
+  if (!path90)
     return obj;
-  return path88.reduce((acc, key) => acc?.[key], obj);
+  return path90.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -13244,11 +13244,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path88, issues) {
+function prefixIssues(path90, issues) {
   return issues.map((iss) => {
     var _a4;
     (_a4 = iss).path ?? (_a4.path = []);
-    iss.path.unshift(path88);
+    iss.path.unshift(path90);
     return iss;
   });
 }
@@ -13465,16 +13465,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path88 = []) => {
+  const processError = (error52, path90 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path88, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path90, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path88, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path90, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path88, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path90, ...issue2.path]);
       } else {
-        const fullpath = [...path88, ...issue2.path];
+        const fullpath = [...path90, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -13501,17 +13501,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path88 = []) => {
+  const processError = (error52, path90 = []) => {
     var _a4, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path88, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path90, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path88, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path90, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path88, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path90, ...issue2.path]);
       } else {
-        const fullpath = [...path88, ...issue2.path];
+        const fullpath = [...path90, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -13543,8 +13543,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path88 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path88) {
+  const path90 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path90) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -26974,13 +26974,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path88 = ref.slice(1).split("/").filter(Boolean);
-  if (path88.length === 0) {
+  const path90 = ref.slice(1).split("/").filter(Boolean);
+  if (path90.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path88[0] === defsKey) {
-    const key = path88[1];
+  if (path90[0] === defsKey) {
+    const key = path90[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -30063,7 +30063,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js"(exports, module) {
     "use strict";
-    var os10 = __require("os");
+    var os11 = __require("os");
     var tty = __require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
@@ -30111,7 +30111,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os10.release().split(".");
+        const osRelease = os11.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -30357,10 +30357,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(path88, isFile, isDirectory) {
-      log2(`checking %s`, path88);
+    function check2(path90, isFile, isDirectory) {
+      log2(`checking %s`, path90);
       try {
-        const stat3 = fs_1.statSync(path88);
+        const stat3 = fs_1.statSync(path90);
         if (stat3.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -30380,8 +30380,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path88, type = exports.READABLE) {
-      return check2(path88, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path90, type = exports.READABLE) {
+      return check2(path90, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -30462,7 +30462,7 @@ var {
 } = import_index.default;
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.85".length > 0 ? "0.1.85" : "0.0.0-dev";
+var CLI_VERSION = "0.1.86".length > 0 ? "0.1.86" : "0.0.0-dev";
 
 // src/cli/defaults.ts
 var DEFAULT_API_URL = process.env.BUILDAUTOMATON_API_URL ?? "https://api.buildautomaton.com";
@@ -30470,8 +30470,8 @@ var DEFAULT_FIREHOSE_URL = "https://buildautomaton-firehose.fly.dev";
 
 // src/cli/run-cli-action.ts
 init_cli_log_level();
-import * as fs66 from "node:fs";
-import * as path87 from "node:path";
+import * as fs68 from "node:fs";
+import * as path89 from "node:path";
 
 // src/config.ts
 import fs from "node:fs";
@@ -33552,8 +33552,8 @@ async function cancelRun(ctx, runId) {
 }
 
 // src/agents/acp/ensure-acp-client.ts
-import * as fs24 from "node:fs";
-import * as path30 from "node:path";
+import * as fs25 from "node:fs";
+import * as path32 from "node:path";
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports = {};
@@ -34033,8 +34033,8 @@ function getErrorMap() {
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path88, errorMaps, issueData } = params;
-  const fullPath = [...path88, ...issueData.path || []];
+  const { data, path: path90, errorMaps, issueData } = params;
+  const fullPath = [...path90, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -34150,11 +34150,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path88, key) {
+  constructor(parent, value, path90, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path88;
+    this._path = path90;
     this._key = key;
   }
   get path() {
@@ -39738,6 +39738,7 @@ init_log();
 function createCursorAcpSessionContext(options) {
   const suppressLoadReplayRef = { value: false };
   return {
+    cloudSessionId: options.cloudSessionId,
     cwd: options.cwd,
     onFileChange: options.onFileChange,
     mcpServers: options.mcpServers ?? [],
@@ -39830,6 +39831,41 @@ function createCursorAcpHandle(options) {
 // src/agents/acp/clients/cursor/cursor-acp-init.ts
 import * as readline from "node:readline";
 
+// src/agents/acp/clients/cursor/cursor-incoming-cursor-create-plan.ts
+function buildCursorCreatePlanToolCallUpdate(requestId, params) {
+  const toolCallId = params.toolCallId ?? params.tool_call_id;
+  if (typeof toolCallId !== "string" || !toolCallId.trim()) return null;
+  const name = typeof params.name === "string" ? params.name.trim() : "";
+  const overview = typeof params.overview === "string" ? params.overview : void 0;
+  const plan = typeof params.plan === "string" ? params.plan : "";
+  const todos = Array.isArray(params.todos) ? params.todos : void 0;
+  const phases = Array.isArray(params.phases) ? params.phases : void 0;
+  const isProject = typeof params.isProject === "boolean" ? params.isProject : void 0;
+  return {
+    sessionUpdate: "tool_call",
+    toolCallId,
+    title: name || "Plan",
+    status: "pending",
+    cursorPlan: {
+      requestId,
+      ...name ? { name } : {},
+      ...overview != null ? { overview } : {},
+      plan,
+      ...todos != null ? { todos } : {},
+      ...phases != null ? { phases } : {},
+      ...isProject != null ? { isProject } : {}
+    }
+  };
+}
+function queueCursorCreatePlanRequest(method, id, msg, deps) {
+  const params = msg.params ?? {};
+  const requestId = String(id);
+  deps.pendingRequests.set(id, { method, params });
+  const update = buildCursorCreatePlanToolCallUpdate(requestId, params);
+  if (update) deps.onSessionUpdate?.(update);
+  deps.onRequest?.({ requestId, method, params });
+}
+
 // src/agents/acp/clients/cursor/cursor-incoming-cursor-task.ts
 function buildCursorTaskToolCallUpdate(params) {
   const toolCallId = params.toolCallId ?? params.tool_call_id;
@@ -39862,9 +39898,13 @@ function handleCursorIncomingCursorTask(id, msg, deps) {
 }
 
 // src/agents/acp/clients/cursor/cursor-incoming-cursor-methods.ts
-var CURSOR_BRIDGE_METHODS = /* @__PURE__ */ new Set(["cursor/create_plan", "cursor/ask_question"]);
+var CURSOR_BRIDGE_METHODS = /* @__PURE__ */ new Set(["cursor/ask_question"]);
 var CURSOR_NOOP_METHODS = /* @__PURE__ */ new Set(["cursor/update_todos", "cursor/generate_image"]);
 function handleCursorIncomingCursorMethods(method, id, msg, deps) {
+  if (method === "cursor/create_plan") {
+    queueCursorCreatePlanRequest(method, id, msg, deps);
+    return true;
+  }
   if (CURSOR_BRIDGE_METHODS.has(method)) {
     const params = msg.params ?? {};
     deps.pendingRequests.set(id, { method, params });
@@ -39978,10 +40018,71 @@ function handleCursorIncomingPermissionRequest(id, method, msg, deps) {
   return true;
 }
 
+// src/agents/acp/clients/cursor/write-create-plan-file.ts
+import * as fs24 from "node:fs";
+import * as path29 from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+
+// src/paths/session-plans-paths.ts
+import * as os8 from "node:os";
+import * as path28 from "node:path";
+function getSessionPlansRootDir() {
+  return path28.join(os8.homedir(), ".buildautomaton", "plans");
+}
+function sanitizeSessionPlansKey(sessionId) {
+  const t = sessionId.replace(/[^a-zA-Z0-9_-]+/g, "_").slice(0, 220);
+  return t || "session";
+}
+function getSessionPlansDir(sessionId) {
+  return path28.join(getSessionPlansRootDir(), sanitizeSessionPlansKey(sessionId));
+}
+
+// src/agents/acp/clients/cursor/write-create-plan-file.ts
+function sanitizePlanFileBase(toolCallId) {
+  const t = toolCallId.replace(/[^a-zA-Z0-9_-]+/g, "_").slice(0, 120);
+  return t || "plan";
+}
+function writeCreatePlanFile(params) {
+  const dir = getSessionPlansDir(params.cloudSessionId);
+  fs24.mkdirSync(dir, { recursive: true });
+  const filePath = path29.join(dir, `${sanitizePlanFileBase(params.toolCallId)}.md`);
+  fs24.writeFileSync(filePath, params.planMarkdown, "utf8");
+  return pathToFileURL2(filePath).href;
+}
+
+// src/agents/acp/clients/cursor/enrich-create-plan-rpc-result.ts
+function asRecord2(v) {
+  return v != null && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function enrichCreatePlanRpcResult(result, pendingParams, cloudSessionId) {
+  const root = asRecord2(result);
+  const outcome = asRecord2(root?.outcome);
+  if (!outcome) return result;
+  const kind = typeof outcome.outcome === "string" ? outcome.outcome : "";
+  if (kind !== "accepted") {
+    const { plan: _drop, ...rest } = outcome;
+    return { ...root, outcome: rest };
+  }
+  const planMarkdown = typeof outcome.plan === "string" ? outcome.plan : "";
+  const toolCallIdRaw = pendingParams.toolCallId ?? pendingParams.tool_call_id;
+  const toolCallId = typeof toolCallIdRaw === "string" ? toolCallIdRaw.trim() : "";
+  const sessionId = cloudSessionId?.trim() ?? "";
+  if (planMarkdown && toolCallId && sessionId) {
+    const planUri = writeCreatePlanFile({ cloudSessionId: sessionId, toolCallId, planMarkdown });
+    return { outcome: { outcome: "accepted", planUri } };
+  }
+  return { outcome: { outcome: "accepted" } };
+}
+
 // src/agents/acp/clients/cursor/cursor-incoming-resolve-request.ts
-function resolveCursorIncomingRequest(pendingRequests2, respond, requestId, result) {
+function resolveCursorIncomingRequest(pendingRequests2, respond, requestId, result, cloudSessionId) {
   const pending2 = pendingRequests2.get(requestId);
-  const payload = pending2?.method === "session/request_permission" ? enrichAcpPermissionRpcResultFromRequestParams(result, pending2.params) : result;
+  let payload = result;
+  if (pending2?.method === "session/request_permission") {
+    payload = enrichAcpPermissionRpcResultFromRequestParams(result, pending2.params);
+  } else if (pending2?.method === "cursor/create_plan") {
+    payload = enrichCreatePlanRpcResult(result, pending2.params, cloudSessionId ?? void 0);
+  }
   respond(requestId, payload);
   pendingRequests2.delete(requestId);
 }
@@ -40042,7 +40143,13 @@ function createCursorAcpIncomingLineHandler(deps) {
     pendingRequests: deps.pendingRequests
   };
   return {
-    resolveRequest: (requestId, result) => resolveCursorIncomingRequest(deps.pendingRequests, deps.respond, requestId, result),
+    resolveRequest: (requestId, result) => resolveCursorIncomingRequest(
+      deps.pendingRequests,
+      deps.respond,
+      requestId,
+      result,
+      deps.sessionCtx.cloudSessionId
+    ),
     handleLine(line) {
       const msg = safeJsonParse(line);
       if (!msg) return;
@@ -40245,6 +40352,7 @@ async function createCursorAcpClient(options) {
   const skipBrowserAuthenticate = cursorAgentUsesApiKeyAuth(spawnEnv);
   const sessionCtx = createCursorAcpSessionContext({
     cwd,
+    cloudSessionId: options.cloudSessionId,
     mcpServers: options.mcpServers,
     persistedAcpSessionId,
     backendAgentType,
@@ -40394,18 +40502,18 @@ import { existsSync as existsSync4, statSync } from "node:fs";
 
 // src/git/get-git-repo-root-sync.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import * as path28 from "node:path";
+import * as path30 from "node:path";
 var GIT_LOOKUP_TIMEOUT_MS = 2e3;
 function getGitRepoRootSync(startDir) {
   try {
     const out = execFileSync3("git", ["rev-parse", "--show-toplevel"], {
-      cwd: path28.resolve(startDir),
+      cwd: path30.resolve(startDir),
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       maxBuffer: 1024 * 1024,
       timeout: GIT_LOOKUP_TIMEOUT_MS
     }).trim();
-    return out ? path28.resolve(out) : null;
+    return out ? path30.resolve(out) : null;
   } catch {
     return null;
   }
@@ -40414,26 +40522,26 @@ function getGitRepoRootSync(startDir) {
 // src/agents/acp/workspace-files.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
 import { readFileSync as readFileSync4 } from "node:fs";
-import * as path29 from "node:path";
+import * as path31 from "node:path";
 var GIT_FILE_READ_TIMEOUT_MS = 2e3;
 function resolveWorkspaceFilePath(sessionParentPath, rawPath) {
   const trimmed2 = rawPath.trim();
   if (!trimmed2) return null;
-  const normalizedSessionParent = path29.resolve(sessionParentPath);
+  const normalizedSessionParent = path31.resolve(sessionParentPath);
   let resolvedPath = resolveSafePathUnderCwd(sessionParentPath, trimmed2);
   if (!resolvedPath) {
-    const candidate = path29.isAbsolute(trimmed2) ? path29.normalize(trimmed2) : path29.normalize(path29.resolve(normalizedSessionParent, trimmed2));
+    const candidate = path31.isAbsolute(trimmed2) ? path31.normalize(trimmed2) : path31.normalize(path31.resolve(normalizedSessionParent, trimmed2));
     const gitRoot2 = getGitRepoRootSync(sessionParentPath);
     if (!gitRoot2) return null;
-    const rel = path29.relative(gitRoot2, candidate);
-    if (rel.startsWith("..") || path29.isAbsolute(rel)) return null;
+    const rel = path31.relative(gitRoot2, candidate);
+    if (rel.startsWith("..") || path31.isAbsolute(rel)) return null;
     resolvedPath = candidate;
   }
   const gitRoot = getGitRepoRootSync(sessionParentPath);
   if (gitRoot) {
-    const relFromRoot = path29.relative(gitRoot, resolvedPath);
-    if (!relFromRoot.startsWith("..") && !path29.isAbsolute(relFromRoot)) {
-      return { resolvedPath, display: relFromRoot.split(path29.sep).join("/") };
+    const relFromRoot = path31.relative(gitRoot, resolvedPath);
+    if (!relFromRoot.startsWith("..") && !path31.isAbsolute(relFromRoot)) {
+      return { resolvedPath, display: relFromRoot.split(path31.sep).join("/") };
     }
   }
   return { resolvedPath, display: toDisplayPathRelativeToCwd(sessionParentPath, resolvedPath) };
@@ -40442,9 +40550,9 @@ function readUtf8WorkspaceFile(sessionParentPath, displayPath) {
   if (!displayPath || displayPath.includes("..")) return "";
   const gitRoot = getGitRepoRootSync(sessionParentPath);
   if (gitRoot) {
-    const resolvedPath2 = path29.resolve(gitRoot, displayPath);
-    const rel = path29.relative(gitRoot, resolvedPath2);
-    if (!rel.startsWith("..") && !path29.isAbsolute(rel)) {
+    const resolvedPath2 = path31.resolve(gitRoot, displayPath);
+    const rel = path31.relative(gitRoot, resolvedPath2);
+    if (!rel.startsWith("..") && !path31.isAbsolute(rel)) {
       try {
         return readFileSync4(resolvedPath2, "utf8");
       } catch {
@@ -40463,9 +40571,9 @@ function tryWorkspaceDisplayToPath(sessionParentPath, displayPath) {
   if (!displayPath || displayPath.includes("..")) return null;
   const gitRoot = getGitRepoRootSync(sessionParentPath);
   if (gitRoot) {
-    const resolvedPath = path29.resolve(gitRoot, displayPath);
-    const rel = path29.relative(gitRoot, resolvedPath);
-    if (!rel.startsWith("..") && !path29.isAbsolute(rel)) return resolvedPath;
+    const resolvedPath = path31.resolve(gitRoot, displayPath);
+    const rel = path31.relative(gitRoot, resolvedPath);
+    if (!rel.startsWith("..") && !path31.isAbsolute(rel)) return resolvedPath;
   }
   return resolveSafePathUnderCwd(sessionParentPath, displayPath);
 }
@@ -41352,11 +41460,11 @@ init_cli_process_interrupt();
 var BRIDGE_MCP_SERVER_NAME2 = "buildautomaton-bridge";
 
 // src/mcp/resolve-bridge-mcp-server-path.ts
-import { dirname as dirname7, join as join8 } from "node:path";
+import { dirname as dirname7, join as join10 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 function resolveBridgeMcpServerScriptPath() {
   const cliDir = dirname7(fileURLToPath7(import.meta.url));
-  return join8(cliDir, "bridge-mcp-server.js");
+  return join10(cliDir, "bridge-mcp-server.js");
 }
 
 // src/mcp/build-acp-mcp-servers.ts
@@ -41415,7 +41523,7 @@ async function ensureAcpClient(options) {
   if (state.acpStartPromise && !state.acpHandle) {
     await state.acpStartPromise;
   }
-  if (state.acpHandle && state.lastAcpCwd != null && path30.resolve(state.lastAcpCwd) !== path30.resolve(targetSessionParentPath)) {
+  if (state.acpHandle && state.lastAcpCwd != null && path32.resolve(state.lastAcpCwd) !== path32.resolve(targetSessionParentPath)) {
     try {
       state.acpHandle.disconnect();
     } catch {
@@ -41447,7 +41555,7 @@ async function ensureAcpClient(options) {
   if (!state.acpStartPromise) {
     let statOk = false;
     try {
-      const st = await fs24.promises.stat(targetSessionParentPath);
+      const st = await fs25.promises.stat(targetSessionParentPath);
       statOk = st.isDirectory();
       if (!statOk) {
         state.lastAcpStartError = `Agent cwd is not a directory: ${targetSessionParentPath}`;
@@ -41526,6 +41634,7 @@ async function ensureAcpClient(options) {
       },
       ...hooks,
       cwd: targetSessionParentPath,
+      cloudSessionId: cloudSessionId ?? null,
       mcpServers
     }).then(async (h) => {
       if (spawnEpoch !== state.clientEpoch || isCliImmediateShutdownRequested()) {
@@ -41745,8 +41854,8 @@ async function execGitFile(args, options) {
 }
 
 // src/git/changes/parse/normalize-git-diff-path.ts
-function normalizeGitDiffPath(path88) {
-  return path88.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
+function normalizeGitDiffPath(path90) {
+  return path90.replace(/\\/g, "/").replace(/\/ +/g, "/").trim();
 }
 
 // src/git/changes/parse/parse-name-status-entries.ts
@@ -41785,7 +41894,7 @@ function parseNameStatusLines(lines) {
 }
 
 // src/git/snapshot/diff/messages.ts
-import * as path31 from "node:path";
+import * as path33 from "node:path";
 
 // src/git/snapshot/diff/files.ts
 import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
@@ -41816,7 +41925,7 @@ async function buildTrackedChangeMessage(options) {
   const diffArgs = entry.change === "moved" && oldRel ? ["diff", "--no-color", "-M", baselineRev, "--", oldRel, rel] : ["diff", "--no-color", "-M", baselineRev, "--", rel];
   const { stdout: patchContent } = await execGitFile(diffArgs, { cwd: repoPath });
   if (!patchContent.trim()) return null;
-  const workspaceFilePath = path31.join(repoPath, rel);
+  const workspaceFilePath = path33.join(repoPath, rel);
   const newText = entry.change === "removed" ? "" : await readWorkspaceFileAsUtf8(workspaceFilePath);
   const oldText = entry.change === "added" ? "" : await readGitBlobAsUtf8(repoPath, baselineRev, oldRel ?? rel);
   return {
@@ -41848,9 +41957,9 @@ function buildUntrackedChangeMessage(options) {
 }
 
 // src/git/snapshot/diff/paths.ts
-import * as path32 from "node:path";
+import * as path34 from "node:path";
 function repoDisplayPath(repoPath, multiRepo) {
-  const slug = path32.basename(repoPath).replace(/[^\w.-]+/g, "_") || "repo";
+  const slug = path34.basename(repoPath).replace(/[^\w.-]+/g, "_") || "repo";
   return (rel) => multiRepo ? `${slug}/${rel}` : rel;
 }
 function safeRelPath(rel) {
@@ -41862,12 +41971,12 @@ function newUntrackedPaths(raw, baselineUntracked, seen) {
 }
 
 // src/git/snapshot/diff/move-pairs.ts
-import * as path33 from "node:path";
+import * as path35 from "node:path";
 async function readUntrackedTexts(repoPath, untracked) {
   const out = /* @__PURE__ */ new Map();
   await forEachWithGitYield(untracked, async (rel) => {
     if (!safeRelPath(rel)) return;
-    const newText = await readWorkspaceFileAsUtf8(path33.join(repoPath, rel));
+    const newText = await readWorkspaceFileAsUtf8(path35.join(repoPath, rel));
     if (newText !== void 0) out.set(rel, newText);
   });
   return out;
@@ -41984,12 +42093,12 @@ async function collectRepoTurnChanges(options) {
 import { readFile as readFile3 } from "node:fs/promises";
 
 // src/git/snapshot/types.ts
-import * as path34 from "node:path";
+import * as path36 from "node:path";
 function snapshotsDirForCwd(agentCwd) {
-  return path34.join(agentCwd, ".buildautomaton", "snapshots");
+  return path36.join(agentCwd, ".buildautomaton", "snapshots");
 }
 function snapshotFilePath(agentCwd, runId) {
-  return path34.join(snapshotsDirForCwd(agentCwd), `${runId}.json`);
+  return path36.join(snapshotsDirForCwd(agentCwd), `${runId}.json`);
 }
 
 // src/git/snapshot/diff/load-pre-turn-snapshot.ts
@@ -42057,6 +42166,18 @@ function reportPostTurnEnrichment(options) {
   });
 }
 
+// src/agents/acp/clients/cursor/cleanup-session-plans.ts
+import * as fs26 from "node:fs";
+function cleanupSessionPlans(sessionId) {
+  const id = typeof sessionId === "string" ? sessionId.trim() : "";
+  if (!id) return;
+  const dir = getSessionPlansDir(id);
+  try {
+    fs26.rmSync(dir, { recursive: true, force: true });
+  } catch {
+  }
+}
+
 // src/agents/acp/prompts/finalize-and-send-prompt-result.ts
 async function finalizeAndSendPromptResult(params) {
   const {
@@ -42074,6 +42195,7 @@ async function finalizeAndSendPromptResult(params) {
     sendSessionUpdate,
     log: log2
   } = params;
+  cleanupSessionPlans(sessionId);
   const planningTodosSubmit = isPlanningSession ? await maybeSubmitPlanningTodosAfterAgentSuccess({
     sessionId,
     runId,
@@ -43197,7 +43319,7 @@ async function createBridgeAccessState(options = {}) {
 }
 
 // src/agents/capabilities/warmup-agent-capabilities-on-connect.ts
-import * as path36 from "node:path";
+import * as path38 from "node:path";
 
 // src/agents/detect-local-agent-types.ts
 init_yield_to_event_loop();
@@ -43302,7 +43424,7 @@ function listCliAgentCapabilityCacheForWorkspace(db, workspaceId) {
 init_cli_database();
 
 // src/agents/capabilities/probe-one-agent-type-for-capabilities.ts
-import * as path35 from "node:path";
+import * as path37 from "node:path";
 init_cli_database();
 init_cli_process_interrupt();
 async function probeOneAgentTypeForCapabilities(params) {
@@ -43342,7 +43464,7 @@ async function probeOneAgentTypeForCapabilities(params) {
     if (!canContinue()) return false;
     handle = await resolved.createClient({
       command: resolved.command,
-      cwd: path35.resolve(cwd),
+      cwd: path37.resolve(cwd),
       backendAgentType: agentType,
       sessionMode: "agent",
       persistedAcpSessionId: null,
@@ -43435,7 +43557,7 @@ async function warmupAgentCapabilitiesOnConnect(params) {
   const { workspaceId, log: log2, getWs } = params;
   const isCurrent = beginAgentCapabilityWarmupRun();
   if (!isCurrent()) return;
-  const cwd = path36.resolve(getBridgeRoot());
+  const cwd = path38.resolve(getBridgeRoot());
   async function sendBatchFromCache() {
     if (!isCurrent()) return;
     const socket = getWs();
@@ -43562,7 +43684,7 @@ async function createBridgeAccessAndAcp(options) {
 }
 
 // src/connection/create-bridge-preview-stack.ts
-import * as path39 from "node:path";
+import * as path41 from "node:path";
 
 // src/preview-environments/manager/firehose-messages.ts
 function buildFirehoseSnapshotMessage(params) {
@@ -43880,7 +44002,7 @@ function attachChildErrorHandler(d) {
 }
 
 // src/preview-environments/process/wire/handle-exit.ts
-import fs25 from "node:fs";
+import fs27 from "node:fs";
 function logStopLine(d, code, signal) {
   const { title } = d;
   if (signal) {
@@ -43919,7 +44041,7 @@ function attachChildExitHandler(d) {
     const cleanupDir = d.mergedCleanupDir;
     const mergedPath = d.mergedLogPath;
     if (mergedPath && !stale) {
-      fs25.readFile(mergedPath, (err, buf) => {
+      fs27.readFile(mergedPath, (err, buf) => {
         if (!err && buf.length > d.mergedReadPos.value) {
           const chunk = Buffer.from(buf.subarray(d.mergedReadPos.value));
           if (chunk.length > 0) {
@@ -43965,7 +44087,7 @@ function wireChildOutputPipes(d) {
 }
 
 // src/preview-environments/process/wire/poll-merged-log.ts
-import fs26 from "node:fs";
+import fs28 from "node:fs";
 function startMergedLogPoll(d) {
   if (!d.mergedLogPath || !d.mergedCleanupDir) return;
   const { environmentId } = d;
@@ -43975,7 +44097,7 @@ function startMergedLogPoll(d) {
       d.setPollInterval(void 0);
       return;
     }
-    fs26.readFile(d.mergedLogPath, (err, buf) => {
+    fs28.readFile(d.mergedLogPath, (err, buf) => {
       if (err || (d.getSpawnGeneration() ?? 0) !== d.scheduledGen) return;
       if (buf.length <= d.mergedReadPos.value) return;
       const chunk = Buffer.from(buf.subarray(d.mergedReadPos.value));
@@ -44190,7 +44312,7 @@ function previewEnvironmentSpawnOptions(lifecycle = DEFAULT_PREVIEW_ENVIRONMENT_
 }
 
 // src/preview-environments/manager/shell-spawn/utils.ts
-import fs27 from "node:fs";
+import fs29 from "node:fs";
 function mergePreviewEnvironmentSpawnOptions(opts, lifecycle = DEFAULT_PREVIEW_ENVIRONMENT_PROCESS_LIFECYCLE) {
   return { ...opts, ...previewEnvironmentSpawnOptions(lifecycle) };
 }
@@ -44199,7 +44321,7 @@ function isSpawnEbadf(e) {
 }
 function rmDirQuiet(dir) {
   try {
-    fs27.rmSync(dir, { recursive: true, force: true });
+    fs29.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -44207,7 +44329,7 @@ var cachedDevNullReadFd;
 function devNullReadFd() {
   if (cachedDevNullReadFd === void 0) {
     const devPath = process.platform === "win32" ? "nul" : "/dev/null";
-    cachedDevNullReadFd = fs27.openSync(devPath, "r");
+    cachedDevNullReadFd = fs29.openSync(devPath, "r");
   }
   return cachedDevNullReadFd;
 }
@@ -44287,15 +44409,15 @@ function trySpawnShellTruePiped(command, env, cwd, devNullFd, signal, lifecycle)
 
 // src/preview-environments/manager/shell-spawn/try-spawn-merged-log-file.ts
 import { spawn as spawn6 } from "node:child_process";
-import fs28 from "node:fs";
+import fs30 from "node:fs";
 import { tmpdir } from "node:os";
-import path37 from "node:path";
+import path39 from "node:path";
 function trySpawnMergedLogFile(command, env, cwd, signal, lifecycle) {
-  const tmpRoot = fs28.mkdtempSync(path37.join(tmpdir(), "ba-devsrv-log-"));
-  const logPath = path37.join(tmpRoot, "combined.log");
+  const tmpRoot = fs30.mkdtempSync(path39.join(tmpdir(), "ba-devsrv-log-"));
+  const logPath = path39.join(tmpRoot, "combined.log");
   let logFd;
   try {
-    logFd = fs28.openSync(logPath, "a");
+    logFd = fs30.openSync(logPath, "a");
   } catch {
     rmDirQuiet(tmpRoot);
     return null;
@@ -44319,7 +44441,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal, lifecycle) {
         mergePreviewEnvironmentSpawnOptions({ env, cwd, stdio, ...signal ? { signal } : {} }, lifecycle)
       );
     }
-    fs28.closeSync(logFd);
+    fs30.closeSync(logFd);
     return {
       proc,
       pipedStdoutStderr: true,
@@ -44328,7 +44450,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal, lifecycle) {
     };
   } catch (e) {
     try {
-      fs28.closeSync(logFd);
+      fs30.closeSync(logFd);
     } catch {
     }
     rmDirQuiet(tmpRoot);
@@ -44339,22 +44461,22 @@ function trySpawnMergedLogFile(command, env, cwd, signal, lifecycle) {
 
 // src/preview-environments/manager/shell-spawn/try-spawn-shell-script-log-redirect.ts
 import { spawn as spawn7 } from "node:child_process";
-import fs29 from "node:fs";
+import fs31 from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path38 from "node:path";
+import path40 from "node:path";
 function shSingleQuote(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 function trySpawnShellScriptLogRedirectUnix(command, env, cwd, signal, lifecycle) {
-  const tmpRoot = fs29.mkdtempSync(path38.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path38.join(tmpRoot, "combined.log");
-  const innerPath = path38.join(tmpRoot, "_cmd.sh");
-  const runnerPath = path38.join(tmpRoot, "_run.sh");
+  const tmpRoot = fs31.mkdtempSync(path40.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path40.join(tmpRoot, "combined.log");
+  const innerPath = path40.join(tmpRoot, "_cmd.sh");
+  const runnerPath = path40.join(tmpRoot, "_run.sh");
   try {
-    fs29.writeFileSync(innerPath, `#!/bin/sh
+    fs31.writeFileSync(innerPath, `#!/bin/sh
 ${command}
 `);
-    fs29.writeFileSync(
+    fs31.writeFileSync(
       runnerPath,
       `#!/bin/sh
 cd ${shSingleQuote(cwd)}
@@ -44382,13 +44504,13 @@ cd ${shSingleQuote(cwd)}
   }
 }
 function trySpawnShellScriptLogRedirectWin(command, env, cwd, signal, lifecycle) {
-  const tmpRoot = fs29.mkdtempSync(path38.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path38.join(tmpRoot, "combined.log");
-  const runnerPath = path38.join(tmpRoot, "_run.bat");
+  const tmpRoot = fs31.mkdtempSync(path40.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path40.join(tmpRoot, "combined.log");
+  const runnerPath = path40.join(tmpRoot, "_run.bat");
   const q = (p) => `"${p.replace(/"/g, '""')}"`;
   const com = process.env.ComSpec || "cmd.exe";
   try {
-    fs29.writeFileSync(
+    fs31.writeFileSync(
       runnerPath,
       `@ECHO OFF\r
 CD /D ${q(cwd)}\r
@@ -44706,8 +44828,8 @@ function createBridgePreviewStack(options) {
     scheduleInitialIndexBuilds(getBridgeRoot());
   };
   const identifyReportedPaths = {
-    bridgeRootPath: path39.resolve(getBridgeRoot()),
-    worktreesRootPath: path39.resolve(options.worktreesRootPath),
+    bridgeRootPath: path41.resolve(getBridgeRoot()),
+    worktreesRootPath: path41.resolve(options.worktreesRootPath),
     localShortcutPort: 0,
     localShortcutToken: ""
   };
@@ -45670,17 +45792,17 @@ async function yieldSkillDiscoveryWork(entryCount) {
 }
 
 // src/skills/discovery/discover-local-skills.ts
-import fs30 from "node:fs";
-import path40 from "node:path";
+import fs32 from "node:fs";
+import path42 from "node:path";
 function collectSkillFromDir(rel, base, name, seenKeys, out) {
-  const dir = path40.join(base, name);
+  const dir = path42.join(base, name);
   try {
-    if (!fs30.statSync(dir).isDirectory()) return;
+    if (!fs32.statSync(dir).isDirectory()) return;
   } catch {
     return;
   }
-  const skillMd = path40.join(dir, "SKILL.md");
-  if (!fs30.existsSync(skillMd)) return;
+  const skillMd = path42.join(dir, "SKILL.md");
+  if (!fs32.existsSync(skillMd)) return;
   const key = `${rel}/${name}`;
   if (seenKeys.has(key)) return;
   seenKeys.add(key);
@@ -45692,11 +45814,11 @@ async function discoverLocalSkillsAsync(cwd) {
   let work = 0;
   for (const rel of SKILL_DISCOVERY_ROOTS) {
     await yieldSkillDiscoveryWork(++work);
-    const base = path40.join(cwd, rel);
-    if (!fs30.existsSync(base) || !fs30.statSync(base).isDirectory()) continue;
+    const base = path42.join(cwd, rel);
+    if (!fs32.existsSync(base) || !fs32.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs30.readdirSync(base);
+      entries = fs32.readdirSync(base);
     } catch {
       continue;
     }
@@ -45709,16 +45831,16 @@ async function discoverLocalSkillsAsync(cwd) {
 }
 
 // src/skills/discovery/discover-skill-layout-roots.ts
-import fs31 from "node:fs";
-import path41 from "node:path";
+import fs33 from "node:fs";
+import path43 from "node:path";
 function collectLayoutSkill(rel, base, name, skills2) {
-  const dir = path41.join(base, name);
+  const dir = path43.join(base, name);
   try {
-    if (!fs31.statSync(dir).isDirectory()) return;
+    if (!fs33.statSync(dir).isDirectory()) return;
   } catch {
     return;
   }
-  if (!fs31.existsSync(path41.join(dir, "SKILL.md"))) return;
+  if (!fs33.existsSync(path43.join(dir, "SKILL.md"))) return;
   const relPath = `${rel}/${name}`.replace(/\\/g, "/");
   skills2.push({ name, relPath });
 }
@@ -45727,11 +45849,11 @@ async function discoverSkillLayoutRootsAsync(cwd) {
   let work = 0;
   for (const rel of SKILL_DISCOVERY_ROOTS) {
     await yieldSkillDiscoveryWork(++work);
-    const base = path41.join(cwd, rel);
-    if (!fs31.existsSync(base) || !fs31.statSync(base).isDirectory()) continue;
+    const base = path43.join(cwd, rel);
+    if (!fs33.existsSync(base) || !fs33.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs31.readdirSync(base);
+      entries = fs33.readdirSync(base);
     } catch {
       continue;
     }
@@ -45878,12 +46000,12 @@ function createBridgeRuntimeMessageSetup(options) {
 }
 
 // src/worktrees/worktree-layout-file.ts
-import * as fs32 from "node:fs";
-import * as path42 from "node:path";
-import os8 from "node:os";
+import * as fs34 from "node:fs";
+import * as path44 from "node:path";
+import os9 from "node:os";
 var LAYOUT_FILENAME = "worktree-launcher-layout.json";
 function defaultWorktreeLayoutPath() {
-  return path42.join(os8.homedir(), ".buildautomaton", LAYOUT_FILENAME);
+  return path44.join(os9.homedir(), ".buildautomaton", LAYOUT_FILENAME);
 }
 function normalizeLoadedLayout(raw) {
   if (raw && typeof raw === "object" && "launcherCwds" in raw) {
@@ -45895,8 +46017,8 @@ function normalizeLoadedLayout(raw) {
 function loadWorktreeLayout() {
   try {
     const p = defaultWorktreeLayoutPath();
-    if (!fs32.existsSync(p)) return { launcherCwds: [] };
-    const raw = JSON.parse(fs32.readFileSync(p, "utf8"));
+    if (!fs34.existsSync(p)) return { launcherCwds: [] };
+    const raw = JSON.parse(fs34.readFileSync(p, "utf8"));
     return normalizeLoadedLayout(raw);
   } catch {
     return { launcherCwds: [] };
@@ -45904,24 +46026,24 @@ function loadWorktreeLayout() {
 }
 function saveWorktreeLayout(layout) {
   try {
-    const dir = path42.dirname(defaultWorktreeLayoutPath());
-    fs32.mkdirSync(dir, { recursive: true });
-    fs32.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
+    const dir = path44.dirname(defaultWorktreeLayoutPath());
+    fs34.mkdirSync(dir, { recursive: true });
+    fs34.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
   } catch {
   }
 }
 function baseNameSafe(pathString) {
-  return path42.basename(pathString).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
+  return path44.basename(pathString).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
 }
 function getLauncherDirNameIfPresent(layout, bridgeRootPath2) {
-  const norm = path42.resolve(bridgeRootPath2);
-  const existing = layout.launcherCwds.find((e) => path42.resolve(e.absolutePath) === norm);
+  const norm = path44.resolve(bridgeRootPath2);
+  const existing = layout.launcherCwds.find((e) => path44.resolve(e.absolutePath) === norm);
   return existing?.dirName;
 }
 function allocateDirNameForLauncherCwd(layout, bridgeRootPath2) {
   const existing = getLauncherDirNameIfPresent(layout, bridgeRootPath2);
   if (existing) return existing;
-  const norm = path42.resolve(bridgeRootPath2);
+  const norm = path44.resolve(bridgeRootPath2);
   const base = baseNameSafe(norm);
   const used = new Set(layout.launcherCwds.map((e) => e.dirName));
   let name = base;
@@ -46014,8 +46136,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path88) {
-  return path88 instanceof String && cache.has(path88);
+function isPathSpec(path90) {
+  return path90 instanceof String && cache.has(path90);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -46104,8 +46226,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path88) {
-  return (0, import_file_exists.exists)(path88, import_file_exists.FOLDER);
+function folderExists(path90) {
+  return (0, import_file_exists.exists)(path90, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -46509,8 +46631,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path88) {
-      return /^\.(git)?$/.test(path88.trim());
+    parser(path90) {
+      return /^\.(git)?$/.test(path90.trim());
     }
   };
 }
@@ -46944,11 +47066,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path88, line, preview] = input.split(NULL);
-    paths.add(path88);
-    (results[path88] = results[path88] || []).push({
+    const [path90, line, preview] = input.split(NULL);
+    paths.add(path90);
+    (results[path90] = results[path90] || []).push({
       line: asNumber(line),
-      path: path88,
+      path: path90,
       preview
     });
   });
@@ -47713,14 +47835,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path88, text) {
+function parseInit(bare, path90, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path88, false, result[1]);
+    return new InitSummary(bare, path90, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path88, true, result[1]);
+    return new InitSummary(bare, path90, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -47731,7 +47853,7 @@ function parseInit(bare, path88, text) {
       break;
     }
   }
-  return new InitSummary(bare, path88, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path90, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -47740,9 +47862,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path88, existing, gitDir) {
+      constructor(bare, path90, existing, gitDir) {
         this.bare = bare;
-        this.path = path88;
+        this.path = path90;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -47754,7 +47876,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path88, customArgs) {
+function initTask(bare = false, path90, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -47763,7 +47885,7 @@ function initTask(bare = false, path88, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path88, text);
+      return parseInit(commands.includes("--bare"), path90, text);
     }
   };
 }
@@ -48579,12 +48701,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path88, index, working_dir) {
-        this.path = path88;
+      constructor(path90, index, working_dir) {
+        this.path = path90;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path88) || [null, path88, path88];
+          const detail = fromPathRegex.exec(path90) || [null, path90, path90];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -48615,14 +48737,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path88) {
+  function data(index, workingDir, path90) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path88);
+      handler(result, path90);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path88, index, workingDir));
+      result.files.push(new FileStatusSummary(path90, index, workingDir));
     }
   }
 }
@@ -48931,9 +49053,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path88, write) {
+      hashObject(path90, write) {
         return this._runTask(
-          hashObjectTask(path88, write === true),
+          hashObjectTask(path90, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -49286,8 +49408,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path88 = input.trim().replace(/^["']|["']$/g, "");
-  return path88 && normalize3(path88);
+  const path90 = input.trim().replace(/^["']|["']$/g, "");
+  return path90 && normalize3(path90);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -49601,8 +49723,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path88) {
-  return subModuleTask(["add", repo, path88]);
+function addSubModuleTask(repo, path90) {
+  return subModuleTask(["add", repo, path90]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -49935,8 +50057,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path88, then) {
-      return this._runTask(addSubModuleTask2(repo, path88), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path90, then) {
+      return this._runTask(addSubModuleTask2(repo, path90), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -50675,8 +50797,8 @@ function parseNumstatEntries(lines) {
 }
 function parseNumstat(lines) {
   const m = /* @__PURE__ */ new Map();
-  for (const [path88, entry] of parseNumstatEntries(lines)) {
-    m.set(path88, { additions: entry.additions, deletions: entry.deletions });
+  for (const [path90, entry] of parseNumstatEntries(lines)) {
+    m.set(path90, { additions: entry.additions, deletions: entry.deletions });
   }
   return m;
 }
@@ -50805,7 +50927,7 @@ async function resolveDefaultRemoteBranchSha(g, remote) {
 }
 
 // src/git/commits/remote-tracking/resolve-base-sha-for-unpushed-commits.ts
-import * as path43 from "node:path";
+import * as path45 from "node:path";
 var BASE_SHA_CACHE_TTL_MS = 3e4;
 var baseShaCache = /* @__PURE__ */ new Map();
 async function resolveBaseShaForUnpushedCommitsUncached(g) {
@@ -50816,7 +50938,7 @@ async function resolveBaseShaForUnpushedCommitsUncached(g) {
 }
 async function resolveBaseShaForUnpushedCommits(g, repoDir) {
   if (repoDir) {
-    const key = path43.resolve(repoDir);
+    const key = path45.resolve(repoDir);
     const now = Date.now();
     const cached2 = baseShaCache.get(key);
     if (cached2 && cached2.expiresAt > now) return cached2.baseSha;
@@ -50951,17 +51073,17 @@ function formatRemoteDisplayLabel(remoteUrl) {
 }
 
 // src/git/changes/repo/get-working-tree-change-repo-details.ts
-import * as path53 from "node:path";
+import * as path55 from "node:path";
 
 // src/git/changes/repo/build-working-tree-change-repo-detail.ts
-import * as path52 from "node:path";
+import * as path54 from "node:path";
 
 // src/git/is-git-repo.ts
-import * as fs33 from "node:fs";
-import * as path44 from "node:path";
+import * as fs35 from "node:fs";
+import * as path46 from "node:path";
 async function isGitRepoDirectory(dirPath) {
   try {
-    await fs33.promises.access(path44.join(dirPath, ".git"));
+    await fs35.promises.access(path46.join(dirPath, ".git"));
     return true;
   } catch {
     return false;
@@ -50969,8 +51091,8 @@ async function isGitRepoDirectory(dirPath) {
 }
 
 // src/git/changes/listing/apply-untracked-file-stats.ts
-import * as fs34 from "node:fs";
-import * as path45 from "node:path";
+import * as fs36 from "node:fs";
+import * as path47 from "node:path";
 
 // src/git/changes/lines/count-lines.ts
 import { createReadStream } from "node:fs";
@@ -51002,7 +51124,7 @@ function createUntrackedStatsApplier(options) {
     if (!options.untrackedSet.has(pathInRepo)) return;
     if (options.nameByPath.has(pathInRepo)) return;
     if (row.change === "moved") return;
-    const repoFilePath = path45.join(options.repoGitCwd, pathInRepo);
+    const repoFilePath = path47.join(options.repoGitCwd, pathInRepo);
     const fromGit = await numstatFromGitNoIndex(options.g, pathInRepo);
     if (fromGit) {
       row.additions = fromGit.additions;
@@ -51010,7 +51132,7 @@ function createUntrackedStatsApplier(options) {
       return;
     }
     try {
-      const st = await fs34.promises.stat(repoFilePath);
+      const st = await fs36.promises.stat(repoFilePath);
       row.additions = st.isFile() ? await countTextFileLines(repoFilePath) : 0;
     } catch {
       row.additions = 0;
@@ -51087,7 +51209,7 @@ async function buildChangedFileRowsFromPaths(options) {
 }
 
 // src/git/changes/listing/enrich-working-tree-file-rows.ts
-import * as path47 from "node:path";
+import * as path49 from "node:path";
 
 // src/git/changes/patch/patch-truncate.ts
 function truncatePatch(s) {
@@ -51175,10 +51297,10 @@ async function readGitBlobLines(repoCwd, pathInRepo) {
 }
 
 // src/git/changes/patch/hydrate/read-worktree-file-lines.ts
-import * as fs35 from "node:fs";
+import * as fs37 from "node:fs";
 async function readWorktreeFileLines(filePath) {
   try {
-    const raw = await fs35.promises.readFile(filePath, "utf8");
+    const raw = await fs37.promises.readFile(filePath, "utf8");
     return raw.split(/\r?\n/);
   } catch {
     return null;
@@ -51316,8 +51438,8 @@ async function unifiedDiffForFileInRange(repoCwd, range, pathInRepo, change, mov
 }
 
 // src/git/changes/total-lines/resolve-changed-file-total-lines.ts
-import * as fs36 from "node:fs";
-import * as path46 from "node:path";
+import * as fs38 from "node:fs";
+import * as path48 from "node:path";
 var MAX_BYTES = 512e3;
 async function countLinesInGitRef(repoGitCwd, ref, pathInRepo) {
   const spec = `${ref}:${pathInRepo}`;
@@ -51337,13 +51459,13 @@ async function countLinesInGitRef(repoGitCwd, ref, pathInRepo) {
 }
 async function resolveWorkingTreeFileTotalLines(options) {
   if (options.isBinary) return null;
-  const filePath = path46.join(options.repoGitCwd, options.pathInRepo);
+  const filePath = path48.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 fs36.promises.stat(filePath);
+      const st = await fs38.promises.stat(filePath);
       if (!st.isFile()) return null;
       return await countTextFileLines(filePath);
     } catch {
@@ -51386,7 +51508,7 @@ async function enrichWorkingTreeFileRows(options) {
       row.workspaceRelPath,
       options.repoPathRelativeToWorkspaceRoot
     );
-    const filePath = path47.join(options.repoGitCwd, filePathRelativeToRepoRoot);
+    const filePath = path49.join(options.repoGitCwd, filePathRelativeToRepoRoot);
     const hydrateKind = row.change === "moved" ? "modified" : row.change;
     let patch = await unifiedDiffForFile(
       options.repoGitCwd,
@@ -51544,7 +51666,7 @@ async function listChangedFilesForRepo(repoGitCwd, repoPathRelativeToWorkspaceRo
 }
 
 // src/git/changes/listing/list-changed-files-for-commit.ts
-import * as path48 from "node:path";
+import * as path50 from "node:path";
 
 // src/git/changes/listing/enrich-commit-file-rows.ts
 async function enrichCommitFileRows(options) {
@@ -51589,7 +51711,7 @@ async function parentForCommitDiff(g, sha) {
 var COMMIT_FILES_CACHE_TTL_MS = 5 * 6e4;
 var commitFilesCache = /* @__PURE__ */ new Map();
 function commitFilesCacheKey(repoGitCwd, commitSha) {
-  return `${path48.resolve(repoGitCwd)}:${commitSha}`;
+  return `${path50.resolve(repoGitCwd)}:${commitSha}`;
 }
 async function listChangedFilesForCommit(repoGitCwd, repoPathRelativeToWorkspaceRoot, commitSha, options = {}) {
   const cacheKey = commitFilesCacheKey(repoGitCwd, commitSha);
@@ -51644,7 +51766,7 @@ async function listChangedFilesForCommit(repoGitCwd, repoPathRelativeToWorkspace
 }
 
 // src/git/commits/list-unpushed-commits.ts
-import * as path49 from "node:path";
+import * as path51 from "node:path";
 
 // src/git/commits/lib/parse-log-lines.ts
 function parseLogShaDateSubjectLines(raw) {
@@ -51679,7 +51801,7 @@ async function gitLogNotReachableFromBase(g, baseSha, headSha) {
   }
 }
 async function listUnpushedCommits(repoDir) {
-  const key = path49.resolve(repoDir);
+  const key = path51.resolve(repoDir);
   const now = Date.now();
   const cached2 = unpushedCache.get(key);
   if (cached2 && cached2.expiresAt > now) return cached2.commits;
@@ -51740,7 +51862,7 @@ async function loadRecentAndUnpushedCommitsForRepoDetail(repoDir, recentCommitsL
 }
 
 // src/git/changes/repo/load-working-tree-change-repo-git-info.ts
-import * as path50 from "node:path";
+import * as path52 from "node:path";
 
 // src/git/remote-origin-url.ts
 async function getRemoteOriginUrl(gitDir) {
@@ -51755,7 +51877,7 @@ async function getRemoteOriginUrl(gitDir) {
 
 // src/git/changes/repo/load-working-tree-change-repo-git-info.ts
 async function loadWorkingTreeChangeRepoGitInfo(checkoutPath) {
-  const resolvedCheckoutPath = path50.resolve(checkoutPath);
+  const resolvedCheckoutPath = path52.resolve(checkoutPath);
   const git = cliSimpleGit(resolvedCheckoutPath);
   await yieldToEventLoop2();
   const [branch, remoteUrl] = await Promise.all([
@@ -51770,14 +51892,14 @@ async function loadWorkingTreeChangeRepoGitInfo(checkoutPath) {
 }
 
 // src/git/changes/repo/resolve-repo-path-relative-to-workspace-root.ts
-import * as path51 from "node:path";
+import * as path53 from "node:path";
 async function resolveRepoPathRelativeToWorkspaceRoot(options) {
-  const checkoutPath = path51.resolve(options.checkoutPath);
+  const checkoutPath = path53.resolve(options.checkoutPath);
   const git = cliSimpleGit(checkoutPath);
-  const sessionParentPath = options.sessionParentPath ? path51.resolve(options.sessionParentPath) : null;
+  const sessionParentPath = options.sessionParentPath ? path53.resolve(options.sessionParentPath) : null;
   let repoPathRelativeToWorkspaceRoot;
   if (sessionParentPath) {
-    const checkoutPathRelativeToSessionParent = path51.relative(sessionParentPath, checkoutPath);
+    const checkoutPathRelativeToSessionParent = path53.relative(sessionParentPath, checkoutPath);
     repoPathRelativeToWorkspaceRoot = checkoutPathRelativeToSessionParent === "" ? "." : checkoutPathRelativeToSessionParent.replace(/\\/g, "/");
   } else {
     let gitTopLevel = checkoutPath;
@@ -51787,8 +51909,8 @@ async function resolveRepoPathRelativeToWorkspaceRoot(options) {
     } catch {
       gitTopLevel = checkoutPath;
     }
-    const gitTopLevelRelativeToBridgeRoot = path51.relative(options.bridgeRoot, path51.resolve(gitTopLevel)).replace(/\\/g, "/") || ".";
-    repoPathRelativeToWorkspaceRoot = gitTopLevelRelativeToBridgeRoot.startsWith("..") ? path51.basename(path51.resolve(gitTopLevel)) : gitTopLevelRelativeToBridgeRoot;
+    const gitTopLevelRelativeToBridgeRoot = path53.relative(options.bridgeRoot, path53.resolve(gitTopLevel)).replace(/\\/g, "/") || ".";
+    repoPathRelativeToWorkspaceRoot = gitTopLevelRelativeToBridgeRoot.startsWith("..") ? path53.basename(path53.resolve(gitTopLevel)) : gitTopLevelRelativeToBridgeRoot;
   }
   return normalizeRepoPathRelativeToWorkspaceRoot(
     repoPathRelativeToWorkspaceRoot === "" ? "." : repoPathRelativeToWorkspaceRoot
@@ -51797,10 +51919,10 @@ async function resolveRepoPathRelativeToWorkspaceRoot(options) {
 
 // src/git/changes/repo/build-working-tree-change-repo-detail.ts
 async function buildWorkingTreeChangeRepoDetail(options) {
-  const checkoutPath = path52.resolve(options.targetPath);
+  const checkoutPath = path54.resolve(options.targetPath);
   if (!await isGitRepoDirectory(checkoutPath)) return null;
   const isCommitView = options.basis.kind === "commit";
-  const sessionParentPath = options.sessionParentPath ? path52.resolve(options.sessionParentPath) : null;
+  const sessionParentPath = options.sessionParentPath ? path54.resolve(options.sessionParentPath) : null;
   const git = cliSimpleGit(checkoutPath);
   const repoPathRelativeToWorkspaceRoot = await resolveRepoPathRelativeToWorkspaceRoot({
     checkoutPath,
@@ -51848,8 +51970,8 @@ async function buildWorkingTreeChangeRepoDetail(options) {
 
 // src/git/changes/repo/get-working-tree-change-repo-details.ts
 async function getWorkingTreeChangeRepoDetails(options) {
-  const bridgeRoot = path53.resolve(getBridgeRoot());
-  const sessionParentPath = options.sessionParentPath ? path53.resolve(options.sessionParentPath) : null;
+  const bridgeRoot = path55.resolve(getBridgeRoot());
+  const sessionParentPath = options.sessionParentPath ? path55.resolve(options.sessionParentPath) : null;
   const out = [];
   const filter = options.repoFilterRelPath != null ? normalizeRepoPathRelativeToWorkspaceRoot(options.repoFilterRelPath) : null;
   const basisInput = options.basis ?? { kind: "working" };
@@ -51880,9 +52002,9 @@ async function getWorkingTreeChangeRepoDetails(options) {
 }
 
 // src/git/changes/repo/get-working-tree-change-file-patch.ts
-import * as path54 from "node:path";
+import * as path56 from "node:path";
 async function getWorkingTreeChangeFilePatch(options) {
-  const repoGitCwd = path54.resolve(options.repoGitCwd);
+  const repoGitCwd = path56.resolve(options.repoGitCwd);
   if (!await isGitRepoDirectory(repoGitCwd)) {
     throw new Error("Not a git repository");
   }
@@ -51921,7 +52043,7 @@ async function getWorkingTreeChangeFilePatch(options) {
     });
     return { patchContent: patchContent2, totalLines: totalLines2 };
   }
-  const filePath = path54.join(repoGitCwd, filePathRelativeToRepoRoot);
+  const filePath = path56.join(repoGitCwd, filePathRelativeToRepoRoot);
   const hydrateKind = options.change === "moved" ? "modified" : options.change;
   let patchContent = await unifiedDiffForFile(
     repoGitCwd,
@@ -51967,18 +52089,18 @@ function parseWorkingTreeChangeKind(value) {
 }
 
 // src/worktrees/manager/git/get-session-working-tree-change-file-patch.ts
-import * as path55 from "node:path";
+import * as path57 from "node:path";
 async function getSessionWorkingTreeChangeFilePatch(cache2, sessionId, discover, opts) {
   const targets = await resolveCommitTargetsAsync(sessionId, cache2, discover);
-  const bridgeRoot = path55.resolve(getBridgeRoot());
-  const sessionParentPath = cache2.getSessionParentPath(sessionId) ? path55.resolve(cache2.getSessionParentPath(sessionId)) : null;
+  const bridgeRoot = path57.resolve(getBridgeRoot());
+  const sessionParentPath = cache2.getSessionParentPath(sessionId) ? path57.resolve(cache2.getSessionParentPath(sessionId)) : null;
   const repoPathRelativeToWorkspaceRootFilter = normalizeRepoPathRelativeToWorkspaceRoot(
     opts.repoRelPath.trim()
   );
   let result = null;
   await forEachWithGitYield(targets, async (targetPath) => {
     if (result) return;
-    const checkoutPath = path55.resolve(targetPath);
+    const checkoutPath = path57.resolve(targetPath);
     if (!await isGitRepoDirectory(checkoutPath)) return;
     const repoPathRelativeToWorkspaceRoot = await resolveRepoPathRelativeToWorkspaceRoot({
       checkoutPath,
@@ -52011,13 +52133,13 @@ async function pushSessionUpstream(cache2, sessionId, discover) {
 }
 
 // src/worktrees/remove-session-worktrees.ts
-import * as fs39 from "node:fs";
+import * as fs41 from "node:fs";
 
 // src/git/worktrees/worktree-remove.ts
-import * as fs38 from "node:fs";
+import * as fs40 from "node:fs";
 
 // src/worktrees/is-removable-session-worktree-checkout-path.ts
-import path56 from "node:path";
+import path58 from "node:path";
 init_normalize_resolved_path();
 function isBridgeRootCheckoutPath(checkoutPath) {
   return normalizeResolvedPath(checkoutPath) === normalizeResolvedPath(getBridgeRoot());
@@ -52026,23 +52148,23 @@ function isRemovableSessionWorktreeCheckoutPath(checkoutPath, worktreesRootPath)
   if (isBridgeRootCheckoutPath(checkoutPath)) return false;
   const normalized = normalizeResolvedPath(checkoutPath);
   const worktreesRoot = normalizeResolvedPath(worktreesRootPath);
-  const rel = path56.relative(worktreesRoot, normalized);
-  if (rel === "" || rel.startsWith("..") || path56.isAbsolute(rel)) return false;
+  const rel = path58.relative(worktreesRoot, normalized);
+  if (rel === "" || rel.startsWith("..") || path58.isAbsolute(rel)) return false;
   return true;
 }
 
 // src/git/worktrees/resolve-main-repo-from-git-file.ts
-import * as fs37 from "node:fs";
-import * as path57 from "node:path";
+import * as fs39 from "node:fs";
+import * as path59 from "node:path";
 function resolveMainRepoFromWorktreeGitFile(wt) {
-  const gitDirFile = path57.join(wt, ".git");
-  if (!fs37.existsSync(gitDirFile) || !fs37.statSync(gitDirFile).isFile()) return "";
-  const first2 = fs37.readFileSync(gitDirFile, "utf8").trim();
+  const gitDirFile = path59.join(wt, ".git");
+  if (!fs39.existsSync(gitDirFile) || !fs39.statSync(gitDirFile).isFile()) return "";
+  const first2 = fs39.readFileSync(gitDirFile, "utf8").trim();
   const m = first2.match(/^gitdir:\s*(.+)$/im);
   if (!m) return "";
-  const gitWorktreePath = path57.resolve(wt, m[1].trim());
-  const gitDir = path57.dirname(path57.dirname(gitWorktreePath));
-  return path57.dirname(gitDir);
+  const gitWorktreePath = path59.resolve(wt, m[1].trim());
+  const gitDir = path59.dirname(path59.dirname(gitWorktreePath));
+  return path59.dirname(gitDir);
 }
 
 // src/git/worktrees/worktree-remove.ts
@@ -52053,7 +52175,7 @@ async function gitWorktreeRemoveForce(worktreePath) {
     return true;
   }
   if (isBridgeRootCheckoutPath(worktreePath)) return false;
-  fs38.rmSync(worktreePath, { recursive: true, force: true });
+  fs40.rmSync(worktreePath, { recursive: true, force: true });
   return true;
 }
 
@@ -52075,7 +52197,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 {
-          fs39.rmSync(wt, { recursive: true, force: true });
+          fs41.rmSync(wt, { recursive: true, force: true });
         } catch {
         }
       }
@@ -52131,12 +52253,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 fs43 from "node:fs";
-import * as path62 from "node:path";
+import * as fs45 from "node:fs";
+import * as path64 from "node:path";
 
 // src/worktrees/discovery/collect-worktree-paths.ts
-import * as fs41 from "node:fs";
-import * as path59 from "node:path";
+import * as fs43 from "node:fs";
+import * as path61 from "node:path";
 
 // src/worktrees/discovery/disk-walk-constants.ts
 var DISK_WALK_YIELD_EVERY = 64;
@@ -52166,8 +52288,8 @@ function shouldSkipDiskWalkEntry(name) {
 // src/worktrees/discovery/disk-walk-utils.ts
 init_cli_process_interrupt();
 init_yield_to_event_loop();
-import * as fs40 from "node:fs";
-import * as path58 from "node:path";
+import * as fs42 from "node:fs";
+import * as path60 from "node:path";
 async function yieldDuringDiskWalk(state) {
   state.entries++;
   if (state.entries % DISK_WALK_YIELD_EVERY !== 0) return true;
@@ -52177,7 +52299,7 @@ async function yieldDuringDiskWalk(state) {
 }
 async function isGitDir(dirPath) {
   try {
-    await fs40.promises.access(path58.join(dirPath, ".git"));
+    await fs42.promises.access(path60.join(dirPath, ".git"));
     return true;
   } catch {
     return false;
@@ -52191,23 +52313,23 @@ async function collectGitRepoRootsUnderDirectory(rootPath) {
   const walk = async (dir) => {
     if (!await yieldDuringDiskWalk(state)) return;
     if (await isGitDir(dir)) {
-      out.push(path59.resolve(dir));
+      out.push(path61.resolve(dir));
       return;
     }
     let entries;
     try {
-      entries = await fs41.promises.readdir(dir, { withFileTypes: true });
+      entries = await fs43.promises.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (shouldSkipDiskWalkEntry(e.name)) continue;
-      const full = path59.join(dir, e.name);
+      const full = path61.join(dir, e.name);
       if (!e.isDirectory()) continue;
       await walk(full);
     }
   };
-  await walk(path59.resolve(rootPath));
+  await walk(path61.resolve(rootPath));
   return { paths: [...new Set(out)], entriesVisited: state.entries };
 }
 async function collectWorktreeRootsNamed(root, sessionId, maxDepth = LEGACY_WALK_MAX_DEPTH) {
@@ -52218,16 +52340,16 @@ async function collectWorktreeRootsNamed(root, sessionId, maxDepth = LEGACY_WALK
     if (!await yieldDuringDiskWalk(state)) return;
     let entries;
     try {
-      entries = await fs41.promises.readdir(dir, { withFileTypes: true });
+      entries = await fs43.promises.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (shouldSkipDiskWalkEntry(e.name)) continue;
-      const full = path59.join(dir, e.name);
+      const full = path61.join(dir, e.name);
       if (!e.isDirectory()) continue;
       if (e.name === sessionId) {
-        if (await isGitDir(full)) out.push(path59.resolve(full));
+        if (await isGitDir(full)) out.push(path61.resolve(full));
         continue;
       }
       if (await isGitDir(full)) continue;
@@ -52239,14 +52361,14 @@ async function collectWorktreeRootsNamed(root, sessionId, maxDepth = LEGACY_WALK
 }
 
 // src/worktrees/discovery/layout-keys-for-bridge-root.ts
-import * as path60 from "node:path";
+import * as path62 from "node:path";
 function layoutKeysForBridgeRoot(layout, bridgeRoot, keysOnDisk) {
-  const bridge = path60.resolve(bridgeRoot);
+  const bridge = path62.resolve(bridgeRoot);
   const preferred = getLauncherDirNameIfPresent(layout, bridgeRoot);
   const relevant = layout.launcherCwds.filter((e) => {
-    const entry = path60.resolve(e.absolutePath);
-    return bridge === entry || bridge.startsWith(entry + path60.sep) || entry.startsWith(bridge + path60.sep);
-  }).sort((a, b) => path60.resolve(b.absolutePath).length - path60.resolve(a.absolutePath).length).map((e) => e.dirName).filter((name) => keysOnDisk.includes(name));
+    const entry = path62.resolve(e.absolutePath);
+    return bridge === entry || bridge.startsWith(entry + path62.sep) || entry.startsWith(bridge + path62.sep);
+  }).sort((a, b) => path62.resolve(b.absolutePath).length - path62.resolve(a.absolutePath).length).map((e) => e.dirName).filter((name) => keysOnDisk.includes(name));
   const ordered = [];
   const seen = /* @__PURE__ */ new Set();
   const add = (k) => {
@@ -52264,19 +52386,19 @@ function layoutKeysForBridgeRoot(layout, bridgeRoot, keysOnDisk) {
 }
 
 // src/worktrees/discovery/try-binding-from-isolated-directory.ts
-import * as fs42 from "node:fs";
-import * as path61 from "node:path";
+import * as fs44 from "node:fs";
+import * as path63 from "node:path";
 async function tryBindingFromIsolatedDirectory(scopeDir) {
   let st;
   try {
-    st = await fs42.promises.stat(scopeDir);
+    st = await fs44.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 = path61.resolve(scopeDir);
+  const abs = path63.resolve(scopeDir);
   return {
     parentPath: abs,
     repoCheckoutPaths: worktreePaths
@@ -52299,7 +52421,7 @@ async function discoverSessionWorktreeOnDisk(options) {
   const sid = sessionId.trim();
   if (!sid) return null;
   try {
-    await fs43.promises.access(worktreesRootPath);
+    await fs45.promises.access(worktreesRootPath);
   } catch {
     return null;
   }
@@ -52308,13 +52430,13 @@ async function discoverSessionWorktreeOnDisk(options) {
   if (preferredKey) keysOnDisk.push(preferredKey);
   const scanState = { entries: 0 };
   try {
-    for (const name of await fs43.promises.readdir(worktreesRootPath)) {
+    for (const name of await fs45.promises.readdir(worktreesRootPath)) {
       if (!await yieldDuringDiskWalk(scanState)) break;
       if (name.startsWith(".")) continue;
-      const p = path62.join(worktreesRootPath, name);
+      const p = path64.join(worktreesRootPath, name);
       let st;
       try {
-        st = await fs43.promises.stat(p);
+        st = await fs45.promises.stat(p);
       } catch {
         continue;
       }
@@ -52328,23 +52450,23 @@ async function discoverSessionWorktreeOnDisk(options) {
   for (const key of keys) {
     if (isCliImmediateShutdownRequested()) return null;
     await yieldToEventLoop();
-    const layoutRoot = path62.join(worktreesRootPath, key);
+    const layoutRoot = path64.join(worktreesRootPath, key);
     let layoutSt;
     try {
-      layoutSt = await fs43.promises.stat(layoutRoot);
+      layoutSt = await fs45.promises.stat(layoutRoot);
     } catch {
       continue;
     }
     if (!layoutSt.isDirectory()) continue;
-    const sessionDir = path62.join(layoutRoot, sid);
+    const sessionDir = path64.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) ?? path62.resolve(legacy.paths[0]);
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacy.paths) ?? path64.resolve(legacy.paths[0]);
       return {
-        sessionParentPath: path62.resolve(isolated),
-        repoCheckoutPaths: legacy.paths.map((p) => path62.resolve(p))
+        sessionParentPath: path64.resolve(isolated),
+        repoCheckoutPaths: legacy.paths.map((p) => path64.resolve(p))
       };
     }
   }
@@ -52352,31 +52474,31 @@ async function discoverSessionWorktreeOnDisk(options) {
 }
 
 // src/worktrees/discovery/discover-session-worktrees-under-session-worktree-root.ts
-import * as fs44 from "node:fs";
-import * as path64 from "node:path";
+import * as fs46 from "node:fs";
+import * as path66 from "node:path";
 
 // src/worktrees/discovery/discover-legacy-binding-ascending-from-checkout.ts
 init_cli_process_interrupt();
 init_yield_to_event_loop();
-import * as path63 from "node:path";
+import * as path65 from "node:path";
 async function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hintR = path63.resolve(checkoutPath);
+  const hintR = path65.resolve(checkoutPath);
   let best = null;
-  let cur = path63.dirname(hintR);
+  let cur = path65.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) => path63.resolve(p) === hintR)) {
-      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths.paths) ?? path63.resolve(paths.paths[0]);
+    if (paths.paths.some((p) => path65.resolve(p) === hintR)) {
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths.paths) ?? path65.resolve(paths.paths[0]);
       best = {
-        sessionParentPath: path63.resolve(isolated),
-        repoCheckoutPaths: paths.paths.map((p) => path63.resolve(p))
+        sessionParentPath: path65.resolve(isolated),
+        repoCheckoutPaths: paths.paths.map((p) => path65.resolve(p))
       };
     }
-    const next = path63.dirname(cur);
+    const next = path65.dirname(cur);
     if (next === cur) break;
     cur = next;
   }
@@ -52387,12 +52509,12 @@ async function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPat
 async function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionParentPathOrHint, sessionId) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hint = path64.resolve(sessionParentPathOrHint);
-  const underHint = await tryBindingFromSessionDirectory(path64.join(hint, sid));
+  const hint = path66.resolve(sessionParentPathOrHint);
+  const underHint = await tryBindingFromSessionDirectory(path66.join(hint, sid));
   if (underHint) return underHint;
   const direct = await tryBindingFromSessionDirectory(hint);
   if (direct) {
-    if (path64.basename(hint) === sid && await isGitDir(hint)) {
+    if (path66.basename(hint) === sid && await isGitDir(hint)) {
       const legacyFromCheckout = await discoverLegacyBindingAscendingFromCheckout(sid, hint);
       if (legacyFromCheckout && legacyFromCheckout.repoCheckoutPaths.length > direct.repoCheckoutPaths.length) {
         return legacyFromCheckout;
@@ -52400,23 +52522,23 @@ async function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionParentPat
     }
     return direct;
   }
-  if (path64.basename(hint) === sid && await isGitDir(hint)) {
+  if (path66.basename(hint) === sid && await isGitDir(hint)) {
     const legacyFromCheckout = await discoverLegacyBindingAscendingFromCheckout(sid, hint);
     if (legacyFromCheckout) return legacyFromCheckout;
   }
   let st;
   try {
-    st = await fs44.promises.stat(hint);
+    st = await fs46.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) ?? path64.resolve(legacyPaths.paths[0]);
+  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths.paths) ?? path66.resolve(legacyPaths.paths[0]);
   return {
-    sessionParentPath: path64.resolve(isolated),
-    repoCheckoutPaths: legacyPaths.paths.map((p) => path64.resolve(p))
+    sessionParentPath: path66.resolve(isolated),
+    repoCheckoutPaths: legacyPaths.paths.map((p) => path66.resolve(p))
   };
 }
 
@@ -52477,11 +52599,11 @@ function parseSessionParent(v) {
 }
 
 // src/worktrees/prepare/prepare-new-isolated-worktrees.ts
-import * as fs48 from "node:fs";
+import * as fs50 from "node:fs";
 
 // src/git/discover-repos.ts
-import * as fs45 from "node:fs";
-import * as path65 from "node:path";
+import * as fs47 from "node:fs";
+import * as path67 from "node:path";
 init_yield_to_event_loop();
 var GIT_DISCOVER_YIELD_EVERY = 32;
 async function yieldGitDiscoverWork(entryCount) {
@@ -52491,14 +52613,14 @@ async function yieldGitDiscoverWork(entryCount) {
 }
 async function discoverGitRepos(cwd = getBridgeRoot()) {
   const result = [];
-  const cwdResolved = path65.resolve(cwd);
+  const cwdResolved = path67.resolve(cwd);
   if (await isGitRepoDirectory(cwdResolved)) {
     const remoteUrl = await getRemoteOriginUrl(cwdResolved);
     result.push({ absolutePath: cwdResolved, remoteUrl });
   }
   let entries;
   try {
-    entries = fs45.readdirSync(cwdResolved, { withFileTypes: true });
+    entries = fs47.readdirSync(cwdResolved, { withFileTypes: true });
   } catch {
     return result;
   }
@@ -52506,7 +52628,7 @@ async function discoverGitRepos(cwd = getBridgeRoot()) {
     await yieldGitDiscoverWork(i + 1);
     const ent = entries[i];
     if (!ent.isDirectory()) continue;
-    const childPath2 = path65.join(cwdResolved, ent.name);
+    const childPath2 = path67.join(cwdResolved, ent.name);
     if (await isGitRepoDirectory(childPath2)) {
       const remoteUrl = await getRemoteOriginUrl(childPath2);
       result.push({ absolutePath: childPath2, remoteUrl });
@@ -52515,17 +52637,17 @@ async function discoverGitRepos(cwd = getBridgeRoot()) {
   return result;
 }
 async function discoverGitReposUnderRoot(rootPath) {
-  const root = path65.resolve(rootPath);
+  const root = path67.resolve(rootPath);
   const roots = [];
   let walkEntries = 0;
   async function walk(dir) {
     if (await isGitRepoDirectory(dir)) {
-      roots.push(path65.resolve(dir));
+      roots.push(path67.resolve(dir));
       return;
     }
     let entries;
     try {
-      entries = fs45.readdirSync(dir, { withFileTypes: true });
+      entries = fs47.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -52533,7 +52655,7 @@ async function discoverGitReposUnderRoot(rootPath) {
       await yieldGitDiscoverWork(++walkEntries);
       const ent = entries[i];
       if (!ent.isDirectory() || ent.name === ".git") continue;
-      await walk(path65.join(dir, ent.name));
+      await walk(path67.join(dir, ent.name));
     }
   }
   await walk(root);
@@ -52549,8 +52671,8 @@ async function discoverGitReposUnderRoot(rootPath) {
 }
 
 // src/worktrees/prepare/add-isolated-repo-worktree.ts
-import * as fs47 from "node:fs";
-import * as path67 from "node:path";
+import * as fs49 from "node:fs";
+import * as path69 from "node:path";
 
 // src/git/worktrees/worktree-add.ts
 async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch, baseRef = "HEAD") {
@@ -52566,8 +52688,8 @@ async function gitWorktreeAddExistingBranch(mainRepoPath, worktreePath, branch)
 }
 
 // src/worktrees/prepare/copy-bridge-files-along-worktree-path.ts
-import * as fs46 from "node:fs";
-import * as path66 from "node:path";
+import * as fs48 from "node:fs";
+import * as path68 from "node:path";
 var BRIDGE_FILES_ALONG_WORKTREE_PATH = ["AGENTS.md"];
 function copyBridgeFilesAlongWorktreePath(options) {
   const { bridgeRoot, scopeDir, repoPathRelativeToBridgeRoot, log: log2 } = options;
@@ -52576,19 +52698,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 ? path66.join(bridgeRoot, prefix) : bridgeRoot;
-    const destDir = prefix ? path66.join(scopeDir, prefix) : scopeDir;
+    const bridgeDir = prefix ? path68.join(bridgeRoot, prefix) : bridgeRoot;
+    const destDir = prefix ? path68.join(scopeDir, prefix) : scopeDir;
     for (const fileName of fileNames) {
       copyFileIfPresent(bridgeDir, destDir, fileName, log2);
     }
   }
 }
 function copyFileIfPresent(srcDir, destDir, fileName, log2) {
-  const src = path66.join(srcDir, fileName);
-  if (!fs46.existsSync(src)) return;
-  const dest = path66.join(destDir, fileName);
+  const src = path68.join(srcDir, fileName);
+  if (!fs48.existsSync(src)) return;
+  const dest = path68.join(destDir, fileName);
   try {
-    fs46.copyFileSync(src, dest);
+    fs48.copyFileSync(src, dest);
     log2?.(`[worktrees] Copied ${fileName} to ${dest}`);
   } catch (e) {
     log2?.(
@@ -52620,16 +52742,16 @@ async function addIsolatedRepoWorktree(options) {
     worktreeBaseBranches,
     log: log2
   } = options;
-  const repoPathRelativeToBridgeRootRaw = path67.relative(bridgeResolved, repoAbsolutePath);
-  if (repoPathRelativeToBridgeRootRaw.startsWith("..") || path67.isAbsolute(repoPathRelativeToBridgeRootRaw)) {
+  const repoPathRelativeToBridgeRootRaw = path69.relative(bridgeResolved, repoAbsolutePath);
+  if (repoPathRelativeToBridgeRootRaw.startsWith("..") || path69.isAbsolute(repoPathRelativeToBridgeRootRaw)) {
     return null;
   }
   const repoPathRelativeToBridgeRoot = normalizeRepoPathRelativeToWorkspaceRoot(
     repoPathRelativeToBridgeRootRaw === "" ? "." : repoPathRelativeToBridgeRootRaw
   );
-  const worktreePath = repoPathRelativeToBridgeRoot === "." ? scopeDir : path67.join(scopeDir, repoPathRelativeToBridgeRoot);
+  const worktreePath = repoPathRelativeToBridgeRoot === "." ? scopeDir : path69.join(scopeDir, repoPathRelativeToBridgeRoot);
   if (repoPathRelativeToBridgeRoot !== ".") {
-    fs47.mkdirSync(path67.dirname(worktreePath), { recursive: true });
+    fs49.mkdirSync(path69.dirname(worktreePath), { recursive: true });
     copyBridgeFilesAlongWorktreePath({
       bridgeRoot: bridgeResolved,
       scopeDir,
@@ -52657,7 +52779,7 @@ async function addIsolatedRepoWorktree(options) {
 }
 
 // src/worktrees/prepare/resolve-isolated-scope-dir.ts
-import * as path68 from "node:path";
+import * as path70 from "node:path";
 
 // src/worktrees/worktree-layout-kind.ts
 function sanitizeWorktreeBranchSegment(value) {
@@ -52687,10 +52809,10 @@ function previewDeployBranchName(environmentId) {
 
 // src/worktrees/prepare/resolve-isolated-scope-dir.ts
 function resolveIsolatedScopeDir(options) {
-  const bridgeResolved = path68.resolve(options.bridgeRoot);
+  const bridgeResolved = path70.resolve(options.bridgeRoot);
   const cwdKey = allocateDirNameForLauncherCwd(options.layout, bridgeResolved);
-  const bridgeKeyDir = path68.join(options.worktreesRootPath, cwdKey);
-  const scopeDir = path68.join(bridgeKeyDir, ...layoutDirSegments(options.kind, options.scopeId));
+  const bridgeKeyDir = path70.join(options.worktreesRootPath, cwdKey);
+  const scopeDir = path70.join(bridgeKeyDir, ...layoutDirSegments(options.kind, options.scopeId));
   return { bridgeResolved, scopeDir };
 }
 
@@ -52720,7 +52842,7 @@ async function prepareNewIsolatedWorktrees(options) {
     return null;
   }
   const worktreePaths = [];
-  fs48.mkdirSync(scopeDir, { recursive: true });
+  fs50.mkdirSync(scopeDir, { recursive: true });
   await forEachWithGitYield(repos, async (repo) => {
     const worktreePath = await addIsolatedRepoWorktree({
       kind,
@@ -52792,10 +52914,10 @@ async function resolveExistingSessionParentPath(sessionId, cache2, discover) {
 }
 
 // src/worktrees/manager/resolve-explicit-session-parent-path.ts
-import * as path69 from "node:path";
+import * as path71 from "node:path";
 init_yield_to_event_loop();
 async function resolveExplicitSessionParentPath(params) {
-  const resolved = path69.resolve(params.parentPathRaw);
+  const resolved = path71.resolve(params.parentPathRaw);
   if (parseSessionParent(params.sessionParent) !== "worktrees_root") {
     return resolved;
   }
@@ -52812,7 +52934,7 @@ async function resolveExplicitSessionParentPath(params) {
     await yieldToEventLoop();
     const tryRoot = await discoverSessionWorktreesUnderSessionWorktreeRoot(cur, params.sessionId);
     if (tryRoot) return rememberAndReturn(tryRoot);
-    const next = path69.dirname(cur);
+    const next = path71.dirname(cur);
     if (next === cur) break;
     cur = next;
   }
@@ -52973,15 +53095,15 @@ var SessionWorktreeManager = class {
 };
 
 // src/worktrees/discovery/discover-preview-worktree-on-disk.ts
-import * as fs49 from "node:fs";
-import * as path70 from "node:path";
+import * as fs51 from "node:fs";
+import * as path72 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 fs49.promises.access(worktreesRootPath);
+    await fs51.promises.access(worktreesRootPath);
   } catch {
     return null;
   }
@@ -52990,13 +53112,13 @@ async function discoverPreviewWorktreeOnDisk(options) {
   if (preferredKey) keysOnDisk.push(preferredKey);
   const scanState = { entries: 0 };
   try {
-    for (const name of await fs49.promises.readdir(worktreesRootPath)) {
+    for (const name of await fs51.promises.readdir(worktreesRootPath)) {
       if (!await yieldDuringDiskWalk(scanState)) break;
       if (name.startsWith(".")) continue;
-      const p = path70.join(worktreesRootPath, name);
+      const p = path72.join(worktreesRootPath, name);
       let st;
       try {
-        st = await fs49.promises.stat(p);
+        st = await fs51.promises.stat(p);
       } catch {
         continue;
       }
@@ -53010,7 +53132,7 @@ async function discoverPreviewWorktreeOnDisk(options) {
   const previewDirRel = layoutDirSegments("preview_environment", eid);
   for (const key of keys) {
     await yieldToEventLoop();
-    const previewDir = path70.join(worktreesRootPath, key, ...previewDirRel);
+    const previewDir = path72.join(worktreesRootPath, key, ...previewDirRel);
     const binding = await tryBindingFromIsolatedDirectory(previewDir);
     if (binding) return binding;
   }
@@ -53137,7 +53259,7 @@ var PreviewWorktreeManager = class {
 };
 
 // src/worktrees/deploy/deploy-session-to-preview-environment.ts
-import * as path74 from "node:path";
+import * as path76 from "node:path";
 
 // src/git/worktrees/reset-worktree-to-branch.ts
 async function gitResetWorktreeToBranch(worktreePath, branch) {
@@ -53148,8 +53270,8 @@ async function gitResetWorktreeToBranch(worktreePath, branch) {
 }
 
 // src/worktrees/deploy/capture-and-apply-wip.ts
-import * as fs50 from "node:fs";
-import * as path71 from "node:path";
+import * as fs52 from "node:fs";
+import * as path73 from "node:path";
 
 // src/git/snapshot/git.ts
 var SNAPSHOT_GIT_TIMEOUT_MS = 5e3;
@@ -53204,12 +53326,12 @@ async function applyWorkingTreeWip(targetRepoPath, sourceRepoPath, wip, log2) {
     if (!ap.ok) return ap;
   }
   await forEachWithGitYield(wip.untrackedPaths, async (rel) => {
-    const src = path71.join(sourceRepoPath, rel);
-    const dst = path71.join(targetRepoPath, rel);
+    const src = path73.join(sourceRepoPath, rel);
+    const dst = path73.join(targetRepoPath, rel);
     try {
-      if (!fs50.existsSync(src)) return;
-      fs50.mkdirSync(path71.dirname(dst), { recursive: true });
-      fs50.copyFileSync(src, dst);
+      if (!fs52.existsSync(src)) return;
+      fs52.mkdirSync(path73.dirname(dst), { recursive: true });
+      fs52.copyFileSync(src, dst);
     } catch (e) {
       log2(
         `[worktrees] Failed to copy untracked ${rel}: ${e instanceof Error ? e.message : String(e)}`
@@ -53220,14 +53342,14 @@ async function applyWorkingTreeWip(targetRepoPath, sourceRepoPath, wip, log2) {
 }
 
 // src/worktrees/deploy/resolve-isolated-checkout-for-repo-path-relative-to-workspace-root.ts
-import * as path72 from "node:path";
+import * as path74 from "node:path";
 async function resolveIsolatedCheckoutForRepoPathRelativeToWorkspaceRoot(options) {
   const { checkoutPaths, sessionParentPath, bridgeRoot, repoPathRelativeToWorkspaceRoot } = options;
-  const resolvedSessionParentPath = sessionParentPath ? path72.resolve(sessionParentPath) : null;
+  const resolvedSessionParentPath = sessionParentPath ? path74.resolve(sessionParentPath) : null;
   let match = null;
   await forEachWithGitYield(checkoutPaths, async (checkoutPath) => {
     if (match) return;
-    const resolvedCheckoutPath = path72.resolve(checkoutPath);
+    const resolvedCheckoutPath = path74.resolve(checkoutPath);
     if (!await isGitRepoDirectory(resolvedCheckoutPath)) return;
     const resolvedRepoPathRelativeToWorkspaceRoot = await resolveRepoPathRelativeToWorkspaceRoot({
       checkoutPath: resolvedCheckoutPath,
@@ -53281,7 +53403,7 @@ async function applySessionWipToPreviewCheckouts(options) {
 }
 
 // src/worktrees/deploy/collect-session-repo-deploy-states.ts
-import * as path73 from "node:path";
+import * as path75 from "node:path";
 
 // src/git/branches/create-or-update-branch.ts
 async function gitCreateOrUpdateBranch(repoPath, branch, startRef, options) {
@@ -53318,19 +53440,19 @@ async function collectSessionRepoDeployStates(options) {
   const sessionParentPath = sessionWorktreeManager.getSessionParentPath(sid);
   const states = [];
   await forEachWithGitYield(sessionTargets, async (sessionCheckout) => {
-    const checkoutPath = path73.resolve(sessionCheckout);
+    const checkoutPath = path75.resolve(sessionCheckout);
     if (!await isGitRepoDirectory(checkoutPath)) return;
     const repoPathRelativeToWorkspaceRoot = await resolveRepoPathRelativeToWorkspaceRoot({
       checkoutPath,
       bridgeRoot,
-      sessionParentPath: sessionParentPath ? path73.resolve(sessionParentPath) : null
+      sessionParentPath: sessionParentPath ? path75.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 ? path73.resolve(previewParentPath) : null,
+      sessionParentPath: previewParentPath ? path75.resolve(previewParentPath) : null,
       bridgeRoot,
       repoPathRelativeToWorkspaceRoot
     }) : null;
@@ -53350,7 +53472,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 = path74.resolve(getBridgeRoot());
+  const bridgeRoot = path76.resolve(getBridgeRoot());
   await previewWorktreeManager.ensureCached(eid);
   const existingPreviewParentPath = previewWorktreeManager.getPreviewParentPath(eid) ?? null;
   const existingPreviewCheckoutPaths = previewWorktreeManager.getRepoCheckoutPaths(eid) ?? [];
@@ -53390,10 +53512,10 @@ async function deploySessionToPreviewEnvironment(options) {
 }
 
 // src/worktrees/manager/default-worktrees-root-path.ts
-import * as path75 from "node:path";
-import os9 from "node:os";
+import * as path77 from "node:path";
+import os10 from "node:os";
 function defaultWorktreesRootPath() {
-  return path75.join(os9.homedir(), ".buildautomaton", "worktrees");
+  return path77.join(os10.homedir(), ".buildautomaton", "worktrees");
 }
 
 // src/connection/create-bridge-worktree-managers.ts
@@ -53523,14 +53645,14 @@ function assertBridgeWorkspace(ctx) {
 }
 
 // src/files/list-dir/index.ts
-import fs52 from "node:fs";
+import fs54 from "node:fs";
 
 // src/files/ensure-under-cwd.ts
-import path76 from "node:path";
+import path78 from "node:path";
 function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
-  const normalized = path76.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path76.resolve(cwd, normalized);
-  if (!resolved.startsWith(cwd + path76.sep) && resolved !== cwd) {
+  const normalized = path78.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path78.resolve(cwd, normalized);
+  if (!resolved.startsWith(cwd + path78.sep) && resolved !== cwd) {
     return null;
   }
   return resolved;
@@ -53543,15 +53665,15 @@ init_yield_to_event_loop();
 var LIST_DIR_YIELD_EVERY = 256;
 
 // src/files/list-dir/map-dir-entry.ts
-import path77 from "node:path";
-import fs51 from "node:fs";
+import path79 from "node:path";
+import fs53 from "node:fs";
 async function mapDirEntry(d, relativePath, resolved) {
-  const entryPath = path77.join(relativePath || ".", d.name).replace(/\\/g, "/");
-  const fullPath = path77.join(resolved, d.name);
+  const entryPath = path79.join(relativePath || ".", d.name).replace(/\\/g, "/");
+  const fullPath = path79.join(resolved, d.name);
   let isDir = d.isDirectory();
   if (d.isSymbolicLink()) {
     try {
-      const targetStat = await fs51.promises.stat(fullPath);
+      const targetStat = await fs53.promises.stat(fullPath);
       isDir = targetStat.isDirectory();
     } catch {
       isDir = false;
@@ -53581,7 +53703,7 @@ async function listDirAsync(relativePath, sessionParentPath = getBridgeRoot()) {
     return { error: "Path is outside working directory" };
   }
   try {
-    const names = await fs52.promises.readdir(resolved, { withFileTypes: true });
+    const names = await fs54.promises.readdir(resolved, { withFileTypes: true });
     const entries = [];
     for (let i = 0; i < names.length; i++) {
       if (i > 0 && i % LIST_DIR_YIELD_EVERY === 0) {
@@ -53597,13 +53719,13 @@ async function listDirAsync(relativePath, sessionParentPath = getBridgeRoot()) {
 }
 
 // src/git/tree/resolve-repo-abs-path.ts
-import * as path78 from "node:path";
+import * as path80 from "node:path";
 function resolveRepoAbsPathFromBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path78.resolve(bridgeRoot);
+  const bridgeResolved = path80.resolve(bridgeRoot);
   const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
-  const repoPath = rel === "" ? bridgeResolved : path78.join(bridgeResolved, rel);
-  const resolved = path78.resolve(repoPath);
-  if (!resolved.startsWith(bridgeResolved + path78.sep) && resolved !== bridgeResolved) {
+  const repoPath = rel === "" ? bridgeResolved : path80.join(bridgeResolved, rel);
+  const resolved = path80.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path80.sep) && resolved !== bridgeResolved) {
     return null;
   }
   return resolved;
@@ -54084,25 +54206,25 @@ async function GET2(ctx) {
 init_in_flight();
 
 // src/files/read/read-file-async.ts
-import fs58 from "node:fs";
+import fs60 from "node:fs";
 init_yield_to_event_loop();
 
 // src/files/read/resolve-file-cache.ts
-import fs53 from "node:fs";
-import path79 from "node:path";
+import fs55 from "node:fs";
+import path81 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 = path79.resolve(sessionParentPath);
-  const resolved = path79.resolve(filePath);
-  return resolved === parent || resolved.startsWith(`${parent}${path79.sep}`);
+  const parent = path81.resolve(sessionParentPath);
+  const resolved = path81.resolve(filePath);
+  return resolved === parent || resolved.startsWith(`${parent}${path81.sep}`);
 }
 function statMatchesCacheSync(entry) {
   try {
-    const stat3 = fs53.statSync(entry.path);
+    const stat3 = fs55.statSync(entry.path);
     return stat3.isFile() && stat3.mtimeMs === entry.mtimeMs && stat3.size === entry.size;
   } catch {
     return false;
@@ -54135,7 +54257,7 @@ function joinInflightResolve(cacheKey, factory) {
 }
 
 // src/files/read/resolve-file-for-read-core.ts
-import fs54 from "node:fs";
+import fs56 from "node:fs";
 import { isMainThread as isMainThread4 } from "node:worker_threads";
 function resolveFileForReadImplSync(relativePath, sessionParentPath) {
   const cacheKey = resolveCacheKey(sessionParentPath, relativePath);
@@ -54145,13 +54267,13 @@ function resolveFileForReadImplSync(relativePath, sessionParentPath) {
   let size;
   let mtimeMs;
   try {
-    const lstat = fs54.lstatSync(resolved);
+    const lstat = fs56.lstatSync(resolved);
     if (lstat.isSymbolicLink()) {
-      real = fs54.realpathSync(resolved);
+      real = fs56.realpathSync(resolved);
       if (!pathStaysUnderParent(real, sessionParentPath)) {
         return { error: "Path is outside working directory" };
       }
-      const stat3 = fs54.statSync(real);
+      const stat3 = fs56.statSync(real);
       if (!stat3.isFile()) return { error: "Not a file" };
       size = stat3.size;
       mtimeMs = stat3.mtimeMs;
@@ -54179,13 +54301,13 @@ async function resolveFileForReadImpl(relativePath, sessionParentPath) {
   let size;
   let mtimeMs;
   try {
-    const lstat = await fs54.promises.lstat(resolved);
+    const lstat = await fs56.promises.lstat(resolved);
     if (lstat.isSymbolicLink()) {
-      real = await fs54.promises.realpath(resolved);
+      real = await fs56.promises.realpath(resolved);
       if (!pathStaysUnderParent(real, sessionParentPath)) {
         return { error: "Path is outside working directory" };
       }
-      const stat3 = await fs54.promises.stat(real);
+      const stat3 = await fs56.promises.stat(real);
       if (!stat3.isFile()) return { error: "Not a file" };
       size = stat3.size;
       mtimeMs = stat3.mtimeMs;
@@ -54234,7 +54356,7 @@ async function resolveFilePathAsync(relativePath, sessionParentPath = getBridgeR
 
 // src/files/read/read-file-range-async.ts
 init_yield_to_event_loop();
-import fs55 from "node:fs";
+import fs57 from "node:fs";
 import { StringDecoder as StringDecoder2 } from "node:string_decoder";
 
 // src/files/read/read-file-range-line-zero.ts
@@ -54348,8 +54470,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 fs55.promises.stat(filePath)).size;
-  const fd = await fs55.promises.open(filePath, "r");
+  const fileSize = fileSizeIn ?? (await fs57.promises.stat(filePath)).size;
+  const fd = await fs57.promises.open(filePath, "r");
   const bufSize = 64 * 1024;
   const buf = Buffer.alloc(bufSize);
   const decoder = new StringDecoder2("utf8");
@@ -54450,7 +54572,7 @@ async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, li
 }
 
 // src/files/read/read-small-file-range-async.ts
-import fs56 from "node:fs";
+import fs58 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) {
@@ -54480,7 +54602,7 @@ function sliceLineRange(lines, startLine, endLine, lineOffsetIn, lineChunkSize,
   };
 }
 function readSmallFileRangeSync(filePath, fileSize, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
-  const raw = fs56.readFileSync(filePath, "utf8");
+  const raw = fs58.readFileSync(filePath, "utf8");
   const lines = raw.split(/\r?\n/);
   return sliceLineRange(lines, startLine, endLine, lineOffsetIn, lineChunkSize, fileSize);
 }
@@ -54488,28 +54610,28 @@ async function readSmallFileRangeAsync(filePath, fileSize, startLine, endLine, l
   if (isMainThread5) {
     return readSmallFileRangeSync(filePath, fileSize, startLine, endLine, lineOffsetIn, lineChunkSize);
   }
-  const raw = await fs56.promises.readFile(filePath, "utf8");
+  const raw = await fs58.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 fs57 from "node:fs";
+import fs59 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 ?? fs57.statSync(filePath).size;
+    const size2 = knownSize ?? fs59.statSync(filePath).size;
     if (size2 <= MAIN_THREAD_SYNC_READ_MAX_BYTES) {
       await yieldToEventLoop();
-      const buffer = fs57.readFileSync(filePath);
+      const buffer = fs59.readFileSync(filePath);
       return { buffer, size: buffer.length };
     }
   }
-  const size = knownSize ?? (await fs57.promises.stat(filePath)).size;
-  const fd = await fs57.promises.open(filePath, "r");
+  const size = knownSize ?? (await fs59.promises.stat(filePath)).size;
+  const fd = await fs59.promises.open(filePath, "r");
   const chunks = [];
   let position = 0;
   let bytesSinceYield = 0;
@@ -54612,7 +54734,7 @@ async function readFileAsync(relativePath, startLine, endLine, lineOffset, lineC
     }
     if (hasRange) {
       if (fileSize == null) {
-        const stat3 = await fs58.promises.stat(resolvedPath);
+        const stat3 = await fs60.promises.stat(resolvedPath);
         fileSize = stat3.size;
       }
       const read2 = fileSize <= SMALL_FILE_RANGE_MAX_BYTES ? await readSmallFileRangeAsync(
@@ -54910,12 +55032,12 @@ function parseOptionalInt2(raw) {
   return Number.isInteger(parsed) ? parsed : void 0;
 }
 function parseCodeNavParams(url2) {
-  const path88 = url2.searchParams.get("path") ?? "";
+  const path90 = 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: path88, op, line, column };
+  return { path: path90, op, line, column };
 }
 function parseCodeNavPath(url2) {
   const raw = url2.searchParams.get("path")?.trim();
@@ -55713,18 +55835,18 @@ function hasRunningTurn(turns) {
 }
 
 // src/prompt-turn-queue/runner/run-local-revert-before-queued-prompt.ts
-import fs61 from "node:fs";
+import fs63 from "node:fs";
 
 // src/git/snapshot/capture.ts
-import * as fs60 from "node:fs";
-import * as path81 from "node:path";
+import * as fs62 from "node:fs";
+import * as path83 from "node:path";
 
 // src/git/snapshot/apply-pre-turn-snapshot.ts
-import * as fs59 from "node:fs";
+import * as fs61 from "node:fs";
 async function applyPreTurnSnapshot(filePath, log2) {
   let data;
   try {
-    data = JSON.parse(fs59.readFileSync(filePath, "utf8"));
+    data = JSON.parse(fs61.readFileSync(filePath, "utf8"));
   } catch (error51) {
     return { ok: false, error: error51 instanceof Error ? error51.message : String(error51) };
   }
@@ -55753,18 +55875,18 @@ async function applyPreTurnSnapshot(filePath, log2) {
 }
 
 // src/git/snapshot/resolve-repo-roots.ts
-import * as path80 from "node:path";
+import * as path82 from "node:path";
 async function resolveSnapshotRepoRoots(options) {
   const { worktreePaths, fallbackCwd, sessionId, log: log2 } = options;
   if (worktreePaths?.length) {
-    const paths = [...new Set(worktreePaths.map((p) => path80.resolve(p)))];
+    const paths = [...new Set(worktreePaths.map((p) => path82.resolve(p)))];
     return (await Promise.all(paths.map(async (p) => await isGitRepoDirectory(p) ? p : null))).filter((p) => p != null);
   }
   try {
     const roots = (await discoverGitReposUnderRoot(fallbackCwd)).map((repo) => repo.absolutePath);
     const sid = sessionId?.trim();
     if (!sid) return roots;
-    const sessionRoots = roots.filter((root) => path80.basename(root) === sid);
+    const sessionRoots = roots.filter((root) => path82.basename(root) === sid);
     return sessionRoots.length > 0 ? sessionRoots : roots;
   } catch (error51) {
     log2(`[snapshot] Discover repositories failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
@@ -55786,7 +55908,7 @@ async function capturePreTurnSnapshot(options) {
   });
   const dir = snapshotsDirForCwd(agentCwd);
   try {
-    fs60.mkdirSync(dir, { recursive: true });
+    fs62.mkdirSync(dir, { recursive: true });
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
   }
@@ -55795,9 +55917,9 @@ async function capturePreTurnSnapshot(options) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     repos
   };
-  const filePath = path81.join(dir, `${runId}.json`);
+  const filePath = path83.join(dir, `${runId}.json`);
   try {
-    fs60.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
+    fs62.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
   } catch (e) {
     return { ok: false, error: e instanceof Error ? e.message : String(e) };
   }
@@ -55817,7 +55939,7 @@ async function runLocalRevertBeforeQueuedPrompt(next, deps) {
   const agentBase = deps.sessionWorktreeManager.getSessionWorktreeRootForSession(sid) ?? getBridgeRoot();
   const file2 = snapshotFilePath(agentBase, tid);
   try {
-    await fs61.promises.access(file2, fs61.constants.F_OK);
+    await fs63.promises.access(file2, fs63.constants.F_OK);
   } catch {
     deps.log(
       `[Queue] requeued_with_revert: no pre-turn snapshot for ${tid.slice(0, 8)}\u2026; continuing without revert.`
@@ -56468,6 +56590,7 @@ var handleRenameSessionBranchMessage = (msg, deps) => {
 var handleSessionArchivedMessage = (msg, deps) => {
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
   if (!sessionId) return;
+  cleanupSessionPlans(sessionId);
   void deps.sessionWorktreeManager.removeSessionWorktrees(sessionId);
 };
 
@@ -56475,11 +56598,12 @@ var handleSessionArchivedMessage = (msg, deps) => {
 var handleSessionDiscardedMessage = (msg, deps) => {
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
   if (!sessionId) return;
+  cleanupSessionPlans(sessionId);
   void deps.sessionWorktreeManager.removeSessionWorktrees(sessionId);
 };
 
 // src/routing/handlers/revert-turn-snapshot.ts
-import * as fs62 from "node:fs";
+import * as fs64 from "node:fs";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
@@ -56492,7 +56616,7 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
     const agentBase = sessionWorktreeManager.getSessionWorktreeRootForSession(sessionId) ?? getBridgeRoot();
     const file2 = snapshotFilePath(agentBase, turnId);
     try {
-      await fs62.promises.access(file2, fs62.constants.F_OK);
+      await fs64.promises.access(file2, fs64.constants.F_OK);
     } catch {
       sendWsMessage(s, {
         type: "revert_turn_snapshot_result",
@@ -56566,8 +56690,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path88, body) {
-  const url2 = `http://127.0.0.1:${port}${path88}`;
+async function requestPreviewApi(port, secret, method, path90, body) {
+  const url2 = `http://127.0.0.1:${port}${path90}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -56579,7 +56703,7 @@ async function requestPreviewApi(port, secret, method, path88, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path88}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path90}: ${res.status}`);
   }
   return data;
 }
@@ -56764,8 +56888,8 @@ function isValidRemoteSkillInstallItem(item) {
 
 // src/skills/install/install-remote-skills-async.ts
 init_yield_to_event_loop();
-import fs63 from "node:fs";
-import path82 from "node:path";
+import fs65 from "node:fs";
+import path84 from "node:path";
 
 // src/skills/install/constants.ts
 var INSTALL_SKILLS_YIELD_EVERY = 16;
@@ -56776,12 +56900,12 @@ async function writeInstallFileAsync(skillDir, f, filesWritten) {
   if (++filesWritten.count % INSTALL_SKILLS_YIELD_EVERY === 0) {
     await yieldToEventLoop();
   }
-  const dest = path82.join(skillDir, f.path);
-  await fs63.promises.mkdir(path82.dirname(dest), { recursive: true });
+  const dest = path84.join(skillDir, f.path);
+  await fs65.promises.mkdir(path84.dirname(dest), { recursive: true });
   if (f.text !== void 0) {
-    await fs63.promises.writeFile(dest, f.text, "utf8");
+    await fs65.promises.writeFile(dest, f.text, "utf8");
   } else if (f.base64) {
-    await fs63.promises.writeFile(dest, Buffer.from(f.base64, "base64"));
+    await fs65.promises.writeFile(dest, Buffer.from(f.base64, "base64"));
   }
 }
 async function installRemoteSkillsAsync(cwd, targetDir, items) {
@@ -56793,7 +56917,7 @@ async function installRemoteSkillsAsync(cwd, targetDir, items) {
   try {
     for (const item of items) {
       if (!isValidRemoteSkillInstallItem(item)) continue;
-      const skillDir = path82.join(cwd, targetDir, item.skillName);
+      const skillDir = path84.join(cwd, targetDir, item.skillName);
       for (const f of item.files) {
         await writeInstallFileAsync(skillDir, f, filesWritten);
       }
@@ -57156,13 +57280,13 @@ function handleFileBrowserRequest(msg, socket, e2ee, sessionWorktreeManager) {
 
 // src/files/handle-file-browser-search.ts
 init_yield_to_event_loop();
-import path83 from "node:path";
+import path85 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 = path83.resolve(
+    const sessionParentPath = path85.resolve(
       sessionWorktreeManager != null ? await resolveFileBrowserSessionParent(sessionWorktreeManager, msg.sessionId) : getBridgeRoot()
     );
     if (!await bridgeFileIndexIsPopulated(sessionParentPath)) {
@@ -57260,7 +57384,7 @@ function handleFileBrowserCodeNavMessage(msg, { getWs, e2ee, sessionWorktreeMana
 }
 
 // src/git/bridge-git-context.ts
-import * as path84 from "node:path";
+import * as path86 from "node:path";
 init_yield_to_event_loop();
 
 // src/git/branches/get-current-branch.ts
@@ -57328,12 +57452,12 @@ function listPendingCheckouts() {
 // src/git/bridge-git-context.ts
 function folderNameForRelPath(relPath, bridgeRoot) {
   if (relPath === "." || relPath === "") {
-    return path84.basename(path84.resolve(bridgeRoot)) || "repo";
+    return path86.basename(path86.resolve(bridgeRoot)) || "repo";
   }
-  return path84.basename(relPath) || relPath;
+  return path86.basename(relPath) || relPath;
 }
 async function discoverGitReposForBridgeContext(bridgeRoot) {
-  const root = path84.resolve(bridgeRoot);
+  const root = path86.resolve(bridgeRoot);
   if (await isGitRepoDirectory(root)) {
     const remoteUrl = await getRemoteOriginUrl(root);
     return [{ absolutePath: root, remoteUrl }];
@@ -57341,19 +57465,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(path84.resolve(repo.absolutePath), repo);
+    byPath.set(path86.resolve(repo.absolutePath), repo);
   }
   return [...byPath.values()];
 }
 async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path84.resolve(bridgeRoot);
+  const bridgeResolved = path86.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 = path84.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path84.isAbsolute(rel)) continue;
+    let rel = path86.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path86.isAbsolute(rel)) continue;
     const relPath = rel === "" ? "." : rel.replace(/\\/g, "/");
     const currentBranch = await getCurrentBranch(repo.absolutePath);
     const remoteUrl = repo.remoteUrl.trim() || null;
@@ -57384,11 +57508,11 @@ async function getBridgeGitContext(bridgeRoot = getBridgeRoot()) {
   return rows;
 }
 async function listRepoBranchesForBridge(repoRelPath, bridgeRoot = getBridgeRoot()) {
-  const bridgeResolved = path84.resolve(bridgeRoot);
+  const bridgeResolved = path86.resolve(bridgeRoot);
   const rel = repoRelPath.trim() === "." ? "" : repoRelPath.trim().replace(/\\/g, "/");
-  const repoPath = rel === "" ? bridgeResolved : path84.join(bridgeResolved, rel);
-  const resolved = path84.resolve(repoPath);
-  if (!resolved.startsWith(bridgeResolved + path84.sep) && resolved !== bridgeResolved) {
+  const repoPath = rel === "" ? bridgeResolved : path86.join(bridgeResolved, rel);
+  const resolved = path86.resolve(repoPath);
+  if (!resolved.startsWith(bridgeResolved + path86.sep) && resolved !== bridgeResolved) {
     return [];
   }
   return listRepoBranchRefs(resolved);
@@ -57438,8 +57562,8 @@ function handleListRepoBranchesRequestMessage(msg, getWs) {
 }
 
 // src/git/checkout/bridge-git-checkout.ts
-import * as fs65 from "node:fs/promises";
-import * as path86 from "node:path";
+import * as fs67 from "node:fs/promises";
+import * as path88 from "node:path";
 
 // src/git/checkout/normalize-clone-url.ts
 function normalizeCloneUrl(url2) {
@@ -57459,12 +57583,12 @@ function cloneUrlWithHttpsAuth(url2, auth) {
 }
 
 // src/git/checkout/resolve-checkout-target.ts
-import * as fs64 from "node:fs/promises";
-import * as path85 from "node:path";
+import * as fs66 from "node:fs/promises";
+import * as path87 from "node:path";
 var FOLDER_NAME_RE = /^[A-Za-z0-9._-]+$/;
 async function pathExists(p) {
   try {
-    await fs64.access(p);
+    await fs66.access(p);
     return true;
   } catch {
     return false;
@@ -57476,7 +57600,7 @@ async function resolveCheckoutTarget(opts) {
     if (await isGitRepoDirectory(bridgeRoot)) {
       throw new Error("Bridge root is already a git repository");
     }
-    const entries = await fs64.readdir(bridgeRoot).catch(() => []);
+    const entries = await fs66.readdir(bridgeRoot).catch(() => []);
     if (entries.length > 0) {
       throw new Error("Bridge root must be empty to initialize a monorepo checkout");
     }
@@ -57489,8 +57613,8 @@ async function resolveCheckoutTarget(opts) {
   if (await isGitRepoDirectory(bridgeRoot)) {
     throw new Error("Cannot add a nested repo while the bridge root is itself a git repository");
   }
-  const targetDir = path85.resolve(bridgeRoot, folder);
-  if (!targetDir.startsWith(bridgeRoot + path85.sep)) {
+  const targetDir = path87.resolve(bridgeRoot, folder);
+  if (!targetDir.startsWith(bridgeRoot + path87.sep)) {
     throw new Error("Invalid folderName");
   }
   if (await pathExists(targetDir)) {
@@ -57509,10 +57633,10 @@ async function bridgeGitCheckout(params) {
   });
   const folderName = relPath === "." ? "repo" : relPath;
   beginPendingCheckout({ relPath, folderName, remoteUrl: cloneUrl });
-  const parent = path86.dirname(targetDir);
-  await fs65.mkdir(parent, { recursive: true });
+  const parent = path88.dirname(targetDir);
+  await fs67.mkdir(parent, { recursive: true });
   if (relPath !== ".") {
-    await fs65.mkdir(targetDir, { recursive: true });
+    await fs67.mkdir(targetDir, { recursive: true });
   }
   const url2 = cloneUrlWithHttpsAuth(cloneUrl, params.auth ?? null);
   try {
@@ -57523,7 +57647,7 @@ async function bridgeGitCheckout(params) {
     return { relPath, folderName };
   } catch (e) {
     if (relPath !== ".") {
-      await fs65.rm(targetDir, { recursive: true, force: true }).catch(() => void 0);
+      await fs67.rm(targetDir, { recursive: true, force: true }).catch(() => void 0);
     }
     const msg = e instanceof Error ? e.message : String(e);
     throw new Error(
@@ -58257,9 +58381,9 @@ async function runCliAction(program2, opts) {
   const firehoseServerUrl = opts.firehoseUrl ?? opts.proxyUrl ?? process.env.BUILDAUTOMATON_FIREHOSE_URL ?? process.env.BUILDAUTOMATON_PROXY_URL ?? DEFAULT_FIREHOSE_URL;
   const bridgeRootOpt = (opts.bridgeRoot && typeof opts.bridgeRoot === "string" && opts.bridgeRoot.trim() ? opts.bridgeRoot.trim() : null) ?? (opts.cwd && typeof opts.cwd === "string" && opts.cwd.trim() ? opts.cwd.trim() : null);
   if (bridgeRootOpt) {
-    const resolvedBridgeRoot = path87.resolve(process.cwd(), bridgeRootOpt);
+    const resolvedBridgeRoot = path89.resolve(process.cwd(), bridgeRootOpt);
     try {
-      const st = fs66.statSync(resolvedBridgeRoot);
+      const st = fs68.statSync(resolvedBridgeRoot);
       if (!st.isDirectory()) {
         console.error(`Bridge root is not a directory: ${resolvedBridgeRoot}`);
         process.exit(1);
@@ -58279,7 +58403,7 @@ async function runCliAction(program2, opts) {
   );
   let worktreesRootPath;
   if (opts.worktreesRoot && opts.worktreesRoot.trim()) {
-    worktreesRootPath = path87.resolve(opts.worktreesRoot.trim());
+    worktreesRootPath = path89.resolve(opts.worktreesRoot.trim());
   }
   const e2eCertificates = opts.e2eeCertificatesDir?.trim() ? await loadOrCreateE2eCertificates(opts.e2eeCertificatesDir.trim()) : void 0;
   if (e2eCertificates) {