@buildautomaton/cli 0.1.24 → 0.1.26

package/dist/index.js

@@ -4065,8 +4065,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path34, errorMaps, issueData } = params;
-      const fullPath = [...path34, ...issueData.path || []];
+      const { data, path: path35, errorMaps, issueData } = params;
+      const fullPath = [...path35, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -4374,11 +4374,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path34, key) {
+      constructor(parent, value, path35, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path34;
+        this._path = path35;
         this._key = key;
       }
       get path() {
@@ -7993,10 +7993,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path34) {
-  if (!path34)
+function getElementAtPath(obj, path35) {
+  if (!path35)
     return obj;
-  return path34.reduce((acc, key) => acc?.[key], obj);
+  return path35.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -8245,11 +8245,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path34, issues) {
+function prefixIssues(path35, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path34);
+    iss.path.unshift(path35);
     return iss;
   });
 }
@@ -8438,7 +8438,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path34 = []) => {
+  const processError = (error41, path35 = []) => {
     var _a2, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -8448,7 +8448,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path34, ...issue2.path];
+        const fullpath = [...path35, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -8478,9 +8478,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path34) {
+function toDotPath(path35) {
   const segs = [];
-  for (const seg of path34) {
+  for (const seg of path35) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -21669,7 +21669,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;
@@ -21717,7 +21717,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;
         }
@@ -21963,10 +21963,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(path34, isFile, isDirectory) {
-      log2(`checking %s`, path34);
+    function check2(path35, isFile, isDirectory) {
+      log2(`checking %s`, path35);
       try {
-        const stat2 = fs_1.statSync(path34);
+        const stat2 = fs_1.statSync(path35);
         if (stat2.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -21986,8 +21986,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path34, type = exports.READABLE) {
-      return check2(path34, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path35, type = exports.READABLE) {
+      return check2(path35, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -22189,6 +22189,309 @@ function sendWsMessage(ws, payload) {
   }
 }
 
+// src/lib/local-agent-auth.ts
+var LOCAL_AGENT_AUTH_ERROR_HINTS = {
+  "kiro-acp": [/not logged in/i, /kiro-cli\s+login/i, /log in with kiro-cli/i],
+  "cursor-cli": [/cursor_login/i, /authenticate.*cursor/i, /not logged in.*cursor/i, /run:\s*agent\s+login/i],
+  "codex-acp": [
+    /authentication failed/i,
+    /not authenticated/i,
+    /invalid.*api key/i,
+    /sign in.*openai/i,
+    /login.*openai/i,
+    /unauthorized/i
+  ],
+  "claude-code": [
+    /ANTHROPIC_API_KEY/i,
+    /not authenticated/i,
+    /authentication failed/i,
+    /claude\s+login/i,
+    /please run.*claude.*login/i
+  ]
+};
+function localAgentErrorSuggestsAuth(agentType, errorText) {
+  if (agentType == null || agentType === "" || errorText == null || !String(errorText).trim()) return false;
+  const hints = LOCAL_AGENT_AUTH_ERROR_HINTS[agentType];
+  if (!hints?.length) return false;
+  return hints.some((re) => re.test(String(errorText)));
+}
+
+// src/agents/acp/clients/sdk/sdk-stdio-acp-client.ts
+import { spawn } from "node:child_process";
+import { Readable, Writable } from "node:stream";
+
+// src/files/cwd/bridge-root.ts
+import * as path from "node:path";
+var bridgeRootPath = null;
+function getBridgeRoot() {
+  if (bridgeRootPath == null) {
+    bridgeRootPath = path.resolve(process.cwd());
+  }
+  return bridgeRootPath;
+}
+
+// src/agents/acp/clients/agent-stderr-capture.ts
+var STDERR_CAPTURE_MAX = 48e3;
+function createStderrCapture(child) {
+  const chunks = [];
+  let total = 0;
+  return {
+    append(chunk) {
+      try {
+        process.stderr.write(chunk);
+      } catch {
+      }
+      if (total >= STDERR_CAPTURE_MAX) return;
+      const n = Math.min(chunk.length, STDERR_CAPTURE_MAX - total);
+      if (n <= 0) return;
+      chunks.push(n === chunk.length ? chunk : chunk.subarray(0, n));
+      total += n;
+    },
+    getText() {
+      return Buffer.concat(chunks).toString("utf8").trim();
+    }
+  };
+}
+function formatJsonRpcStyleError(err) {
+  if (err instanceof Error) return err.message;
+  if (err != null && typeof err === "object") {
+    const o = err;
+    const msg = typeof o.message === "string" ? o.message : null;
+    const code = o.code != null ? String(o.code) : "";
+    if (msg) return code ? `[${code}] ${msg}` : msg;
+  }
+  if (typeof err === "string") return err;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+function mergeErrorWithStderr(primary, stderrText) {
+  const s = stderrText.trim();
+  const p = (primary ?? "").trim();
+  if (!s) return p;
+  if (!p) return s;
+  if (p.includes(s) || s.includes(p)) return p.length >= s.length ? p : s;
+  return `${p}
+${s}`;
+}
+
+// src/agents/acp/clients/kiro-sdk-ext-notifications.ts
+function createKiroSdkExtNotificationHandler(options) {
+  const { onSessionUpdate } = options;
+  return async (method, params) => {
+    if (method === "_kiro.dev/metadata") {
+      const p = params && typeof params === "object" ? params : {};
+      const pct = p.contextUsagePercentage;
+      if (typeof pct !== "number" || !Number.isFinite(pct) || !onSessionUpdate) return;
+      onSessionUpdate({
+        sessionUpdate: "context_usage",
+        contextUsagePercentage: pct
+      });
+      return;
+    }
+  };
+}
+
+// src/agents/acp/clients/sdk/sdk-stdio-ext-notifications.ts
+var noopExtNotification = async () => {
+};
+function createSdkStdioExtNotificationHandler(options) {
+  const { backendAgentType, onSessionUpdate } = options;
+  switch (backendAgentType) {
+    case "kiro-acp":
+      return createKiroSdkExtNotificationHandler({ onSessionUpdate });
+    default:
+      return noopExtNotification;
+  }
+}
+
+// src/agents/acp/enrich-acp-permission-rpc-result.ts
+var META_KEY = "permissionOptionKind";
+function optionRecordId(rec) {
+  const raw = rec.optionId ?? rec.id;
+  if (typeof raw === "string" && raw.trim() !== "") return raw.trim();
+  if (typeof raw === "number" && Number.isFinite(raw)) return String(raw);
+  return "";
+}
+function enrichAcpPermissionRpcResultFromRequestParams(result, params) {
+  if (params == null || result == null || typeof result !== "object" || Array.isArray(result)) {
+    return result;
+  }
+  const root = result;
+  const outcome = root.outcome;
+  if (outcome == null || typeof outcome !== "object" || Array.isArray(outcome)) return result;
+  const o = outcome;
+  if (o.outcome !== "selected" || typeof o.optionId !== "string" || o.optionId.trim() === "") {
+    return result;
+  }
+  const selectedId = o.optionId.trim();
+  const prevMeta = o._meta != null && typeof o._meta === "object" && !Array.isArray(o._meta) ? o._meta : {};
+  if (typeof prevMeta[META_KEY] === "string" && prevMeta[META_KEY].trim() !== "") {
+    return result;
+  }
+  const rawOpts = Array.isArray(params.options) ? params.options : [];
+  let matchedKind;
+  for (const item of rawOpts) {
+    if (item == null || typeof item !== "object" || Array.isArray(item)) continue;
+    const rec = item;
+    const id = optionRecordId(rec);
+    if (!id || id !== selectedId) continue;
+    if (typeof rec.kind === "string" && rec.kind.trim() !== "") {
+      matchedKind = rec.kind.trim();
+      break;
+    }
+  }
+  if (!matchedKind) return result;
+  return {
+    ...root,
+    outcome: {
+      ...o,
+      _meta: { ...prevMeta, [META_KEY]: matchedKind }
+    }
+  };
+}
+
+// src/cli-log-level.ts
+var verbosity = "info";
+function setCliLogVerbosity(level) {
+  verbosity = level;
+}
+function getCliLogVerbosity() {
+  return verbosity;
+}
+function isCliTrace() {
+  return verbosity === "trace";
+}
+
+// src/log.ts
+function timestampPrefix() {
+  const time3 = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+  return `[${time3}]`;
+}
+function log(line) {
+  console.log(`${timestampPrefix()} ${line}`);
+}
+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}`);
+}
+
+// src/agents/acp/clients/shared/acp-fs-read-write.ts
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } 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]);
+      }
+    }
+  }
+  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 path2 from "node:path";
+function resolveSafePathUnderCwd(cwd, filePath) {
+  const trimmed2 = filePath.trim();
+  if (!trimmed2) return null;
+  const normalizedCwd = path2.resolve(cwd);
+  const resolved = path2.isAbsolute(trimmed2) ? path2.normalize(trimmed2) : path2.resolve(normalizedCwd, trimmed2);
+  const rel = path2.relative(normalizedCwd, resolved);
+  if (rel.startsWith("..") || path2.isAbsolute(rel)) return null;
+  return resolved;
+}
+function toDisplayPathRelativeToCwd(cwd, absolutePath) {
+  const normalizedCwd = path2.resolve(cwd);
+  const rel = path2.relative(normalizedCwd, path2.resolve(absolutePath));
+  if (!rel || rel === "") return path2.basename(absolutePath);
+  return rel.split(path2.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 acpReadTextFileInProcess(ctx, filePath, line, limit) {
+  const resolvedPath = resolveSafePathUnderCwd(ctx.cwd, filePath);
+  if (!resolvedPath) throw new Error("Invalid or disallowed path");
+  try {
+    let content = readFileSync(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 = readFileSync(resolvedPath, "utf8");
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+  mkdirSync(dirname(resolvedPath), { recursive: true });
+  writeFileSync(resolvedPath, newText, "utf8");
+  const displayPath = toDisplayPathRelativeToCwd(ctx.cwd, resolvedPath);
+  const patchContent = editSnippetToUnifiedDiff(displayPath, oldText, newText);
+  ctx.onFileChange?.({ path: displayPath, oldText, newText, patchContent });
+  return {};
+}
+
 // ../types/src/work-items.ts
 init_zod();
 var WorkItemStatusSchema = external_exports.enum(["backlog", "in-progress", "completed"]);
@@ -22489,9 +22792,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 path34 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
-    if (!path34) continue;
-    rows.push({ path: path34, summary: clampSummaryToAtMostTwoLines(summary) });
+    const path35 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
+    if (!path35) continue;
+    rows.push({ path: path35, summary: clampSummaryToAtMostTwoLines(summary) });
   }
   return rows;
 }
@@ -22630,263 +22933,358 @@ function isClaudeCodePermissionMode(value) {
   return MODE_SET.has(value);
 }
 
-// ../types/src/agent-config.ts
-var AGENT_CONFIG_CLAUDE_PERMISSION_MODE_KEY = "claude_permission_mode";
-function getClaudePermissionModeFromAgentConfig(config2) {
-  if (!config2) return null;
-  const raw = config2[AGENT_CONFIG_CLAUDE_PERMISSION_MODE_KEY];
-  if (typeof raw !== "string") return null;
+// ../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();
-  return isClaudeCodePermissionMode(t) ? t : null;
+  if (t === CLI_PERMISSION_MODE_DANGEROUS) return CLI_PERMISSION_MODE_DANGEROUS;
+  if (t === "standard") return CLI_PERMISSION_MODE_DEFAULT;
+  return CLI_PERMISSION_MODE_DEFAULT;
 }
 
-// src/lib/local-agent-auth.ts
-var LOCAL_AGENT_AUTH_ERROR_HINTS = {
-  "kiro-acp": [/not logged in/i, /kiro-cli\s+login/i, /log in with kiro-cli/i],
-  "cursor-cli": [/cursor_login/i, /authenticate.*cursor/i, /not logged in.*cursor/i, /run:\s*agent\s+login/i],
-  "codex-acp": [
-    /authentication failed/i,
-    /not authenticated/i,
-    /invalid.*api key/i,
-    /sign in.*openai/i,
-    /login.*openai/i,
-    /unauthorized/i
-  ],
-  "claude-code": [
-    /ANTHROPIC_API_KEY/i,
-    /not authenticated/i,
-    /authentication failed/i,
-    /claude\s+login/i,
-    /please run.*claude.*login/i
-  ]
-};
-function localAgentErrorSuggestsAuth(agentType, errorText) {
-  if (agentType == null || agentType === "" || errorText == null || !String(errorText).trim()) return false;
-  const hints = LOCAL_AGENT_AUTH_ERROR_HINTS[agentType];
-  if (!hints?.length) return false;
-  return hints.some((re) => re.test(String(errorText)));
+// ../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 } } : {}
+    }
+  };
 }
 
-// src/agents/acp/clients/sdk-stdio-acp-client.ts
-import { spawn } from "node:child_process";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-import { Readable, Writable } from "node:stream";
+// ../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];
+  if (typeof raw !== "string") return null;
+  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/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]);
+// 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;
   }
-  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--;
+  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)}`);
+      }
     }
   }
-  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/files/cwd/bridge-root.ts
-import * as path from "node:path";
-var bridgeRootPath = null;
-function getBridgeRoot() {
-  if (bridgeRootPath == null) {
-    bridgeRootPath = path.resolve(process.cwd());
-  }
-  return bridgeRootPath;
+// 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/safe-fs-path.ts
-import * as path2 from "node:path";
-function resolveSafePathUnderCwd(cwd, filePath) {
-  const trimmed2 = filePath.trim();
-  if (!trimmed2) return null;
-  const normalizedCwd = path2.resolve(cwd);
-  const resolved = path2.isAbsolute(trimmed2) ? path2.normalize(trimmed2) : path2.resolve(normalizedCwd, trimmed2);
-  const rel = path2.relative(normalizedCwd, resolved);
-  if (rel.startsWith("..") || path2.isAbsolute(rel)) return null;
-  return resolved;
+// 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 toDisplayPathRelativeToCwd(cwd, absolutePath) {
-  const normalizedCwd = path2.resolve(cwd);
-  const rel = path2.relative(normalizedCwd, path2.resolve(absolutePath));
-  if (!rel || rel === "") return path2.basename(absolutePath);
-  return rel.split(path2.sep).join("/");
+function sessionIdFromNewSessionResult(raw) {
+  const r = raw && typeof raw === "object" ? raw : {};
+  return typeof r.sessionId === "string" ? r.sessionId : "";
 }
-
-// src/agents/acp/clients/agent-stderr-capture.ts
-var STDERR_CAPTURE_MAX = 48e3;
-function createStderrCapture(child) {
-  const chunks = [];
-  let total = 0;
-  return {
-    append(chunk) {
+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 {
-        process.stderr.write(chunk);
-      } catch {
+        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;
       }
-      if (total >= STDERR_CAPTURE_MAX) return;
-      const n = Math.min(chunk.length, STDERR_CAPTURE_MAX - total);
-      if (n <= 0) return;
-      chunks.push(n === chunk.length ? chunk : chunk.subarray(0, n));
-      total += n;
-    },
-    getText() {
-      return Buffer.concat(chunks).toString("utf8").trim();
     }
-  };
-}
-function formatJsonRpcStyleError(err) {
-  if (err instanceof Error) return err.message;
-  if (err != null && typeof err === "object") {
-    const o = err;
-    const msg = typeof o.message === "string" ? o.message : null;
-    const code = o.code != null ? String(o.code) : "";
-    if (msg) return code ? `[${code}] ${msg}` : msg;
-  }
-  if (typeof err === "string") return err;
-  try {
-    return JSON.stringify(err);
-  } catch {
-    return String(err);
   }
+  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);
 }
-function mergeErrorWithStderr(primary, stderrText) {
-  const s = stderrText.trim();
-  const p = (primary ?? "").trim();
-  if (!s) return p;
-  if (!p) return s;
-  if (p.includes(s) || s.includes(p)) return p.length >= s.length ? p : s;
-  return `${p}
-${s}`;
+
+// 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/kiro-sdk-ext-notifications.ts
-function createKiroSdkExtNotificationHandler(options) {
-  const { onSessionUpdate } = options;
-  return async (method, params) => {
-    if (method === "_kiro.dev/metadata") {
-      const p = params && typeof params === "object" ? params : {};
-      const pct = p.contextUsagePercentage;
-      if (typeof pct !== "number" || !Number.isFinite(pct) || !onSessionUpdate) return;
-      onSessionUpdate({
-        sessionUpdate: "context_usage",
-        contextUsagePercentage: pct
-      });
-      return;
-    }
-  };
+// 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/sdk-stdio-ext-notifications.ts
-var noopExtNotification = async () => {
-};
-function createSdkStdioExtNotificationHandler(options) {
-  const { backendAgentType, onSessionUpdate } = options;
-  switch (backendAgentType) {
-    case "kiro-acp":
-      return createKiroSdkExtNotificationHandler({ onSessionUpdate });
-    default:
-      return noopExtNotification;
+// 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/enrich-acp-permission-rpc-result.ts
-var META_KEY = "permissionOptionKind";
-function optionRecordId(rec) {
-  const raw = rec.optionId ?? rec.id;
-  if (typeof raw === "string" && raw.trim() !== "") return raw.trim();
-  if (typeof raw === "number" && Number.isFinite(raw)) return String(raw);
-  return "";
+// src/agents/acp/clients/shared/flatten-sdk-session-notification.ts
+function flattenSdkSessionNotificationParams(params) {
+  return { sessionId: params.sessionId, ...params.update };
 }
-function enrichAcpPermissionRpcResultFromRequestParams(result, params) {
-  if (params == null || result == null || typeof result !== "object" || Array.isArray(result)) {
-    return result;
-  }
-  const root = result;
-  const outcome = root.outcome;
-  if (outcome == null || typeof outcome !== "object" || Array.isArray(outcome)) return result;
-  const o = outcome;
-  if (o.outcome !== "selected" || typeof o.optionId !== "string" || o.optionId.trim() === "") {
-    return result;
+
+// 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)
+    };
   }
-  const selectedId = o.optionId.trim();
-  const prevMeta = o._meta != null && typeof o._meta === "object" && !Array.isArray(o._meta) ? o._meta : {};
-  if (typeof prevMeta[META_KEY] === "string" && prevMeta[META_KEY].trim() !== "") {
-    return result;
+  if (refusal) {
+    return {
+      success: false,
+      stopReason,
+      output: mergedOutput,
+      error: mergeErrorWithStderr("The agent refused the request.", stderrCaptureText)
+    };
   }
-  const rawOpts = Array.isArray(params.options) ? params.options : [];
-  let matchedKind;
-  for (const item of rawOpts) {
-    if (item == null || typeof item !== "object" || Array.isArray(item)) continue;
-    const rec = item;
-    const id = optionRecordId(rec);
-    if (!id || id !== selectedId) continue;
-    if (typeof rec.kind === "string" && rec.kind.trim() !== "") {
-      matchedKind = rec.kind.trim();
-      break;
-    }
+  if (stderrSuggestsAuth) {
+    return {
+      success: false,
+      stopReason,
+      output: mergedOutput,
+      error: stderrCaptureText
+    };
   }
-  if (!matchedKind) return result;
   return {
-    ...root,
-    outcome: {
-      ...o,
-      _meta: { ...prevMeta, [META_KEY]: matchedKind }
+    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((resolve16) => {
+    pending.set(requestId, { resolve: resolve16, 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-stdio-acp-client.ts
+// 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);
 }
-function sliceFileContentRange(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) {
-  return { sessionId: params.sessionId, ...params.update };
-}
 async function createSdkStdioAcpClient(options) {
   const { ClientSideConnection: ClientSideConnection2, ndJsonStream: ndJsonStream2, PROTOCOL_VERSION: PROTOCOL_VERSION2 } = await Promise.resolve().then(() => (init_acp(), acp_exports));
   const {
@@ -22898,7 +23296,11 @@ async function createSdkStdioAcpClient(options) {
     onFileChange,
     killSubprocessAfterCancelMs,
     onAgentSubprocessExit,
-    agentConfig
+    agentConfig,
+    persistedAcpSessionId,
+    onAcpSessionEstablished,
+    onAcpConfigOptionsUpdated,
+    getActiveConfigOptions
   } = options;
   const isWindows = process.platform === "win32";
   const child = spawn(command[0], command.slice(1), {
@@ -22947,54 +23349,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((resolve17) => {
-              pendingPermissionReplies.set(requestId, { resolve: resolve17, 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 = readFileSync(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 = readFileSync(resolvedPath, "utf8");
-            } catch (e) {
-              if (e.code !== "ENOENT") throw e;
-            }
-            mkdirSync(dirname(resolvedPath), { recursive: true });
-            writeFileSync(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);
@@ -23004,84 +23401,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()]) {
@@ -23089,7 +23421,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) {
@@ -23315,8 +23647,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path34, body) {
-  const url2 = `http://127.0.0.1:${port}${path34}`;
+async function requestPreviewApi(port, secret, method, path35, body) {
+  const url2 = `http://127.0.0.1:${port}${path35}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -23328,7 +23660,7 @@ async function requestPreviewApi(port, secret, method, path34, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path34}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path35}: ${res.status}`);
   }
   return data;
 }
@@ -23471,40 +23803,6 @@ async function callSkill(skillId, operationId, params) {
   return skill.execute(operationId, params);
 }
 
-// src/cli-log-level.ts
-var verbosity = "info";
-function setCliLogVerbosity(level) {
-  verbosity = level;
-}
-function getCliLogVerbosity() {
-  return verbosity;
-}
-function isCliTrace() {
-  return verbosity === "trace";
-}
-
-// src/log.ts
-function timestampPrefix() {
-  const time3 = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
-  return `[${time3}]`;
-}
-function log(line) {
-  console.log(`${timestampPrefix()} ${line}`);
-}
-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}`);
-}
-
 // src/config.ts
 import fs from "node:fs";
 import path3 from "node:path";
@@ -23577,7 +23875,7 @@ function installBridgeProcessResilience() {
 }
 
 // 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";
 
 // ../../node_modules/.pnpm/open@10.2.0/node_modules/open/index.js
 import process7 from "node:process";
@@ -24741,8 +25039,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path34) {
-  return path34 instanceof String && cache.has(path34);
+function isPathSpec(path35) {
+  return path35 instanceof String && cache.has(path35);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -24831,8 +25129,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path34) {
-  return (0, import_file_exists.exists)(path34, import_file_exists.FOLDER);
+function folderExists(path35) {
+  return (0, import_file_exists.exists)(path35, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -25236,8 +25534,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path34) {
-      return /^\.(git)?$/.test(path34.trim());
+    parser(path35) {
+      return /^\.(git)?$/.test(path35.trim());
     }
   };
 }
@@ -25671,11 +25969,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path34, line, preview] = input.split(NULL);
-    paths.add(path34);
-    (results[path34] = results[path34] || []).push({
+    const [path35, line, preview] = input.split(NULL);
+    paths.add(path35);
+    (results[path35] = results[path35] || []).push({
       line: asNumber(line),
-      path: path34,
+      path: path35,
       preview
     });
   });
@@ -26440,14 +26738,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path34, text) {
+function parseInit(bare, path35, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path34, false, result[1]);
+    return new InitSummary(bare, path35, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path34, true, result[1]);
+    return new InitSummary(bare, path35, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -26458,7 +26756,7 @@ function parseInit(bare, path34, text) {
       break;
     }
   }
-  return new InitSummary(bare, path34, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path35, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -26467,9 +26765,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path34, existing, gitDir) {
+      constructor(bare, path35, existing, gitDir) {
         this.bare = bare;
-        this.path = path34;
+        this.path = path35;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -26481,7 +26779,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path34, customArgs) {
+function initTask(bare = false, path35, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -26490,7 +26788,7 @@ function initTask(bare = false, path34, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path34, text);
+      return parseInit(commands.includes("--bare"), path35, text);
     }
   };
 }
@@ -27306,12 +27604,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path34, index, working_dir) {
-        this.path = path34;
+      constructor(path35, index, working_dir) {
+        this.path = path35;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path34) || [null, path34, path34];
+          const detail = fromPathRegex.exec(path35) || [null, path35, path35];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -27342,14 +27640,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path34) {
+  function data(index, workingDir, path35) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path34);
+      handler(result, path35);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path34, index, workingDir));
+      result.files.push(new FileStatusSummary(path35, index, workingDir));
     }
   }
 }
@@ -27658,9 +27956,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path34, write) {
+      hashObject(path35, write) {
         return this._runTask(
-          hashObjectTask(path34, write === true),
+          hashObjectTask(path35, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -28013,8 +28311,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path34 = input.trim().replace(/^["']|["']$/g, "");
-  return path34 && normalize2(path34);
+  const path35 = input.trim().replace(/^["']|["']$/g, "");
+  return path35 && normalize2(path35);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -28328,8 +28626,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path34) {
-  return subModuleTask(["add", repo, path34]);
+function addSubModuleTask(repo, path35) {
+  return subModuleTask(["add", repo, path35]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -28662,8 +28960,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path34, then) {
-      return this._runTask(addSubModuleTask2(repo, path34), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path35, then) {
+      return this._runTask(addSubModuleTask2(repo, path35), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -29550,9 +29848,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: path34, summary }) => {
+  const entries = params.rows.map(({ path: path35, summary }) => {
     const enc = params.e2ee.encryptFields({ summary }, ["summary"]);
-    return { path: path34, summary: JSON.stringify(enc) };
+    return { path: path35, summary: JSON.stringify(enc) };
   });
   const res = await fetch(
     `${base}/api/sessions/${encodeURIComponent(params.sessionId)}/follow-ups/summarize-changes`,
@@ -29734,8 +30032,8 @@ async function sendPromptToAgent(options) {
 }
 
 // src/agents/acp/ensure-acp-client.ts
-import * as fs9 from "node:fs";
-import * as path11 from "node:path";
+import * as fs10 from "node:fs";
+import * as path12 from "node:path";
 
 // src/error-message.ts
 function errorMessage(err) {
@@ -29825,7 +30123,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,
@@ -29833,8 +30131,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 spawn4 } from "node:child_process";
 import * as readline from "node:readline";
 
@@ -29851,7 +30147,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) {
@@ -29868,13 +30180,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();
@@ -29888,7 +30193,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";
@@ -29900,6 +30209,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((resolve16, reject) => {
     child.on("error", (err) => {
       child.kill();
@@ -29908,6 +30236,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";
@@ -29931,7 +30269,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);
@@ -29960,11 +30297,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") {
@@ -29984,21 +30322,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));
@@ -30015,32 +30345,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") {
@@ -30062,16 +30377,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" } });
@@ -30079,76 +30385,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;
         resolve16({
           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);
@@ -30296,7 +30551,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 path10 from "node:path";
 function resolveWorkspaceFilePath(sessionParentPath, rawPath) {
   const trimmed2 = rawPath.trim();
@@ -30328,7 +30583,7 @@ function readUtf8WorkspaceFile(sessionParentPath, displayPath) {
     const rel = path10.relative(gitRoot, resolvedPath2);
     if (!rel.startsWith("..") && !path10.isAbsolute(rel)) {
       try {
-        return readFileSync4(resolvedPath2, "utf8");
+        return readFileSync3(resolvedPath2, "utf8");
       } catch {
       }
     }
@@ -30336,7 +30591,7 @@ function readUtf8WorkspaceFile(sessionParentPath, displayPath) {
   const resolvedPath = resolveSafePathUnderCwd(sessionParentPath, displayPath);
   if (!resolvedPath) return "";
   try {
-    return readFileSync4(resolvedPath, "utf8");
+    return readFileSync3(resolvedPath, "utf8");
   } catch {
     return "";
   }
@@ -30432,7 +30687,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;
@@ -30440,6 +30695,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",
@@ -30840,6 +31115,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;
@@ -30926,14 +31204,73 @@ function buildAcpSessionBridgeHooks(opts) {
   };
 }
 
+// src/agents/acp/local-agent-session-file.ts
+import fs9 from "node:fs";
+import os3 from "node:os";
+import path11 from "node:path";
+var LOCAL_AGENT_SESSION_DIR = path11.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 path11.join(LOCAL_AGENT_SESSION_DIR, `${safeFileSlug(cloudSessionId)}.json`);
+}
+function readLocalAgentSessionFile(cloudSessionId) {
+  try {
+    const p = localAgentSessionFilePath(cloudSessionId);
+    const raw = fs9.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 (!fs9.existsSync(dir)) fs9.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()
+    };
+    fs9.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 && path11.resolve(state.lastAcpCwd) !== path11.resolve(targetSessionParentPath)) {
+  if (state.acpHandle && state.lastAcpCwd != null && path12.resolve(state.lastAcpCwd) !== path12.resolve(targetSessionParentPath)) {
     try {
       state.acpHandle.disconnect();
     } catch {
@@ -30941,6 +31278,7 @@ async function ensureAcpClient(options) {
     state.acpHandle = null;
     state.acpStartPromise = null;
     state.acpAgentKey = null;
+    state.activeSessionConfigOptions = null;
   }
   const resolved = resolveAgentCommand(preferredAgentType);
   if (!resolved) {
@@ -30961,12 +31299,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 = fs9.statSync(targetSessionParentPath);
+      const st = fs10.statSync(targetSessionParentPath);
       statOk = st.isDirectory();
       if (!statOk) {
         state.lastAcpStartError = `Agent cwd is not a directory: ${targetSessionParentPath}`;
@@ -30984,17 +31323,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,
@@ -31024,7 +31393,9 @@ async function createAcpManager(options) {
     acpStartPromise: null,
     lastAcpStartError: null,
     lastAcpCwd: null,
-    acpAgentKey: null
+    acpAgentKey: null,
+    activeSessionConfigOptions: null,
+    latestAgentConfigForBridgeHooks: null
   };
   let backendFallbackAgentType = null;
   const promptRouting = {};
@@ -31074,6 +31445,7 @@ async function createAcpManager(options) {
         agentConfig: agentConfig ?? null,
         sessionParentPath,
         routing: promptRouting,
+        cloudSessionId: sessionId,
         sendSessionUpdate,
         sendRequest: sendSessionUpdate,
         log: log2
@@ -31164,6 +31536,8 @@ async function createAcpManager(options) {
     state.acpHandle = null;
     state.acpStartPromise = null;
     state.acpAgentKey = null;
+    state.activeSessionConfigOptions = null;
+    state.latestAgentConfigForBridgeHooks = null;
   }
   return {
     setPreferredAgentType,
@@ -31176,12 +31550,12 @@ async function createAcpManager(options) {
 }
 
 // src/worktrees/session-worktree-manager.ts
-import * as path18 from "node:path";
-import os4 from "node:os";
+import * as path19 from "node:path";
+import os5 from "node:os";
 
 // src/worktrees/prepare-new-session-worktrees.ts
-import * as fs11 from "node:fs";
-import * as path13 from "node:path";
+import * as fs12 from "node:fs";
+import * as path14 from "node:path";
 
 // src/git/worktree-add.ts
 async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch) {
@@ -31190,12 +31564,12 @@ async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch) {
 }
 
 // src/worktrees/worktree-layout-file.ts
-import * as fs10 from "node:fs";
-import * as path12 from "node:path";
-import os3 from "node:os";
+import * as fs11 from "node:fs";
+import * as path13 from "node:path";
+import os4 from "node:os";
 var LAYOUT_FILENAME = "worktree-launcher-layout.json";
 function defaultWorktreeLayoutPath() {
-  return path12.join(os3.homedir(), ".buildautomaton", LAYOUT_FILENAME);
+  return path13.join(os4.homedir(), ".buildautomaton", LAYOUT_FILENAME);
 }
 function normalizeLoadedLayout(raw) {
   if (raw && typeof raw === "object" && "launcherCwds" in raw) {
@@ -31207,8 +31581,8 @@ function normalizeLoadedLayout(raw) {
 function loadWorktreeLayout() {
   try {
     const p = defaultWorktreeLayoutPath();
-    if (!fs10.existsSync(p)) return { launcherCwds: [] };
-    const raw = JSON.parse(fs10.readFileSync(p, "utf8"));
+    if (!fs11.existsSync(p)) return { launcherCwds: [] };
+    const raw = JSON.parse(fs11.readFileSync(p, "utf8"));
     return normalizeLoadedLayout(raw);
   } catch {
     return { launcherCwds: [] };
@@ -31216,24 +31590,24 @@ function loadWorktreeLayout() {
 }
 function saveWorktreeLayout(layout) {
   try {
-    const dir = path12.dirname(defaultWorktreeLayoutPath());
-    fs10.mkdirSync(dir, { recursive: true });
-    fs10.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
+    const dir = path13.dirname(defaultWorktreeLayoutPath());
+    fs11.mkdirSync(dir, { recursive: true });
+    fs11.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
   } catch {
   }
 }
 function baseNameSafe(pathString) {
-  return path12.basename(pathString).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
+  return path13.basename(pathString).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
 }
 function getLauncherDirNameIfPresent(layout, bridgeRootPath2) {
-  const norm = path12.resolve(bridgeRootPath2);
-  const existing = layout.launcherCwds.find((e) => path12.resolve(e.absolutePath) === norm);
+  const norm = path13.resolve(bridgeRootPath2);
+  const existing = layout.launcherCwds.find((e) => path13.resolve(e.absolutePath) === norm);
   return existing?.dirName;
 }
 function allocateDirNameForLauncherCwd(layout, bridgeRootPath2) {
   const existing = getLauncherDirNameIfPresent(layout, bridgeRootPath2);
   if (existing) return existing;
-  const norm = path12.resolve(bridgeRootPath2);
+  const norm = path13.resolve(bridgeRootPath2);
   const base = baseNameSafe(norm);
   const used = new Set(layout.launcherCwds.map((e) => e.dirName));
   let name = base;
@@ -31250,10 +31624,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 = path13.resolve(bridgeRoot);
+  const bridgeResolved = path14.resolve(bridgeRoot);
   const cwdKey = allocateDirNameForLauncherCwd(layout, bridgeResolved);
-  const bridgeKeyDir = path13.join(worktreesRootPath, cwdKey);
-  const sessionDir = path13.join(bridgeKeyDir, sessionId);
+  const bridgeKeyDir = path14.join(worktreesRootPath, cwdKey);
+  const sessionDir = path14.join(bridgeKeyDir, sessionId);
   const repos = await discoverGitReposUnderRoot(bridgeResolved);
   if (repos.length === 0) {
     log2("[worktrees] No Git repositories under bridge root; skipping worktree creation.");
@@ -31261,14 +31635,14 @@ async function prepareNewSessionWorktrees(options) {
   }
   const branch = `session-${sessionId}`;
   const worktreePaths = [];
-  fs11.mkdirSync(sessionDir, { recursive: true });
+  fs12.mkdirSync(sessionDir, { recursive: true });
   for (const repo of repos) {
-    let rel = path13.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path13.isAbsolute(rel)) continue;
+    let rel = path14.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path14.isAbsolute(rel)) continue;
     const relNorm = rel === "" ? "." : rel;
-    const wtPath = relNorm === "." ? sessionDir : path13.join(sessionDir, relNorm);
+    const wtPath = relNorm === "." ? sessionDir : path14.join(sessionDir, relNorm);
     if (relNorm !== ".") {
-      fs11.mkdirSync(path13.dirname(wtPath), { recursive: true });
+      fs12.mkdirSync(path14.dirname(wtPath), { recursive: true });
     }
     try {
       await gitWorktreeAddBranch(repo.absolutePath, wtPath, branch);
@@ -31310,23 +31684,23 @@ async function renameSessionWorktreeBranches(paths, newBranch, log2) {
 }
 
 // src/worktrees/remove-session-worktrees.ts
-import * as fs14 from "node:fs";
+import * as fs15 from "node:fs";
 
 // src/git/worktree-remove.ts
-import * as fs13 from "node:fs";
+import * as fs14 from "node:fs";
 
 // src/git/resolve-main-repo-from-git-file.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";
 function resolveMainRepoFromWorktreeGitFile(wt) {
-  const gitDirFile = path14.join(wt, ".git");
-  if (!fs12.existsSync(gitDirFile) || !fs12.statSync(gitDirFile).isFile()) return "";
-  const first2 = fs12.readFileSync(gitDirFile, "utf8").trim();
+  const gitDirFile = path15.join(wt, ".git");
+  if (!fs13.existsSync(gitDirFile) || !fs13.statSync(gitDirFile).isFile()) return "";
+  const first2 = fs13.readFileSync(gitDirFile, "utf8").trim();
   const m = first2.match(/^gitdir:\s*(.+)$/im);
   if (!m) return "";
-  const gitWorktreePath = path14.resolve(wt, m[1].trim());
-  const gitDir = path14.dirname(path14.dirname(gitWorktreePath));
-  return path14.dirname(gitDir);
+  const gitWorktreePath = path15.resolve(wt, m[1].trim());
+  const gitDir = path15.dirname(path15.dirname(gitWorktreePath));
+  return path15.dirname(gitDir);
 }
 
 // src/git/worktree-remove.ts
@@ -31335,7 +31709,7 @@ async function gitWorktreeRemoveForce(worktreePath) {
   if (mainRepo) {
     await cliSimpleGit(mainRepo).raw(["worktree", "remove", "--force", worktreePath]);
   } else {
-    fs13.rmSync(worktreePath, { recursive: true, force: true });
+    fs14.rmSync(worktreePath, { recursive: true, force: true });
   }
 }
 
@@ -31348,7 +31722,7 @@ async function removeSessionWorktrees(paths, log2) {
     } catch (e) {
       log2(`[worktrees] Remove failed for ${wt}: ${e instanceof Error ? e.message : String(e)}`);
       try {
-        fs14.rmSync(wt, { recursive: true, force: true });
+        fs15.rmSync(wt, { recursive: true, force: true });
       } catch {
       }
     }
@@ -31568,7 +31942,7 @@ function formatRemoteDisplayLabel(remoteUrl) {
 }
 
 // src/git/working-directory/changes/get-working-tree-change-repo-details.ts
-import * as path16 from "node:path";
+import * as path17 from "node:path";
 
 // src/git/working-directory/changes/parse-git-status.ts
 function parseNameStatusLines(lines) {
@@ -31688,8 +32062,8 @@ async function listChangedFilesForCommit(repoGitCwd, repoRelPath, commitSha) {
 }
 
 // src/git/working-directory/changes/list-changed-files-for-repo.ts
-import * as fs16 from "node:fs";
-import * as path15 from "node:path";
+import * as fs17 from "node:fs";
+import * as path16 from "node:path";
 
 // src/git/working-directory/changes/count-lines.ts
 import { createReadStream } from "node:fs";
@@ -31713,7 +32087,7 @@ async function countTextFileLines(filePath) {
 }
 
 // src/git/working-directory/changes/hydrate-patch.ts
-import * as fs15 from "node:fs";
+import * as fs16 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;
@@ -31728,7 +32102,7 @@ async function readGitBlobLines(repoCwd, pathInRepo) {
 }
 async function readWorktreeFileLines(filePath) {
   try {
-    const raw = await fs15.promises.readFile(filePath, "utf8");
+    const raw = await fs16.promises.readFile(filePath, "utf8");
     return raw.split(/\r?\n/);
   } catch {
     return null;
@@ -31863,7 +32237,7 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
   const rows = [];
   for (const pathInRepo of paths) {
     const relLauncher = posixJoinDirFile(repoRelPath, pathInRepo.replace(/\\/g, "/"));
-    const repoFilePath = path15.join(repoGitCwd, pathInRepo);
+    const repoFilePath = path16.join(repoGitCwd, pathInRepo);
     const nums = numByPath.get(pathInRepo);
     let additions = nums?.additions ?? 0;
     let deletions = nums?.deletions ?? 0;
@@ -31876,7 +32250,7 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
         deletions = fromGit.deletions;
       } else {
         try {
-          const st = await fs16.promises.stat(repoFilePath);
+          const st = await fs17.promises.stat(repoFilePath);
           if (st.isFile()) additions = await countTextFileLines(repoFilePath);
           else additions = 0;
         } catch {
@@ -31902,7 +32276,7 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
     } else {
       pathInRepo = row.pathRelLauncher;
     }
-    const filePath = path15.join(repoGitCwd, pathInRepo);
+    const filePath = path16.join(repoGitCwd, pathInRepo);
     let patch = await unifiedDiffForFile(repoGitCwd, pathInRepo, row.change);
     if (patch) {
       patch = await hydrateUnifiedPatchWithFileContext(patch, filePath, repoGitCwd, pathInRepo, row.change);
@@ -31918,8 +32292,8 @@ function normRepoRel(p) {
   return x === "" ? "." : x;
 }
 async function getWorkingTreeChangeRepoDetails(options) {
-  const bridgeRoot = path16.resolve(getBridgeRoot());
-  const sessionWtRoot = options.sessionWorktreeRootPath ? path16.resolve(options.sessionWorktreeRootPath) : null;
+  const bridgeRoot = path17.resolve(getBridgeRoot());
+  const sessionWtRoot = options.sessionWorktreeRootPath ? path17.resolve(options.sessionWorktreeRootPath) : null;
   const legacyNested = options.legacyRepoNestedSessionLayout === true;
   const out = [];
   const filter = options.repoFilterRelPath != null ? normRepoRel(options.repoFilterRelPath) : null;
@@ -31932,7 +32306,7 @@ async function getWorkingTreeChangeRepoDetails(options) {
   }
   const basis = filter == null && basisInput.kind === "commit" ? { kind: "working" } : basisInput;
   for (const target of options.commitTargetPaths) {
-    const t = path16.resolve(target);
+    const t = path17.resolve(target);
     if (!await isGitRepoDirectory(t)) continue;
     const g = cliSimpleGit(t);
     let branch = "HEAD";
@@ -31945,8 +32319,8 @@ async function getWorkingTreeChangeRepoDetails(options) {
     const remoteDisplay = formatRemoteDisplayLabel(remoteUrl);
     let repoRelPath;
     if (sessionWtRoot) {
-      const anchor = legacyNested ? path16.dirname(t) : t;
-      const relNorm = path16.relative(sessionWtRoot, anchor);
+      const anchor = legacyNested ? path17.dirname(t) : t;
+      const relNorm = path17.relative(sessionWtRoot, anchor);
       repoRelPath = relNorm === "" ? "." : relNorm.replace(/\\/g, "/");
     } else {
       let top = t;
@@ -31955,8 +32329,8 @@ async function getWorkingTreeChangeRepoDetails(options) {
       } catch {
         top = t;
       }
-      const rel = path16.relative(bridgeRoot, path16.resolve(top)).replace(/\\/g, "/") || ".";
-      repoRelPath = rel.startsWith("..") ? path16.basename(path16.resolve(top)) : rel;
+      const rel = path17.relative(bridgeRoot, path17.resolve(top)).replace(/\\/g, "/") || ".";
+      repoRelPath = rel.startsWith("..") ? path17.basename(path17.resolve(top)) : rel;
     }
     const norm = normRepoRel(repoRelPath === "" ? "." : repoRelPath);
     if (filter && norm !== filter) continue;
@@ -32021,11 +32395,11 @@ async function commitSessionWorktrees(options) {
 }
 
 // src/worktrees/discover-session-worktree-on-disk.ts
-import * as fs17 from "node:fs";
-import * as path17 from "node:path";
+import * as fs18 from "node:fs";
+import * as path18 from "node:path";
 function isGitDir(dirPath) {
   try {
-    return fs17.existsSync(path17.join(dirPath, ".git"));
+    return fs18.existsSync(path18.join(dirPath, ".git"));
   } catch {
     return false;
   }
@@ -32034,23 +32408,23 @@ function collectGitRepoRootsUnderDirectory(rootPath) {
   const out = [];
   const walk = (dir) => {
     if (isGitDir(dir)) {
-      out.push(path17.resolve(dir));
+      out.push(path18.resolve(dir));
       return;
     }
     let entries;
     try {
-      entries = fs17.readdirSync(dir, { withFileTypes: true });
+      entries = fs18.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
-      const full = path17.join(dir, e.name);
+      const full = path18.join(dir, e.name);
       if (!e.isDirectory()) continue;
       walk(full);
     }
   };
-  walk(path17.resolve(rootPath));
+  walk(path18.resolve(rootPath));
   return [...new Set(out)];
 }
 function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
@@ -32059,16 +32433,16 @@ function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = fs17.readdirSync(dir, { withFileTypes: true });
+      entries = fs18.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
-      const full = path17.join(dir, e.name);
+      const full = path18.join(dir, e.name);
       if (!e.isDirectory()) continue;
       if (e.name === sessionId) {
-        if (isGitDir(full)) out.push(path17.resolve(full));
+        if (isGitDir(full)) out.push(path18.resolve(full));
       } else {
         walk(full, depth + 1);
       }
@@ -32080,14 +32454,14 @@ function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
 function tryBindingFromSessionDirectory(sessionDir) {
   let st;
   try {
-    st = fs17.statSync(sessionDir);
+    st = fs18.statSync(sessionDir);
   } catch {
     return null;
   }
   if (!st.isDirectory()) return null;
   const worktreePaths = collectGitRepoRootsUnderDirectory(sessionDir);
   if (worktreePaths.length === 0) return null;
-  const abs = path17.resolve(sessionDir);
+  const abs = path18.resolve(sessionDir);
   return {
     sessionParentPath: abs,
     workingTreeRelRoot: abs,
@@ -32097,20 +32471,20 @@ function tryBindingFromSessionDirectory(sessionDir) {
 function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hintR = path17.resolve(checkoutPath);
+  const hintR = path18.resolve(checkoutPath);
   let best = null;
-  let cur = path17.dirname(hintR);
+  let cur = path18.dirname(hintR);
   for (let i = 0; i < 40; i++) {
     const paths = collectWorktreeRootsNamed(cur, sid, 24);
-    if (paths.some((p) => path17.resolve(p) === hintR)) {
-      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths) ?? path17.resolve(paths[0]);
+    if (paths.some((p) => path18.resolve(p) === hintR)) {
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths) ?? path18.resolve(paths[0]);
       best = {
-        sessionParentPath: path17.resolve(isolated),
-        workingTreeRelRoot: path17.resolve(cur),
-        repoCheckoutPaths: paths.map((p) => path17.resolve(p))
+        sessionParentPath: path18.resolve(isolated),
+        workingTreeRelRoot: path18.resolve(cur),
+        repoCheckoutPaths: paths.map((p) => path18.resolve(p))
       };
     }
-    const next = path17.dirname(cur);
+    const next = path18.dirname(cur);
     if (next === cur) break;
     cur = next;
   }
@@ -32118,33 +32492,33 @@ function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
 }
 function discoverSessionWorktreeOnDisk(options) {
   const { sessionId, worktreesRootPath, layout, bridgeRoot } = options;
-  if (!sessionId.trim() || !fs17.existsSync(worktreesRootPath)) return null;
+  if (!sessionId.trim() || !fs18.existsSync(worktreesRootPath)) return null;
   const preferredKey = getLauncherDirNameIfPresent(layout, bridgeRoot);
   const keys = [];
   if (preferredKey) keys.push(preferredKey);
   try {
-    for (const name of fs17.readdirSync(worktreesRootPath)) {
+    for (const name of fs18.readdirSync(worktreesRootPath)) {
       if (name.startsWith(".")) continue;
-      const p = path17.join(worktreesRootPath, name);
-      if (!fs17.statSync(p).isDirectory()) continue;
+      const p = path18.join(worktreesRootPath, name);
+      if (!fs18.statSync(p).isDirectory()) continue;
       if (name !== preferredKey) keys.push(name);
     }
   } catch {
     return null;
   }
   for (const key of keys) {
-    const layoutRoot = path17.join(worktreesRootPath, key);
-    if (!fs17.existsSync(layoutRoot) || !fs17.statSync(layoutRoot).isDirectory()) continue;
-    const sessionDir = path17.join(layoutRoot, sessionId);
+    const layoutRoot = path18.join(worktreesRootPath, key);
+    if (!fs18.existsSync(layoutRoot) || !fs18.statSync(layoutRoot).isDirectory()) continue;
+    const sessionDir = path18.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) ?? path17.resolve(legacyPaths[0]);
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path18.resolve(legacyPaths[0]);
       return {
-        sessionParentPath: path17.resolve(isolated),
-        workingTreeRelRoot: path17.resolve(layoutRoot),
-        repoCheckoutPaths: legacyPaths.map((p) => path17.resolve(p))
+        sessionParentPath: path18.resolve(isolated),
+        workingTreeRelRoot: path18.resolve(layoutRoot),
+        repoCheckoutPaths: legacyPaths.map((p) => path18.resolve(p))
       };
     }
   }
@@ -32153,12 +32527,12 @@ function discoverSessionWorktreeOnDisk(options) {
 function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeRootPathOrHint, sessionId) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hint = path17.resolve(sessionWorktreeRootPathOrHint);
-  const underHint = tryBindingFromSessionDirectory(path17.join(hint, sid));
+  const hint = path18.resolve(sessionWorktreeRootPathOrHint);
+  const underHint = tryBindingFromSessionDirectory(path18.join(hint, sid));
   if (underHint) return underHint;
   const direct = tryBindingFromSessionDirectory(hint);
   if (direct) {
-    if (path17.basename(hint) === sid && isGitDir(hint)) {
+    if (path18.basename(hint) === sid && isGitDir(hint)) {
       const legacyFromCheckout = discoverLegacyBindingAscendingFromCheckout(sid, hint);
       if (legacyFromCheckout && legacyFromCheckout.repoCheckoutPaths.length > direct.repoCheckoutPaths.length) {
         return legacyFromCheckout;
@@ -32166,24 +32540,24 @@ function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeRootPat
     }
     return direct;
   }
-  if (path17.basename(hint) === sid && isGitDir(hint)) {
+  if (path18.basename(hint) === sid && isGitDir(hint)) {
     const legacyFromCheckout = discoverLegacyBindingAscendingFromCheckout(sid, hint);
     if (legacyFromCheckout) return legacyFromCheckout;
   }
   let st;
   try {
-    st = fs17.statSync(hint);
+    st = fs18.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) ?? path17.resolve(legacyPaths[0]);
+  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path18.resolve(legacyPaths[0]);
   return {
-    sessionParentPath: path17.resolve(isolated),
+    sessionParentPath: path18.resolve(isolated),
     workingTreeRelRoot: hint,
-    repoCheckoutPaths: legacyPaths.map((p) => path17.resolve(p))
+    repoCheckoutPaths: legacyPaths.map((p) => path18.resolve(p))
   };
 }
 
@@ -32206,10 +32580,10 @@ var SessionWorktreeManager = class {
     this.layout = loadWorktreeLayout();
   }
   rememberSessionWorktrees(sessionId, binding) {
-    const paths = binding.repoCheckoutPaths.map((p) => path18.resolve(p));
+    const paths = binding.repoCheckoutPaths.map((p) => path19.resolve(p));
     this.sessionRepoCheckoutPaths.set(sessionId, paths);
-    this.sessionParentPathBySession.set(sessionId, path18.resolve(binding.sessionParentPath));
-    this.sessionWorkingTreeRelRootBySession.set(sessionId, path18.resolve(binding.workingTreeRelRoot));
+    this.sessionParentPathBySession.set(sessionId, path19.resolve(binding.sessionParentPath));
+    this.sessionWorkingTreeRelRootBySession.set(sessionId, path19.resolve(binding.workingTreeRelRoot));
   }
   sessionParentPathAfterRemember(sessionId) {
     return this.sessionParentPathBySession.get(sessionId);
@@ -32226,7 +32600,7 @@ var SessionWorktreeManager = class {
     const parent = this.sessionParentPathBySession.get(sessionId);
     const relRoot = this.sessionWorkingTreeRelRootBySession.get(sessionId);
     if (!parent || !relRoot) return false;
-    return path18.resolve(parent) !== path18.resolve(relRoot);
+    return path19.resolve(parent) !== path19.resolve(relRoot);
   }
   /**
    * Session parent path for `worktrees_root`: the per-session directory (new layout) or primary checkout (legacy).
@@ -32235,7 +32609,7 @@ var SessionWorktreeManager = class {
     if (!sessionId) return null;
     const sid = sessionId.trim();
     const cached2 = this.sessionParentPathBySession.get(sid);
-    if (cached2) return path18.resolve(cached2);
+    if (cached2) return path19.resolve(cached2);
     const paths = this.ensureRepoCheckoutPathsForSession(sid) ?? this.getRepoCheckoutPathsForSession(sid);
     if (!paths?.length) return null;
     return resolveIsolatedSessionParentPathFromCheckouts(paths);
@@ -32249,7 +32623,7 @@ var SessionWorktreeManager = class {
     const sid = sessionId.trim();
     const parentPathRaw = opts.sessionParentPath?.trim();
     if (parentPathRaw) {
-      const resolved = path18.resolve(parentPathRaw);
+      const resolved = path19.resolve(parentPathRaw);
       if (sid && parseSessionParent(opts.sessionParent) === "worktrees_root") {
         const diskFirst = this.tryDiscoverFromDisk(sid);
         if (diskFirst) {
@@ -32268,7 +32642,7 @@ var SessionWorktreeManager = class {
             this.rememberSessionWorktrees(sid, tryRoot);
             return this.sessionParentPathAfterRemember(sid);
           }
-          const next = path18.dirname(cur);
+          const next = path19.dirname(cur);
           if (next === cur) break;
           cur = next;
         }
@@ -32421,15 +32795,15 @@ var SessionWorktreeManager = class {
   }
 };
 function defaultWorktreesRootPath() {
-  return path18.join(os4.homedir(), ".buildautomaton", "worktrees");
+  return path19.join(os5.homedir(), ".buildautomaton", "worktrees");
 }
 
 // src/files/watch-file-index.ts
 import { watch } from "node:fs";
-import path25 from "node:path";
+import path26 from "node:path";
 
 // src/files/index/build-file-index.ts
-import path22 from "node:path";
+import path23 from "node:path";
 
 // src/runtime/yield-to-event-loop.ts
 function yieldToEventLoop() {
@@ -32437,14 +32811,14 @@ function yieldToEventLoop() {
 }
 
 // src/files/index/walk-workspace-tree.ts
-import fs18 from "node:fs";
-import path20 from "node:path";
+import fs19 from "node:fs";
+import path21 from "node:path";
 
 // src/files/index/constants.ts
-import path19 from "node:path";
-import os5 from "node:os";
+import path20 from "node:path";
+import os6 from "node:os";
 var INDEX_WORK_YIELD_EVERY = 256;
-var INDEX_DIR = path19.join(os5.homedir(), ".buildautomaton");
+var INDEX_DIR = path20.join(os6.homedir(), ".buildautomaton");
 var INDEX_HASH_LEN = 16;
 var INDEX_VERSION = 2;
 var INDEX_LOG_PREFIX = "[file-index]";
@@ -32453,20 +32827,20 @@ var INDEX_LOG_PREFIX = "[file-index]";
 function walkWorkspaceTreeSync(dir, baseDir, out) {
   let names;
   try {
-    names = fs18.readdirSync(dir);
+    names = fs19.readdirSync(dir);
   } catch {
     return;
   }
   for (const name of names) {
     if (name.startsWith(".")) continue;
-    const full = path20.join(dir, name);
+    const full = path21.join(dir, name);
     let stat2;
     try {
-      stat2 = fs18.statSync(full);
+      stat2 = fs19.statSync(full);
     } catch {
       continue;
     }
-    const relative5 = path20.relative(baseDir, full).replace(/\\/g, "/");
+    const relative5 = path21.relative(baseDir, full).replace(/\\/g, "/");
     if (stat2.isDirectory()) {
       walkWorkspaceTreeSync(full, baseDir, out);
     } else if (stat2.isFile()) {
@@ -32477,7 +32851,7 @@ function walkWorkspaceTreeSync(dir, baseDir, out) {
 async function walkWorkspaceTreeAsync(dir, baseDir, out, state) {
   let names;
   try {
-    names = await fs18.promises.readdir(dir);
+    names = await fs19.promises.readdir(dir);
   } catch {
     return;
   }
@@ -32487,14 +32861,14 @@ async function walkWorkspaceTreeAsync(dir, baseDir, out, state) {
       await yieldToEventLoop();
     }
     state.n++;
-    const full = path20.join(dir, name);
+    const full = path21.join(dir, name);
     let stat2;
     try {
-      stat2 = await fs18.promises.stat(full);
+      stat2 = await fs19.promises.stat(full);
     } catch {
       continue;
     }
-    const relative5 = path20.relative(baseDir, full).replace(/\\/g, "/");
+    const relative5 = path21.relative(baseDir, full).replace(/\\/g, "/");
     if (stat2.isDirectory()) {
       await walkWorkspaceTreeAsync(full, baseDir, out, state);
     } else if (stat2.isFile()) {
@@ -32575,22 +32949,22 @@ async function buildTrigramMapForPathsAsync(paths) {
 }
 
 // src/files/index/write-index-file.ts
-import fs19 from "node:fs";
+import fs20 from "node:fs";
 
 // src/files/index/paths.ts
-import path21 from "node:path";
+import path22 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 path21.join(INDEX_DIR, `.file-index-${hash}.json`);
+  return path22.join(INDEX_DIR, `.file-index-${hash}.json`);
 }
 
 // src/files/index/write-index-file.ts
 function writeIndexFileSync(resolvedCwd, data) {
   const indexPath = getIndexPathForCwd(resolvedCwd);
   try {
-    if (!fs19.existsSync(INDEX_DIR)) fs19.mkdirSync(INDEX_DIR, { recursive: true });
-    fs19.writeFileSync(indexPath, JSON.stringify(data), "utf8");
+    if (!fs20.existsSync(INDEX_DIR)) fs20.mkdirSync(INDEX_DIR, { recursive: true });
+    fs20.writeFileSync(indexPath, JSON.stringify(data), "utf8");
   } catch (e) {
     console.error(`${INDEX_LOG_PREFIX} Failed to write index:`, e);
   }
@@ -32598,8 +32972,8 @@ function writeIndexFileSync(resolvedCwd, data) {
 async function writeIndexFileAsync(resolvedCwd, data) {
   const indexPath = getIndexPathForCwd(resolvedCwd);
   try {
-    await fs19.promises.mkdir(INDEX_DIR, { recursive: true });
-    await fs19.promises.writeFile(indexPath, JSON.stringify(data), "utf8");
+    await fs20.promises.mkdir(INDEX_DIR, { recursive: true });
+    await fs20.promises.writeFile(indexPath, JSON.stringify(data), "utf8");
   } catch (e) {
     console.error(`${INDEX_LOG_PREFIX} Failed to write index:`, e);
   }
@@ -32613,7 +32987,7 @@ function sortPaths(paths) {
   paths.sort((a, b) => a.localeCompare(b, void 0, { sensitivity: "base" }));
 }
 function buildFileIndex(cwd) {
-  const resolved = path22.resolve(cwd);
+  const resolved = path23.resolve(cwd);
   const paths = [];
   walkWorkspaceTreeSync(resolved, resolved, paths);
   sortPaths(paths);
@@ -32623,7 +32997,7 @@ function buildFileIndex(cwd) {
   return data;
 }
 async function buildFileIndexAsync(cwd) {
-  const resolved = path22.resolve(cwd);
+  const resolved = path23.resolve(cwd);
   const paths = [];
   await walkWorkspaceTreeAsync(resolved, resolved, paths, createWalkYieldState());
   await yieldToEventLoop();
@@ -32635,13 +33009,13 @@ async function buildFileIndexAsync(cwd) {
 }
 
 // src/files/index/load-file-index.ts
-import fs20 from "node:fs";
-import path23 from "node:path";
+import fs21 from "node:fs";
+import path24 from "node:path";
 function loadFileIndex(cwd) {
-  const resolved = path23.resolve(cwd);
+  const resolved = path24.resolve(cwd);
   const indexPath = getIndexPathForCwd(resolved);
   try {
-    const raw = fs20.readFileSync(indexPath, "utf8");
+    const raw = fs21.readFileSync(indexPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed !== null && typeof parsed === "object" && Array.isArray(parsed.paths)) {
       const obj = parsed;
@@ -32660,9 +33034,9 @@ function loadFileIndex(cwd) {
 }
 
 // src/files/index/ensure-file-index.ts
-import path24 from "node:path";
+import path25 from "node:path";
 async function ensureFileIndexAsync(cwd) {
-  const resolved = path24.resolve(cwd);
+  const resolved = path25.resolve(cwd);
   const cached2 = loadFileIndex(resolved);
   if (cached2 !== null) return { data: cached2, fromCache: true };
   const data = await buildFileIndexAsync(resolved);
@@ -32745,7 +33119,7 @@ function createFsWatcher(resolved, schedule) {
   }
 }
 function startFileIndexWatcher(cwd = getBridgeRoot()) {
-  const resolved = path25.resolve(cwd);
+  const resolved = path26.resolve(cwd);
   void buildFileIndexAsync(resolved).catch((e) => {
     console.error("[file-index] Initial index build failed:", e);
   });
@@ -32773,7 +33147,7 @@ function startFileIndexWatcher(cwd = getBridgeRoot()) {
 }
 
 // src/connection/create-bridge-connection.ts
-import * as path33 from "node:path";
+import * as path34 from "node:path";
 
 // src/dev-servers/manager/dev-server-manager.ts
 import { rm as rm2 } from "node:fs/promises";
@@ -32817,7 +33191,7 @@ function forceKillChild(proc, log2, shortId, graceMs) {
 }
 
 // src/dev-servers/process/wire-dev-server-child-process.ts
-import fs21 from "node:fs";
+import fs22 from "node:fs";
 
 // src/dev-servers/manager/forward-pipe.ts
 function forwardChildPipe(childReadable, terminal, onData) {
@@ -32853,7 +33227,7 @@ function wireDevServerChildProcess(d) {
         d.setPollInterval(void 0);
         return;
       }
-      fs21.readFile(d.mergedLogPath, (err, buf) => {
+      fs22.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));
@@ -32891,7 +33265,7 @@ ${errTail}` : ""}`);
       d.sendStatus(code === 0 || code == null ? "stopped" : "error", detail, tails);
     };
     if (mergedPath) {
-      fs21.readFile(mergedPath, (err, buf) => {
+      fs22.readFile(mergedPath, (err, buf) => {
         if (!err && buf.length > d.mergedReadPos.value) {
           const chunk = Buffer.from(buf.subarray(d.mergedReadPos.value));
           if (chunk.length > 0) {
@@ -32993,13 +33367,13 @@ function parseDevServerDefs(servers) {
 }
 
 // src/dev-servers/manager/shell-spawn/utils.ts
-import fs22 from "node:fs";
+import fs23 from "node:fs";
 function isSpawnEbadf(e) {
   return typeof e === "object" && e !== null && "code" in e && e.code === "EBADF";
 }
 function rmDirQuiet(dir) {
   try {
-    fs22.rmSync(dir, { recursive: true, force: true });
+    fs23.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -33007,7 +33381,7 @@ var cachedDevNullReadFd;
 function devNullReadFd() {
   if (cachedDevNullReadFd === void 0) {
     const devPath = process.platform === "win32" ? "nul" : "/dev/null";
-    cachedDevNullReadFd = fs22.openSync(devPath, "r");
+    cachedDevNullReadFd = fs23.openSync(devPath, "r");
   }
   return cachedDevNullReadFd;
 }
@@ -33081,15 +33455,15 @@ function trySpawnShellTruePiped(command, env, cwd, devNullFd, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-merged-log-file.ts
 import { spawn as spawn7 } from "node:child_process";
-import fs23 from "node:fs";
+import fs24 from "node:fs";
 import { tmpdir } from "node:os";
-import path26 from "node:path";
+import path27 from "node:path";
 function trySpawnMergedLogFile(command, env, cwd, signal) {
-  const tmpRoot = fs23.mkdtempSync(path26.join(tmpdir(), "ba-devsrv-log-"));
-  const logPath = path26.join(tmpRoot, "combined.log");
+  const tmpRoot = fs24.mkdtempSync(path27.join(tmpdir(), "ba-devsrv-log-"));
+  const logPath = path27.join(tmpRoot, "combined.log");
   let logFd;
   try {
-    logFd = fs23.openSync(logPath, "a");
+    logFd = fs24.openSync(logPath, "a");
   } catch {
     rmDirQuiet(tmpRoot);
     return null;
@@ -33108,7 +33482,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     } else {
       proc = spawn7("/bin/sh", ["-c", command], { env, cwd, stdio, ...signal ? { signal } : {} });
     }
-    fs23.closeSync(logFd);
+    fs24.closeSync(logFd);
     return {
       proc,
       pipedStdoutStderr: true,
@@ -33117,7 +33491,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     };
   } catch (e) {
     try {
-      fs23.closeSync(logFd);
+      fs24.closeSync(logFd);
     } catch {
     }
     rmDirQuiet(tmpRoot);
@@ -33128,22 +33502,22 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-shell-script-log-redirect.ts
 import { spawn as spawn8 } from "node:child_process";
-import fs24 from "node:fs";
+import fs25 from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path27 from "node:path";
+import path28 from "node:path";
 function shSingleQuote(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 function trySpawnShellScriptLogRedirectUnix(command, env, cwd, signal) {
-  const tmpRoot = fs24.mkdtempSync(path27.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path27.join(tmpRoot, "combined.log");
-  const innerPath = path27.join(tmpRoot, "_cmd.sh");
-  const runnerPath = path27.join(tmpRoot, "_run.sh");
+  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");
   try {
-    fs24.writeFileSync(innerPath, `#!/bin/sh
+    fs25.writeFileSync(innerPath, `#!/bin/sh
 ${command}
 `);
-    fs24.writeFileSync(
+    fs25.writeFileSync(
       runnerPath,
       `#!/bin/sh
 cd ${shSingleQuote(cwd)}
@@ -33169,13 +33543,13 @@ cd ${shSingleQuote(cwd)}
   }
 }
 function trySpawnShellScriptLogRedirectWin(command, env, cwd, signal) {
-  const tmpRoot = fs24.mkdtempSync(path27.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path27.join(tmpRoot, "combined.log");
-  const runnerPath = path27.join(tmpRoot, "_run.bat");
+  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 q = (p) => `"${p.replace(/"/g, '""')}"`;
   const com = process.env.ComSpec || "cmd.exe";
   try {
-    fs24.writeFileSync(
+    fs25.writeFileSync(
       runnerPath,
       `@ECHO OFF\r
 CD /D ${q(cwd)}\r
@@ -33944,30 +34318,30 @@ function createOnBridgeIdentified(opts) {
 }
 
 // src/skills/discover-local-agent-skills.ts
-import fs25 from "node:fs";
-import path28 from "node:path";
+import fs26 from "node:fs";
+import path29 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 = path28.join(cwd, rel);
-    if (!fs25.existsSync(base) || !fs25.statSync(base).isDirectory()) continue;
+    const base = path29.join(cwd, rel);
+    if (!fs26.existsSync(base) || !fs26.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs25.readdirSync(base);
+      entries = fs26.readdirSync(base);
     } catch {
       continue;
     }
     for (const name of entries) {
-      const dir = path28.join(base, name);
+      const dir = path29.join(base, name);
       try {
-        if (!fs25.statSync(dir).isDirectory()) continue;
+        if (!fs26.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      const skillMd = path28.join(dir, "SKILL.md");
-      if (!fs25.existsSync(skillMd)) continue;
+      const skillMd = path29.join(dir, "SKILL.md");
+      if (!fs26.existsSync(skillMd)) continue;
       const key = `${rel}/${name}`;
       if (seenKeys.has(key)) continue;
       seenKeys.add(key);
@@ -33979,23 +34353,23 @@ function discoverLocalSkills(cwd) {
 function discoverSkillLayoutRoots(cwd) {
   const roots = [];
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path28.join(cwd, rel);
-    if (!fs25.existsSync(base) || !fs25.statSync(base).isDirectory()) continue;
+    const base = path29.join(cwd, rel);
+    if (!fs26.existsSync(base) || !fs26.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs25.readdirSync(base);
+      entries = fs26.readdirSync(base);
     } catch {
       continue;
     }
     const skills2 = [];
     for (const name of entries) {
-      const dir = path28.join(base, name);
+      const dir = path29.join(base, name);
       try {
-        if (!fs25.statSync(dir).isDirectory()) continue;
+        if (!fs26.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      if (!fs25.existsSync(path28.join(dir, "SKILL.md"))) continue;
+      if (!fs26.existsSync(path29.join(dir, "SKILL.md"))) continue;
       const relPath = `${rel}/${name}`.replace(/\\/g, "/");
       skills2.push({ name, relPath });
     }
@@ -34177,7 +34551,7 @@ var handleAgentConfigMessage = (msg, deps) => {
 };
 
 // src/prompt-turn-queue/runner.ts
-import fs28 from "node:fs";
+import fs29 from "node:fs";
 
 // src/prompt-turn-queue/client-report.ts
 function sendPromptQueueClientReport(ws, queues) {
@@ -34187,13 +34561,13 @@ function sendPromptQueueClientReport(ws, queues) {
 }
 
 // src/prompt-turn-queue/disk-store.ts
-import fs27 from "node:fs";
+import fs28 from "node:fs";
 
 // src/prompt-turn-queue/paths.ts
 import crypto3 from "node:crypto";
-import fs26 from "node:fs";
-import path29 from "node:path";
-import os6 from "node:os";
+import fs27 from "node:fs";
+import path30 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();
@@ -34201,15 +34575,15 @@ function queueStateFileSlug(queueKey) {
 }
 function getPromptQueuesDirectory() {
   const override = process.env.BUILDAMATON_PROMPT_QUEUES_DIR?.trim();
-  if (override) return path29.resolve(override);
-  return path29.join(os6.homedir(), ".buildautomaton", "queues");
+  if (override) return path30.resolve(override);
+  return path30.join(os7.homedir(), ".buildautomaton", "queues");
 }
 function ensurePromptQueuesDirectory() {
   const dir = getPromptQueuesDirectory();
-  if (!fs26.existsSync(dir)) fs26.mkdirSync(dir, { recursive: true });
+  if (!fs27.existsSync(dir)) fs27.mkdirSync(dir, { recursive: true });
 }
 function queueStateFilePath(queueKey) {
-  return path29.join(getPromptQueuesDirectory(), `${queueStateFileSlug(queueKey)}.json`);
+  return path30.join(getPromptQueuesDirectory(), `${queueStateFileSlug(queueKey)}.json`);
 }
 
 // src/prompt-turn-queue/disk-store.ts
@@ -34234,7 +34608,7 @@ function parsePersistedQueueFile(raw) {
 function readPersistedQueue(queueKey) {
   const p = queueStateFilePath(queueKey);
   try {
-    return parsePersistedQueueFile(fs27.readFileSync(p, "utf8"));
+    return parsePersistedQueueFile(fs28.readFileSync(p, "utf8"));
   } catch {
     return null;
   }
@@ -34242,7 +34616,7 @@ function readPersistedQueue(queueKey) {
 function writePersistedQueue(file2) {
   ensurePromptQueuesDirectory();
   const p = queueStateFilePath(file2.queueKey);
-  fs27.writeFileSync(p, JSON.stringify(file2, null, 2), "utf8");
+  fs28.writeFileSync(p, JSON.stringify(file2, null, 2), "utf8");
 }
 function mergeServerQueueSnapshot(queueKey, serverTurns) {
   const prev = readPersistedQueue(queueKey);
@@ -34300,7 +34674,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 (!fs28.existsSync(file2)) {
+  if (!fs29.existsSync(file2)) {
     deps.log(
       `[Queue] requeued_with_revert: no pre-turn snapshot for ${tid.slice(0, 8)}\u2026; continuing without revert.`
     );
@@ -34523,9 +34897,9 @@ function parseChangeSummarySnapshots(raw) {
   for (const item of raw) {
     if (!item || typeof item !== "object") continue;
     const o = item;
-    const path34 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
-    if (!path34) continue;
-    const row = { path: path34 };
+    const path35 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
+    if (!path35) continue;
+    const row = { path: path35 };
     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;
@@ -34756,15 +35130,15 @@ var handleSkillCallMessage = (msg, { getWs, log: log2 }) => {
 };
 
 // src/files/list-dir.ts
-import fs29 from "node:fs";
-import path31 from "node:path";
+import fs30 from "node:fs";
+import path32 from "node:path";
 
 // src/files/ensure-under-cwd.ts
-import path30 from "node:path";
+import path31 from "node:path";
 function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
-  const normalized = path30.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path30.resolve(cwd, normalized);
-  if (!resolved.startsWith(cwd + path30.sep) && resolved !== cwd) {
+  const normalized = path31.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path31.resolve(cwd, normalized);
+  if (!resolved.startsWith(cwd + path31.sep) && resolved !== cwd) {
     return null;
   }
   return resolved;
@@ -34778,7 +35152,7 @@ async function listDirAsync(relativePath) {
     return { error: "Path is outside working directory" };
   }
   try {
-    const names = await fs29.promises.readdir(resolved, { withFileTypes: true });
+    const names = await fs30.promises.readdir(resolved, { withFileTypes: true });
     const visible = names.filter((d) => !d.name.startsWith("."));
     const entries = [];
     for (let i = 0; i < visible.length; i++) {
@@ -34786,12 +35160,12 @@ async function listDirAsync(relativePath) {
         await yieldToEventLoop();
       }
       const d = visible[i];
-      const entryPath = path31.join(relativePath || ".", d.name).replace(/\\/g, "/");
-      const fullPath = path31.join(resolved, d.name);
+      const entryPath = path32.join(relativePath || ".", d.name).replace(/\\/g, "/");
+      const fullPath = path32.join(resolved, d.name);
       let isDir = d.isDirectory();
       if (d.isSymbolicLink()) {
         try {
-          const targetStat = await fs29.promises.stat(fullPath);
+          const targetStat = await fs30.promises.stat(fullPath);
           isDir = targetStat.isDirectory();
         } catch {
           isDir = false;
@@ -34816,25 +35190,25 @@ async function listDirAsync(relativePath) {
 }
 
 // src/files/read-file.ts
-import fs30 from "node:fs";
+import fs31 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 = fs30.realpathSync(resolved);
+    real = fs31.realpathSync(resolved);
   } catch {
     real = resolved;
   }
-  const stat2 = fs30.statSync(real);
+  const stat2 = fs31.statSync(real);
   if (!stat2.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 = fs30.statSync(filePath).size;
-  const fd = fs30.openSync(filePath, "r");
+  const fileSize = fs31.statSync(filePath).size;
+  const fd = fs31.openSync(filePath, "r");
   const bufSize = 64 * 1024;
   const buf = Buffer.alloc(bufSize);
   const decoder = new StringDecoder("utf8");
@@ -34847,7 +35221,7 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
   let line0Accum = "";
   try {
     let bytesRead;
-    while (!done && (bytesRead = fs30.readSync(fd, buf, 0, bufSize, null)) > 0) {
+    while (!done && (bytesRead = fs31.readSync(fd, buf, 0, bufSize, null)) > 0) {
       const text = partial2 + decoder.write(buf.subarray(0, bytesRead));
       partial2 = "";
       let lineStart = 0;
@@ -34982,7 +35356,7 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
     }
     return { content: resultLines.join("\n"), size: fileSize };
   } finally {
-    fs30.closeSync(fd);
+    fs31.closeSync(fd);
   }
 }
 function readFile2(relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE) {
@@ -34993,8 +35367,8 @@ function readFile2(relativePath, startLine, endLine, lineOffset, lineChunkSize =
     if (hasRange) {
       return readFileRange(result, startLine, endLine, lineOffset, lineChunkSize);
     }
-    const stat2 = fs30.statSync(result);
-    const raw = fs30.readFileSync(result, "utf8");
+    const stat2 = fs31.statSync(result);
+    const raw = fs31.readFileSync(result, "utf8");
     const lines = raw.split(/\r?\n/);
     return { content: raw, totalLines: lines.length, size: stat2.size };
   } catch (err) {
@@ -35112,8 +35486,8 @@ function handleSkillLayoutRequest(msg, deps) {
 }
 
 // src/skills/install-remote-skills.ts
-import fs31 from "node:fs";
-import path32 from "node:path";
+import fs32 from "node:fs";
+import path33 from "node:path";
 function installRemoteSkills(cwd, targetDir, items) {
   const installed2 = [];
   if (!Array.isArray(items)) {
@@ -35124,15 +35498,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 = path32.join(cwd, targetDir, item.skillName);
+      const skillDir = path33.join(cwd, targetDir, item.skillName);
       for (const f of item.files) {
         if (typeof f.path !== "string" || !f.text && !f.base64) continue;
-        const dest = path32.join(skillDir, f.path);
-        fs31.mkdirSync(path32.dirname(dest), { recursive: true });
+        const dest = path33.join(skillDir, f.path);
+        fs32.mkdirSync(path33.dirname(dest), { recursive: true });
         if (f.text !== void 0) {
-          fs31.writeFileSync(dest, f.text, "utf8");
+          fs32.writeFileSync(dest, f.text, "utf8");
         } else if (f.base64) {
-          fs31.writeFileSync(dest, Buffer.from(f.base64, "base64"));
+          fs32.writeFileSync(dest, Buffer.from(f.base64, "base64"));
         }
       }
       installed2.push({
@@ -35282,7 +35656,7 @@ var handleSessionDiscardedMessage = (msg, deps) => {
 };
 
 // src/routing/handlers/revert-turn-snapshot.ts
-import * as fs32 from "node:fs";
+import * as fs33 from "node:fs";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
@@ -35294,7 +35668,7 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
     if (!s) return;
     const agentBase = sessionWorktreeManager.getSessionWorktreeRootForSession(sessionId) ?? getBridgeRoot();
     const file2 = snapshotFilePath(agentBase, turnId);
-    if (!fs32.existsSync(file2)) {
+    if (!fs33.existsSync(file2)) {
       sendWsMessage(s, {
         type: "revert_turn_snapshot_result",
         id,
@@ -35735,8 +36109,8 @@ async function createBridgeConnection(options) {
     getCloudAccessToken: () => tokens.accessToken
   };
   const identifyReportedPaths = {
-    bridgeRootPath: path33.resolve(getBridgeRoot()),
-    worktreesRootPath: path33.resolve(worktreesRootPath)
+    bridgeRootPath: path34.resolve(getBridgeRoot()),
+    worktreesRootPath: path34.resolve(worktreesRootPath)
   };
   const { connect } = createMainBridgeWebSocketLifecycle({
     state,