@buildautomaton/cli 0.1.24 → 0.1.26

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 path36 = __require("node:path");
-    var fs35 = __require("node:fs");
+    var path37 = __require("node:path");
+    var fs36 = __require("node:fs");
     var process8 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1906,11 +1906,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path36.resolve(baseDir, baseName);
-          if (fs35.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path36.extname(baseName))) return void 0;
+          const localBin = path37.resolve(baseDir, baseName);
+          if (fs36.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path37.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs35.existsSync(`${localBin}${ext}`)
+            (ext) => fs36.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 = fs35.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs36.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path36.resolve(
-            path36.dirname(resolvedScriptPath),
+          executableDir = path37.resolve(
+            path37.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path36.basename(
+            const legacyName = path37.basename(
               this._scriptPath,
-              path36.extname(this._scriptPath)
+              path37.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1947,7 +1947,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path36.extname(executableFile));
+        launchWithNode = sourceExt.includes(path37.extname(executableFile));
         let proc;
         if (process8.platform !== "win32") {
           if (launchWithNode) {
@@ -2787,7 +2787,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path36.basename(filename, path36.extname(filename));
+        this._name = path37.basename(filename, path37.extname(filename));
         return this;
       }
       /**
@@ -2801,9 +2801,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path37) {
-        if (path37 === void 0) return this._executableDir;
-        this._executableDir = path37;
+      executableDir(path38) {
+        if (path38 === void 0) return this._executableDir;
+        this._executableDir = path38;
         return this;
       }
       /**
@@ -7061,8 +7061,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path36, errorMaps, issueData } = params;
-      const fullPath = [...path36, ...issueData.path || []];
+      const { data, path: path37, errorMaps, issueData } = params;
+      const fullPath = [...path37, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -7370,11 +7370,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path36, key) {
+      constructor(parent, value, path37, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path36;
+        this._path = path37;
         this._key = key;
       }
       get path() {
@@ -11235,7 +11235,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 os7 = __require("os");
+    var os8 = __require("os");
     var tty = __require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
@@ -11283,7 +11283,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os7.release().split(".");
+        const osRelease = os8.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -11529,10 +11529,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(path36, isFile, isDirectory) {
-      log2(`checking %s`, path36);
+    function check2(path37, isFile, isDirectory) {
+      log2(`checking %s`, path37);
       try {
-        const stat3 = fs_1.statSync(path36);
+        const stat3 = fs_1.statSync(path37);
         if (stat3.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -11552,8 +11552,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path36, type = exports.READABLE) {
-      return check2(path36, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path37, type = exports.READABLE) {
+      return check2(path37, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -11850,10 +11850,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path36) {
-  if (!path36)
+function getElementAtPath(obj, path37) {
+  if (!path37)
     return obj;
-  return path36.reduce((acc, key) => acc?.[key], obj);
+  return path37.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -12102,11 +12102,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path36, issues) {
+function prefixIssues(path37, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path36);
+    iss.path.unshift(path37);
     return iss;
   });
 }
@@ -12295,7 +12295,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path36 = []) => {
+  const processError = (error41, path37 = []) => {
     var _a2, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -12305,7 +12305,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path36, ...issue2.path];
+        const fullpath = [...path37, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -12335,9 +12335,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path36) {
+function toDotPath(path37) {
   const segs = [];
-  for (const seg of path36) {
+  for (const seg of path37) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -25064,15 +25064,15 @@ var {
 } = import_index.default;
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.24".length > 0 ? "0.1.24" : "0.0.0-dev";
+var CLI_VERSION = "0.1.26".length > 0 ? "0.1.26" : "0.0.0-dev";
 
 // src/cli/defaults.ts
 var DEFAULT_API_URL = process.env.BUILDAUTOMATON_API_URL ?? "https://api.buildautomaton.com";
 var DEFAULT_FIREHOSE_URL = "https://buildautomaton-firehose.fly.dev";
 
 // src/cli/run-cli-action.ts
-import * as fs34 from "node:fs";
-import * as path35 from "node:path";
+import * as fs35 from "node:fs";
+import * as path36 from "node:path";
 
 // src/cli-log-level.ts
 var verbosity = "info";
@@ -25465,6 +25465,11 @@ function logImmediate(line) {
   process.stdout.write(`${timestampPrefix()} ${line}
 `);
 }
+function logDebug(line) {
+  const v = getCliLogVerbosity();
+  if (v !== "debug" && v !== "trace") return;
+  console.log(`${timestampPrefix()} [debug] ${line}`);
+}
 function logTrace(line) {
   if (getCliLogVerbosity() !== "trace") return;
   console.log(`${timestampPrefix()} [trace] ${line}`);
@@ -27058,9 +27063,9 @@ function parseChangeSummaryJson(raw, allowedPaths, options) {
     const rawPath = typeof o.path === "string" ? o.path.trim() : "";
     const summary = typeof o.summary === "string" ? o.summary.trim() : "";
     if (!rawPath || !summary) continue;
-    const path36 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
-    if (!path36) continue;
-    rows.push({ path: path36, summary: clampSummaryToAtMostTwoLines(summary) });
+    const path37 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
+    if (!path37) continue;
+    rows.push({ path: path37, summary: clampSummaryToAtMostTwoLines(summary) });
   }
   return rows;
 }
@@ -27199,8 +27204,77 @@ function isClaudeCodePermissionMode(value) {
   return MODE_SET.has(value);
 }
 
+// ../types/src/cli-permission-mode.ts
+var CLI_PERMISSION_MODE_DEFAULT = "default";
+var CLI_PERMISSION_MODE_DANGEROUS = "dangerous";
+function normalizeCliPermissionModeInput(raw) {
+  if (typeof raw !== "string") return CLI_PERMISSION_MODE_DEFAULT;
+  const t = raw.trim();
+  if (t === CLI_PERMISSION_MODE_DANGEROUS) return CLI_PERMISSION_MODE_DANGEROUS;
+  if (t === "standard") return CLI_PERMISSION_MODE_DEFAULT;
+  return CLI_PERMISSION_MODE_DEFAULT;
+}
+
+// ../types/src/acp-permission-auto-approve.ts
+function isRejectKind(kind) {
+  return kind === "reject_once" || kind === "reject_always";
+}
+function normalizeOptions(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const item of raw) {
+    if (item == null || typeof item !== "object" || Array.isArray(item)) continue;
+    const o = item;
+    const rawId = o.optionId ?? o.id;
+    const optionId = typeof rawId === "string" && rawId.trim() !== "" ? rawId.trim() : typeof rawId === "number" && Number.isFinite(rawId) ? String(rawId) : "";
+    if (!optionId) continue;
+    const kind = typeof o.kind === "string" ? o.kind : void 0;
+    out.push({ optionId, ...kind ? { kind } : {} });
+  }
+  return out;
+}
+function pickAllowOption(options) {
+  const nonReject = options.filter((o) => !isRejectKind(o.kind));
+  if (nonReject.length === 0) return null;
+  const allowOnce = nonReject.find((o) => o.kind === "allow_once");
+  if (allowOnce) return allowOnce;
+  const notAlways = nonReject.filter((o) => o.kind !== "allow_always");
+  if (notAlways.length > 0) return notAlways[0] ?? null;
+  return nonReject.find((o) => o.kind === "allow_always") ?? nonReject[0] ?? null;
+}
+function firstNonEmptyOptionsArray(...candidates) {
+  for (const c of candidates) {
+    if (Array.isArray(c) && c.length > 0) return c;
+  }
+  const fallback = candidates[0];
+  return Array.isArray(fallback) ? fallback : [];
+}
+function extractAcpPermissionRequestOptionArray(params) {
+  const toolCall = params.toolCall;
+  const fromToolCall = toolCall != null && typeof toolCall === "object" && !Array.isArray(toolCall) ? toolCall : null;
+  return firstNonEmptyOptionsArray(
+    params.options,
+    params.permissionOptions,
+    fromToolCall?.options,
+    fromToolCall?.permissionOptions
+  );
+}
+function buildCliAutoApprovedPermissionRpcResult(requestParams) {
+  const opt = pickAllowOption(normalizeOptions(extractAcpPermissionRequestOptionArray(requestParams)));
+  if (!opt) return null;
+  const kind = opt.kind?.trim();
+  return {
+    outcome: {
+      outcome: "selected",
+      optionId: opt.optionId,
+      ...kind ? { _meta: { permissionOptionKind: kind } } : {}
+    }
+  };
+}
+
 // ../types/src/agent-config.ts
 var AGENT_CONFIG_CLAUDE_PERMISSION_MODE_KEY = "claude_permission_mode";
+var AGENT_CONFIG_CLI_PERMISSION_MODE_KEY = "cli_permission_mode";
 function getClaudePermissionModeFromAgentConfig(config2) {
   if (!config2) return null;
   const raw = config2[AGENT_CONFIG_CLAUDE_PERMISSION_MODE_KEY];
@@ -27208,6 +27282,10 @@ function getClaudePermissionModeFromAgentConfig(config2) {
   const t = raw.trim();
   return isClaudeCodePermissionMode(t) ? t : null;
 }
+function getCliPermissionModeFromAgentConfig(config2) {
+  if (!config2) return CLI_PERMISSION_MODE_DEFAULT;
+  return normalizeCliPermissionModeInput(config2[AGENT_CONFIG_CLI_PERMISSION_MODE_KEY]);
+}
 
 // src/git/session-git-queue.ts
 import { execFile as execFile7 } from "node:child_process";
@@ -27262,8 +27340,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path36) {
-  return path36 instanceof String && cache.has(path36);
+function isPathSpec(path37) {
+  return path37 instanceof String && cache.has(path37);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -27352,8 +27430,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path36) {
-  return (0, import_file_exists.exists)(path36, import_file_exists.FOLDER);
+function folderExists(path37) {
+  return (0, import_file_exists.exists)(path37, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -27757,8 +27835,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path36) {
-      return /^\.(git)?$/.test(path36.trim());
+    parser(path37) {
+      return /^\.(git)?$/.test(path37.trim());
     }
   };
 }
@@ -28192,11 +28270,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path36, line, preview] = input.split(NULL);
-    paths.add(path36);
-    (results[path36] = results[path36] || []).push({
+    const [path37, line, preview] = input.split(NULL);
+    paths.add(path37);
+    (results[path37] = results[path37] || []).push({
       line: asNumber(line),
-      path: path36,
+      path: path37,
       preview
     });
   });
@@ -28961,14 +29039,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path36, text) {
+function parseInit(bare, path37, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path36, false, result[1]);
+    return new InitSummary(bare, path37, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path36, true, result[1]);
+    return new InitSummary(bare, path37, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -28979,7 +29057,7 @@ function parseInit(bare, path36, text) {
       break;
     }
   }
-  return new InitSummary(bare, path36, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path37, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -28988,9 +29066,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path36, existing, gitDir) {
+      constructor(bare, path37, existing, gitDir) {
         this.bare = bare;
-        this.path = path36;
+        this.path = path37;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -29002,7 +29080,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path36, customArgs) {
+function initTask(bare = false, path37, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -29011,7 +29089,7 @@ function initTask(bare = false, path36, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path36, text);
+      return parseInit(commands.includes("--bare"), path37, text);
     }
   };
 }
@@ -29827,12 +29905,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path36, index, working_dir) {
-        this.path = path36;
+      constructor(path37, index, working_dir) {
+        this.path = path37;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path36) || [null, path36, path36];
+          const detail = fromPathRegex.exec(path37) || [null, path37, path37];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -29863,14 +29941,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path36) {
+  function data(index, workingDir, path37) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path36);
+      handler(result, path37);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path36, index, workingDir));
+      result.files.push(new FileStatusSummary(path37, index, workingDir));
     }
   }
 }
@@ -30179,9 +30257,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path36, write) {
+      hashObject(path37, write) {
         return this._runTask(
-          hashObjectTask(path36, write === true),
+          hashObjectTask(path37, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -30534,8 +30612,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path36 = input.trim().replace(/^["']|["']$/g, "");
-  return path36 && normalize(path36);
+  const path37 = input.trim().replace(/^["']|["']$/g, "");
+  return path37 && normalize(path37);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -30849,8 +30927,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path36) {
-  return subModuleTask(["add", repo, path36]);
+function addSubModuleTask(repo, path37) {
+  return subModuleTask(["add", repo, path37]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -31183,8 +31261,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path36, then) {
-      return this._runTask(addSubModuleTask2(repo, path36), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path37, then) {
+      return this._runTask(addSubModuleTask2(repo, path37), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -32071,9 +32149,9 @@ async function collectTurnGitDiffFromPreTurnSnapshot(options) {
 // src/agents/acp/put-summarize-change-summaries.ts
 async function putEncryptedChangeSummaryRows(params) {
   const base = params.apiBaseUrl.replace(/\/+$/, "");
-  const entries = params.rows.map(({ path: path36, summary }) => {
+  const entries = params.rows.map(({ path: path37, summary }) => {
     const enc = params.e2ee.encryptFields({ summary }, ["summary"]);
-    return { path: path36, summary: JSON.stringify(enc) };
+    return { path: path37, summary: JSON.stringify(enc) };
   });
   const res = await fetch(
     `${base}/api/sessions/${encodeURIComponent(params.sessionId)}/follow-ups/summarize-changes`,
@@ -32255,8 +32333,8 @@ async function sendPromptToAgent(options) {
 }
 
 // src/agents/acp/ensure-acp-client.ts
-import * as fs10 from "node:fs";
-import * as path12 from "node:path";
+import * as fs11 from "node:fs";
+import * as path13 from "node:path";
 
 // src/error-message.ts
 function errorMessage(err) {
@@ -32292,76 +32370,10 @@ async function isCommandOnPath(command, timeoutMs = 4e3) {
   }
 }
 
-// src/agents/acp/clients/sdk-stdio-acp-client.ts
+// src/agents/acp/clients/sdk/sdk-stdio-acp-client.ts
 import { spawn as spawn2 } from "node:child_process";
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2 } from "node:path";
 import { Readable, Writable } from "node:stream";
 
-// src/files/diff/unified-diff.ts
-function computeLineDiff(oldText, newText) {
-  const oldLines = oldText.split("\n");
-  const newLines = newText.split("\n");
-  const m = oldLines.length;
-  const n = newLines.length;
-  const dp = Array(m + 1);
-  for (let i2 = 0; i2 <= m; i2++) dp[i2] = Array(n + 1).fill(0);
-  for (let i2 = 1; i2 <= m; i2++) {
-    for (let j2 = 1; j2 <= n; j2++) {
-      if (oldLines[i2 - 1] === newLines[j2 - 1]) {
-        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
-      } else {
-        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
-      }
-    }
-  }
-  const result = [];
-  let i = m;
-  let j = n;
-  while (i > 0 || j > 0) {
-    if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
-      result.unshift({ type: "context", line: oldLines[i - 1] });
-      i--;
-      j--;
-    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
-      result.unshift({ type: "add", line: newLines[j - 1] });
-      j--;
-    } else {
-      result.unshift({ type: "remove", line: oldLines[i - 1] });
-      i--;
-    }
-  }
-  return result;
-}
-function editSnippetToUnifiedDiff(filePath, oldText, newText) {
-  const lines = computeLineDiff(oldText, newText);
-  const out = [`--- ${filePath}`, `+++ ${filePath}`];
-  for (const d of lines) {
-    if (d.type === "add") out.push(`+${d.line}`);
-    else if (d.type === "remove") out.push(`-${d.line}`);
-    else out.push(` ${d.line}`);
-  }
-  return out.join("\n");
-}
-
-// src/agents/acp/safe-fs-path.ts
-import * as path9 from "node:path";
-function resolveSafePathUnderCwd(cwd, filePath) {
-  const trimmed2 = filePath.trim();
-  if (!trimmed2) return null;
-  const normalizedCwd = path9.resolve(cwd);
-  const resolved = path9.isAbsolute(trimmed2) ? path9.normalize(trimmed2) : path9.resolve(normalizedCwd, trimmed2);
-  const rel = path9.relative(normalizedCwd, resolved);
-  if (rel.startsWith("..") || path9.isAbsolute(rel)) return null;
-  return resolved;
-}
-function toDisplayPathRelativeToCwd(cwd, absolutePath) {
-  const normalizedCwd = path9.resolve(cwd);
-  const rel = path9.relative(normalizedCwd, path9.resolve(absolutePath));
-  if (!rel || rel === "") return path9.basename(absolutePath);
-  return rel.split(path9.sep).join("/");
-}
-
 // src/agents/acp/clients/agent-stderr-capture.ts
 var STDERR_CAPTURE_MAX = 48e3;
 function createStderrCapture(child) {
@@ -32426,7 +32438,7 @@ function createKiroSdkExtNotificationHandler(options) {
   };
 }
 
-// src/agents/acp/clients/sdk-stdio-ext-notifications.ts
+// src/agents/acp/clients/sdk/sdk-stdio-ext-notifications.ts
 var noopExtNotification = async () => {
 };
 function createSdkStdioExtNotificationHandler(options) {
@@ -32485,23 +32497,380 @@ function enrichAcpPermissionRpcResultFromRequestParams(result, params) {
   };
 }
 
-// src/agents/acp/clients/sdk-stdio-acp-client.ts
-function formatSpawnError(err, command) {
-  if (err.code === "ENOENT") {
-    return `Command "${command}" not found. Install the agent (e.g. Cursor CLI) or add it to PATH.`;
+// src/agents/acp/clients/shared/acp-fs-read-write.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+
+// src/files/diff/unified-diff.ts
+function computeLineDiff(oldText, newText) {
+  const oldLines = oldText.split("\n");
+  const newLines = newText.split("\n");
+  const m = oldLines.length;
+  const n = newLines.length;
+  const dp = Array(m + 1);
+  for (let i2 = 0; i2 <= m; i2++) dp[i2] = Array(n + 1).fill(0);
+  for (let i2 = 1; i2 <= m; i2++) {
+    for (let j2 = 1; j2 <= n; j2++) {
+      if (oldLines[i2 - 1] === newLines[j2 - 1]) {
+        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
+      } else {
+        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+      }
+    }
   }
-  return err.message || String(err);
+  const result = [];
+  let i = m;
+  let j = n;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
+      result.unshift({ type: "context", line: oldLines[i - 1] });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      result.unshift({ type: "add", line: newLines[j - 1] });
+      j--;
+    } else {
+      result.unshift({ type: "remove", line: oldLines[i - 1] });
+      i--;
+    }
+  }
+  return result;
+}
+function editSnippetToUnifiedDiff(filePath, oldText, newText) {
+  const lines = computeLineDiff(oldText, newText);
+  const out = [`--- ${filePath}`, `+++ ${filePath}`];
+  for (const d of lines) {
+    if (d.type === "add") out.push(`+${d.line}`);
+    else if (d.type === "remove") out.push(`-${d.line}`);
+    else out.push(` ${d.line}`);
+  }
+  return out.join("\n");
+}
+
+// src/agents/acp/safe-fs-path.ts
+import * as path9 from "node:path";
+function resolveSafePathUnderCwd(cwd, filePath) {
+  const trimmed2 = filePath.trim();
+  if (!trimmed2) return null;
+  const normalizedCwd = path9.resolve(cwd);
+  const resolved = path9.isAbsolute(trimmed2) ? path9.normalize(trimmed2) : path9.resolve(normalizedCwd, trimmed2);
+  const rel = path9.relative(normalizedCwd, resolved);
+  if (rel.startsWith("..") || path9.isAbsolute(rel)) return null;
+  return resolved;
 }
-function sliceFileContentRange(content, line, limit) {
+function toDisplayPathRelativeToCwd(cwd, absolutePath) {
+  const normalizedCwd = path9.resolve(cwd);
+  const rel = path9.relative(normalizedCwd, path9.resolve(absolutePath));
+  if (!rel || rel === "") return path9.basename(absolutePath);
+  return rel.split(path9.sep).join("/");
+}
+
+// src/agents/acp/clients/shared/acp-fs-read-write.ts
+function sliceFileContentForAcp(content, line, limit) {
   if (line == null && limit == null) return content;
   const lines = content.split("\n");
   const start = line != null && line > 0 ? line - 1 : 0;
   const end = limit != null && limit > 0 ? start + limit : lines.length;
   return lines.slice(start, end).join("\n");
 }
-function bridgePayloadFromSdkSessionNotification(params) {
+function acpReadTextFileInProcess(ctx, filePath, line, limit) {
+  const resolvedPath = resolveSafePathUnderCwd(ctx.cwd, filePath);
+  if (!resolvedPath) throw new Error("Invalid or disallowed path");
+  try {
+    let content = readFileSync2(resolvedPath, "utf8");
+    content = sliceFileContentForAcp(content, line, limit);
+    return { content };
+  } catch (e) {
+    if (e.code === "ENOENT") return { content: "" };
+    throw e;
+  }
+}
+function acpWriteTextFileInProcess(ctx, filePath, newText) {
+  const resolvedPath = resolveSafePathUnderCwd(ctx.cwd, filePath);
+  if (!resolvedPath) throw new Error("Invalid or disallowed path");
+  let oldText = "";
+  try {
+    oldText = readFileSync2(resolvedPath, "utf8");
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+  mkdirSync2(dirname2(resolvedPath), { recursive: true });
+  writeFileSync2(resolvedPath, newText, "utf8");
+  const displayPath = toDisplayPathRelativeToCwd(ctx.cwd, resolvedPath);
+  const patchContent = editSnippetToUnifiedDiff(displayPath, oldText, newText);
+  ctx.onFileChange?.({ path: displayPath, oldText, newText, patchContent });
+  return {};
+}
+
+// src/agents/acp/claude-acp-permission-from-session.ts
+function flattenSelectOptions(options) {
+  if (options == null || options.length === 0) return [];
+  const first2 = options[0];
+  if (first2 != null && typeof first2 === "object" && "group" in first2 && first2.group != null) {
+    return options.flatMap(
+      (g) => Array.isArray(g.options) ? g.options : []
+    );
+  }
+  return options;
+}
+function pickModeConfigOption(configOptions) {
+  if (configOptions == null || configOptions.length === 0) return null;
+  const byCategory = configOptions.find((o) => o.category === "mode");
+  if (byCategory) return byCategory;
+  return configOptions.find((o) => o.id === "mode") ?? null;
+}
+async function applyClaudePermissionFromAcpSession(params) {
+  const { sessionId, agentConfig, configOptions, modes, setSessionConfigOption, setSessionMode, logDebug: logDebug2 } = params;
+  const desiredMode = getClaudePermissionModeFromAgentConfig(agentConfig);
+  if (desiredMode == null) return;
+  const modeOpt = pickModeConfigOption(configOptions ?? null);
+  if (modeOpt != null) {
+    const flat = flattenSelectOptions(modeOpt.options);
+    const allowed = flat.some((o) => o.value === desiredMode);
+    if (allowed && modeOpt.currentValue !== desiredMode) {
+      try {
+        logDebug2(
+          `[Agent] Claude Code: sending ACP session/set_config_option (permission mode) configId=${JSON.stringify(modeOpt.id)} value=${JSON.stringify(desiredMode)} was=${JSON.stringify(modeOpt.currentValue)} sessionId=${sessionId.slice(0, 8)}\u2026`
+        );
+        await setSessionConfigOption({ sessionId, configId: modeOpt.id, value: desiredMode });
+      } catch (e) {
+        logDebug2(
+          `[Agent] Claude Code: session/set_config_option failed: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    }
+    return;
+  }
+  if (modes?.availableModes?.length) {
+    const allowed = modes.availableModes.some((m) => m.id === desiredMode);
+    if (allowed && desiredMode !== modes.currentModeId) {
+      try {
+        logDebug2(
+          `[Agent] Claude Code: sending ACP session/set_mode (permission mode) modeId=${JSON.stringify(desiredMode)} was=${JSON.stringify(modes.currentModeId ?? null)} sessionId=${sessionId.slice(0, 8)}\u2026`
+        );
+        await setSessionMode({ sessionId, modeId: desiredMode });
+      } catch (e) {
+        logDebug2(`[Agent] Claude Code: session/set_mode failed: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+  }
+}
+
+// src/agents/acp/clients/shared/config-options-for-permission.ts
+function configOptionsForPermission(getActive, established) {
+  const mem = getActive?.();
+  if (Array.isArray(mem) && mem.length > 0) return mem;
+  return established ?? void 0;
+}
+
+// src/agents/acp/clients/shared/establish-acp-session.ts
+function establishedFromResult(raw, sessionId) {
+  const r = raw && typeof raw === "object" ? raw : {};
+  return {
+    sessionId,
+    configOptions: Array.isArray(r.configOptions) ? r.configOptions : null,
+    modes: r.modes ?? null
+  };
+}
+function sessionIdFromNewSessionResult(raw) {
+  const r = raw && typeof raw === "object" ? raw : {};
+  return typeof r.sessionId === "string" ? r.sessionId : "";
+}
+async function establishAcpSessionWithTransport(transport, ctx, canResume, canLoad) {
+  const { cwd, mcpServers, persistedAcpSessionId, agentLabel, suppressLoadReplay } = ctx;
+  const prev = typeof persistedAcpSessionId === "string" && persistedAcpSessionId.trim() !== "" ? persistedAcpSessionId.trim() : "";
+  if (prev) {
+    if (canResume) {
+      try {
+        logDebug(`[Agent] ${agentLabel} ACP session/resume for stored session ${prev.slice(0, 8)}\u2026`);
+        const result2 = await transport.resumeSession({ sessionId: prev, cwd, mcpServers });
+        return establishedFromResult(result2, prev);
+      } catch (e) {
+        logDebug(`[Agent] ${agentLabel} ACP session/resume failed: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+    if (canLoad) {
+      suppressLoadReplay.value = true;
+      try {
+        logDebug(`[Agent] ${agentLabel} ACP session/load for stored session ${prev.slice(0, 8)}\u2026`);
+        const result2 = await transport.loadSession({ sessionId: prev, cwd, mcpServers });
+        return establishedFromResult(result2, prev);
+      } catch (e) {
+        logDebug(`[Agent] ${agentLabel} ACP session/load failed: ${e instanceof Error ? e.message : String(e)}`);
+      } finally {
+        suppressLoadReplay.value = false;
+      }
+    }
+  }
+  const result = await transport.newSession({ cwd, mcpServers });
+  const sid = sessionIdFromNewSessionResult(result);
+  if (!sid) throw new Error(`${agentLabel} ACP session/new did not return sessionId`);
+  return establishedFromResult(result, sid);
+}
+
+// src/agents/acp/clients/shared/parse-acp-init-capabilities.ts
+function parseAcpInitAgentCapabilities(initResult) {
+  const agentCapabilities = initResult?.agentCapabilities;
+  const canLoad = agentCapabilities?.loadSession === true;
+  const sessionCaps = agentCapabilities?.sessionCapabilities;
+  const canResume = Boolean(sessionCaps?.resume);
+  return { canResume, canLoad };
+}
+
+// src/agents/acp/clients/shared/bootstrap-acp-wire-session.ts
+async function bootstrapAcpWireSession(transport, ctx, initializeRequest) {
+  const initResult = await transport.initialize(initializeRequest);
+  const { canResume, canLoad } = parseAcpInitAgentCapabilities(initResult);
+  await transport.afterInitialize?.();
+  const established = await establishAcpSessionWithTransport(transport, ctx, canResume, canLoad);
+  const sessionId = established.sessionId;
+  ctx.onAcpSessionEstablished?.({
+    acpSessionId: sessionId,
+    configOptions: established.configOptions,
+    modes: established.modes
+  });
+  if (ctx.backendAgentType === "claude-code") {
+    const cfg = ctx.agentConfig != null && typeof ctx.agentConfig === "object" && !Array.isArray(ctx.agentConfig) ? ctx.agentConfig : null;
+    const configOptionsTyped = established.configOptions;
+    const modesTyped = established.modes;
+    await applyClaudePermissionFromAcpSession({
+      sessionId,
+      agentConfig: cfg,
+      configOptions: configOptionsForPermission(ctx.getActiveConfigOptions, configOptionsTyped),
+      modes: modesTyped,
+      setSessionConfigOption: transport.setSessionConfigOption ? (p) => transport.setSessionConfigOption(p) : async () => {
+      },
+      setSessionMode: transport.setSessionMode ? (p) => transport.setSessionMode(p) : async () => {
+      },
+      logDebug: ctx.logDebug
+    });
+  }
+  return established;
+}
+
+// src/agents/acp/clients/shared/dispatch-session-update.ts
+function dispatchAcpSessionUpdate(opts) {
+  const { flatPayload, onAcpConfigOptionsUpdated, onSessionUpdate, suppressLoadReplay } = opts;
+  const su = flatPayload.sessionUpdate ?? flatPayload.session_update;
+  if (su === "config_option_update") {
+    const co = flatPayload.configOptions;
+    if (Array.isArray(co)) onAcpConfigOptionsUpdated?.(co);
+    return;
+  }
+  if (suppressLoadReplay()) return;
+  onSessionUpdate?.(flatPayload);
+}
+
+// src/agents/acp/clients/shared/flatten-sdk-session-notification.ts
+function flattenSdkSessionNotificationParams(params) {
   return { sessionId: params.sessionId, ...params.update };
 }
+
+// src/agents/acp/clients/shared/normalize-acp-prompt-result.ts
+function normalizeAcpPromptTurnSuccess(opts) {
+  const { stopReason, output, stderrCaptureText, backendAgentType } = opts;
+  const mergedOutput = output || void 0;
+  const stop = (stopReason ?? "").toLowerCase();
+  const cancelled = stop === "cancelled";
+  const refusal = stop === "refusal";
+  const stderrEvaluated = Boolean(stderrCaptureText && backendAgentType);
+  const stderrSuggestsAuth = stderrEvaluated ? localAgentErrorSuggestsAuth(backendAgentType, stderrCaptureText) : false;
+  if (cancelled) {
+    return {
+      success: false,
+      stopReason,
+      output: mergedOutput,
+      error: mergeErrorWithStderr("Stopped by user", stderrCaptureText)
+    };
+  }
+  if (refusal) {
+    return {
+      success: false,
+      stopReason,
+      output: mergedOutput,
+      error: mergeErrorWithStderr("The agent refused the request.", stderrCaptureText)
+    };
+  }
+  if (stderrSuggestsAuth) {
+    return {
+      success: false,
+      stopReason,
+      output: mergedOutput,
+      error: stderrCaptureText
+    };
+  }
+  return {
+    success: true,
+    stopReason,
+    output: mergedOutput
+  };
+}
+function normalizeAcpPromptTurnFailure(err, stderrCaptureText) {
+  const merged = mergeErrorWithStderr(formatJsonRpcStyleError(err), stderrCaptureText);
+  return { success: false, error: merged };
+}
+
+// src/agents/acp/clients/shared/send-acp-prompt-via-transport.ts
+async function sendAcpPromptViaTransport(transport, ctx, sessionId, promptText) {
+  try {
+    const response = await transport.prompt({
+      sessionId,
+      prompt: [{ type: "text", text: promptText }]
+    });
+    await new Promise((r2) => setImmediate(r2));
+    const r = response;
+    return normalizeAcpPromptTurnSuccess({
+      stopReason: r?.stopReason,
+      output: r?.output,
+      stderrCaptureText: ctx.getStderrText(),
+      backendAgentType: ctx.backendAgentType
+    });
+  } catch (err) {
+    await new Promise((r) => setImmediate(r));
+    return normalizeAcpPromptTurnFailure(err, ctx.getStderrText());
+  }
+}
+
+// src/agents/acp/clients/sdk/sdk-stdio-permission-request-handshake.ts
+function awaitSdkStdioPermissionRequestHandshake(params) {
+  const { requestId, paramsRecord, pending, onRequest } = params;
+  return new Promise((resolve18) => {
+    pending.set(requestId, { resolve: resolve18, params: paramsRecord });
+    try {
+      onRequest?.({
+        requestId,
+        method: "session/request_permission",
+        params: paramsRecord
+      });
+    } catch {
+    }
+  });
+}
+
+// src/agents/acp/clients/sdk/sdk-acp-session-transport.ts
+function createSdkAcpSessionTransport(connection) {
+  const c = connection;
+  return {
+    initialize: (request) => c.initialize(request),
+    resumeSession: (p) => c.unstable_resumeSession(p),
+    loadSession: (p) => c.loadSession(p),
+    newSession: (p) => c.newSession(p),
+    prompt: (p) => c.prompt(p),
+    cancelSession: async (sessionId) => {
+      await c.cancel({ sessionId });
+    },
+    setSessionConfigOption: c.setSessionConfigOption ? (p) => c.setSessionConfigOption(p) : void 0,
+    setSessionMode: c.setSessionMode ? (p) => c.setSessionMode(p) : void 0
+  };
+}
+
+// src/agents/acp/clients/sdk/sdk-stdio-acp-client.ts
+function formatSpawnError(err, command) {
+  if (err.code === "ENOENT") {
+    return `Command "${command}" not found. Install the agent (e.g. Cursor CLI) or add it to PATH.`;
+  }
+  return err.message || String(err);
+}
 async function createSdkStdioAcpClient(options) {
   const { ClientSideConnection: ClientSideConnection2, ndJsonStream: ndJsonStream2, PROTOCOL_VERSION: PROTOCOL_VERSION2 } = await Promise.resolve().then(() => (init_acp(), acp_exports));
   const {
@@ -32513,7 +32882,11 @@ async function createSdkStdioAcpClient(options) {
     onFileChange,
     killSubprocessAfterCancelMs,
     onAgentSubprocessExit,
-    agentConfig
+    agentConfig,
+    persistedAcpSessionId,
+    onAcpSessionEstablished,
+    onAcpConfigOptionsUpdated,
+    getActiveConfigOptions
   } = options;
   const isWindows = process.platform === "win32";
   const child = spawn2(command[0], command.slice(1), {
@@ -32562,54 +32935,49 @@ async function createSdkStdioAcpClient(options) {
           backendAgentType,
           onSessionUpdate
         });
+        const suppressLoadReplayRef = { value: false };
+        const sessionCtx = {
+          cwd,
+          onFileChange,
+          mcpServers: [],
+          persistedAcpSessionId,
+          agentLabel: "ACP",
+          suppressLoadReplay: suppressLoadReplayRef,
+          backendAgentType: backendAgentType ?? null,
+          agentConfig,
+          getActiveConfigOptions,
+          onAcpSessionEstablished,
+          onAcpConfigOptionsUpdated,
+          logDebug,
+          getStderrText: () => stderrCapture.getText()
+        };
         let permissionSeq = 0;
         const pendingPermissionReplies = /* @__PURE__ */ new Map();
         const client = (_agent) => ({
           async requestPermission(params) {
             const requestId = `perm-${++permissionSeq}`;
             const paramsRecord = params != null && typeof params === "object" ? params : {};
-            try {
-              onRequest?.({
-                requestId,
-                method: "session/request_permission",
-                params: paramsRecord
-              });
-            } catch {
-            }
-            return await new Promise((resolve19) => {
-              pendingPermissionReplies.set(requestId, { resolve: resolve19, params: paramsRecord });
+            return await awaitSdkStdioPermissionRequestHandshake({
+              requestId,
+              paramsRecord,
+              pending: pendingPermissionReplies,
+              onRequest
             });
           },
           async readTextFile(params) {
-            const resolvedPath = resolveSafePathUnderCwd(cwd, params.path);
-            if (!resolvedPath) throw new Error("Invalid or disallowed path");
-            try {
-              let content = readFileSync2(resolvedPath, "utf8");
-              content = sliceFileContentRange(content, params.line, params.limit);
-              return { content };
-            } catch (e) {
-              if (e.code === "ENOENT") return { content: "" };
-              throw e;
-            }
+            return acpReadTextFileInProcess(sessionCtx, params.path, params.line, params.limit);
           },
           async writeTextFile(params) {
-            const resolvedPath = resolveSafePathUnderCwd(cwd, params.path);
-            if (!resolvedPath) throw new Error("Invalid or disallowed path");
-            let oldText = "";
-            try {
-              oldText = readFileSync2(resolvedPath, "utf8");
-            } catch (e) {
-              if (e.code !== "ENOENT") throw e;
-            }
-            mkdirSync2(dirname2(resolvedPath), { recursive: true });
-            writeFileSync2(resolvedPath, params.content, "utf8");
-            const displayPath = toDisplayPathRelativeToCwd(cwd, resolvedPath);
-            const patchContent = editSnippetToUnifiedDiff(displayPath, oldText, params.content);
-            onFileChange?.({ path: displayPath, oldText, newText: params.content, patchContent });
-            return {};
+            return acpWriteTextFileInProcess(sessionCtx, params.path, params.content);
           },
           async sessionUpdate(params) {
-            onSessionUpdate?.(bridgePayloadFromSdkSessionNotification(params));
+            const bridged = flattenSdkSessionNotificationParams(params);
+            dispatchAcpSessionUpdate({
+              flatPayload: bridged,
+              onAcpConfigOptionsUpdated: sessionCtx.onAcpConfigOptionsUpdated,
+              onSessionUpdate,
+              suppressLoadReplay: () => sessionCtx.suppressLoadReplay.value
+            });
           },
           async extNotification(method, params) {
             await extNotification(method, params);
@@ -32619,84 +32987,19 @@ async function createSdkStdioAcpClient(options) {
         connection.signal.addEventListener("abort", () => {
           child.kill();
         });
-        await connection.initialize({
+        const transport = createSdkAcpSessionTransport(connection);
+        const established = await bootstrapAcpWireSession(transport, sessionCtx, {
           protocolVersion: PROTOCOL_VERSION2,
           clientCapabilities: {
             fs: { readTextFile: true, writeTextFile: true }
           },
           clientInfo: { name: "buildautomaton-cli", version: "0.1.0" }
         });
-        const newSessionRes = await connection.newSession({ cwd, mcpServers: [] });
-        const sessionId = newSessionRes.sessionId;
-        if (backendAgentType === "claude-code") {
-          const cfg = agentConfig != null && typeof agentConfig === "object" && !Array.isArray(agentConfig) ? agentConfig : null;
-          const desiredMode = getClaudePermissionModeFromAgentConfig(cfg);
-          const modes = newSessionRes.modes;
-          if (desiredMode != null && modes?.availableModes?.length) {
-            const allowed = modes.availableModes.some((m) => m.id === desiredMode);
-            if (allowed && desiredMode !== modes.currentModeId) {
-              try {
-                await connection.setSessionMode({ sessionId, modeId: desiredMode });
-              } catch {
-              }
-            }
-          }
-        }
+        const sessionId = established.sessionId;
         settleResolve({
           sessionId,
           async sendPrompt(prompt, _options) {
-            try {
-              const response = await connection.prompt({
-                sessionId,
-                prompt: [{ type: "text", text: prompt }]
-              });
-              await new Promise((r2) => setImmediate(r2));
-              const r = response;
-              const stopReason = (r?.stopReason ?? "").toLowerCase();
-              const cancelled = stopReason === "cancelled";
-              const refusal = stopReason === "refusal";
-              const stderrAfter = stderrCapture.getText();
-              const agentType = backendAgentType ?? null;
-              const stderrEvaluated = Boolean(stderrAfter && agentType);
-              const stderrSuggestsAuth = stderrEvaluated ? localAgentErrorSuggestsAuth(agentType, stderrAfter) : false;
-              if (cancelled) {
-                return {
-                  success: false,
-                  stopReason: r?.stopReason,
-                  output: r?.output,
-                  error: mergeErrorWithStderr("Stopped by user", stderrAfter)
-                };
-              }
-              if (refusal) {
-                return {
-                  success: false,
-                  stopReason: r?.stopReason,
-                  output: r?.output,
-                  error: mergeErrorWithStderr("The agent refused the request.", stderrAfter)
-                };
-              }
-              if (stderrSuggestsAuth) {
-                return {
-                  success: false,
-                  stopReason: r?.stopReason,
-                  output: r?.output,
-                  error: stderrAfter
-                };
-              }
-              return {
-                success: true,
-                stopReason: r?.stopReason,
-                output: r?.output
-              };
-            } catch (err) {
-              await new Promise((r) => setImmediate(r));
-              const stderrAfter = stderrCapture.getText();
-              const merged = mergeErrorWithStderr(formatJsonRpcStyleError(err), stderrAfter);
-              return {
-                success: false,
-                error: merged
-              };
-            }
+            return sendAcpPromptViaTransport(transport, sessionCtx, sessionId, prompt);
           },
           async cancel() {
             for (const [id, entry] of [...pendingPermissionReplies.entries()]) {
@@ -32704,7 +33007,7 @@ async function createSdkStdioAcpClient(options) {
               entry.resolve({ outcome: { outcome: "cancelled" } });
             }
             try {
-              await connection.cancel({ sessionId });
+              await transport.cancelSession(sessionId);
             } catch {
             }
             if (killSubprocessAfterCancelMs != null && killSubprocessAfterCancelMs >= 0) {
@@ -32795,7 +33098,7 @@ async function createCodexAcpClient(options) {
   return createSdkStdioAcpClient({ ...options, command });
 }
 
-// src/agents/acp/clients/cursor-acp-client.ts
+// src/agents/acp/clients/cursor/cursor-acp-client.ts
 var cursor_acp_client_exports = {};
 __export(cursor_acp_client_exports, {
   BACKEND_LOCAL_AGENT_TYPE: () => BACKEND_LOCAL_AGENT_TYPE3,
@@ -32803,8 +33106,6 @@ __export(cursor_acp_client_exports, {
   createCursorAcpClient: () => createCursorAcpClient,
   detectLocalAgentPresence: () => detectLocalAgentPresence3
 });
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "node:fs";
-import { dirname as dirname3 } from "node:path";
 import { spawn as spawn3 } from "node:child_process";
 import * as readline from "node:readline";
 
@@ -32821,7 +33122,23 @@ function formatSessionUpdateKindForLog(kind) {
   return kind.split("_").filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(" ");
 }
 
-// src/agents/acp/clients/cursor-acp-client.ts
+// src/agents/acp/clients/cursor/cursor-json-rpc-acp-transport.ts
+function createCursorJsonRpcAcpTransport(deps) {
+  const { send, cancelSessionNotification } = deps;
+  return {
+    initialize: (request) => send("initialize", request),
+    afterInitialize: async () => {
+      await send("authenticate", { methodId: "cursor_login" });
+    },
+    resumeSession: (p) => send("session/resume", p),
+    loadSession: (p) => send("session/load", p),
+    newSession: (p) => send("session/new", p),
+    prompt: (p) => send("session/prompt", p),
+    cancelSession: (sessionId) => cancelSessionNotification(sessionId)
+  };
+}
+
+// src/agents/acp/clients/cursor/cursor-acp-client.ts
 var FS_READ_METHODS = /* @__PURE__ */ new Set(["fs/read_text_file", "fs/readTextFile"]);
 var FS_WRITE_METHODS = /* @__PURE__ */ new Set(["fs/write_text_file", "fs/writeTextFile"]);
 function formatSpawnError2(err, command) {
@@ -32838,13 +33155,6 @@ function safeJsonParse(value) {
     return null;
   }
 }
-function sliceLinesByRange(content, line, limit) {
-  if (line == null && limit == null) return content;
-  const lines = content.split("\n");
-  const start = line != null && line > 0 ? line - 1 : 0;
-  const end = limit != null && limit > 0 ? start + limit : lines.length;
-  return lines.slice(start, end).join("\n");
-}
 function buildCursorAcpSpawnCommand(base, sessionMode) {
   if (!sessionMode) return [...base];
   const m = sessionMode.trim();
@@ -32858,7 +33168,11 @@ async function createCursorAcpClient(options) {
     backendAgentType,
     onSessionUpdate,
     onRequest,
-    onFileChange
+    onFileChange,
+    persistedAcpSessionId,
+    onAcpSessionEstablished,
+    onAcpConfigOptionsUpdated,
+    onAgentSubprocessExit
   } = options;
   const dbgFs = process.env.BUILDAUTOMATON_DEBUG_ACP_FS === "1";
   const isWindows = process.platform === "win32";
@@ -32870,6 +33184,25 @@ async function createCursorAcpClient(options) {
   });
   const stderrCapture = createStderrCapture(child);
   child.stderr?.on("data", (chunk) => stderrCapture.append(chunk));
+  child.once("close", (code, signal) => {
+    onAgentSubprocessExit?.({ code, signal });
+  });
+  const suppressLoadReplayRef = { value: false };
+  const sessionCtx = {
+    cwd,
+    onFileChange,
+    mcpServers: [],
+    persistedAcpSessionId,
+    agentLabel: "Cursor",
+    suppressLoadReplay: suppressLoadReplayRef,
+    backendAgentType: backendAgentType ?? null,
+    agentConfig: options.agentConfig,
+    getActiveConfigOptions: options.getActiveConfigOptions,
+    onAcpSessionEstablished,
+    onAcpConfigOptionsUpdated,
+    logDebug,
+    getStderrText: () => stderrCapture.getText()
+  };
   return new Promise((resolve18, reject) => {
     child.on("error", (err) => {
       child.kill();
@@ -32878,6 +33211,16 @@ async function createCursorAcpClient(options) {
     let nextId = 1;
     const pending = /* @__PURE__ */ new Map();
     const pendingRequests = /* @__PURE__ */ new Map();
+    function cancelSessionNotification(sessionId) {
+      const line = JSON.stringify({
+        jsonrpc: "2.0",
+        method: "session/cancel",
+        params: { sessionId }
+      }) + "\n";
+      return new Promise((res, rej) => {
+        child.stdin.write(line, (err) => err ? rej(err) : res());
+      });
+    }
     function send(method, params) {
       const id = nextId++;
       const line = JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n";
@@ -32901,7 +33244,6 @@ async function createCursorAcpClient(options) {
       respond(requestId, payload);
       pendingRequests.delete(requestId);
     }
-    let promptOutputBuffer = "";
     const rl = readline.createInterface({ input: child.stdout });
     rl.on("line", (line) => {
       const msg = safeJsonParse(line);
@@ -32930,11 +33272,12 @@ async function createCursorAcpClient(options) {
             `[acp] Received session update (${kindLabel}) tool=${toolName || "(none)"}`
           );
         }
-        const isTextChunk = sessionUpdate === "agent_message_chunk" && update.content?.text;
-        if (isTextChunk && update.content?.text) {
-          promptOutputBuffer += update.content.text;
-        }
-        onSessionUpdate?.(update);
+        dispatchAcpSessionUpdate({
+          flatPayload: update,
+          onAcpConfigOptionsUpdated: sessionCtx.onAcpConfigOptionsUpdated,
+          onSessionUpdate,
+          suppressLoadReplay: () => sessionCtx.suppressLoadReplay.value
+        });
         return;
       }
       if (method === "session/request_permission" && typeof id === "number") {
@@ -32954,21 +33297,13 @@ async function createCursorAcpClient(options) {
           if (dbgFs) {
             console.error(`[acp-fs] ${method} path=${filePath.slice(0, 200)}${filePath.length > 200 ? "\u2026" : ""}`);
           }
-          const resolvedPath = resolveSafePathUnderCwd(cwd, filePath);
-          if (!resolvedPath) {
-            if (dbgFs) console.error(`[acp-fs] ${method} rejected path (outside cwd or empty)`);
-            respondJsonRpcError(id, -32602, "Invalid or disallowed path");
-            return;
-          }
           try {
-            let content = readFileSync3(resolvedPath, "utf8");
-            const line2 = typeof params.line === "number" ? params.line : void 0;
-            const limit = typeof params.limit === "number" ? params.limit : void 0;
-            content = sliceLinesByRange(content, line2, limit);
-            respond(id, { content });
+            const lineNum = typeof params.line === "number" ? params.line : void 0;
+            const limitNum = typeof params.limit === "number" ? params.limit : void 0;
+            const out = acpReadTextFileInProcess(sessionCtx, filePath, lineNum, limitNum);
+            respond(id, out);
           } catch (e) {
-            const code = e?.code;
-            if (code === "ENOENT") {
+            if (e?.code === "ENOENT") {
               respond(id, { content: "" });
             } else {
               respondJsonRpcError(id, -32e3, e instanceof Error ? e.message : String(e));
@@ -32985,32 +33320,17 @@ async function createCursorAcpClient(options) {
               `[acp-fs] ${method} path=${filePath.slice(0, 200)}${filePath.length > 200 ? "\u2026" : ""} newBytes=${newText.length}`
             );
           }
-          const resolvedPath = resolveSafePathUnderCwd(cwd, filePath);
-          if (!resolvedPath) {
-            if (dbgFs) console.error(`[acp-fs] ${method} rejected path (outside cwd or empty): ${filePath.slice(0, 120)}`);
-            respondJsonRpcError(id, -32602, "Invalid or disallowed path");
-            return;
-          }
-          let oldText = "";
           try {
-            oldText = readFileSync3(resolvedPath, "utf8");
+            acpWriteTextFileInProcess(sessionCtx, filePath, newText);
+            respond(id, null);
           } catch (e) {
-            if (e.code !== "ENOENT") {
+            if (e.message === "Invalid or disallowed path") {
+              if (dbgFs) console.error(`[acp-fs] ${method} rejected path (outside cwd or empty): ${filePath.slice(0, 120)}`);
+              respondJsonRpcError(id, -32602, "Invalid or disallowed path");
+            } else {
               respondJsonRpcError(id, -32e3, e instanceof Error ? e.message : String(e));
-              return;
             }
           }
-          try {
-            mkdirSync3(dirname3(resolvedPath), { recursive: true });
-            writeFileSync3(resolvedPath, newText, "utf8");
-          } catch (e) {
-            respondJsonRpcError(id, -32e3, e instanceof Error ? e.message : String(e));
-            return;
-          }
-          const displayPath = toDisplayPathRelativeToCwd(cwd, resolvedPath);
-          const patchContent = editSnippetToUnifiedDiff(displayPath, oldText, newText);
-          onFileChange?.({ path: displayPath, oldText, newText, patchContent });
-          respond(id, null);
           return;
         }
         if (method === "cursor/create_plan" || method === "cursor/ask_question") {
@@ -33032,16 +33352,7 @@ async function createCursorAcpClient(options) {
     });
     (async () => {
       try {
-        let sendSessionCancelNotification2 = function() {
-          const line = JSON.stringify({
-            jsonrpc: "2.0",
-            method: "session/cancel",
-            params: { sessionId }
-          }) + "\n";
-          return new Promise((res, rej) => {
-            child.stdin.write(line, (err) => err ? rej(err) : res());
-          });
-        }, cancelPendingPermissionRequests2 = function() {
+        let cancelPendingPermissionRequests2 = function() {
           for (const [reqId, pending2] of [...pendingRequests.entries()]) {
             if (pending2.method === "session/request_permission") {
               respond(reqId, { outcome: { outcome: "cancelled" } });
@@ -33049,76 +33360,25 @@ async function createCursorAcpClient(options) {
             }
           }
         };
-        var sendSessionCancelNotification = sendSessionCancelNotification2, cancelPendingPermissionRequests = cancelPendingPermissionRequests2;
-        await send("initialize", {
+        var cancelPendingPermissionRequests = cancelPendingPermissionRequests2;
+        const transport = createCursorJsonRpcAcpTransport({
+          send,
+          cancelSessionNotification
+        });
+        const established = await bootstrapAcpWireSession(transport, sessionCtx, {
           protocolVersion: 1,
           clientCapabilities: { fs: { readTextFile: true, writeTextFile: true }, terminal: false },
           clientInfo: { name: "buildautomaton-cli", version: "0.1.0" }
         });
-        await send("authenticate", { methodId: "cursor_login" });
-        const newResult = await send("session/new", { cwd, mcpServers: [] });
-        const sessionId = newResult?.sessionId ?? "";
-        if (!sessionId) throw new Error("Cursor ACP session/new did not return sessionId");
+        const sessionId = established.sessionId;
         resolve18({
           sessionId,
           async sendPrompt(prompt, _options) {
-            promptOutputBuffer = "";
-            try {
-              const result = await send("session/prompt", {
-                sessionId,
-                prompt: [{ type: "text", text: prompt }]
-              });
-              await new Promise((r) => setImmediate(r));
-              const output = (result?.output ?? promptOutputBuffer) || void 0;
-              const stopReason = (result?.stopReason ?? "").toLowerCase();
-              const cancelled = stopReason === "cancelled";
-              const refusal = stopReason === "refusal";
-              const stderrAfter = stderrCapture.getText();
-              const agentType = backendAgentType ?? null;
-              const stderrEvaluated = Boolean(stderrAfter && agentType);
-              const stderrSuggestsAuth = stderrEvaluated ? localAgentErrorSuggestsAuth(agentType, stderrAfter) : false;
-              if (cancelled) {
-                return {
-                  success: false,
-                  stopReason: result?.stopReason,
-                  output: output || void 0,
-                  error: mergeErrorWithStderr("Stopped by user", stderrAfter)
-                };
-              }
-              if (refusal) {
-                return {
-                  success: false,
-                  stopReason: result?.stopReason,
-                  output: output || void 0,
-                  error: mergeErrorWithStderr("The agent refused the request.", stderrAfter)
-                };
-              }
-              if (stderrSuggestsAuth) {
-                return {
-                  success: false,
-                  stopReason: result?.stopReason,
-                  output: output || void 0,
-                  error: stderrAfter
-                };
-              }
-              return {
-                success: true,
-                stopReason: result?.stopReason,
-                output: output || void 0
-              };
-            } catch (err) {
-              await new Promise((r) => setImmediate(r));
-              const stderrAfter = stderrCapture.getText();
-              const merged = mergeErrorWithStderr(formatJsonRpcStyleError(err), stderrAfter);
-              return {
-                success: false,
-                error: merged
-              };
-            }
+            return sendAcpPromptViaTransport(transport, sessionCtx, sessionId, prompt);
           },
           async cancel() {
             cancelPendingPermissionRequests2();
-            await sendSessionCancelNotification2();
+            await transport.cancelSession(sessionId);
           },
           resolveRequest(requestId, result) {
             const numericId = Number(requestId);
@@ -33266,7 +33526,7 @@ function getGitRepoRootSync(startDir) {
 
 // src/agents/acp/workspace-files.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync3 } from "node:fs";
 import * as path11 from "node:path";
 function resolveWorkspaceFilePath(sessionParentPath, rawPath) {
   const trimmed2 = rawPath.trim();
@@ -33298,7 +33558,7 @@ function readUtf8WorkspaceFile(sessionParentPath, displayPath) {
     const rel = path11.relative(gitRoot, resolvedPath2);
     if (!rel.startsWith("..") && !path11.isAbsolute(rel)) {
       try {
-        return readFileSync4(resolvedPath2, "utf8");
+        return readFileSync3(resolvedPath2, "utf8");
       } catch {
       }
     }
@@ -33306,7 +33566,7 @@ function readUtf8WorkspaceFile(sessionParentPath, displayPath) {
   const resolvedPath = resolveSafePathUnderCwd(sessionParentPath, displayPath);
   if (!resolvedPath) return "";
   try {
-    return readFileSync4(resolvedPath, "utf8");
+    return readFileSync3(resolvedPath, "utf8");
   } catch {
     return "";
   }
@@ -33402,7 +33662,7 @@ function createBridgeOnFileChange(opts) {
 
 // src/agents/acp/hooks/bridge-on-request.ts
 function createBridgeOnRequest(opts) {
-  const { routing, getSendRequest, log: log2 } = opts;
+  const { routing, getSendRequest, log: log2, getAutoApproveAcpPermissions, resolveAcpPermissionRequest } = opts;
   return (request) => {
     const runId = routing.runId;
     const sessionId = routing.sessionId;
@@ -33410,6 +33670,26 @@ function createBridgeOnRequest(opts) {
     if (!runId || !sendReq) return;
     const kind = request.method === "cursor/create_plan" ? "plan" : request.method === "session/request_permission" ? "permission" : "question";
     const sessionUpdate = request.method === "cursor/create_plan" ? "plan" : request.method === "session/request_permission" ? "permission" : "question";
+    if (request.method === "session/request_permission" && getAutoApproveAcpPermissions() && resolveAcpPermissionRequest) {
+      const params = request.params != null && typeof request.params === "object" && !Array.isArray(request.params) ? request.params : {};
+      const auto = buildCliAutoApprovedPermissionRpcResult(params);
+      if (auto != null) {
+        try {
+          resolveAcpPermissionRequest(request.requestId, auto);
+          log2(
+            `[Bridge service] CLI dangerous mode: auto-approved permission requestId=${request.requestId} runId=${runId}`
+          );
+          return;
+        } catch (err) {
+          log2(
+            `[Bridge service] CLI dangerous mode: auto-approve failed (${errorMessage(err)}); forwarding permission`
+          );
+        }
+      }
+      log2(
+        `[Bridge service] CLI dangerous mode: no allow option to auto-select; forwarding permission requestId=${request.requestId}`
+      );
+    }
     try {
       sendReq({
         type: "session_update",
@@ -33810,6 +34090,9 @@ function createBridgeOnSessionUpdate(opts) {
     const sentFileChangePaths = /* @__PURE__ */ new Set();
     const p = params;
     const updateKind = p.sessionUpdate ?? p.session_update ?? p.type ?? "update";
+    if (updateKind === "config_option_update") {
+      return;
+    }
     const isCompletedToolCallUpdate = updateKind === "tool_call_update" && isCompletedToolStatus(p.status);
     const toolName = p.toolCall?.name ?? p.tool_call?.name ?? "";
     const isToolUpdate = updateKind === "tool_call" || updateKind === "tool_call_update" || typeof toolName === "string" && toolName.length > 0;
@@ -33896,14 +34179,73 @@ function buildAcpSessionBridgeHooks(opts) {
   };
 }
 
+// src/agents/acp/local-agent-session-file.ts
+import fs10 from "node:fs";
+import os3 from "node:os";
+import path12 from "node:path";
+var LOCAL_AGENT_SESSION_DIR = path12.join(os3.homedir(), ".buildautomaton", "agent-sessions");
+function safeFileSlug(cloudSessionId) {
+  const t = cloudSessionId.replace(/[^a-zA-Z0-9_-]+/g, "_").slice(0, 220);
+  return t.length > 0 ? t : "session";
+}
+function localAgentSessionFilePath(cloudSessionId) {
+  return path12.join(LOCAL_AGENT_SESSION_DIR, `${safeFileSlug(cloudSessionId)}.json`);
+}
+function readLocalAgentSessionFile(cloudSessionId) {
+  try {
+    const p = localAgentSessionFilePath(cloudSessionId);
+    const raw = fs10.readFileSync(p, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.v !== 1) return null;
+    return {
+      v: 1,
+      acpSessionId: typeof parsed.acpSessionId === "string" ? parsed.acpSessionId : null,
+      backendAgentType: typeof parsed.backendAgentType === "string" ? parsed.backendAgentType : null,
+      configOptions: Array.isArray(parsed.configOptions) ? parsed.configOptions : null,
+      updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch {
+    return null;
+  }
+}
+function writeLocalAgentSessionFile(cloudSessionId, patch) {
+  try {
+    const dir = LOCAL_AGENT_SESSION_DIR;
+    if (!fs10.existsSync(dir)) fs10.mkdirSync(dir, { recursive: true });
+    const p = localAgentSessionFilePath(cloudSessionId);
+    const prev = readLocalAgentSessionFile(cloudSessionId);
+    const next = {
+      v: 1,
+      acpSessionId: patch.acpSessionId !== void 0 ? patch.acpSessionId : prev?.acpSessionId ?? null,
+      backendAgentType: patch.backendAgentType !== void 0 ? patch.backendAgentType : prev?.backendAgentType ?? null,
+      configOptions: patch.configOptions !== void 0 ? patch.configOptions : prev?.configOptions ?? null,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    fs10.writeFileSync(p, JSON.stringify(next, null, 2), "utf8");
+  } catch {
+  }
+}
+
 // src/agents/acp/ensure-acp-client.ts
 async function ensureAcpClient(options) {
-  const { state, preferredAgentType, mode, agentConfig, sessionParentPath, routing, sendSessionUpdate, sendRequest, log: log2 } = options;
+  const {
+    state,
+    preferredAgentType,
+    mode,
+    agentConfig,
+    sessionParentPath,
+    routing,
+    cloudSessionId,
+    sendSessionUpdate,
+    sendRequest,
+    log: log2
+  } = options;
+  state.latestAgentConfigForBridgeHooks = agentConfig != null && typeof agentConfig === "object" && !Array.isArray(agentConfig) ? agentConfig : null;
   const targetSessionParentPath = resolveSessionParentPathForAgentProcess(sessionParentPath);
   if (state.acpStartPromise && !state.acpHandle) {
     await state.acpStartPromise;
   }
-  if (state.acpHandle && state.lastAcpCwd != null && path12.resolve(state.lastAcpCwd) !== path12.resolve(targetSessionParentPath)) {
+  if (state.acpHandle && state.lastAcpCwd != null && path13.resolve(state.lastAcpCwd) !== path13.resolve(targetSessionParentPath)) {
     try {
       state.acpHandle.disconnect();
     } catch {
@@ -33911,6 +34253,7 @@ async function ensureAcpClient(options) {
     state.acpHandle = null;
     state.acpStartPromise = null;
     state.acpAgentKey = null;
+    state.activeSessionConfigOptions = null;
   }
   const resolved = resolveAgentCommand(preferredAgentType);
   if (!resolved) {
@@ -33931,12 +34274,13 @@ async function ensureAcpClient(options) {
     state.acpHandle = null;
     state.acpStartPromise = null;
     state.acpAgentKey = null;
+    state.activeSessionConfigOptions = null;
   }
   if (state.acpHandle) return state.acpHandle;
   if (!state.acpStartPromise) {
     let statOk = false;
     try {
-      const st = fs10.statSync(targetSessionParentPath);
+      const st = fs11.statSync(targetSessionParentPath);
       statOk = st.isDirectory();
       if (!statOk) {
         state.lastAcpStartError = `Agent cwd is not a directory: ${targetSessionParentPath}`;
@@ -33954,17 +34298,47 @@ async function ensureAcpClient(options) {
       sessionParentPath: targetSessionParentPath,
       getSendSessionUpdate: () => sendSessionUpdate,
       getSendRequest: () => sendRequest,
-      log: log2
+      log: log2,
+      getAutoApproveAcpPermissions: () => getCliPermissionModeFromAgentConfig(state.latestAgentConfigForBridgeHooks) === CLI_PERMISSION_MODE_DANGEROUS,
+      resolveAcpPermissionRequest: (requestId, result) => {
+        state.acpHandle?.resolveRequest?.(requestId, result);
+      }
     });
+    const persisted = cloudSessionId != null && cloudSessionId !== "" && preferredAgentType != null && preferredAgentType !== "" ? readLocalAgentSessionFile(cloudSessionId) : null;
+    const persistedAcpSessionId = persisted && persisted.backendAgentType === preferredAgentType && typeof persisted.acpSessionId === "string" && persisted.acpSessionId.trim() !== "" ? persisted.acpSessionId.trim() : null;
+    state.activeSessionConfigOptions = Array.isArray(persisted?.configOptions) ? persisted.configOptions : null;
     state.acpStartPromise = resolved.createClient({
       command: resolved.command,
       sessionMode: mode,
       agentConfig: agentConfig ?? null,
       backendAgentType: preferredAgentType,
+      persistedAcpSessionId,
+      getActiveConfigOptions: () => state.activeSessionConfigOptions,
+      onAcpSessionEstablished: (info) => {
+        state.activeSessionConfigOptions = info.configOptions ?? state.activeSessionConfigOptions;
+        if (cloudSessionId != null && cloudSessionId !== "" && preferredAgentType != null && preferredAgentType !== "") {
+          writeLocalAgentSessionFile(cloudSessionId, {
+            acpSessionId: info.acpSessionId,
+            configOptions: info.configOptions,
+            backendAgentType: preferredAgentType
+          });
+        }
+      },
+      onAcpConfigOptionsUpdated: (configOptions) => {
+        state.activeSessionConfigOptions = configOptions;
+        if (cloudSessionId != null && cloudSessionId !== "" && preferredAgentType != null && preferredAgentType !== "") {
+          writeLocalAgentSessionFile(cloudSessionId, {
+            configOptions,
+            backendAgentType: preferredAgentType
+          });
+        }
+      },
       onAgentSubprocessExit: () => {
         state.acpHandle = null;
         state.acpStartPromise = null;
         state.acpAgentKey = null;
+        state.activeSessionConfigOptions = null;
+        state.latestAgentConfigForBridgeHooks = null;
         state.lastAcpStartError = "Agent subprocess exited";
       },
       ...hooks,
@@ -33994,7 +34368,9 @@ async function createAcpManager(options) {
     acpStartPromise: null,
     lastAcpStartError: null,
     lastAcpCwd: null,
-    acpAgentKey: null
+    acpAgentKey: null,
+    activeSessionConfigOptions: null,
+    latestAgentConfigForBridgeHooks: null
   };
   let backendFallbackAgentType = null;
   const promptRouting = {};
@@ -34044,6 +34420,7 @@ async function createAcpManager(options) {
         agentConfig: agentConfig ?? null,
         sessionParentPath,
         routing: promptRouting,
+        cloudSessionId: sessionId,
         sendSessionUpdate,
         sendRequest: sendSessionUpdate,
         log: log2
@@ -34134,6 +34511,8 @@ async function createAcpManager(options) {
     state.acpHandle = null;
     state.acpStartPromise = null;
     state.acpAgentKey = null;
+    state.activeSessionConfigOptions = null;
+    state.latestAgentConfigForBridgeHooks = null;
   }
   return {
     setPreferredAgentType,
@@ -34146,12 +34525,12 @@ async function createAcpManager(options) {
 }
 
 // src/worktrees/session-worktree-manager.ts
-import * as path19 from "node:path";
-import os4 from "node:os";
+import * as path20 from "node:path";
+import os5 from "node:os";
 
 // src/worktrees/prepare-new-session-worktrees.ts
-import * as fs12 from "node:fs";
-import * as path14 from "node:path";
+import * as fs13 from "node:fs";
+import * as path15 from "node:path";
 
 // src/git/worktree-add.ts
 async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch) {
@@ -34160,12 +34539,12 @@ async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch) {
 }
 
 // src/worktrees/worktree-layout-file.ts
-import * as fs11 from "node:fs";
-import * as path13 from "node:path";
-import os3 from "node:os";
+import * as fs12 from "node:fs";
+import * as path14 from "node:path";
+import os4 from "node:os";
 var LAYOUT_FILENAME = "worktree-launcher-layout.json";
 function defaultWorktreeLayoutPath() {
-  return path13.join(os3.homedir(), ".buildautomaton", LAYOUT_FILENAME);
+  return path14.join(os4.homedir(), ".buildautomaton", LAYOUT_FILENAME);
 }
 function normalizeLoadedLayout(raw) {
   if (raw && typeof raw === "object" && "launcherCwds" in raw) {
@@ -34177,8 +34556,8 @@ function normalizeLoadedLayout(raw) {
 function loadWorktreeLayout() {
   try {
     const p = defaultWorktreeLayoutPath();
-    if (!fs11.existsSync(p)) return { launcherCwds: [] };
-    const raw = JSON.parse(fs11.readFileSync(p, "utf8"));
+    if (!fs12.existsSync(p)) return { launcherCwds: [] };
+    const raw = JSON.parse(fs12.readFileSync(p, "utf8"));
     return normalizeLoadedLayout(raw);
   } catch {
     return { launcherCwds: [] };
@@ -34186,24 +34565,24 @@ function loadWorktreeLayout() {
 }
 function saveWorktreeLayout(layout) {
   try {
-    const dir = path13.dirname(defaultWorktreeLayoutPath());
-    fs11.mkdirSync(dir, { recursive: true });
-    fs11.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
+    const dir = path14.dirname(defaultWorktreeLayoutPath());
+    fs12.mkdirSync(dir, { recursive: true });
+    fs12.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
   } catch {
   }
 }
 function baseNameSafe(pathString) {
-  return path13.basename(pathString).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
+  return path14.basename(pathString).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
 }
 function getLauncherDirNameIfPresent(layout, bridgeRootPath2) {
-  const norm = path13.resolve(bridgeRootPath2);
-  const existing = layout.launcherCwds.find((e) => path13.resolve(e.absolutePath) === norm);
+  const norm = path14.resolve(bridgeRootPath2);
+  const existing = layout.launcherCwds.find((e) => path14.resolve(e.absolutePath) === norm);
   return existing?.dirName;
 }
 function allocateDirNameForLauncherCwd(layout, bridgeRootPath2) {
   const existing = getLauncherDirNameIfPresent(layout, bridgeRootPath2);
   if (existing) return existing;
-  const norm = path13.resolve(bridgeRootPath2);
+  const norm = path14.resolve(bridgeRootPath2);
   const base = baseNameSafe(norm);
   const used = new Set(layout.launcherCwds.map((e) => e.dirName));
   let name = base;
@@ -34220,10 +34599,10 @@ function allocateDirNameForLauncherCwd(layout, bridgeRootPath2) {
 // src/worktrees/prepare-new-session-worktrees.ts
 async function prepareNewSessionWorktrees(options) {
   const { worktreesRootPath, bridgeRoot, sessionId, layout, log: log2 } = options;
-  const bridgeResolved = path14.resolve(bridgeRoot);
+  const bridgeResolved = path15.resolve(bridgeRoot);
   const cwdKey = allocateDirNameForLauncherCwd(layout, bridgeResolved);
-  const bridgeKeyDir = path14.join(worktreesRootPath, cwdKey);
-  const sessionDir = path14.join(bridgeKeyDir, sessionId);
+  const bridgeKeyDir = path15.join(worktreesRootPath, cwdKey);
+  const sessionDir = path15.join(bridgeKeyDir, sessionId);
   const repos = await discoverGitReposUnderRoot(bridgeResolved);
   if (repos.length === 0) {
     log2("[worktrees] No Git repositories under bridge root; skipping worktree creation.");
@@ -34231,14 +34610,14 @@ async function prepareNewSessionWorktrees(options) {
   }
   const branch = `session-${sessionId}`;
   const worktreePaths = [];
-  fs12.mkdirSync(sessionDir, { recursive: true });
+  fs13.mkdirSync(sessionDir, { recursive: true });
   for (const repo of repos) {
-    let rel = path14.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path14.isAbsolute(rel)) continue;
+    let rel = path15.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path15.isAbsolute(rel)) continue;
     const relNorm = rel === "" ? "." : rel;
-    const wtPath = relNorm === "." ? sessionDir : path14.join(sessionDir, relNorm);
+    const wtPath = relNorm === "." ? sessionDir : path15.join(sessionDir, relNorm);
     if (relNorm !== ".") {
-      fs12.mkdirSync(path14.dirname(wtPath), { recursive: true });
+      fs13.mkdirSync(path15.dirname(wtPath), { recursive: true });
     }
     try {
       await gitWorktreeAddBranch(repo.absolutePath, wtPath, branch);
@@ -34280,23 +34659,23 @@ async function renameSessionWorktreeBranches(paths, newBranch, log2) {
 }
 
 // src/worktrees/remove-session-worktrees.ts
-import * as fs15 from "node:fs";
+import * as fs16 from "node:fs";
 
 // src/git/worktree-remove.ts
-import * as fs14 from "node:fs";
+import * as fs15 from "node:fs";
 
 // src/git/resolve-main-repo-from-git-file.ts
-import * as fs13 from "node:fs";
-import * as path15 from "node:path";
+import * as fs14 from "node:fs";
+import * as path16 from "node:path";
 function resolveMainRepoFromWorktreeGitFile(wt) {
-  const gitDirFile = path15.join(wt, ".git");
-  if (!fs13.existsSync(gitDirFile) || !fs13.statSync(gitDirFile).isFile()) return "";
-  const first2 = fs13.readFileSync(gitDirFile, "utf8").trim();
+  const gitDirFile = path16.join(wt, ".git");
+  if (!fs14.existsSync(gitDirFile) || !fs14.statSync(gitDirFile).isFile()) return "";
+  const first2 = fs14.readFileSync(gitDirFile, "utf8").trim();
   const m = first2.match(/^gitdir:\s*(.+)$/im);
   if (!m) return "";
-  const gitWorktreePath = path15.resolve(wt, m[1].trim());
-  const gitDir = path15.dirname(path15.dirname(gitWorktreePath));
-  return path15.dirname(gitDir);
+  const gitWorktreePath = path16.resolve(wt, m[1].trim());
+  const gitDir = path16.dirname(path16.dirname(gitWorktreePath));
+  return path16.dirname(gitDir);
 }
 
 // src/git/worktree-remove.ts
@@ -34305,7 +34684,7 @@ async function gitWorktreeRemoveForce(worktreePath) {
   if (mainRepo) {
     await cliSimpleGit(mainRepo).raw(["worktree", "remove", "--force", worktreePath]);
   } else {
-    fs14.rmSync(worktreePath, { recursive: true, force: true });
+    fs15.rmSync(worktreePath, { recursive: true, force: true });
   }
 }
 
@@ -34318,7 +34697,7 @@ async function removeSessionWorktrees(paths, log2) {
     } catch (e) {
       log2(`[worktrees] Remove failed for ${wt}: ${e instanceof Error ? e.message : String(e)}`);
       try {
-        fs15.rmSync(wt, { recursive: true, force: true });
+        fs16.rmSync(wt, { recursive: true, force: true });
       } catch {
       }
     }
@@ -34538,7 +34917,7 @@ function formatRemoteDisplayLabel(remoteUrl) {
 }
 
 // src/git/working-directory/changes/get-working-tree-change-repo-details.ts
-import * as path17 from "node:path";
+import * as path18 from "node:path";
 
 // src/git/working-directory/changes/parse-git-status.ts
 function parseNameStatusLines(lines) {
@@ -34658,8 +35037,8 @@ async function listChangedFilesForCommit(repoGitCwd, repoRelPath, commitSha) {
 }
 
 // src/git/working-directory/changes/list-changed-files-for-repo.ts
-import * as fs17 from "node:fs";
-import * as path16 from "node:path";
+import * as fs18 from "node:fs";
+import * as path17 from "node:path";
 
 // src/git/working-directory/changes/count-lines.ts
 import { createReadStream } from "node:fs";
@@ -34683,7 +35062,7 @@ async function countTextFileLines(filePath) {
 }
 
 // src/git/working-directory/changes/hydrate-patch.ts
-import * as fs16 from "node:fs";
+import * as fs17 from "node:fs";
 var UNIFIED_HUNK_HEADER_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
 var MAX_HYDRATE_LINES_PER_GAP = 8e3;
 var MAX_HYDRATE_LINES_PER_FILE = 8e4;
@@ -34698,7 +35077,7 @@ async function readGitBlobLines(repoCwd, pathInRepo) {
 }
 async function readWorktreeFileLines(filePath) {
   try {
-    const raw = await fs16.promises.readFile(filePath, "utf8");
+    const raw = await fs17.promises.readFile(filePath, "utf8");
     return raw.split(/\r?\n/);
   } catch {
     return null;
@@ -34833,7 +35212,7 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
   const rows = [];
   for (const pathInRepo of paths) {
     const relLauncher = posixJoinDirFile(repoRelPath, pathInRepo.replace(/\\/g, "/"));
-    const repoFilePath = path16.join(repoGitCwd, pathInRepo);
+    const repoFilePath = path17.join(repoGitCwd, pathInRepo);
     const nums = numByPath.get(pathInRepo);
     let additions = nums?.additions ?? 0;
     let deletions = nums?.deletions ?? 0;
@@ -34846,7 +35225,7 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
         deletions = fromGit.deletions;
       } else {
         try {
-          const st = await fs17.promises.stat(repoFilePath);
+          const st = await fs18.promises.stat(repoFilePath);
           if (st.isFile()) additions = await countTextFileLines(repoFilePath);
           else additions = 0;
         } catch {
@@ -34872,7 +35251,7 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
     } else {
       pathInRepo = row.pathRelLauncher;
     }
-    const filePath = path16.join(repoGitCwd, pathInRepo);
+    const filePath = path17.join(repoGitCwd, pathInRepo);
     let patch = await unifiedDiffForFile(repoGitCwd, pathInRepo, row.change);
     if (patch) {
       patch = await hydrateUnifiedPatchWithFileContext(patch, filePath, repoGitCwd, pathInRepo, row.change);
@@ -34888,8 +35267,8 @@ function normRepoRel(p) {
   return x === "" ? "." : x;
 }
 async function getWorkingTreeChangeRepoDetails(options) {
-  const bridgeRoot = path17.resolve(getBridgeRoot());
-  const sessionWtRoot = options.sessionWorktreeRootPath ? path17.resolve(options.sessionWorktreeRootPath) : null;
+  const bridgeRoot = path18.resolve(getBridgeRoot());
+  const sessionWtRoot = options.sessionWorktreeRootPath ? path18.resolve(options.sessionWorktreeRootPath) : null;
   const legacyNested = options.legacyRepoNestedSessionLayout === true;
   const out = [];
   const filter = options.repoFilterRelPath != null ? normRepoRel(options.repoFilterRelPath) : null;
@@ -34902,7 +35281,7 @@ async function getWorkingTreeChangeRepoDetails(options) {
   }
   const basis = filter == null && basisInput.kind === "commit" ? { kind: "working" } : basisInput;
   for (const target of options.commitTargetPaths) {
-    const t = path17.resolve(target);
+    const t = path18.resolve(target);
     if (!await isGitRepoDirectory(t)) continue;
     const g = cliSimpleGit(t);
     let branch = "HEAD";
@@ -34915,8 +35294,8 @@ async function getWorkingTreeChangeRepoDetails(options) {
     const remoteDisplay = formatRemoteDisplayLabel(remoteUrl);
     let repoRelPath;
     if (sessionWtRoot) {
-      const anchor = legacyNested ? path17.dirname(t) : t;
-      const relNorm = path17.relative(sessionWtRoot, anchor);
+      const anchor = legacyNested ? path18.dirname(t) : t;
+      const relNorm = path18.relative(sessionWtRoot, anchor);
       repoRelPath = relNorm === "" ? "." : relNorm.replace(/\\/g, "/");
     } else {
       let top = t;
@@ -34925,8 +35304,8 @@ async function getWorkingTreeChangeRepoDetails(options) {
       } catch {
         top = t;
       }
-      const rel = path17.relative(bridgeRoot, path17.resolve(top)).replace(/\\/g, "/") || ".";
-      repoRelPath = rel.startsWith("..") ? path17.basename(path17.resolve(top)) : rel;
+      const rel = path18.relative(bridgeRoot, path18.resolve(top)).replace(/\\/g, "/") || ".";
+      repoRelPath = rel.startsWith("..") ? path18.basename(path18.resolve(top)) : rel;
     }
     const norm = normRepoRel(repoRelPath === "" ? "." : repoRelPath);
     if (filter && norm !== filter) continue;
@@ -34991,11 +35370,11 @@ async function commitSessionWorktrees(options) {
 }
 
 // src/worktrees/discover-session-worktree-on-disk.ts
-import * as fs18 from "node:fs";
-import * as path18 from "node:path";
+import * as fs19 from "node:fs";
+import * as path19 from "node:path";
 function isGitDir(dirPath) {
   try {
-    return fs18.existsSync(path18.join(dirPath, ".git"));
+    return fs19.existsSync(path19.join(dirPath, ".git"));
   } catch {
     return false;
   }
@@ -35004,23 +35383,23 @@ function collectGitRepoRootsUnderDirectory(rootPath) {
   const out = [];
   const walk = (dir) => {
     if (isGitDir(dir)) {
-      out.push(path18.resolve(dir));
+      out.push(path19.resolve(dir));
       return;
     }
     let entries;
     try {
-      entries = fs18.readdirSync(dir, { withFileTypes: true });
+      entries = fs19.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
-      const full = path18.join(dir, e.name);
+      const full = path19.join(dir, e.name);
       if (!e.isDirectory()) continue;
       walk(full);
     }
   };
-  walk(path18.resolve(rootPath));
+  walk(path19.resolve(rootPath));
   return [...new Set(out)];
 }
 function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
@@ -35029,16 +35408,16 @@ function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = fs18.readdirSync(dir, { withFileTypes: true });
+      entries = fs19.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
-      const full = path18.join(dir, e.name);
+      const full = path19.join(dir, e.name);
       if (!e.isDirectory()) continue;
       if (e.name === sessionId) {
-        if (isGitDir(full)) out.push(path18.resolve(full));
+        if (isGitDir(full)) out.push(path19.resolve(full));
       } else {
         walk(full, depth + 1);
       }
@@ -35050,14 +35429,14 @@ function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
 function tryBindingFromSessionDirectory(sessionDir) {
   let st;
   try {
-    st = fs18.statSync(sessionDir);
+    st = fs19.statSync(sessionDir);
   } catch {
     return null;
   }
   if (!st.isDirectory()) return null;
   const worktreePaths = collectGitRepoRootsUnderDirectory(sessionDir);
   if (worktreePaths.length === 0) return null;
-  const abs = path18.resolve(sessionDir);
+  const abs = path19.resolve(sessionDir);
   return {
     sessionParentPath: abs,
     workingTreeRelRoot: abs,
@@ -35067,20 +35446,20 @@ function tryBindingFromSessionDirectory(sessionDir) {
 function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hintR = path18.resolve(checkoutPath);
+  const hintR = path19.resolve(checkoutPath);
   let best = null;
-  let cur = path18.dirname(hintR);
+  let cur = path19.dirname(hintR);
   for (let i = 0; i < 40; i++) {
     const paths = collectWorktreeRootsNamed(cur, sid, 24);
-    if (paths.some((p) => path18.resolve(p) === hintR)) {
-      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths) ?? path18.resolve(paths[0]);
+    if (paths.some((p) => path19.resolve(p) === hintR)) {
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths) ?? path19.resolve(paths[0]);
       best = {
-        sessionParentPath: path18.resolve(isolated),
-        workingTreeRelRoot: path18.resolve(cur),
-        repoCheckoutPaths: paths.map((p) => path18.resolve(p))
+        sessionParentPath: path19.resolve(isolated),
+        workingTreeRelRoot: path19.resolve(cur),
+        repoCheckoutPaths: paths.map((p) => path19.resolve(p))
       };
     }
-    const next = path18.dirname(cur);
+    const next = path19.dirname(cur);
     if (next === cur) break;
     cur = next;
   }
@@ -35088,33 +35467,33 @@ function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
 }
 function discoverSessionWorktreeOnDisk(options) {
   const { sessionId, worktreesRootPath, layout, bridgeRoot } = options;
-  if (!sessionId.trim() || !fs18.existsSync(worktreesRootPath)) return null;
+  if (!sessionId.trim() || !fs19.existsSync(worktreesRootPath)) return null;
   const preferredKey = getLauncherDirNameIfPresent(layout, bridgeRoot);
   const keys = [];
   if (preferredKey) keys.push(preferredKey);
   try {
-    for (const name of fs18.readdirSync(worktreesRootPath)) {
+    for (const name of fs19.readdirSync(worktreesRootPath)) {
       if (name.startsWith(".")) continue;
-      const p = path18.join(worktreesRootPath, name);
-      if (!fs18.statSync(p).isDirectory()) continue;
+      const p = path19.join(worktreesRootPath, name);
+      if (!fs19.statSync(p).isDirectory()) continue;
       if (name !== preferredKey) keys.push(name);
     }
   } catch {
     return null;
   }
   for (const key of keys) {
-    const layoutRoot = path18.join(worktreesRootPath, key);
-    if (!fs18.existsSync(layoutRoot) || !fs18.statSync(layoutRoot).isDirectory()) continue;
-    const sessionDir = path18.join(layoutRoot, sessionId);
+    const layoutRoot = path19.join(worktreesRootPath, key);
+    if (!fs19.existsSync(layoutRoot) || !fs19.statSync(layoutRoot).isDirectory()) continue;
+    const sessionDir = path19.join(layoutRoot, sessionId);
     const nested = tryBindingFromSessionDirectory(sessionDir);
     if (nested) return nested;
     const legacyPaths = collectWorktreeRootsNamed(layoutRoot, sessionId, 24);
     if (legacyPaths.length > 0) {
-      const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path18.resolve(legacyPaths[0]);
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path19.resolve(legacyPaths[0]);
       return {
-        sessionParentPath: path18.resolve(isolated),
-        workingTreeRelRoot: path18.resolve(layoutRoot),
-        repoCheckoutPaths: legacyPaths.map((p) => path18.resolve(p))
+        sessionParentPath: path19.resolve(isolated),
+        workingTreeRelRoot: path19.resolve(layoutRoot),
+        repoCheckoutPaths: legacyPaths.map((p) => path19.resolve(p))
       };
     }
   }
@@ -35123,12 +35502,12 @@ function discoverSessionWorktreeOnDisk(options) {
 function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeRootPathOrHint, sessionId) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hint = path18.resolve(sessionWorktreeRootPathOrHint);
-  const underHint = tryBindingFromSessionDirectory(path18.join(hint, sid));
+  const hint = path19.resolve(sessionWorktreeRootPathOrHint);
+  const underHint = tryBindingFromSessionDirectory(path19.join(hint, sid));
   if (underHint) return underHint;
   const direct = tryBindingFromSessionDirectory(hint);
   if (direct) {
-    if (path18.basename(hint) === sid && isGitDir(hint)) {
+    if (path19.basename(hint) === sid && isGitDir(hint)) {
       const legacyFromCheckout = discoverLegacyBindingAscendingFromCheckout(sid, hint);
       if (legacyFromCheckout && legacyFromCheckout.repoCheckoutPaths.length > direct.repoCheckoutPaths.length) {
         return legacyFromCheckout;
@@ -35136,24 +35515,24 @@ function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeRootPat
     }
     return direct;
   }
-  if (path18.basename(hint) === sid && isGitDir(hint)) {
+  if (path19.basename(hint) === sid && isGitDir(hint)) {
     const legacyFromCheckout = discoverLegacyBindingAscendingFromCheckout(sid, hint);
     if (legacyFromCheckout) return legacyFromCheckout;
   }
   let st;
   try {
-    st = fs18.statSync(hint);
+    st = fs19.statSync(hint);
   } catch {
     return null;
   }
   if (!st.isDirectory()) return null;
   const legacyPaths = collectWorktreeRootsNamed(hint, sid, 24);
   if (legacyPaths.length === 0) return null;
-  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path18.resolve(legacyPaths[0]);
+  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path19.resolve(legacyPaths[0]);
   return {
-    sessionParentPath: path18.resolve(isolated),
+    sessionParentPath: path19.resolve(isolated),
     workingTreeRelRoot: hint,
-    repoCheckoutPaths: legacyPaths.map((p) => path18.resolve(p))
+    repoCheckoutPaths: legacyPaths.map((p) => path19.resolve(p))
   };
 }
 
@@ -35176,10 +35555,10 @@ var SessionWorktreeManager = class {
     this.layout = loadWorktreeLayout();
   }
   rememberSessionWorktrees(sessionId, binding) {
-    const paths = binding.repoCheckoutPaths.map((p) => path19.resolve(p));
+    const paths = binding.repoCheckoutPaths.map((p) => path20.resolve(p));
     this.sessionRepoCheckoutPaths.set(sessionId, paths);
-    this.sessionParentPathBySession.set(sessionId, path19.resolve(binding.sessionParentPath));
-    this.sessionWorkingTreeRelRootBySession.set(sessionId, path19.resolve(binding.workingTreeRelRoot));
+    this.sessionParentPathBySession.set(sessionId, path20.resolve(binding.sessionParentPath));
+    this.sessionWorkingTreeRelRootBySession.set(sessionId, path20.resolve(binding.workingTreeRelRoot));
   }
   sessionParentPathAfterRemember(sessionId) {
     return this.sessionParentPathBySession.get(sessionId);
@@ -35196,7 +35575,7 @@ var SessionWorktreeManager = class {
     const parent = this.sessionParentPathBySession.get(sessionId);
     const relRoot = this.sessionWorkingTreeRelRootBySession.get(sessionId);
     if (!parent || !relRoot) return false;
-    return path19.resolve(parent) !== path19.resolve(relRoot);
+    return path20.resolve(parent) !== path20.resolve(relRoot);
   }
   /**
    * Session parent path for `worktrees_root`: the per-session directory (new layout) or primary checkout (legacy).
@@ -35205,7 +35584,7 @@ var SessionWorktreeManager = class {
     if (!sessionId) return null;
     const sid = sessionId.trim();
     const cached2 = this.sessionParentPathBySession.get(sid);
-    if (cached2) return path19.resolve(cached2);
+    if (cached2) return path20.resolve(cached2);
     const paths = this.ensureRepoCheckoutPathsForSession(sid) ?? this.getRepoCheckoutPathsForSession(sid);
     if (!paths?.length) return null;
     return resolveIsolatedSessionParentPathFromCheckouts(paths);
@@ -35219,7 +35598,7 @@ var SessionWorktreeManager = class {
     const sid = sessionId.trim();
     const parentPathRaw = opts.sessionParentPath?.trim();
     if (parentPathRaw) {
-      const resolved = path19.resolve(parentPathRaw);
+      const resolved = path20.resolve(parentPathRaw);
       if (sid && parseSessionParent(opts.sessionParent) === "worktrees_root") {
         const diskFirst = this.tryDiscoverFromDisk(sid);
         if (diskFirst) {
@@ -35238,7 +35617,7 @@ var SessionWorktreeManager = class {
             this.rememberSessionWorktrees(sid, tryRoot);
             return this.sessionParentPathAfterRemember(sid);
           }
-          const next = path19.dirname(cur);
+          const next = path20.dirname(cur);
           if (next === cur) break;
           cur = next;
         }
@@ -35391,15 +35770,15 @@ var SessionWorktreeManager = class {
   }
 };
 function defaultWorktreesRootPath() {
-  return path19.join(os4.homedir(), ".buildautomaton", "worktrees");
+  return path20.join(os5.homedir(), ".buildautomaton", "worktrees");
 }
 
 // src/files/watch-file-index.ts
 import { watch } from "node:fs";
-import path26 from "node:path";
+import path27 from "node:path";
 
 // src/files/index/build-file-index.ts
-import path23 from "node:path";
+import path24 from "node:path";
 
 // src/runtime/yield-to-event-loop.ts
 function yieldToEventLoop() {
@@ -35407,14 +35786,14 @@ function yieldToEventLoop() {
 }
 
 // src/files/index/walk-workspace-tree.ts
-import fs19 from "node:fs";
-import path21 from "node:path";
+import fs20 from "node:fs";
+import path22 from "node:path";
 
 // src/files/index/constants.ts
-import path20 from "node:path";
-import os5 from "node:os";
+import path21 from "node:path";
+import os6 from "node:os";
 var INDEX_WORK_YIELD_EVERY = 256;
-var INDEX_DIR = path20.join(os5.homedir(), ".buildautomaton");
+var INDEX_DIR = path21.join(os6.homedir(), ".buildautomaton");
 var INDEX_HASH_LEN = 16;
 var INDEX_VERSION = 2;
 var INDEX_LOG_PREFIX = "[file-index]";
@@ -35423,20 +35802,20 @@ var INDEX_LOG_PREFIX = "[file-index]";
 function walkWorkspaceTreeSync(dir, baseDir, out) {
   let names;
   try {
-    names = fs19.readdirSync(dir);
+    names = fs20.readdirSync(dir);
   } catch {
     return;
   }
   for (const name of names) {
     if (name.startsWith(".")) continue;
-    const full = path21.join(dir, name);
+    const full = path22.join(dir, name);
     let stat3;
     try {
-      stat3 = fs19.statSync(full);
+      stat3 = fs20.statSync(full);
     } catch {
       continue;
     }
-    const relative5 = path21.relative(baseDir, full).replace(/\\/g, "/");
+    const relative5 = path22.relative(baseDir, full).replace(/\\/g, "/");
     if (stat3.isDirectory()) {
       walkWorkspaceTreeSync(full, baseDir, out);
     } else if (stat3.isFile()) {
@@ -35447,7 +35826,7 @@ function walkWorkspaceTreeSync(dir, baseDir, out) {
 async function walkWorkspaceTreeAsync(dir, baseDir, out, state) {
   let names;
   try {
-    names = await fs19.promises.readdir(dir);
+    names = await fs20.promises.readdir(dir);
   } catch {
     return;
   }
@@ -35457,14 +35836,14 @@ async function walkWorkspaceTreeAsync(dir, baseDir, out, state) {
       await yieldToEventLoop();
     }
     state.n++;
-    const full = path21.join(dir, name);
+    const full = path22.join(dir, name);
     let stat3;
     try {
-      stat3 = await fs19.promises.stat(full);
+      stat3 = await fs20.promises.stat(full);
     } catch {
       continue;
     }
-    const relative5 = path21.relative(baseDir, full).replace(/\\/g, "/");
+    const relative5 = path22.relative(baseDir, full).replace(/\\/g, "/");
     if (stat3.isDirectory()) {
       await walkWorkspaceTreeAsync(full, baseDir, out, state);
     } else if (stat3.isFile()) {
@@ -35545,22 +35924,22 @@ async function buildTrigramMapForPathsAsync(paths) {
 }
 
 // src/files/index/write-index-file.ts
-import fs20 from "node:fs";
+import fs21 from "node:fs";
 
 // src/files/index/paths.ts
-import path22 from "node:path";
+import path23 from "node:path";
 import crypto2 from "node:crypto";
 function getIndexPathForCwd(resolvedCwd) {
   const hash = crypto2.createHash("sha256").update(resolvedCwd).digest("hex").slice(0, INDEX_HASH_LEN);
-  return path22.join(INDEX_DIR, `.file-index-${hash}.json`);
+  return path23.join(INDEX_DIR, `.file-index-${hash}.json`);
 }
 
 // src/files/index/write-index-file.ts
 function writeIndexFileSync(resolvedCwd, data) {
   const indexPath = getIndexPathForCwd(resolvedCwd);
   try {
-    if (!fs20.existsSync(INDEX_DIR)) fs20.mkdirSync(INDEX_DIR, { recursive: true });
-    fs20.writeFileSync(indexPath, JSON.stringify(data), "utf8");
+    if (!fs21.existsSync(INDEX_DIR)) fs21.mkdirSync(INDEX_DIR, { recursive: true });
+    fs21.writeFileSync(indexPath, JSON.stringify(data), "utf8");
   } catch (e) {
     console.error(`${INDEX_LOG_PREFIX} Failed to write index:`, e);
   }
@@ -35568,8 +35947,8 @@ function writeIndexFileSync(resolvedCwd, data) {
 async function writeIndexFileAsync(resolvedCwd, data) {
   const indexPath = getIndexPathForCwd(resolvedCwd);
   try {
-    await fs20.promises.mkdir(INDEX_DIR, { recursive: true });
-    await fs20.promises.writeFile(indexPath, JSON.stringify(data), "utf8");
+    await fs21.promises.mkdir(INDEX_DIR, { recursive: true });
+    await fs21.promises.writeFile(indexPath, JSON.stringify(data), "utf8");
   } catch (e) {
     console.error(`${INDEX_LOG_PREFIX} Failed to write index:`, e);
   }
@@ -35583,7 +35962,7 @@ function sortPaths(paths) {
   paths.sort((a, b) => a.localeCompare(b, void 0, { sensitivity: "base" }));
 }
 function buildFileIndex(cwd) {
-  const resolved = path23.resolve(cwd);
+  const resolved = path24.resolve(cwd);
   const paths = [];
   walkWorkspaceTreeSync(resolved, resolved, paths);
   sortPaths(paths);
@@ -35593,7 +35972,7 @@ function buildFileIndex(cwd) {
   return data;
 }
 async function buildFileIndexAsync(cwd) {
-  const resolved = path23.resolve(cwd);
+  const resolved = path24.resolve(cwd);
   const paths = [];
   await walkWorkspaceTreeAsync(resolved, resolved, paths, createWalkYieldState());
   await yieldToEventLoop();
@@ -35605,13 +35984,13 @@ async function buildFileIndexAsync(cwd) {
 }
 
 // src/files/index/load-file-index.ts
-import fs21 from "node:fs";
-import path24 from "node:path";
+import fs22 from "node:fs";
+import path25 from "node:path";
 function loadFileIndex(cwd) {
-  const resolved = path24.resolve(cwd);
+  const resolved = path25.resolve(cwd);
   const indexPath = getIndexPathForCwd(resolved);
   try {
-    const raw = fs21.readFileSync(indexPath, "utf8");
+    const raw = fs22.readFileSync(indexPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed !== null && typeof parsed === "object" && Array.isArray(parsed.paths)) {
       const obj = parsed;
@@ -35630,9 +36009,9 @@ function loadFileIndex(cwd) {
 }
 
 // src/files/index/ensure-file-index.ts
-import path25 from "node:path";
+import path26 from "node:path";
 async function ensureFileIndexAsync(cwd) {
-  const resolved = path25.resolve(cwd);
+  const resolved = path26.resolve(cwd);
   const cached2 = loadFileIndex(resolved);
   if (cached2 !== null) return { data: cached2, fromCache: true };
   const data = await buildFileIndexAsync(resolved);
@@ -35715,7 +36094,7 @@ function createFsWatcher(resolved, schedule) {
   }
 }
 function startFileIndexWatcher(cwd = getBridgeRoot()) {
-  const resolved = path26.resolve(cwd);
+  const resolved = path27.resolve(cwd);
   void buildFileIndexAsync(resolved).catch((e) => {
     console.error("[file-index] Initial index build failed:", e);
   });
@@ -35743,7 +36122,7 @@ function startFileIndexWatcher(cwd = getBridgeRoot()) {
 }
 
 // src/connection/create-bridge-connection.ts
-import * as path34 from "node:path";
+import * as path35 from "node:path";
 
 // src/dev-servers/manager/dev-server-manager.ts
 import { rm as rm2 } from "node:fs/promises";
@@ -35787,7 +36166,7 @@ function forceKillChild(proc, log2, shortId, graceMs) {
 }
 
 // src/dev-servers/process/wire-dev-server-child-process.ts
-import fs22 from "node:fs";
+import fs23 from "node:fs";
 
 // src/dev-servers/manager/forward-pipe.ts
 function forwardChildPipe(childReadable, terminal, onData) {
@@ -35823,7 +36202,7 @@ function wireDevServerChildProcess(d) {
         d.setPollInterval(void 0);
         return;
       }
-      fs22.readFile(d.mergedLogPath, (err, buf) => {
+      fs23.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));
@@ -35861,7 +36240,7 @@ ${errTail}` : ""}`);
       d.sendStatus(code === 0 || code == null ? "stopped" : "error", detail, tails);
     };
     if (mergedPath) {
-      fs22.readFile(mergedPath, (err, buf) => {
+      fs23.readFile(mergedPath, (err, buf) => {
         if (!err && buf.length > d.mergedReadPos.value) {
           const chunk = Buffer.from(buf.subarray(d.mergedReadPos.value));
           if (chunk.length > 0) {
@@ -35963,13 +36342,13 @@ function parseDevServerDefs(servers) {
 }
 
 // src/dev-servers/manager/shell-spawn/utils.ts
-import fs23 from "node:fs";
+import fs24 from "node:fs";
 function isSpawnEbadf(e) {
   return typeof e === "object" && e !== null && "code" in e && e.code === "EBADF";
 }
 function rmDirQuiet(dir) {
   try {
-    fs23.rmSync(dir, { recursive: true, force: true });
+    fs24.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -35977,7 +36356,7 @@ var cachedDevNullReadFd;
 function devNullReadFd() {
   if (cachedDevNullReadFd === void 0) {
     const devPath = process.platform === "win32" ? "nul" : "/dev/null";
-    cachedDevNullReadFd = fs23.openSync(devPath, "r");
+    cachedDevNullReadFd = fs24.openSync(devPath, "r");
   }
   return cachedDevNullReadFd;
 }
@@ -36051,15 +36430,15 @@ function trySpawnShellTruePiped(command, env, cwd, devNullFd, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-merged-log-file.ts
 import { spawn as spawn6 } from "node:child_process";
-import fs24 from "node:fs";
+import fs25 from "node:fs";
 import { tmpdir } from "node:os";
-import path27 from "node:path";
+import path28 from "node:path";
 function trySpawnMergedLogFile(command, env, cwd, signal) {
-  const tmpRoot = fs24.mkdtempSync(path27.join(tmpdir(), "ba-devsrv-log-"));
-  const logPath = path27.join(tmpRoot, "combined.log");
+  const tmpRoot = fs25.mkdtempSync(path28.join(tmpdir(), "ba-devsrv-log-"));
+  const logPath = path28.join(tmpRoot, "combined.log");
   let logFd;
   try {
-    logFd = fs24.openSync(logPath, "a");
+    logFd = fs25.openSync(logPath, "a");
   } catch {
     rmDirQuiet(tmpRoot);
     return null;
@@ -36078,7 +36457,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     } else {
       proc = spawn6("/bin/sh", ["-c", command], { env, cwd, stdio, ...signal ? { signal } : {} });
     }
-    fs24.closeSync(logFd);
+    fs25.closeSync(logFd);
     return {
       proc,
       pipedStdoutStderr: true,
@@ -36087,7 +36466,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     };
   } catch (e) {
     try {
-      fs24.closeSync(logFd);
+      fs25.closeSync(logFd);
     } catch {
     }
     rmDirQuiet(tmpRoot);
@@ -36098,22 +36477,22 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-shell-script-log-redirect.ts
 import { spawn as spawn7 } from "node:child_process";
-import fs25 from "node:fs";
+import fs26 from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path28 from "node:path";
+import path29 from "node:path";
 function shSingleQuote(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 function trySpawnShellScriptLogRedirectUnix(command, env, cwd, signal) {
-  const tmpRoot = fs25.mkdtempSync(path28.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path28.join(tmpRoot, "combined.log");
-  const innerPath = path28.join(tmpRoot, "_cmd.sh");
-  const runnerPath = path28.join(tmpRoot, "_run.sh");
+  const tmpRoot = fs26.mkdtempSync(path29.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path29.join(tmpRoot, "combined.log");
+  const innerPath = path29.join(tmpRoot, "_cmd.sh");
+  const runnerPath = path29.join(tmpRoot, "_run.sh");
   try {
-    fs25.writeFileSync(innerPath, `#!/bin/sh
+    fs26.writeFileSync(innerPath, `#!/bin/sh
 ${command}
 `);
-    fs25.writeFileSync(
+    fs26.writeFileSync(
       runnerPath,
       `#!/bin/sh
 cd ${shSingleQuote(cwd)}
@@ -36139,13 +36518,13 @@ cd ${shSingleQuote(cwd)}
   }
 }
 function trySpawnShellScriptLogRedirectWin(command, env, cwd, signal) {
-  const tmpRoot = fs25.mkdtempSync(path28.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path28.join(tmpRoot, "combined.log");
-  const runnerPath = path28.join(tmpRoot, "_run.bat");
+  const tmpRoot = fs26.mkdtempSync(path29.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path29.join(tmpRoot, "combined.log");
+  const runnerPath = path29.join(tmpRoot, "_run.bat");
   const q = (p) => `"${p.replace(/"/g, '""')}"`;
   const com = process.env.ComSpec || "cmd.exe";
   try {
-    fs25.writeFileSync(
+    fs26.writeFileSync(
       runnerPath,
       `@ECHO OFF\r
 CD /D ${q(cwd)}\r
@@ -37082,30 +37461,30 @@ function createOnBridgeIdentified(opts) {
 }
 
 // src/skills/discover-local-agent-skills.ts
-import fs26 from "node:fs";
-import path29 from "node:path";
+import fs27 from "node:fs";
+import path30 from "node:path";
 var SKILL_DISCOVERY_ROOTS = [".agents/skills", ".claude/skills", ".cursor/skills", "skills"];
 function discoverLocalSkills(cwd) {
   const out = [];
   const seenKeys = /* @__PURE__ */ new Set();
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path29.join(cwd, rel);
-    if (!fs26.existsSync(base) || !fs26.statSync(base).isDirectory()) continue;
+    const base = path30.join(cwd, rel);
+    if (!fs27.existsSync(base) || !fs27.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs26.readdirSync(base);
+      entries = fs27.readdirSync(base);
     } catch {
       continue;
     }
     for (const name of entries) {
-      const dir = path29.join(base, name);
+      const dir = path30.join(base, name);
       try {
-        if (!fs26.statSync(dir).isDirectory()) continue;
+        if (!fs27.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      const skillMd = path29.join(dir, "SKILL.md");
-      if (!fs26.existsSync(skillMd)) continue;
+      const skillMd = path30.join(dir, "SKILL.md");
+      if (!fs27.existsSync(skillMd)) continue;
       const key = `${rel}/${name}`;
       if (seenKeys.has(key)) continue;
       seenKeys.add(key);
@@ -37117,23 +37496,23 @@ function discoverLocalSkills(cwd) {
 function discoverSkillLayoutRoots(cwd) {
   const roots = [];
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path29.join(cwd, rel);
-    if (!fs26.existsSync(base) || !fs26.statSync(base).isDirectory()) continue;
+    const base = path30.join(cwd, rel);
+    if (!fs27.existsSync(base) || !fs27.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs26.readdirSync(base);
+      entries = fs27.readdirSync(base);
     } catch {
       continue;
     }
     const skills2 = [];
     for (const name of entries) {
-      const dir = path29.join(base, name);
+      const dir = path30.join(base, name);
       try {
-        if (!fs26.statSync(dir).isDirectory()) continue;
+        if (!fs27.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      if (!fs26.existsSync(path29.join(dir, "SKILL.md"))) continue;
+      if (!fs27.existsSync(path30.join(dir, "SKILL.md"))) continue;
       const relPath = `${rel}/${name}`.replace(/\\/g, "/");
       skills2.push({ name, relPath });
     }
@@ -37315,7 +37694,7 @@ var handleAgentConfigMessage = (msg, deps) => {
 };
 
 // src/prompt-turn-queue/runner.ts
-import fs29 from "node:fs";
+import fs30 from "node:fs";
 
 // src/prompt-turn-queue/client-report.ts
 function sendPromptQueueClientReport(ws, queues) {
@@ -37325,13 +37704,13 @@ function sendPromptQueueClientReport(ws, queues) {
 }
 
 // src/prompt-turn-queue/disk-store.ts
-import fs28 from "node:fs";
+import fs29 from "node:fs";
 
 // src/prompt-turn-queue/paths.ts
 import crypto3 from "node:crypto";
-import fs27 from "node:fs";
-import path30 from "node:path";
-import os6 from "node:os";
+import fs28 from "node:fs";
+import path31 from "node:path";
+import os7 from "node:os";
 var QUEUE_KEY_HEX_64 = /^[a-f0-9]{64}$/i;
 function queueStateFileSlug(queueKey) {
   if (QUEUE_KEY_HEX_64.test(queueKey)) return queueKey.toLowerCase();
@@ -37339,15 +37718,15 @@ function queueStateFileSlug(queueKey) {
 }
 function getPromptQueuesDirectory() {
   const override = process.env.BUILDAMATON_PROMPT_QUEUES_DIR?.trim();
-  if (override) return path30.resolve(override);
-  return path30.join(os6.homedir(), ".buildautomaton", "queues");
+  if (override) return path31.resolve(override);
+  return path31.join(os7.homedir(), ".buildautomaton", "queues");
 }
 function ensurePromptQueuesDirectory() {
   const dir = getPromptQueuesDirectory();
-  if (!fs27.existsSync(dir)) fs27.mkdirSync(dir, { recursive: true });
+  if (!fs28.existsSync(dir)) fs28.mkdirSync(dir, { recursive: true });
 }
 function queueStateFilePath(queueKey) {
-  return path30.join(getPromptQueuesDirectory(), `${queueStateFileSlug(queueKey)}.json`);
+  return path31.join(getPromptQueuesDirectory(), `${queueStateFileSlug(queueKey)}.json`);
 }
 
 // src/prompt-turn-queue/disk-store.ts
@@ -37372,7 +37751,7 @@ function parsePersistedQueueFile(raw) {
 function readPersistedQueue(queueKey) {
   const p = queueStateFilePath(queueKey);
   try {
-    return parsePersistedQueueFile(fs28.readFileSync(p, "utf8"));
+    return parsePersistedQueueFile(fs29.readFileSync(p, "utf8"));
   } catch {
     return null;
   }
@@ -37380,7 +37759,7 @@ function readPersistedQueue(queueKey) {
 function writePersistedQueue(file2) {
   ensurePromptQueuesDirectory();
   const p = queueStateFilePath(file2.queueKey);
-  fs28.writeFileSync(p, JSON.stringify(file2, null, 2), "utf8");
+  fs29.writeFileSync(p, JSON.stringify(file2, null, 2), "utf8");
 }
 function mergeServerQueueSnapshot(queueKey, serverTurns) {
   const prev = readPersistedQueue(queueKey);
@@ -37438,7 +37817,7 @@ async function runLocalRevertBeforeQueuedPrompt(next, deps) {
   const tid = typeof pl.snapshotRevertTurnId === "string" && pl.snapshotRevertTurnId.trim() !== "" ? pl.snapshotRevertTurnId.trim() : next.turnId;
   const agentBase = deps.sessionWorktreeManager.getSessionWorktreeRootForSession(sid) ?? getBridgeRoot();
   const file2 = snapshotFilePath(agentBase, tid);
-  if (!fs29.existsSync(file2)) {
+  if (!fs30.existsSync(file2)) {
     deps.log(
       `[Queue] requeued_with_revert: no pre-turn snapshot for ${tid.slice(0, 8)}\u2026; continuing without revert.`
     );
@@ -37661,9 +38040,9 @@ function parseChangeSummarySnapshots(raw) {
   for (const item of raw) {
     if (!item || typeof item !== "object") continue;
     const o = item;
-    const path36 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
-    if (!path36) continue;
-    const row = { path: path36 };
+    const path37 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
+    if (!path37) continue;
+    const row = { path: path37 };
     if (typeof o.patchContent === "string") row.patchContent = o.patchContent;
     if (typeof o.oldText === "string") row.oldText = o.oldText;
     if (typeof o.newText === "string") row.newText = o.newText;
@@ -37864,8 +38243,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path36, body) {
-  const url2 = `http://127.0.0.1:${port}${path36}`;
+async function requestPreviewApi(port, secret, method, path37, body) {
+  const url2 = `http://127.0.0.1:${port}${path37}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -37877,7 +38256,7 @@ async function requestPreviewApi(port, secret, method, path36, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path36}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path37}: ${res.status}`);
   }
   return data;
 }
@@ -38042,15 +38421,15 @@ var handleSkillCallMessage = (msg, { getWs, log: log2 }) => {
 };
 
 // src/files/list-dir.ts
-import fs30 from "node:fs";
-import path32 from "node:path";
+import fs31 from "node:fs";
+import path33 from "node:path";
 
 // src/files/ensure-under-cwd.ts
-import path31 from "node:path";
+import path32 from "node:path";
 function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
-  const normalized = path31.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path31.resolve(cwd, normalized);
-  if (!resolved.startsWith(cwd + path31.sep) && resolved !== cwd) {
+  const normalized = path32.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path32.resolve(cwd, normalized);
+  if (!resolved.startsWith(cwd + path32.sep) && resolved !== cwd) {
     return null;
   }
   return resolved;
@@ -38064,7 +38443,7 @@ async function listDirAsync(relativePath) {
     return { error: "Path is outside working directory" };
   }
   try {
-    const names = await fs30.promises.readdir(resolved, { withFileTypes: true });
+    const names = await fs31.promises.readdir(resolved, { withFileTypes: true });
     const visible = names.filter((d) => !d.name.startsWith("."));
     const entries = [];
     for (let i = 0; i < visible.length; i++) {
@@ -38072,12 +38451,12 @@ async function listDirAsync(relativePath) {
         await yieldToEventLoop();
       }
       const d = visible[i];
-      const entryPath = path32.join(relativePath || ".", d.name).replace(/\\/g, "/");
-      const fullPath = path32.join(resolved, d.name);
+      const entryPath = path33.join(relativePath || ".", d.name).replace(/\\/g, "/");
+      const fullPath = path33.join(resolved, d.name);
       let isDir = d.isDirectory();
       if (d.isSymbolicLink()) {
         try {
-          const targetStat = await fs30.promises.stat(fullPath);
+          const targetStat = await fs31.promises.stat(fullPath);
           isDir = targetStat.isDirectory();
         } catch {
           isDir = false;
@@ -38102,25 +38481,25 @@ async function listDirAsync(relativePath) {
 }
 
 // src/files/read-file.ts
-import fs31 from "node:fs";
+import fs32 from "node:fs";
 import { StringDecoder } from "node:string_decoder";
 function resolveFilePath(relativePath) {
   const resolved = ensureUnderCwd(relativePath, getBridgeRoot());
   if (!resolved) return { error: "Path is outside working directory" };
   let real;
   try {
-    real = fs31.realpathSync(resolved);
+    real = fs32.realpathSync(resolved);
   } catch {
     real = resolved;
   }
-  const stat3 = fs31.statSync(real);
+  const stat3 = fs32.statSync(real);
   if (!stat3.isFile()) return { error: "Not a file" };
   return real;
 }
 var LINE_CHUNK_SIZE = 64 * 1024;
 function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
-  const fileSize = fs31.statSync(filePath).size;
-  const fd = fs31.openSync(filePath, "r");
+  const fileSize = fs32.statSync(filePath).size;
+  const fd = fs32.openSync(filePath, "r");
   const bufSize = 64 * 1024;
   const buf = Buffer.alloc(bufSize);
   const decoder = new StringDecoder("utf8");
@@ -38133,7 +38512,7 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
   let line0Accum = "";
   try {
     let bytesRead;
-    while (!done && (bytesRead = fs31.readSync(fd, buf, 0, bufSize, null)) > 0) {
+    while (!done && (bytesRead = fs32.readSync(fd, buf, 0, bufSize, null)) > 0) {
       const text = partial2 + decoder.write(buf.subarray(0, bytesRead));
       partial2 = "";
       let lineStart = 0;
@@ -38268,7 +38647,7 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
     }
     return { content: resultLines.join("\n"), size: fileSize };
   } finally {
-    fs31.closeSync(fd);
+    fs32.closeSync(fd);
   }
 }
 function readFile3(relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE) {
@@ -38279,8 +38658,8 @@ function readFile3(relativePath, startLine, endLine, lineOffset, lineChunkSize =
     if (hasRange) {
       return readFileRange(result, startLine, endLine, lineOffset, lineChunkSize);
     }
-    const stat3 = fs31.statSync(result);
-    const raw = fs31.readFileSync(result, "utf8");
+    const stat3 = fs32.statSync(result);
+    const raw = fs32.readFileSync(result, "utf8");
     const lines = raw.split(/\r?\n/);
     return { content: raw, totalLines: lines.length, size: stat3.size };
   } catch (err) {
@@ -38398,8 +38777,8 @@ function handleSkillLayoutRequest(msg, deps) {
 }
 
 // src/skills/install-remote-skills.ts
-import fs32 from "node:fs";
-import path33 from "node:path";
+import fs33 from "node:fs";
+import path34 from "node:path";
 function installRemoteSkills(cwd, targetDir, items) {
   const installed2 = [];
   if (!Array.isArray(items)) {
@@ -38410,15 +38789,15 @@ function installRemoteSkills(cwd, targetDir, items) {
       if (typeof item.sourceId !== "string" || typeof item.skillName !== "string" || typeof item.versionHash !== "string" || !Array.isArray(item.files)) {
         continue;
       }
-      const skillDir = path33.join(cwd, targetDir, item.skillName);
+      const skillDir = path34.join(cwd, targetDir, item.skillName);
       for (const f of item.files) {
         if (typeof f.path !== "string" || !f.text && !f.base64) continue;
-        const dest = path33.join(skillDir, f.path);
-        fs32.mkdirSync(path33.dirname(dest), { recursive: true });
+        const dest = path34.join(skillDir, f.path);
+        fs33.mkdirSync(path34.dirname(dest), { recursive: true });
         if (f.text !== void 0) {
-          fs32.writeFileSync(dest, f.text, "utf8");
+          fs33.writeFileSync(dest, f.text, "utf8");
         } else if (f.base64) {
-          fs32.writeFileSync(dest, Buffer.from(f.base64, "base64"));
+          fs33.writeFileSync(dest, Buffer.from(f.base64, "base64"));
         }
       }
       installed2.push({
@@ -38568,7 +38947,7 @@ var handleSessionDiscardedMessage = (msg, deps) => {
 };
 
 // src/routing/handlers/revert-turn-snapshot.ts
-import * as fs33 from "node:fs";
+import * as fs34 from "node:fs";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
@@ -38580,7 +38959,7 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
     if (!s) return;
     const agentBase = sessionWorktreeManager.getSessionWorktreeRootForSession(sessionId) ?? getBridgeRoot();
     const file2 = snapshotFilePath(agentBase, turnId);
-    if (!fs33.existsSync(file2)) {
+    if (!fs34.existsSync(file2)) {
       sendWsMessage(s, {
         type: "revert_turn_snapshot_result",
         id,
@@ -38953,8 +39332,8 @@ async function createBridgeConnection(options) {
     getCloudAccessToken: () => tokens.accessToken
   };
   const identifyReportedPaths = {
-    bridgeRootPath: path34.resolve(getBridgeRoot()),
-    worktreesRootPath: path34.resolve(worktreesRootPath)
+    bridgeRootPath: path35.resolve(getBridgeRoot()),
+    worktreesRootPath: path35.resolve(worktreesRootPath)
   };
   const { connect } = createMainBridgeWebSocketLifecycle({
     state,
@@ -39190,9 +39569,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 = path35.resolve(process.cwd(), bridgeRootOpt);
+    const resolvedBridgeRoot = path36.resolve(process.cwd(), bridgeRootOpt);
     try {
-      const st = fs34.statSync(resolvedBridgeRoot);
+      const st = fs35.statSync(resolvedBridgeRoot);
       if (!st.isDirectory()) {
         console.error(`Bridge root is not a directory: ${resolvedBridgeRoot}`);
         process.exit(1);
@@ -39212,7 +39591,7 @@ async function runCliAction(program2, opts) {
   );
   let worktreesRootPath;
   if (opts.worktreesRoot && opts.worktreesRoot.trim()) {
-    worktreesRootPath = path35.resolve(opts.worktreesRoot.trim());
+    worktreesRootPath = path36.resolve(opts.worktreesRoot.trim());
   }
   const e2eCertificates = opts.e2eeCertificatesDir?.trim() ? await loadOrCreateE2eCertificates(opts.e2eeCertificatesDir.trim()) : void 0;
   if (e2eCertificates) {