@buildautomaton/cli 0.1.23 → 0.1.25

package/dist/cli.js

@@ -973,8 +973,8 @@ var require_command = __commonJS({
   "../../node_modules/.pnpm/commander@12.1.0/node_modules/commander/lib/command.js"(exports) {
     var EventEmitter2 = __require("node:events").EventEmitter;
     var childProcess2 = __require("node:child_process");
-    var path36 = __require("node:path");
-    var fs35 = __require("node:fs");
+    var path37 = __require("node:path");
+    var fs36 = __require("node:fs");
     var process8 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1906,11 +1906,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path36.resolve(baseDir, baseName);
-          if (fs35.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path36.extname(baseName))) return void 0;
+          const localBin = path37.resolve(baseDir, baseName);
+          if (fs36.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path37.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs35.existsSync(`${localBin}${ext}`)
+            (ext) => fs36.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1922,21 +1922,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs35.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs36.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path36.resolve(
-            path36.dirname(resolvedScriptPath),
+          executableDir = path37.resolve(
+            path37.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path36.basename(
+            const legacyName = path37.basename(
               this._scriptPath,
-              path36.extname(this._scriptPath)
+              path37.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1947,7 +1947,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path36.extname(executableFile));
+        launchWithNode = sourceExt.includes(path37.extname(executableFile));
         let proc;
         if (process8.platform !== "win32") {
           if (launchWithNode) {
@@ -2787,7 +2787,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path36.basename(filename, path36.extname(filename));
+        this._name = path37.basename(filename, path37.extname(filename));
         return this;
       }
       /**
@@ -2801,9 +2801,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path37) {
-        if (path37 === void 0) return this._executableDir;
-        this._executableDir = path37;
+      executableDir(path38) {
+        if (path38 === void 0) return this._executableDir;
+        this._executableDir = path38;
         return this;
       }
       /**
@@ -7061,8 +7061,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path36, errorMaps, issueData } = params;
-      const fullPath = [...path36, ...issueData.path || []];
+      const { data, path: path37, errorMaps, issueData } = params;
+      const fullPath = [...path37, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -7370,11 +7370,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path36, key) {
+      constructor(parent, value, path37, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path36;
+        this._path = path37;
         this._key = key;
       }
       get path() {
@@ -11235,7 +11235,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js"(exports, module) {
     "use strict";
-    var os7 = __require("os");
+    var os8 = __require("os");
     var tty = __require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
@@ -11283,7 +11283,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os7.release().split(".");
+        const osRelease = os8.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -11529,10 +11529,10 @@ var require_src2 = __commonJS({
     var fs_1 = __require("fs");
     var debug_1 = __importDefault(require_src());
     var log2 = debug_1.default("@kwsites/file-exists");
-    function check2(path36, isFile, isDirectory) {
-      log2(`checking %s`, path36);
+    function check2(path37, isFile, isDirectory) {
+      log2(`checking %s`, path37);
       try {
-        const stat3 = fs_1.statSync(path36);
+        const stat3 = fs_1.statSync(path37);
         if (stat3.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -11552,8 +11552,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path36, type = exports.READABLE) {
-      return check2(path36, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path37, type = exports.READABLE) {
+      return check2(path37, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -11850,10 +11850,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path36) {
-  if (!path36)
+function getElementAtPath(obj, path37) {
+  if (!path37)
     return obj;
-  return path36.reduce((acc, key) => acc?.[key], obj);
+  return path37.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -12102,11 +12102,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path36, issues) {
+function prefixIssues(path37, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path36);
+    iss.path.unshift(path37);
     return iss;
   });
 }
@@ -12295,7 +12295,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path36 = []) => {
+  const processError = (error41, path37 = []) => {
     var _a2, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -12305,7 +12305,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path36, ...issue2.path];
+        const fullpath = [...path37, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -12335,9 +12335,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path36) {
+function toDotPath(path37) {
   const segs = [];
-  for (const seg of path36) {
+  for (const seg of path37) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -25064,15 +25064,27 @@ var {
 } = import_index.default;
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.23".length > 0 ? "0.1.23" : "0.0.0-dev";
+var CLI_VERSION = "0.1.25".length > 0 ? "0.1.25" : "0.0.0-dev";
 
 // src/cli/defaults.ts
 var DEFAULT_API_URL = process.env.BUILDAUTOMATON_API_URL ?? "https://api.buildautomaton.com";
 var DEFAULT_FIREHOSE_URL = "https://buildautomaton-firehose.fly.dev";
 
 // src/cli/run-cli-action.ts
-import * as fs34 from "node:fs";
-import * as path35 from "node:path";
+import * as fs35 from "node:fs";
+import * as path36 from "node:path";
+
+// src/cli-log-level.ts
+var verbosity = "info";
+function setCliLogVerbosity(level) {
+  verbosity = level;
+}
+function getCliLogVerbosity() {
+  return verbosity;
+}
+function isCliTrace() {
+  return verbosity === "trace";
+}
 
 // src/config.ts
 import fs from "node:fs";
@@ -25442,15 +25454,26 @@ function getBridgeRoot() {
 }
 
 // src/log.ts
-function log(line) {
+function timestampPrefix() {
   const time3 = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
-  console.log(`[${time3}] ${line}`);
+  return `[${time3}]`;
+}
+function log(line) {
+  console.log(`${timestampPrefix()} ${line}`);
 }
 function logImmediate(line) {
-  const time3 = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
-  process.stdout.write(`[${time3}] ${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/process-bridge-resilience.ts
 var installed = false;
@@ -25485,7 +25508,7 @@ function applyCliOutboundNetworkPreferences() {
   }
 }
 
-// src/bridge/connection/cli-ws-client.ts
+// src/connection/cli-ws-client.ts
 import https from "node:https";
 var CLI_WEBSOCKET_CLIENT_PING_MS = 25e3;
 function attachWebSocketClientPing(ws, intervalMs) {
@@ -25545,7 +25568,7 @@ function safeSendWebSocketBinary(ws, data) {
   }
 }
 
-// src/bridge/connection/create-ws-bridge.ts
+// src/connection/create-ws-bridge.ts
 var BRIDGE_AUTH_ERROR_HEADER = "x-bridge-auth-error";
 var BRIDGE_AUTH_ERROR_TOKEN_INVALID = "token_invalid";
 function createWsBridge(options) {
@@ -26156,29 +26179,22 @@ async function openBrowser(connectionId, initialWorkspaceId, preferredBridgeName
   }
 }
 
-// src/bridge/connection/reconnect/constants.ts
-var RECONNECT_FIRST_MS = 100;
-var RECONNECT_MAX_MS = 3e4;
+// src/connection/reconnect/constants.ts
 var RECONNECT_QUIET_MS = 2e3;
-function reconnectDelayMs(attemptBeforeIncrement) {
-  return Math.min(RECONNECT_FIRST_MS * 2 ** attemptBeforeIncrement, RECONNECT_MAX_MS);
+var PENDING_AUTH_RECONNECT_FIRST_MS = 100;
+var PENDING_AUTH_RECONNECT_MAX_MS = 3e4;
+function pendingAuthReconnectDelayMs(attemptBeforeIncrement) {
+  return Math.min(PENDING_AUTH_RECONNECT_FIRST_MS * 2 ** attemptBeforeIncrement, PENDING_AUTH_RECONNECT_MAX_MS);
 }
 
-// src/bridge/connection/reconnect/format-reconnect-delay-for-log.ts
+// src/connection/reconnect/format-reconnect-delay-for-log.ts
 function formatReconnectDelayForLog(delayMs) {
   if (delayMs < 1e3) return `${delayMs}ms`;
   const s = delayMs / 1e3;
   return Number.isInteger(s) ? `${s}s` : `${s.toFixed(1)}s`;
 }
 
-// src/bridge/connection/reconnect/log-next-reconnect-attempt.ts
-function logNextReconnectAttempt(log2, serviceLabel, quiet, delayMs, attempt) {
-  if (!quiet.verboseLogs) return;
-  const delayLabel = formatReconnectDelayForLog(delayMs);
-  log2(`${serviceLabel} Next connection attempt in ${delayLabel} (attempt ${attempt}).`);
-}
-
-// src/bridge/connection/ws-close-diagnostics.ts
+// src/connection/ws-close-diagnostics.ts
 function describeWebSocketCloseCode(code) {
   const known = {
     1e3: "normal closure",
@@ -26209,7 +26225,7 @@ function formatWebSocketClose(label, code, reason, extra) {
   return `${label} Disconnected: code=${code} (${describeWebSocketCloseCode(code)})${reasonPart}${extraPart}`;
 }
 
-// src/bridge/connection/reconnect/reconnect-quiet-slot.ts
+// src/connection/reconnect/reconnect-quiet-slot.ts
 function createEmptyReconnectQuietSlot() {
   return { timer: null, verboseLogs: false, pendingCloseLog: null };
 }
@@ -26219,6 +26235,11 @@ function clearReconnectQuietTimer(quiet) {
     quiet.timer = null;
   }
 }
+function abandonReconnectQuietWindow(quiet) {
+  clearReconnectQuietTimer(quiet);
+  quiet.pendingCloseLog = null;
+  quiet.verboseLogs = false;
+}
 function clearReconnectQuietOnSuccessfulConnection(quiet, log2, reconnectedMessage) {
   clearReconnectQuietTimer(quiet);
   quiet.pendingCloseLog = null;
@@ -26239,12 +26260,16 @@ function beginDeferredDisconnectForReconnect(options) {
     shutdownDetail,
     reconnectingDetail,
     quietMs = RECONNECT_QUIET_MS,
-    shouldAbortQuietWindow
+    shouldAbortQuietWindow,
+    silentWhileReconnect = false
   } = options;
   if (!willReconnect) {
     log2(formatWebSocketClose(serviceLabel, code, reason, shutdownDetail));
     return;
   }
+  if (silentWhileReconnect) {
+    return;
+  }
   quiet.pendingCloseLog = { code, reason };
   if (quiet.timer == null) {
     quiet.timer = setTimeout(() => {
@@ -26261,18 +26286,178 @@ function beginDeferredDisconnectForReconnect(options) {
   }
 }
 
-// src/bridge/connection/reconnect/bridge-main-reconnect.ts
-function beginMainBridgeDeferredDisconnect(state, code, reason, log2, willReconnect) {
+// src/connection/reconnect/reconnect-outage-plan.ts
+function createEmptyReconnectOutageTracker() {
+  return {
+    startedAt: null,
+    totalFailures: 0,
+    lastLoggedTierIndex: -1,
+    originalCloseCode: null,
+    originalCloseReason: null
+  };
+}
+function resetReconnectOutageTracker(tracker) {
+  tracker.startedAt = null;
+  tracker.totalFailures = 0;
+  tracker.lastLoggedTierIndex = -1;
+  tracker.originalCloseCode = null;
+  tracker.originalCloseReason = null;
+}
+function reconnectTierIndexForOutageElapsedMs(elapsedMs) {
+  if (elapsedMs < 6e4) return 0;
+  if (elapsedMs < 36e4) return 1;
+  if (elapsedMs < 12e5) return 2;
+  return 3;
+}
+function reconnectDelayMsForOutageElapsedMs(elapsedMs) {
+  if (elapsedMs < 6e4) return 3e3;
+  if (elapsedMs < 36e4) return 1e4;
+  if (elapsedMs < 12e5) return 2e4;
+  return 6e4;
+}
+function disconnectDetail(code, reason) {
+  const r = reason.trim();
+  const reasonPart = r ? ` reason="${r}"` : "";
+  return `code=${code} (${describeWebSocketCloseCode(code)})${reasonPart}`;
+}
+function formatTierPromotionLogLine(parts) {
+  const detail = disconnectDetail(parts.code, parts.reason);
+  return `${parts.serviceLabel} ${parts.disconnectLeadIn}: ${detail}. Trying to re-establish a connection in the background (retry attempts so far: ${parts.totalFailures}).`;
+}
+function planReconnectAfterFailure(tracker, nowMs, serviceLabel, disconnectLeadIn, closeCode, closeReason) {
+  if (tracker.startedAt == null) {
+    tracker.startedAt = nowMs;
+  }
+  if (closeCode != null && tracker.originalCloseCode == null) {
+    tracker.originalCloseCode = closeCode;
+    tracker.originalCloseReason = closeReason ?? "";
+  }
+  tracker.totalFailures += 1;
+  const elapsed = nowMs - tracker.startedAt;
+  const tier = reconnectTierIndexForOutageElapsedMs(elapsed);
+  const delayMs = reconnectDelayMsForOutageElapsedMs(elapsed);
+  let logLine = null;
+  if (tier > tracker.lastLoggedTierIndex) {
+    tracker.lastLoggedTierIndex = tier;
+    const code = tracker.originalCloseCode ?? closeCode ?? 0;
+    const reason = tracker.originalCloseReason ?? closeReason ?? "";
+    logLine = formatTierPromotionLogLine({
+      serviceLabel,
+      disconnectLeadIn,
+      code,
+      reason,
+      totalFailures: tracker.totalFailures
+    });
+  }
+  return { delayMs, logLine };
+}
+
+// src/connection/reconnect/tiered-channel-reconnect.ts
+var BRIDGE_SERVICE_LABEL = "[Bridge service]";
+var BRIDGE_DISCONNECT_LEAD_IN = "Bridge connection was disconnected";
+var PREVIEW_TUNNEL_SERVICE_LABEL = "[Proxy and log service]";
+var PREVIEW_TUNNEL_DISCONNECT_LEAD_IN = "Preview tunnel connection was disconnected";
+var SHUTDOWN_DETAIL = "Not reconnecting (shutting down).";
+var RECONNECTING_DETAIL = "Reconnecting\u2026";
+function applyTieredReconnectPlanAndLog(tracker, log2, serviceLabel, disconnectLeadIn, closeCode, closeReason) {
+  try {
+    const { delayMs, logLine } = planReconnectAfterFailure(
+      tracker,
+      Date.now(),
+      serviceLabel,
+      disconnectLeadIn,
+      closeCode,
+      closeReason
+    );
+    if (logLine) {
+      try {
+        log2(logLine);
+      } catch {
+      }
+    }
+    return delayMs;
+  } catch {
+    return 3e3;
+  }
+}
+function armReconnectDelayTimer(options) {
+  const {
+    delayMs,
+    bumpAttempt,
+    clearTimer,
+    setTimer,
+    shouldAbortBeforeRun,
+    run,
+    reschedule
+  } = options;
+  clearTimer();
+  bumpAttempt();
+  setTimer(
+    setTimeout(() => {
+      setTimer(null);
+      if (shouldAbortBeforeRun()) return;
+      try {
+        run();
+      } catch {
+        try {
+          if (!shouldAbortBeforeRun()) {
+            reschedule();
+          }
+        } catch {
+        }
+      }
+    }, delayMs)
+  );
+}
+function beginTieredSilentReconnectDisconnect(options) {
+  const {
+    isClosedByUser,
+    quiet,
+    code,
+    reason,
+    willReconnect,
+    log: log2,
+    serviceLabel,
+    shouldAbortQuietWindow
+  } = options;
   beginDeferredDisconnectForReconnect({
+    isClosedByUser,
+    quiet,
+    code,
+    reason,
+    willReconnect,
+    log: log2,
+    serviceLabel,
+    shutdownDetail: SHUTDOWN_DETAIL,
+    reconnectingDetail: RECONNECTING_DETAIL,
+    shouldAbortQuietWindow,
+    silentWhileReconnect: willReconnect
+  });
+}
+function clearTieredReconnectChannelOnOpen(options) {
+  const { quiet, outage, clearLastCloseMeta, log: log2, restoredMessage } = options;
+  const hadOutage = outage.startedAt != null || outage.totalFailures > 0;
+  abandonReconnectQuietWindow(quiet);
+  resetReconnectOutageTracker(outage);
+  clearLastCloseMeta();
+  if (hadOutage) {
+    try {
+      log2(restoredMessage);
+    } catch {
+    }
+  }
+}
+
+// src/connection/reconnect/bridge-main-reconnect.ts
+function beginMainBridgeDeferredDisconnect(state, code, reason, log2, willReconnect) {
+  beginTieredSilentReconnectDisconnect({
     isClosedByUser: () => state.closedByUser,
     quiet: state.mainQuiet,
     code,
     reason,
     willReconnect,
     log: log2,
-    serviceLabel: "[Bridge service]",
-    shutdownDetail: "Not reconnecting (shutting down).",
-    reconnectingDetail: "Reconnecting\u2026",
+    serviceLabel: BRIDGE_SERVICE_LABEL,
     shouldAbortQuietWindow: () => {
       const w = state.currentWs;
       return w != null && w.readyState === wrapper_default.OPEN;
@@ -26280,32 +26465,59 @@ function beginMainBridgeDeferredDisconnect(state, code, reason, log2, willReconn
   });
 }
 function clearMainBridgeReconnectQuietOnOpen(state, log2) {
-  clearReconnectQuietOnSuccessfulConnection(state.mainQuiet, log2, "Bridge connection restored.");
+  clearTieredReconnectChannelOnOpen({
+    quiet: state.mainQuiet,
+    outage: state.mainOutage,
+    clearLastCloseMeta: () => {
+      state.lastReconnectCloseMeta = null;
+    },
+    log: log2,
+    restoredMessage: "Bridge connection restored."
+  });
 }
-function scheduleMainBridgeReconnect(state, connect, log2) {
+function scheduleMainBridgeReconnect(state, connect, log2, closeMeta) {
   if (state.closedByUser || state.currentWs != null) return;
-  const delay2 = reconnectDelayMs(state.reconnectAttempt);
-  state.reconnectAttempt += 1;
-  logNextReconnectAttempt(log2, "[Bridge service]", state.mainQuiet, delay2, state.reconnectAttempt);
-  state.reconnectTimeout = setTimeout(() => {
-    state.reconnectTimeout = null;
-    connect();
-  }, delay2);
+  const meta = closeMeta ?? state.lastReconnectCloseMeta ?? void 0;
+  const delay2 = applyTieredReconnectPlanAndLog(
+    state.mainOutage,
+    log2,
+    BRIDGE_SERVICE_LABEL,
+    BRIDGE_DISCONNECT_LEAD_IN,
+    meta?.code,
+    meta?.reason
+  );
+  armReconnectDelayTimer({
+    delayMs: delay2,
+    bumpAttempt: () => {
+      state.reconnectAttempt += 1;
+    },
+    clearTimer: () => {
+      if (state.reconnectTimeout != null) {
+        clearTimeout(state.reconnectTimeout);
+        state.reconnectTimeout = null;
+      }
+    },
+    setTimer: (id) => {
+      state.reconnectTimeout = id;
+    },
+    shouldAbortBeforeRun: () => state.closedByUser || state.currentWs != null,
+    run: connect,
+    reschedule: () => {
+      scheduleMainBridgeReconnect(state, connect, log2);
+    }
+  });
 }
 
-// src/bridge/connection/reconnect/firehose-reconnect.ts
-var PROXY_AND_LOG_SERVICE_LABEL = "[Proxy and log service]";
+// src/connection/reconnect/firehose-reconnect.ts
 function beginFirehoseDeferredDisconnect(ctx, code, reason, log2) {
-  beginDeferredDisconnectForReconnect({
+  beginTieredSilentReconnectDisconnect({
     isClosedByUser: () => ctx.closedByUser,
     quiet: ctx.firehoseQuiet,
     code,
     reason,
     willReconnect: true,
     log: log2,
-    serviceLabel: PROXY_AND_LOG_SERVICE_LABEL,
-    shutdownDetail: "Not reconnecting (shutting down).",
-    reconnectingDetail: "Reconnecting\u2026",
+    serviceLabel: PREVIEW_TUNNEL_SERVICE_LABEL,
     shouldAbortQuietWindow: () => {
       const w = ctx.currentWs;
       if (!w || w.readyState !== wrapper_default.OPEN) return true;
@@ -26314,11 +26526,15 @@ function beginFirehoseDeferredDisconnect(ctx, code, reason, log2) {
   });
 }
 function clearFirehoseReconnectQuietOnOpen(ctx, log2) {
-  clearReconnectQuietOnSuccessfulConnection(
-    ctx.firehoseQuiet,
-    log2,
-    "Preview tunnel restored (local HTTP proxy and dev logs)."
-  );
+  clearTieredReconnectChannelOnOpen({
+    quiet: ctx.firehoseQuiet,
+    outage: ctx.firehoseOutage,
+    clearLastCloseMeta: () => {
+      ctx.lastFirehoseReconnectCloseMeta = null;
+    },
+    log: log2,
+    restoredMessage: "Preview tunnel restored (local HTTP proxy and dev logs)."
+  });
 }
 
 // src/auth/run-pending-auth.ts
@@ -26414,7 +26630,7 @@ function runPendingAuth(options) {
         }
         if (resolved) return;
         beginDeferredPendingCloseLog(code, reason);
-        const delay2 = reconnectDelayMs(reconnectAttempt);
+        const delay2 = pendingAuthReconnectDelayMs(reconnectAttempt);
         reconnectAttempt += 1;
         if (signInQuiet.verboseLogs) {
           const delayLabel = formatReconnectDelayForLog(delay2);
@@ -26459,7 +26675,7 @@ function runPendingAuth(options) {
   };
 }
 
-// src/bridge/connection/close-bridge-connection.ts
+// src/connection/close-bridge-connection.ts
 async function closeBridgeConnection(state, acpManager, devServerManager, log2) {
   const say = log2 ?? logImmediate;
   say("Cleaning up connections\u2026");
@@ -26847,9 +27063,9 @@ function parseChangeSummaryJson(raw, allowedPaths, options) {
     const rawPath = typeof o.path === "string" ? o.path.trim() : "";
     const summary = typeof o.summary === "string" ? o.summary.trim() : "";
     if (!rawPath || !summary) continue;
-    const path36 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
-    if (!path36) continue;
-    rows.push({ path: path36, summary: clampSummaryToAtMostTwoLines(summary) });
+    const path37 = skip ? normalizeRepoRelativePath(rawPath) || rawPath : resolveChangeSummaryPathAgainstAllowed(rawPath, allowedPaths);
+    if (!path37) continue;
+    rows.push({ path: path37, summary: clampSummaryToAtMostTwoLines(summary) });
   }
   return rows;
 }
@@ -26974,6 +27190,30 @@ var GitRepoMetaSchema = external_exports.object({
   updatedAt: external_exports.string()
 });
 
+// ../types/src/claude-code-permission-mode.ts
+var CLAUDE_CODE_PERMISSION_MODES = [
+  "default",
+  "acceptEdits",
+  "plan",
+  "auto",
+  "dontAsk",
+  "bypassPermissions"
+];
+var MODE_SET = new Set(CLAUDE_CODE_PERMISSION_MODES);
+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;
+  const t = raw.trim();
+  return isClaudeCodePermissionMode(t) ? t : null;
+}
+
 // src/git/session-git-queue.ts
 import { execFile as execFile7 } from "node:child_process";
 import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
@@ -27027,8 +27267,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path36) {
-  return path36 instanceof String && cache.has(path36);
+function isPathSpec(path37) {
+  return path37 instanceof String && cache.has(path37);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -27117,8 +27357,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path36) {
-  return (0, import_file_exists.exists)(path36, import_file_exists.FOLDER);
+function folderExists(path37) {
+  return (0, import_file_exists.exists)(path37, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -27522,8 +27762,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path36) {
-      return /^\.(git)?$/.test(path36.trim());
+    parser(path37) {
+      return /^\.(git)?$/.test(path37.trim());
     }
   };
 }
@@ -27957,11 +28197,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path36, line, preview] = input.split(NULL);
-    paths.add(path36);
-    (results[path36] = results[path36] || []).push({
+    const [path37, line, preview] = input.split(NULL);
+    paths.add(path37);
+    (results[path37] = results[path37] || []).push({
       line: asNumber(line),
-      path: path36,
+      path: path37,
       preview
     });
   });
@@ -28726,14 +28966,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path36, text) {
+function parseInit(bare, path37, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path36, false, result[1]);
+    return new InitSummary(bare, path37, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path36, true, result[1]);
+    return new InitSummary(bare, path37, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -28744,7 +28984,7 @@ function parseInit(bare, path36, text) {
       break;
     }
   }
-  return new InitSummary(bare, path36, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path37, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -28753,9 +28993,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path36, existing, gitDir) {
+      constructor(bare, path37, existing, gitDir) {
         this.bare = bare;
-        this.path = path36;
+        this.path = path37;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -28767,7 +29007,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path36, customArgs) {
+function initTask(bare = false, path37, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -28776,7 +29016,7 @@ function initTask(bare = false, path36, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path36, text);
+      return parseInit(commands.includes("--bare"), path37, text);
     }
   };
 }
@@ -29592,12 +29832,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path36, index, working_dir) {
-        this.path = path36;
+      constructor(path37, index, working_dir) {
+        this.path = path37;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path36) || [null, path36, path36];
+          const detail = fromPathRegex.exec(path37) || [null, path37, path37];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -29628,14 +29868,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path36) {
+  function data(index, workingDir, path37) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path36);
+      handler(result, path37);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path36, index, workingDir));
+      result.files.push(new FileStatusSummary(path37, index, workingDir));
     }
   }
 }
@@ -29944,9 +30184,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path36, write) {
+      hashObject(path37, write) {
         return this._runTask(
-          hashObjectTask(path36, write === true),
+          hashObjectTask(path37, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -30299,8 +30539,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path36 = input.trim().replace(/^["']|["']$/g, "");
-  return path36 && normalize(path36);
+  const path37 = input.trim().replace(/^["']|["']$/g, "");
+  return path37 && normalize(path37);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -30614,8 +30854,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path36) {
-  return subModuleTask(["add", repo, path36]);
+function addSubModuleTask(repo, path37) {
+  return subModuleTask(["add", repo, path37]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -30948,8 +31188,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path36, then) {
-      return this._runTask(addSubModuleTask2(repo, path36), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path37, then) {
+      return this._runTask(addSubModuleTask2(repo, path37), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -31549,10 +31789,28 @@ function gitInstanceFactory(baseDir, options) {
 init_git_response_error();
 var simpleGit = gitInstanceFactory;
 
+// src/git/cli-simple-git.ts
+function cliSimpleGit(baseDir) {
+  const git = simpleGit({ baseDir });
+  git.outputHandler((command, stdout, stderr) => {
+    const trace = isCliTrace();
+    const onChunk = (label) => (chunk) => {
+      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      const line = text.replace(/\s+$/, "");
+      if (trace && line) {
+        logTrace(`[git ${command}] ${label}: ${line}`);
+      }
+    };
+    stdout?.on("data", onChunk("stdout"));
+    stderr?.on("data", onChunk("stderr"));
+  });
+  return git;
+}
+
 // src/git/remote-origin-url.ts
 async function getRemoteOriginUrl(gitDir) {
   try {
-    const git = simpleGit(gitDir);
+    const git = cliSimpleGit(gitDir);
     const remotes = await git.getRemotes(true);
     const list = Array.isArray(remotes) ? remotes : [];
     const origin = list.find((r) => r.name === "origin");
@@ -31566,7 +31824,7 @@ async function getRemoteOriginUrl(gitDir) {
 // src/git/is-git-repo.ts
 async function isGitRepoDirectory(dirPath) {
   try {
-    return await simpleGit(dirPath).checkIsRepo();
+    return await cliSimpleGit(dirPath).checkIsRepo();
   } catch {
     return false;
   }
@@ -31818,9 +32076,9 @@ async function collectTurnGitDiffFromPreTurnSnapshot(options) {
 // src/agents/acp/put-summarize-change-summaries.ts
 async function putEncryptedChangeSummaryRows(params) {
   const base = params.apiBaseUrl.replace(/\/+$/, "");
-  const entries = params.rows.map(({ path: path36, summary }) => {
+  const entries = params.rows.map(({ path: path37, summary }) => {
     const enc = params.e2ee.encryptFields({ summary }, ["summary"]);
-    return { path: path36, summary: JSON.stringify(enc) };
+    return { path: path37, summary: JSON.stringify(enc) };
   });
   const res = await fetch(
     `${base}/api/sessions/${encodeURIComponent(params.sessionId)}/follow-ups/summarize-changes`,
@@ -32002,8 +32260,8 @@ async function sendPromptToAgent(options) {
 }
 
 // src/agents/acp/ensure-acp-client.ts
-import * as fs10 from "node:fs";
-import * as path12 from "node:path";
+import * as fs11 from "node:fs";
+import * as path13 from "node:path";
 
 // src/error-message.ts
 function errorMessage(err) {
@@ -32039,76 +32297,10 @@ async function isCommandOnPath(command, timeoutMs = 4e3) {
   }
 }
 
-// src/agents/acp/clients/sdk-stdio-acp-client.ts
+// src/agents/acp/clients/sdk/sdk-stdio-acp-client.ts
 import { spawn as spawn2 } from "node:child_process";
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2 } from "node:path";
 import { Readable, Writable } from "node:stream";
 
-// src/files/diff/unified-diff.ts
-function computeLineDiff(oldText, newText) {
-  const oldLines = oldText.split("\n");
-  const newLines = newText.split("\n");
-  const m = oldLines.length;
-  const n = newLines.length;
-  const dp = Array(m + 1);
-  for (let i2 = 0; i2 <= m; i2++) dp[i2] = Array(n + 1).fill(0);
-  for (let i2 = 1; i2 <= m; i2++) {
-    for (let j2 = 1; j2 <= n; j2++) {
-      if (oldLines[i2 - 1] === newLines[j2 - 1]) {
-        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
-      } else {
-        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
-      }
-    }
-  }
-  const result = [];
-  let i = m;
-  let j = n;
-  while (i > 0 || j > 0) {
-    if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
-      result.unshift({ type: "context", line: oldLines[i - 1] });
-      i--;
-      j--;
-    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
-      result.unshift({ type: "add", line: newLines[j - 1] });
-      j--;
-    } else {
-      result.unshift({ type: "remove", line: oldLines[i - 1] });
-      i--;
-    }
-  }
-  return result;
-}
-function editSnippetToUnifiedDiff(filePath, oldText, newText) {
-  const lines = computeLineDiff(oldText, newText);
-  const out = [`--- ${filePath}`, `+++ ${filePath}`];
-  for (const d of lines) {
-    if (d.type === "add") out.push(`+${d.line}`);
-    else if (d.type === "remove") out.push(`-${d.line}`);
-    else out.push(` ${d.line}`);
-  }
-  return out.join("\n");
-}
-
-// src/agents/acp/safe-fs-path.ts
-import * as path9 from "node:path";
-function resolveSafePathUnderCwd(cwd, filePath) {
-  const trimmed2 = filePath.trim();
-  if (!trimmed2) return null;
-  const normalizedCwd = path9.resolve(cwd);
-  const resolved = path9.isAbsolute(trimmed2) ? path9.normalize(trimmed2) : path9.resolve(normalizedCwd, trimmed2);
-  const rel = path9.relative(normalizedCwd, resolved);
-  if (rel.startsWith("..") || path9.isAbsolute(rel)) return null;
-  return resolved;
-}
-function toDisplayPathRelativeToCwd(cwd, absolutePath) {
-  const normalizedCwd = path9.resolve(cwd);
-  const rel = path9.relative(normalizedCwd, path9.resolve(absolutePath));
-  if (!rel || rel === "") return path9.basename(absolutePath);
-  return rel.split(path9.sep).join("/");
-}
-
 // src/agents/acp/clients/agent-stderr-capture.ts
 var STDERR_CAPTURE_MAX = 48e3;
 function createStderrCapture(child) {
@@ -32173,7 +32365,7 @@ function createKiroSdkExtNotificationHandler(options) {
   };
 }
 
-// src/agents/acp/clients/sdk-stdio-ext-notifications.ts
+// src/agents/acp/clients/sdk/sdk-stdio-ext-notifications.ts
 var noopExtNotification = async () => {
 };
 function createSdkStdioExtNotificationHandler(options) {
@@ -32232,23 +32424,364 @@ function enrichAcpPermissionRpcResultFromRequestParams(result, params) {
   };
 }
 
-// src/agents/acp/clients/sdk-stdio-acp-client.ts
-function formatSpawnError(err, command) {
-  if (err.code === "ENOENT") {
-    return `Command "${command}" not found. Install the agent (e.g. Cursor CLI) or add it to PATH.`;
+// src/agents/acp/clients/shared/acp-fs-read-write.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+
+// src/files/diff/unified-diff.ts
+function computeLineDiff(oldText, newText) {
+  const oldLines = oldText.split("\n");
+  const newLines = newText.split("\n");
+  const m = oldLines.length;
+  const n = newLines.length;
+  const dp = Array(m + 1);
+  for (let i2 = 0; i2 <= m; i2++) dp[i2] = Array(n + 1).fill(0);
+  for (let i2 = 1; i2 <= m; i2++) {
+    for (let j2 = 1; j2 <= n; j2++) {
+      if (oldLines[i2 - 1] === newLines[j2 - 1]) {
+        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
+      } else {
+        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+      }
+    }
   }
-  return err.message || String(err);
+  const result = [];
+  let i = m;
+  let j = n;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
+      result.unshift({ type: "context", line: oldLines[i - 1] });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      result.unshift({ type: "add", line: newLines[j - 1] });
+      j--;
+    } else {
+      result.unshift({ type: "remove", line: oldLines[i - 1] });
+      i--;
+    }
+  }
+  return result;
+}
+function editSnippetToUnifiedDiff(filePath, oldText, newText) {
+  const lines = computeLineDiff(oldText, newText);
+  const out = [`--- ${filePath}`, `+++ ${filePath}`];
+  for (const d of lines) {
+    if (d.type === "add") out.push(`+${d.line}`);
+    else if (d.type === "remove") out.push(`-${d.line}`);
+    else out.push(` ${d.line}`);
+  }
+  return out.join("\n");
+}
+
+// src/agents/acp/safe-fs-path.ts
+import * as path9 from "node:path";
+function resolveSafePathUnderCwd(cwd, filePath) {
+  const trimmed2 = filePath.trim();
+  if (!trimmed2) return null;
+  const normalizedCwd = path9.resolve(cwd);
+  const resolved = path9.isAbsolute(trimmed2) ? path9.normalize(trimmed2) : path9.resolve(normalizedCwd, trimmed2);
+  const rel = path9.relative(normalizedCwd, resolved);
+  if (rel.startsWith("..") || path9.isAbsolute(rel)) return null;
+  return resolved;
 }
-function sliceFileContentRange(content, line, limit) {
+function toDisplayPathRelativeToCwd(cwd, absolutePath) {
+  const normalizedCwd = path9.resolve(cwd);
+  const rel = path9.relative(normalizedCwd, path9.resolve(absolutePath));
+  if (!rel || rel === "") return path9.basename(absolutePath);
+  return rel.split(path9.sep).join("/");
+}
+
+// src/agents/acp/clients/shared/acp-fs-read-write.ts
+function sliceFileContentForAcp(content, line, limit) {
   if (line == null && limit == null) return content;
   const lines = content.split("\n");
   const start = line != null && line > 0 ? line - 1 : 0;
   const end = limit != null && limit > 0 ? start + limit : lines.length;
   return lines.slice(start, end).join("\n");
 }
-function bridgePayloadFromSdkSessionNotification(params) {
+function acpReadTextFileInProcess(ctx, filePath, line, limit) {
+  const resolvedPath = resolveSafePathUnderCwd(ctx.cwd, filePath);
+  if (!resolvedPath) throw new Error("Invalid or disallowed path");
+  try {
+    let content = readFileSync2(resolvedPath, "utf8");
+    content = sliceFileContentForAcp(content, line, limit);
+    return { content };
+  } catch (e) {
+    if (e.code === "ENOENT") return { content: "" };
+    throw e;
+  }
+}
+function acpWriteTextFileInProcess(ctx, filePath, newText) {
+  const resolvedPath = resolveSafePathUnderCwd(ctx.cwd, filePath);
+  if (!resolvedPath) throw new Error("Invalid or disallowed path");
+  let oldText = "";
+  try {
+    oldText = readFileSync2(resolvedPath, "utf8");
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+  mkdirSync2(dirname2(resolvedPath), { recursive: true });
+  writeFileSync2(resolvedPath, newText, "utf8");
+  const displayPath = toDisplayPathRelativeToCwd(ctx.cwd, resolvedPath);
+  const patchContent = editSnippetToUnifiedDiff(displayPath, oldText, newText);
+  ctx.onFileChange?.({ path: displayPath, oldText, newText, patchContent });
+  return {};
+}
+
+// src/agents/acp/claude-acp-permission-from-session.ts
+function flattenSelectOptions(options) {
+  if (options == null || options.length === 0) return [];
+  const first2 = options[0];
+  if (first2 != null && typeof first2 === "object" && "group" in first2 && first2.group != null) {
+    return options.flatMap(
+      (g) => Array.isArray(g.options) ? g.options : []
+    );
+  }
+  return options;
+}
+function pickModeConfigOption(configOptions) {
+  if (configOptions == null || configOptions.length === 0) return null;
+  const byCategory = configOptions.find((o) => o.category === "mode");
+  if (byCategory) return byCategory;
+  return configOptions.find((o) => o.id === "mode") ?? null;
+}
+async function applyClaudePermissionFromAcpSession(params) {
+  const { sessionId, agentConfig, configOptions, modes, setSessionConfigOption, setSessionMode, logDebug: logDebug2 } = params;
+  const desiredMode = getClaudePermissionModeFromAgentConfig(agentConfig);
+  if (desiredMode == null) return;
+  const modeOpt = pickModeConfigOption(configOptions ?? null);
+  if (modeOpt != null) {
+    const flat = flattenSelectOptions(modeOpt.options);
+    const allowed = flat.some((o) => o.value === desiredMode);
+    if (allowed && modeOpt.currentValue !== desiredMode) {
+      try {
+        logDebug2(
+          `[Agent] Claude Code: sending ACP session/set_config_option (permission mode) configId=${JSON.stringify(modeOpt.id)} value=${JSON.stringify(desiredMode)} was=${JSON.stringify(modeOpt.currentValue)} sessionId=${sessionId.slice(0, 8)}\u2026`
+        );
+        await setSessionConfigOption({ sessionId, configId: modeOpt.id, value: desiredMode });
+      } catch (e) {
+        logDebug2(
+          `[Agent] Claude Code: session/set_config_option failed: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    }
+    return;
+  }
+  if (modes?.availableModes?.length) {
+    const allowed = modes.availableModes.some((m) => m.id === desiredMode);
+    if (allowed && desiredMode !== modes.currentModeId) {
+      try {
+        logDebug2(
+          `[Agent] Claude Code: sending ACP session/set_mode (permission mode) modeId=${JSON.stringify(desiredMode)} was=${JSON.stringify(modes.currentModeId ?? null)} sessionId=${sessionId.slice(0, 8)}\u2026`
+        );
+        await setSessionMode({ sessionId, modeId: desiredMode });
+      } catch (e) {
+        logDebug2(`[Agent] Claude Code: session/set_mode failed: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+  }
+}
+
+// src/agents/acp/clients/shared/config-options-for-permission.ts
+function configOptionsForPermission(getActive, established) {
+  const mem = getActive?.();
+  if (Array.isArray(mem) && mem.length > 0) return mem;
+  return established ?? void 0;
+}
+
+// src/agents/acp/clients/shared/establish-acp-session.ts
+function establishedFromResult(raw, sessionId) {
+  const r = raw && typeof raw === "object" ? raw : {};
+  return {
+    sessionId,
+    configOptions: Array.isArray(r.configOptions) ? r.configOptions : null,
+    modes: r.modes ?? null
+  };
+}
+function sessionIdFromNewSessionResult(raw) {
+  const r = raw && typeof raw === "object" ? raw : {};
+  return typeof r.sessionId === "string" ? r.sessionId : "";
+}
+async function establishAcpSessionWithTransport(transport, ctx, canResume, canLoad) {
+  const { cwd, mcpServers, persistedAcpSessionId, agentLabel, suppressLoadReplay } = ctx;
+  const prev = typeof persistedAcpSessionId === "string" && persistedAcpSessionId.trim() !== "" ? persistedAcpSessionId.trim() : "";
+  if (prev) {
+    if (canResume) {
+      try {
+        logDebug(`[Agent] ${agentLabel} ACP session/resume for stored session ${prev.slice(0, 8)}\u2026`);
+        const result2 = await transport.resumeSession({ sessionId: prev, cwd, mcpServers });
+        return establishedFromResult(result2, prev);
+      } catch (e) {
+        logDebug(`[Agent] ${agentLabel} ACP session/resume failed: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+    if (canLoad) {
+      suppressLoadReplay.value = true;
+      try {
+        logDebug(`[Agent] ${agentLabel} ACP session/load for stored session ${prev.slice(0, 8)}\u2026`);
+        const result2 = await transport.loadSession({ sessionId: prev, cwd, mcpServers });
+        return establishedFromResult(result2, prev);
+      } catch (e) {
+        logDebug(`[Agent] ${agentLabel} ACP session/load failed: ${e instanceof Error ? e.message : String(e)}`);
+      } finally {
+        suppressLoadReplay.value = false;
+      }
+    }
+  }
+  const result = await transport.newSession({ cwd, mcpServers });
+  const sid = sessionIdFromNewSessionResult(result);
+  if (!sid) throw new Error(`${agentLabel} ACP session/new did not return sessionId`);
+  return establishedFromResult(result, sid);
+}
+
+// src/agents/acp/clients/shared/parse-acp-init-capabilities.ts
+function parseAcpInitAgentCapabilities(initResult) {
+  const agentCapabilities = initResult?.agentCapabilities;
+  const canLoad = agentCapabilities?.loadSession === true;
+  const sessionCaps = agentCapabilities?.sessionCapabilities;
+  const canResume = Boolean(sessionCaps?.resume);
+  return { canResume, canLoad };
+}
+
+// src/agents/acp/clients/shared/bootstrap-acp-wire-session.ts
+async function bootstrapAcpWireSession(transport, ctx, initializeRequest) {
+  const initResult = await transport.initialize(initializeRequest);
+  const { canResume, canLoad } = parseAcpInitAgentCapabilities(initResult);
+  await transport.afterInitialize?.();
+  const established = await establishAcpSessionWithTransport(transport, ctx, canResume, canLoad);
+  const sessionId = established.sessionId;
+  ctx.onAcpSessionEstablished?.({
+    acpSessionId: sessionId,
+    configOptions: established.configOptions,
+    modes: established.modes
+  });
+  if (ctx.backendAgentType === "claude-code") {
+    const cfg = ctx.agentConfig != null && typeof ctx.agentConfig === "object" && !Array.isArray(ctx.agentConfig) ? ctx.agentConfig : null;
+    const configOptionsTyped = established.configOptions;
+    const modesTyped = established.modes;
+    await applyClaudePermissionFromAcpSession({
+      sessionId,
+      agentConfig: cfg,
+      configOptions: configOptionsForPermission(ctx.getActiveConfigOptions, configOptionsTyped),
+      modes: modesTyped,
+      setSessionConfigOption: transport.setSessionConfigOption ? (p) => transport.setSessionConfigOption(p) : async () => {
+      },
+      setSessionMode: transport.setSessionMode ? (p) => transport.setSessionMode(p) : async () => {
+      },
+      logDebug: ctx.logDebug
+    });
+  }
+  return established;
+}
+
+// src/agents/acp/clients/shared/dispatch-session-update.ts
+function dispatchAcpSessionUpdate(opts) {
+  const { flatPayload, onAcpConfigOptionsUpdated, onSessionUpdate, suppressLoadReplay } = opts;
+  const su = flatPayload.sessionUpdate ?? flatPayload.session_update;
+  if (su === "config_option_update") {
+    const co = flatPayload.configOptions;
+    if (Array.isArray(co)) onAcpConfigOptionsUpdated?.(co);
+    return;
+  }
+  if (suppressLoadReplay()) return;
+  onSessionUpdate?.(flatPayload);
+}
+
+// src/agents/acp/clients/shared/flatten-sdk-session-notification.ts
+function flattenSdkSessionNotificationParams(params) {
   return { sessionId: params.sessionId, ...params.update };
 }
+
+// src/agents/acp/clients/shared/normalize-acp-prompt-result.ts
+function normalizeAcpPromptTurnSuccess(opts) {
+  const { stopReason, output, stderrCaptureText, backendAgentType } = opts;
+  const mergedOutput = output || void 0;
+  const stop = (stopReason ?? "").toLowerCase();
+  const cancelled = stop === "cancelled";
+  const refusal = stop === "refusal";
+  const stderrEvaluated = Boolean(stderrCaptureText && backendAgentType);
+  const stderrSuggestsAuth = stderrEvaluated ? localAgentErrorSuggestsAuth(backendAgentType, stderrCaptureText) : false;
+  if (cancelled) {
+    return {
+      success: false,
+      stopReason,
+      output: mergedOutput,
+      error: mergeErrorWithStderr("Stopped by user", stderrCaptureText)
+    };
+  }
+  if (refusal) {
+    return {
+      success: false,
+      stopReason,
+      output: mergedOutput,
+      error: mergeErrorWithStderr("The agent refused the request.", stderrCaptureText)
+    };
+  }
+  if (stderrSuggestsAuth) {
+    return {
+      success: false,
+      stopReason,
+      output: mergedOutput,
+      error: stderrCaptureText
+    };
+  }
+  return {
+    success: true,
+    stopReason,
+    output: mergedOutput
+  };
+}
+function normalizeAcpPromptTurnFailure(err, stderrCaptureText) {
+  const merged = mergeErrorWithStderr(formatJsonRpcStyleError(err), stderrCaptureText);
+  return { success: false, error: merged };
+}
+
+// src/agents/acp/clients/shared/send-acp-prompt-via-transport.ts
+async function sendAcpPromptViaTransport(transport, ctx, sessionId, promptText) {
+  try {
+    const response = await transport.prompt({
+      sessionId,
+      prompt: [{ type: "text", text: promptText }]
+    });
+    await new Promise((r2) => setImmediate(r2));
+    const r = response;
+    return normalizeAcpPromptTurnSuccess({
+      stopReason: r?.stopReason,
+      output: r?.output,
+      stderrCaptureText: ctx.getStderrText(),
+      backendAgentType: ctx.backendAgentType
+    });
+  } catch (err) {
+    await new Promise((r) => setImmediate(r));
+    return normalizeAcpPromptTurnFailure(err, ctx.getStderrText());
+  }
+}
+
+// src/agents/acp/clients/sdk/sdk-acp-session-transport.ts
+function createSdkAcpSessionTransport(connection) {
+  const c = connection;
+  return {
+    initialize: (request) => c.initialize(request),
+    resumeSession: (p) => c.unstable_resumeSession(p),
+    loadSession: (p) => c.loadSession(p),
+    newSession: (p) => c.newSession(p),
+    prompt: (p) => c.prompt(p),
+    cancelSession: async (sessionId) => {
+      await c.cancel({ sessionId });
+    },
+    setSessionConfigOption: c.setSessionConfigOption ? (p) => c.setSessionConfigOption(p) : void 0,
+    setSessionMode: c.setSessionMode ? (p) => c.setSessionMode(p) : void 0
+  };
+}
+
+// src/agents/acp/clients/sdk/sdk-stdio-acp-client.ts
+function formatSpawnError(err, command) {
+  if (err.code === "ENOENT") {
+    return `Command "${command}" not found. Install the agent (e.g. Cursor CLI) or add it to PATH.`;
+  }
+  return err.message || String(err);
+}
 async function createSdkStdioAcpClient(options) {
   const { ClientSideConnection: ClientSideConnection2, ndJsonStream: ndJsonStream2, PROTOCOL_VERSION: PROTOCOL_VERSION2 } = await Promise.resolve().then(() => (init_acp(), acp_exports));
   const {
@@ -32259,7 +32792,12 @@ async function createSdkStdioAcpClient(options) {
     onRequest,
     onFileChange,
     killSubprocessAfterCancelMs,
-    onAgentSubprocessExit
+    onAgentSubprocessExit,
+    agentConfig,
+    persistedAcpSessionId,
+    onAcpSessionEstablished,
+    onAcpConfigOptionsUpdated,
+    getActiveConfigOptions
   } = options;
   const isWindows = process.platform === "win32";
   const child = spawn2(command[0], command.slice(1), {
@@ -32308,6 +32846,22 @@ 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) => ({
@@ -32327,35 +32881,19 @@ async function createSdkStdioAcpClient(options) {
             });
           },
           async readTextFile(params) {
-            const resolvedPath = resolveSafePathUnderCwd(cwd, params.path);
-            if (!resolvedPath) throw new Error("Invalid or disallowed path");
-            try {
-              let content = readFileSync2(resolvedPath, "utf8");
-              content = sliceFileContentRange(content, params.line, params.limit);
-              return { content };
-            } catch (e) {
-              if (e.code === "ENOENT") return { content: "" };
-              throw e;
-            }
+            return acpReadTextFileInProcess(sessionCtx, params.path, params.line, params.limit);
           },
           async writeTextFile(params) {
-            const resolvedPath = resolveSafePathUnderCwd(cwd, params.path);
-            if (!resolvedPath) throw new Error("Invalid or disallowed path");
-            let oldText = "";
-            try {
-              oldText = readFileSync2(resolvedPath, "utf8");
-            } catch (e) {
-              if (e.code !== "ENOENT") throw e;
-            }
-            mkdirSync2(dirname2(resolvedPath), { recursive: true });
-            writeFileSync2(resolvedPath, params.content, "utf8");
-            const displayPath = toDisplayPathRelativeToCwd(cwd, resolvedPath);
-            const patchContent = editSnippetToUnifiedDiff(displayPath, oldText, params.content);
-            onFileChange?.({ path: displayPath, oldText, newText: params.content, patchContent });
-            return {};
+            return acpWriteTextFileInProcess(sessionCtx, params.path, params.content);
           },
           async sessionUpdate(params) {
-            onSessionUpdate?.(bridgePayloadFromSdkSessionNotification(params));
+            const bridged = flattenSdkSessionNotificationParams(params);
+            dispatchAcpSessionUpdate({
+              flatPayload: bridged,
+              onAcpConfigOptionsUpdated: sessionCtx.onAcpConfigOptionsUpdated,
+              onSessionUpdate,
+              suppressLoadReplay: () => sessionCtx.suppressLoadReplay.value
+            });
           },
           async extNotification(method, params) {
             await extNotification(method, params);
@@ -32365,70 +32903,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;
+        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()]) {
@@ -32436,7 +32923,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) {
@@ -32485,10 +32972,7 @@ async function detectLocalAgentPresence() {
     return false;
   }
 }
-function buildClaudeCodeAcpSpawnCommand(base, sessionMode) {
-  if (!sessionMode) return [...base];
-  const m = sessionMode.trim();
-  if (m === "plan") return [...base, "--permission-mode", "plan"];
+function buildClaudeCodeAcpSpawnCommand(base, _sessionMode) {
   return [...base];
 }
 async function createClaudeCodeAcpClient(options) {
@@ -32530,7 +33014,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,
@@ -32538,8 +33022,6 @@ __export(cursor_acp_client_exports, {
   createCursorAcpClient: () => createCursorAcpClient,
   detectLocalAgentPresence: () => detectLocalAgentPresence3
 });
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "node:fs";
-import { dirname as dirname3 } from "node:path";
 import { spawn as spawn3 } from "node:child_process";
 import * as readline from "node:readline";
 
@@ -32556,7 +33038,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) {
@@ -32573,13 +33071,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();
@@ -32593,7 +33084,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";
@@ -32605,6 +33100,25 @@ async function createCursorAcpClient(options) {
   });
   const stderrCapture = createStderrCapture(child);
   child.stderr?.on("data", (chunk) => stderrCapture.append(chunk));
+  child.once("close", (code, signal) => {
+    onAgentSubprocessExit?.({ code, signal });
+  });
+  const suppressLoadReplayRef = { value: false };
+  const sessionCtx = {
+    cwd,
+    onFileChange,
+    mcpServers: [],
+    persistedAcpSessionId,
+    agentLabel: "Cursor",
+    suppressLoadReplay: suppressLoadReplayRef,
+    backendAgentType: backendAgentType ?? null,
+    agentConfig: options.agentConfig,
+    getActiveConfigOptions: options.getActiveConfigOptions,
+    onAcpSessionEstablished,
+    onAcpConfigOptionsUpdated,
+    logDebug,
+    getStderrText: () => stderrCapture.getText()
+  };
   return new Promise((resolve18, reject) => {
     child.on("error", (err) => {
       child.kill();
@@ -32613,6 +33127,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";
@@ -32636,7 +33160,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);
@@ -32665,11 +33188,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") {
@@ -32689,21 +33213,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));
@@ -32720,32 +33236,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") {
@@ -32767,16 +33268,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" } });
@@ -32784,76 +33276,25 @@ async function createCursorAcpClient(options) {
             }
           }
         };
-        var sendSessionCancelNotification = sendSessionCancelNotification2, cancelPendingPermissionRequests = cancelPendingPermissionRequests2;
-        await send("initialize", {
+        var cancelPendingPermissionRequests = cancelPendingPermissionRequests2;
+        const transport = createCursorJsonRpcAcpTransport({
+          send,
+          cancelSessionNotification
+        });
+        const established = await bootstrapAcpWireSession(transport, sessionCtx, {
           protocolVersion: 1,
           clientCapabilities: { fs: { readTextFile: true, writeTextFile: true }, terminal: false },
           clientInfo: { name: "buildautomaton-cli", version: "0.1.0" }
         });
-        await send("authenticate", { methodId: "cursor_login" });
-        const newResult = await send("session/new", { cwd, mcpServers: [] });
-        const sessionId = newResult?.sessionId ?? "";
-        if (!sessionId) throw new Error("Cursor ACP session/new did not return sessionId");
+        const sessionId = established.sessionId;
         resolve18({
           sessionId,
           async sendPrompt(prompt, _options) {
-            promptOutputBuffer = "";
-            try {
-              const result = await send("session/prompt", {
-                sessionId,
-                prompt: [{ type: "text", text: prompt }]
-              });
-              await new Promise((r) => setImmediate(r));
-              const output = (result?.output ?? promptOutputBuffer) || void 0;
-              const stopReason = (result?.stopReason ?? "").toLowerCase();
-              const cancelled = stopReason === "cancelled";
-              const refusal = stopReason === "refusal";
-              const stderrAfter = stderrCapture.getText();
-              const agentType = backendAgentType ?? null;
-              const stderrEvaluated = Boolean(stderrAfter && agentType);
-              const stderrSuggestsAuth = stderrEvaluated ? localAgentErrorSuggestsAuth(agentType, stderrAfter) : false;
-              if (cancelled) {
-                return {
-                  success: false,
-                  stopReason: result?.stopReason,
-                  output: output || void 0,
-                  error: mergeErrorWithStderr("Stopped by user", stderrAfter)
-                };
-              }
-              if (refusal) {
-                return {
-                  success: false,
-                  stopReason: result?.stopReason,
-                  output: output || void 0,
-                  error: mergeErrorWithStderr("The agent refused the request.", stderrAfter)
-                };
-              }
-              if (stderrSuggestsAuth) {
-                return {
-                  success: false,
-                  stopReason: result?.stopReason,
-                  output: output || void 0,
-                  error: stderrAfter
-                };
-              }
-              return {
-                success: true,
-                stopReason: result?.stopReason,
-                output: output || void 0
-              };
-            } catch (err) {
-              await new Promise((r) => setImmediate(r));
-              const stderrAfter = stderrCapture.getText();
-              const merged = mergeErrorWithStderr(formatJsonRpcStyleError(err), stderrAfter);
-              return {
-                success: false,
-                error: merged
-              };
-            }
+            return sendAcpPromptViaTransport(transport, sessionCtx, sessionId, prompt);
           },
           async cancel() {
             cancelPendingPermissionRequests2();
-            await sendSessionCancelNotification2();
+            await transport.cancelSession(sessionId);
           },
           resolveRequest(requestId, result) {
             const numericId = Number(requestId);
@@ -32951,7 +33392,7 @@ function resolveAgentCommand(preferredAgentType) {
       command,
       label: preferredAgentType,
       createClient: createCursorAcpClient,
-      spawnCommandForSession: (sessionMode) => buildCursorAcpSpawnCommand(command, sessionMode)
+      spawnCommandForSession: (sessionMode, _agentConfig) => buildCursorAcpSpawnCommand(command, sessionMode)
     };
   }
   if (useCodexAcp(preferredAgentType, command)) {
@@ -32959,7 +33400,7 @@ function resolveAgentCommand(preferredAgentType) {
       command,
       label: preferredAgentType,
       createClient: createCodexAcpClient,
-      spawnCommandForSession: (sessionMode) => buildCodexAcpSpawnCommand(command, sessionMode)
+      spawnCommandForSession: (sessionMode, _agentConfig) => buildCodexAcpSpawnCommand(command, sessionMode)
     };
   }
   if (useKiroAcp(preferredAgentType, command)) {
@@ -32967,7 +33408,7 @@ function resolveAgentCommand(preferredAgentType) {
       command,
       label: preferredAgentType,
       createClient: createKiroAcpClient,
-      spawnCommandForSession: (sessionMode) => buildKiroAcpSpawnCommand(command, sessionMode)
+      spawnCommandForSession: (sessionMode, _agentConfig) => buildKiroAcpSpawnCommand(command, sessionMode)
     };
   }
   return {
@@ -33001,7 +33442,7 @@ function getGitRepoRootSync(startDir) {
 
 // src/agents/acp/workspace-files.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync3 } from "node:fs";
 import * as path11 from "node:path";
 function resolveWorkspaceFilePath(sessionParentPath, rawPath) {
   const trimmed2 = rawPath.trim();
@@ -33033,7 +33474,7 @@ function readUtf8WorkspaceFile(sessionParentPath, displayPath) {
     const rel = path11.relative(gitRoot, resolvedPath2);
     if (!rel.startsWith("..") && !path11.isAbsolute(rel)) {
       try {
-        return readFileSync4(resolvedPath2, "utf8");
+        return readFileSync3(resolvedPath2, "utf8");
       } catch {
       }
     }
@@ -33041,7 +33482,7 @@ function readUtf8WorkspaceFile(sessionParentPath, displayPath) {
   const resolvedPath = resolveSafePathUnderCwd(sessionParentPath, displayPath);
   if (!resolvedPath) return "";
   try {
-    return readFileSync4(resolvedPath, "utf8");
+    return readFileSync3(resolvedPath, "utf8");
   } catch {
     return "";
   }
@@ -33545,6 +33986,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;
@@ -33631,14 +34075,72 @@ function buildAcpSessionBridgeHooks(opts) {
   };
 }
 
+// src/agents/acp/local-agent-session-file.ts
+import fs10 from "node:fs";
+import os3 from "node:os";
+import path12 from "node:path";
+var LOCAL_AGENT_SESSION_DIR = path12.join(os3.homedir(), ".buildautomaton", "agent-sessions");
+function safeFileSlug(cloudSessionId) {
+  const t = cloudSessionId.replace(/[^a-zA-Z0-9_-]+/g, "_").slice(0, 220);
+  return t.length > 0 ? t : "session";
+}
+function localAgentSessionFilePath(cloudSessionId) {
+  return path12.join(LOCAL_AGENT_SESSION_DIR, `${safeFileSlug(cloudSessionId)}.json`);
+}
+function readLocalAgentSessionFile(cloudSessionId) {
+  try {
+    const p = localAgentSessionFilePath(cloudSessionId);
+    const raw = fs10.readFileSync(p, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.v !== 1) return null;
+    return {
+      v: 1,
+      acpSessionId: typeof parsed.acpSessionId === "string" ? parsed.acpSessionId : null,
+      backendAgentType: typeof parsed.backendAgentType === "string" ? parsed.backendAgentType : null,
+      configOptions: Array.isArray(parsed.configOptions) ? parsed.configOptions : null,
+      updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch {
+    return null;
+  }
+}
+function writeLocalAgentSessionFile(cloudSessionId, patch) {
+  try {
+    const dir = LOCAL_AGENT_SESSION_DIR;
+    if (!fs10.existsSync(dir)) fs10.mkdirSync(dir, { recursive: true });
+    const p = localAgentSessionFilePath(cloudSessionId);
+    const prev = readLocalAgentSessionFile(cloudSessionId);
+    const next = {
+      v: 1,
+      acpSessionId: patch.acpSessionId !== void 0 ? patch.acpSessionId : prev?.acpSessionId ?? null,
+      backendAgentType: patch.backendAgentType !== void 0 ? patch.backendAgentType : prev?.backendAgentType ?? null,
+      configOptions: patch.configOptions !== void 0 ? patch.configOptions : prev?.configOptions ?? null,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    fs10.writeFileSync(p, JSON.stringify(next, null, 2), "utf8");
+  } catch {
+  }
+}
+
 // src/agents/acp/ensure-acp-client.ts
 async function ensureAcpClient(options) {
-  const { state, preferredAgentType, mode, sessionParentPath, routing, sendSessionUpdate, sendRequest, log: log2 } = options;
+  const {
+    state,
+    preferredAgentType,
+    mode,
+    agentConfig,
+    sessionParentPath,
+    routing,
+    cloudSessionId,
+    sendSessionUpdate,
+    sendRequest,
+    log: log2
+  } = options;
   const targetSessionParentPath = resolveSessionParentPathForAgentProcess(sessionParentPath);
   if (state.acpStartPromise && !state.acpHandle) {
     await state.acpStartPromise;
   }
-  if (state.acpHandle && state.lastAcpCwd != null && path12.resolve(state.lastAcpCwd) !== path12.resolve(targetSessionParentPath)) {
+  if (state.acpHandle && state.lastAcpCwd != null && path13.resolve(state.lastAcpCwd) !== path13.resolve(targetSessionParentPath)) {
     try {
       state.acpHandle.disconnect();
     } catch {
@@ -33646,6 +34148,7 @@ async function ensureAcpClient(options) {
     state.acpHandle = null;
     state.acpStartPromise = null;
     state.acpAgentKey = null;
+    state.activeSessionConfigOptions = null;
   }
   const resolved = resolveAgentCommand(preferredAgentType);
   if (!resolved) {
@@ -33655,8 +34158,9 @@ async function ensureAcpClient(options) {
     state.lastAcpStartError = "No agent type: ensure the app sends agentType on prompts or agent_config for this bridge.";
     return null;
   }
-  const fullCmd = resolved.spawnCommandForSession(mode);
-  const agentKey = `${resolved.label}::${fullCmd.join("\0")}`;
+  const fullCmd = resolved.spawnCommandForSession(mode, agentConfig ?? null);
+  const cacheConfig = agentConfig != null && typeof agentConfig === "object" && !Array.isArray(agentConfig) && Object.keys(agentConfig).length > 0 ? `\0${JSON.stringify(agentConfig, Object.keys(agentConfig).sort())}` : "";
+  const agentKey = `${resolved.label}::${fullCmd.join("\0")}${cacheConfig}`;
   if (state.acpHandle && state.acpAgentKey !== agentKey) {
     try {
       state.acpHandle.disconnect();
@@ -33665,12 +34169,13 @@ async function ensureAcpClient(options) {
     state.acpHandle = null;
     state.acpStartPromise = null;
     state.acpAgentKey = null;
+    state.activeSessionConfigOptions = null;
   }
   if (state.acpHandle) return state.acpHandle;
   if (!state.acpStartPromise) {
     let statOk = false;
     try {
-      const st = fs10.statSync(targetSessionParentPath);
+      const st = fs11.statSync(targetSessionParentPath);
       statOk = st.isDirectory();
       if (!statOk) {
         state.lastAcpStartError = `Agent cwd is not a directory: ${targetSessionParentPath}`;
@@ -33690,14 +34195,40 @@ async function ensureAcpClient(options) {
       getSendRequest: () => sendRequest,
       log: log2
     });
+    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.lastAcpStartError = "Agent subprocess exited";
       },
       ...hooks,
@@ -33727,7 +34258,8 @@ async function createAcpManager(options) {
     acpStartPromise: null,
     lastAcpStartError: null,
     lastAcpCwd: null,
-    acpAgentKey: null
+    acpAgentKey: null,
+    activeSessionConfigOptions: null
   };
   let backendFallbackAgentType = null;
   const promptRouting = {};
@@ -33754,6 +34286,7 @@ async function createAcpManager(options) {
       runId,
       mode,
       agentType,
+      agentConfig,
       sessionParentPath,
       sendResult: sendResult2,
       sendSessionUpdate,
@@ -33773,8 +34306,10 @@ async function createAcpManager(options) {
         state,
         preferredAgentType: preferredForPrompt,
         mode,
+        agentConfig: agentConfig ?? null,
         sessionParentPath,
         routing: promptRouting,
+        cloudSessionId: sessionId,
         sendSessionUpdate,
         sendRequest: sendSessionUpdate,
         log: log2
@@ -33865,6 +34400,7 @@ async function createAcpManager(options) {
     state.acpHandle = null;
     state.acpStartPromise = null;
     state.acpAgentKey = null;
+    state.activeSessionConfigOptions = null;
   }
   return {
     setPreferredAgentType,
@@ -33877,26 +34413,26 @@ async function createAcpManager(options) {
 }
 
 // src/worktrees/session-worktree-manager.ts
-import * as path19 from "node:path";
-import os4 from "node:os";
+import * as path20 from "node:path";
+import os5 from "node:os";
 
 // src/worktrees/prepare-new-session-worktrees.ts
-import * as fs12 from "node:fs";
-import * as path14 from "node:path";
+import * as fs13 from "node:fs";
+import * as path15 from "node:path";
 
 // src/git/worktree-add.ts
 async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch) {
-  const mainGit = simpleGit(mainRepoPath);
+  const mainGit = cliSimpleGit(mainRepoPath);
   await mainGit.raw(["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
 }
 
 // src/worktrees/worktree-layout-file.ts
-import * as fs11 from "node:fs";
-import * as path13 from "node:path";
-import os3 from "node:os";
+import * as fs12 from "node:fs";
+import * as path14 from "node:path";
+import os4 from "node:os";
 var LAYOUT_FILENAME = "worktree-launcher-layout.json";
 function defaultWorktreeLayoutPath() {
-  return path13.join(os3.homedir(), ".buildautomaton", LAYOUT_FILENAME);
+  return path14.join(os4.homedir(), ".buildautomaton", LAYOUT_FILENAME);
 }
 function normalizeLoadedLayout(raw) {
   if (raw && typeof raw === "object" && "launcherCwds" in raw) {
@@ -33908,8 +34444,8 @@ function normalizeLoadedLayout(raw) {
 function loadWorktreeLayout() {
   try {
     const p = defaultWorktreeLayoutPath();
-    if (!fs11.existsSync(p)) return { launcherCwds: [] };
-    const raw = JSON.parse(fs11.readFileSync(p, "utf8"));
+    if (!fs12.existsSync(p)) return { launcherCwds: [] };
+    const raw = JSON.parse(fs12.readFileSync(p, "utf8"));
     return normalizeLoadedLayout(raw);
   } catch {
     return { launcherCwds: [] };
@@ -33917,24 +34453,24 @@ function loadWorktreeLayout() {
 }
 function saveWorktreeLayout(layout) {
   try {
-    const dir = path13.dirname(defaultWorktreeLayoutPath());
-    fs11.mkdirSync(dir, { recursive: true });
-    fs11.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
+    const dir = path14.dirname(defaultWorktreeLayoutPath());
+    fs12.mkdirSync(dir, { recursive: true });
+    fs12.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
   } catch {
   }
 }
 function baseNameSafe(pathString) {
-  return path13.basename(pathString).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
+  return path14.basename(pathString).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
 }
 function getLauncherDirNameIfPresent(layout, bridgeRootPath2) {
-  const norm = path13.resolve(bridgeRootPath2);
-  const existing = layout.launcherCwds.find((e) => path13.resolve(e.absolutePath) === norm);
+  const norm = path14.resolve(bridgeRootPath2);
+  const existing = layout.launcherCwds.find((e) => path14.resolve(e.absolutePath) === norm);
   return existing?.dirName;
 }
 function allocateDirNameForLauncherCwd(layout, bridgeRootPath2) {
   const existing = getLauncherDirNameIfPresent(layout, bridgeRootPath2);
   if (existing) return existing;
-  const norm = path13.resolve(bridgeRootPath2);
+  const norm = path14.resolve(bridgeRootPath2);
   const base = baseNameSafe(norm);
   const used = new Set(layout.launcherCwds.map((e) => e.dirName));
   let name = base;
@@ -33951,10 +34487,10 @@ function allocateDirNameForLauncherCwd(layout, bridgeRootPath2) {
 // src/worktrees/prepare-new-session-worktrees.ts
 async function prepareNewSessionWorktrees(options) {
   const { worktreesRootPath, bridgeRoot, sessionId, layout, log: log2 } = options;
-  const bridgeResolved = path14.resolve(bridgeRoot);
+  const bridgeResolved = path15.resolve(bridgeRoot);
   const cwdKey = allocateDirNameForLauncherCwd(layout, bridgeResolved);
-  const bridgeKeyDir = path14.join(worktreesRootPath, cwdKey);
-  const sessionDir = path14.join(bridgeKeyDir, sessionId);
+  const bridgeKeyDir = path15.join(worktreesRootPath, cwdKey);
+  const sessionDir = path15.join(bridgeKeyDir, sessionId);
   const repos = await discoverGitReposUnderRoot(bridgeResolved);
   if (repos.length === 0) {
     log2("[worktrees] No Git repositories under bridge root; skipping worktree creation.");
@@ -33962,14 +34498,14 @@ async function prepareNewSessionWorktrees(options) {
   }
   const branch = `session-${sessionId}`;
   const worktreePaths = [];
-  fs12.mkdirSync(sessionDir, { recursive: true });
+  fs13.mkdirSync(sessionDir, { recursive: true });
   for (const repo of repos) {
-    let rel = path14.relative(bridgeResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path14.isAbsolute(rel)) continue;
+    let rel = path15.relative(bridgeResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path15.isAbsolute(rel)) continue;
     const relNorm = rel === "" ? "." : rel;
-    const wtPath = relNorm === "." ? sessionDir : path14.join(sessionDir, relNorm);
+    const wtPath = relNorm === "." ? sessionDir : path15.join(sessionDir, relNorm);
     if (relNorm !== ".") {
-      fs12.mkdirSync(path14.dirname(wtPath), { recursive: true });
+      fs13.mkdirSync(path15.dirname(wtPath), { recursive: true });
     }
     try {
       await gitWorktreeAddBranch(repo.absolutePath, wtPath, branch);
@@ -33991,7 +34527,7 @@ async function prepareNewSessionWorktrees(options) {
 
 // src/git/rename-branch.ts
 async function gitRenameCurrentBranch(repoDir, newName) {
-  const g = simpleGit(repoDir);
+  const g = cliSimpleGit(repoDir);
   await g.raw(["branch", "-m", newName]);
 }
 
@@ -34011,32 +34547,32 @@ async function renameSessionWorktreeBranches(paths, newBranch, log2) {
 }
 
 // src/worktrees/remove-session-worktrees.ts
-import * as fs15 from "node:fs";
+import * as fs16 from "node:fs";
 
 // src/git/worktree-remove.ts
-import * as fs14 from "node:fs";
+import * as fs15 from "node:fs";
 
 // src/git/resolve-main-repo-from-git-file.ts
-import * as fs13 from "node:fs";
-import * as path15 from "node:path";
+import * as fs14 from "node:fs";
+import * as path16 from "node:path";
 function resolveMainRepoFromWorktreeGitFile(wt) {
-  const gitDirFile = path15.join(wt, ".git");
-  if (!fs13.existsSync(gitDirFile) || !fs13.statSync(gitDirFile).isFile()) return "";
-  const first2 = fs13.readFileSync(gitDirFile, "utf8").trim();
+  const gitDirFile = path16.join(wt, ".git");
+  if (!fs14.existsSync(gitDirFile) || !fs14.statSync(gitDirFile).isFile()) return "";
+  const first2 = fs14.readFileSync(gitDirFile, "utf8").trim();
   const m = first2.match(/^gitdir:\s*(.+)$/im);
   if (!m) return "";
-  const gitWorktreePath = path15.resolve(wt, m[1].trim());
-  const gitDir = path15.dirname(path15.dirname(gitWorktreePath));
-  return path15.dirname(gitDir);
+  const gitWorktreePath = path16.resolve(wt, m[1].trim());
+  const gitDir = path16.dirname(path16.dirname(gitWorktreePath));
+  return path16.dirname(gitDir);
 }
 
 // src/git/worktree-remove.ts
 async function gitWorktreeRemoveForce(worktreePath) {
   const mainRepo = resolveMainRepoFromWorktreeGitFile(worktreePath);
   if (mainRepo) {
-    await simpleGit(mainRepo).raw(["worktree", "remove", "--force", worktreePath]);
+    await cliSimpleGit(mainRepo).raw(["worktree", "remove", "--force", worktreePath]);
   } else {
-    fs14.rmSync(worktreePath, { recursive: true, force: true });
+    fs15.rmSync(worktreePath, { recursive: true, force: true });
   }
 }
 
@@ -34049,7 +34585,7 @@ async function removeSessionWorktrees(paths, log2) {
     } catch (e) {
       log2(`[worktrees] Remove failed for ${wt}: ${e instanceof Error ? e.message : String(e)}`);
       try {
-        fs15.rmSync(wt, { recursive: true, force: true });
+        fs16.rmSync(wt, { recursive: true, force: true });
       } catch {
       }
     }
@@ -34164,7 +34700,7 @@ async function gitLogNotReachableFromBase(g, baseSha, headSha) {
   }
 }
 async function commitsAheadOfRemoteTracking(repoDir) {
-  const g = simpleGit(repoDir);
+  const g = cliSimpleGit(repoDir);
   const headSha = await revParseSafe(g, "HEAD");
   if (!headSha) return 0;
   const baseSha = await resolveBaseShaForUnpushedCommits(g);
@@ -34178,14 +34714,14 @@ async function commitsAheadOfRemoteTracking(repoDir) {
   }
 }
 async function getRepoWorkingTreeStatus(repoDir) {
-  const g = simpleGit(repoDir);
+  const g = cliSimpleGit(repoDir);
   const st = await g.status();
   const hasUncommittedChanges = (st.files?.length ?? 0) > 0;
   const ahead = await commitsAheadOfRemoteTracking(repoDir);
   return { hasUncommittedChanges, hasUnpushedCommits: ahead > 0 };
 }
 async function listUnpushedCommits(repoDir) {
-  const g = simpleGit(repoDir);
+  const g = cliSimpleGit(repoDir);
   const headSha = await revParseSafe(g, "HEAD");
   if (!headSha) return [];
   const baseSha = await resolveBaseShaForUnpushedCommits(g);
@@ -34204,7 +34740,7 @@ async function aggregateSessionPathsWorkingTreeStatus(paths) {
 }
 async function pushAheadOfUpstreamForPaths(paths) {
   for (const p of paths) {
-    const g = simpleGit(p);
+    const g = cliSimpleGit(p);
     const ahead = await commitsAheadOfRemoteTracking(p);
     if (ahead <= 0) continue;
     await g.push();
@@ -34269,7 +34805,7 @@ function formatRemoteDisplayLabel(remoteUrl) {
 }
 
 // src/git/working-directory/changes/get-working-tree-change-repo-details.ts
-import * as path17 from "node:path";
+import * as path18 from "node:path";
 
 // src/git/working-directory/changes/parse-git-status.ts
 function parseNameStatusLines(lines) {
@@ -34346,7 +34882,7 @@ async function parentForCommitDiff(g, sha) {
   }
 }
 async function listChangedFilesForCommit(repoGitCwd, repoRelPath, commitSha) {
-  const g = simpleGit(repoGitCwd);
+  const g = cliSimpleGit(repoGitCwd);
   const parent = await parentForCommitDiff(g, commitSha);
   const range = `${parent}..${commitSha}`;
   const [nameStatusRaw, numstatRaw] = await Promise.all([
@@ -34389,8 +34925,8 @@ async function listChangedFilesForCommit(repoGitCwd, repoRelPath, commitSha) {
 }
 
 // src/git/working-directory/changes/list-changed-files-for-repo.ts
-import * as fs17 from "node:fs";
-import * as path16 from "node:path";
+import * as fs18 from "node:fs";
+import * as path17 from "node:path";
 
 // src/git/working-directory/changes/count-lines.ts
 import { createReadStream } from "node:fs";
@@ -34414,14 +34950,14 @@ async function countTextFileLines(filePath) {
 }
 
 // src/git/working-directory/changes/hydrate-patch.ts
-import * as fs16 from "node:fs";
+import * as fs17 from "node:fs";
 var UNIFIED_HUNK_HEADER_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
 var MAX_HYDRATE_LINES_PER_GAP = 8e3;
 var MAX_HYDRATE_LINES_PER_FILE = 8e4;
 async function readGitBlobLines(repoCwd, pathInRepo) {
   try {
     const rel = pathInRepo.replace(/\\/g, "/");
-    const raw = await simpleGit(repoCwd).show([`HEAD:${rel}`]);
+    const raw = await cliSimpleGit(repoCwd).show([`HEAD:${rel}`]);
     return String(raw).split(/\r?\n/);
   } catch {
     return null;
@@ -34429,7 +34965,7 @@ async function readGitBlobLines(repoCwd, pathInRepo) {
 }
 async function readWorktreeFileLines(filePath) {
   try {
-    const raw = await fs16.promises.readFile(filePath, "utf8");
+    const raw = await fs17.promises.readFile(filePath, "utf8");
     return raw.split(/\r?\n/);
   } catch {
     return null;
@@ -34531,7 +35067,7 @@ async function hydrateUnifiedPatchWithFileContext(patch, filePath, repoGitCwd, p
 
 // src/git/working-directory/changes/unified-diff-for-file.ts
 async function unifiedDiffForFile(repoCwd, pathInRepo, change) {
-  const g = simpleGit(repoCwd);
+  const g = cliSimpleGit(repoCwd);
   try {
     let raw;
     if (change === "added") {
@@ -34550,7 +35086,7 @@ async function unifiedDiffForFile(repoCwd, pathInRepo, change) {
 
 // src/git/working-directory/changes/list-changed-files-for-repo.ts
 async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
-  const g = simpleGit(repoGitCwd);
+  const g = cliSimpleGit(repoGitCwd);
   const [nameStatusRaw, numstatRaw, untrackedRaw] = await Promise.all([
     g.raw(["diff", "--name-status", "HEAD"]).catch(() => ""),
     g.raw(["diff", "HEAD", "--numstat"]).catch(() => ""),
@@ -34564,7 +35100,7 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
   const rows = [];
   for (const pathInRepo of paths) {
     const relLauncher = posixJoinDirFile(repoRelPath, pathInRepo.replace(/\\/g, "/"));
-    const repoFilePath = path16.join(repoGitCwd, pathInRepo);
+    const repoFilePath = path17.join(repoGitCwd, pathInRepo);
     const nums = numByPath.get(pathInRepo);
     let additions = nums?.additions ?? 0;
     let deletions = nums?.deletions ?? 0;
@@ -34577,7 +35113,7 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
         deletions = fromGit.deletions;
       } else {
         try {
-          const st = await fs17.promises.stat(repoFilePath);
+          const st = await fs18.promises.stat(repoFilePath);
           if (st.isFile()) additions = await countTextFileLines(repoFilePath);
           else additions = 0;
         } catch {
@@ -34603,7 +35139,7 @@ async function listChangedFilesForRepo(repoGitCwd, repoRelPath) {
     } else {
       pathInRepo = row.pathRelLauncher;
     }
-    const filePath = path16.join(repoGitCwd, pathInRepo);
+    const filePath = path17.join(repoGitCwd, pathInRepo);
     let patch = await unifiedDiffForFile(repoGitCwd, pathInRepo, row.change);
     if (patch) {
       patch = await hydrateUnifiedPatchWithFileContext(patch, filePath, repoGitCwd, pathInRepo, row.change);
@@ -34619,8 +35155,8 @@ function normRepoRel(p) {
   return x === "" ? "." : x;
 }
 async function getWorkingTreeChangeRepoDetails(options) {
-  const bridgeRoot = path17.resolve(getBridgeRoot());
-  const sessionWtRoot = options.sessionWorktreeRootPath ? path17.resolve(options.sessionWorktreeRootPath) : null;
+  const bridgeRoot = path18.resolve(getBridgeRoot());
+  const sessionWtRoot = options.sessionWorktreeRootPath ? path18.resolve(options.sessionWorktreeRootPath) : null;
   const legacyNested = options.legacyRepoNestedSessionLayout === true;
   const out = [];
   const filter = options.repoFilterRelPath != null ? normRepoRel(options.repoFilterRelPath) : null;
@@ -34633,9 +35169,9 @@ async function getWorkingTreeChangeRepoDetails(options) {
   }
   const basis = filter == null && basisInput.kind === "commit" ? { kind: "working" } : basisInput;
   for (const target of options.commitTargetPaths) {
-    const t = path17.resolve(target);
+    const t = path18.resolve(target);
     if (!await isGitRepoDirectory(t)) continue;
-    const g = simpleGit(t);
+    const g = cliSimpleGit(t);
     let branch = "HEAD";
     try {
       branch = (await g.raw(["rev-parse", "--abbrev-ref", "HEAD"])).trim() || "HEAD";
@@ -34646,8 +35182,8 @@ async function getWorkingTreeChangeRepoDetails(options) {
     const remoteDisplay = formatRemoteDisplayLabel(remoteUrl);
     let repoRelPath;
     if (sessionWtRoot) {
-      const anchor = legacyNested ? path17.dirname(t) : t;
-      const relNorm = path17.relative(sessionWtRoot, anchor);
+      const anchor = legacyNested ? path18.dirname(t) : t;
+      const relNorm = path18.relative(sessionWtRoot, anchor);
       repoRelPath = relNorm === "" ? "." : relNorm.replace(/\\/g, "/");
     } else {
       let top = t;
@@ -34656,8 +35192,8 @@ async function getWorkingTreeChangeRepoDetails(options) {
       } catch {
         top = t;
       }
-      const rel = path17.relative(bridgeRoot, path17.resolve(top)).replace(/\\/g, "/") || ".";
-      repoRelPath = rel.startsWith("..") ? path17.basename(path17.resolve(top)) : rel;
+      const rel = path18.relative(bridgeRoot, path18.resolve(top)).replace(/\\/g, "/") || ".";
+      repoRelPath = rel.startsWith("..") ? path18.basename(path18.resolve(top)) : rel;
     }
     const norm = normRepoRel(repoRelPath === "" ? "." : repoRelPath);
     if (filter && norm !== filter) continue;
@@ -34686,7 +35222,7 @@ async function getWorkingTreeChangeRepoDetails(options) {
 
 // src/git/commit-and-push.ts
 async function gitCommitAllIfDirty(repoDir, message, options) {
-  const g = simpleGit(repoDir);
+  const g = cliSimpleGit(repoDir);
   const st = await g.status();
   if (!st.files?.length) return;
   const branch = options.branch.trim();
@@ -34722,11 +35258,11 @@ async function commitSessionWorktrees(options) {
 }
 
 // src/worktrees/discover-session-worktree-on-disk.ts
-import * as fs18 from "node:fs";
-import * as path18 from "node:path";
+import * as fs19 from "node:fs";
+import * as path19 from "node:path";
 function isGitDir(dirPath) {
   try {
-    return fs18.existsSync(path18.join(dirPath, ".git"));
+    return fs19.existsSync(path19.join(dirPath, ".git"));
   } catch {
     return false;
   }
@@ -34735,23 +35271,23 @@ function collectGitRepoRootsUnderDirectory(rootPath) {
   const out = [];
   const walk = (dir) => {
     if (isGitDir(dir)) {
-      out.push(path18.resolve(dir));
+      out.push(path19.resolve(dir));
       return;
     }
     let entries;
     try {
-      entries = fs18.readdirSync(dir, { withFileTypes: true });
+      entries = fs19.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
-      const full = path18.join(dir, e.name);
+      const full = path19.join(dir, e.name);
       if (!e.isDirectory()) continue;
       walk(full);
     }
   };
-  walk(path18.resolve(rootPath));
+  walk(path19.resolve(rootPath));
   return [...new Set(out)];
 }
 function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
@@ -34760,16 +35296,16 @@ function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = fs18.readdirSync(dir, { withFileTypes: true });
+      entries = fs19.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
-      const full = path18.join(dir, e.name);
+      const full = path19.join(dir, e.name);
       if (!e.isDirectory()) continue;
       if (e.name === sessionId) {
-        if (isGitDir(full)) out.push(path18.resolve(full));
+        if (isGitDir(full)) out.push(path19.resolve(full));
       } else {
         walk(full, depth + 1);
       }
@@ -34781,14 +35317,14 @@ function collectWorktreeRootsNamed(root, sessionId, maxDepth) {
 function tryBindingFromSessionDirectory(sessionDir) {
   let st;
   try {
-    st = fs18.statSync(sessionDir);
+    st = fs19.statSync(sessionDir);
   } catch {
     return null;
   }
   if (!st.isDirectory()) return null;
   const worktreePaths = collectGitRepoRootsUnderDirectory(sessionDir);
   if (worktreePaths.length === 0) return null;
-  const abs = path18.resolve(sessionDir);
+  const abs = path19.resolve(sessionDir);
   return {
     sessionParentPath: abs,
     workingTreeRelRoot: abs,
@@ -34798,20 +35334,20 @@ function tryBindingFromSessionDirectory(sessionDir) {
 function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hintR = path18.resolve(checkoutPath);
+  const hintR = path19.resolve(checkoutPath);
   let best = null;
-  let cur = path18.dirname(hintR);
+  let cur = path19.dirname(hintR);
   for (let i = 0; i < 40; i++) {
     const paths = collectWorktreeRootsNamed(cur, sid, 24);
-    if (paths.some((p) => path18.resolve(p) === hintR)) {
-      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths) ?? path18.resolve(paths[0]);
+    if (paths.some((p) => path19.resolve(p) === hintR)) {
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(paths) ?? path19.resolve(paths[0]);
       best = {
-        sessionParentPath: path18.resolve(isolated),
-        workingTreeRelRoot: path18.resolve(cur),
-        repoCheckoutPaths: paths.map((p) => path18.resolve(p))
+        sessionParentPath: path19.resolve(isolated),
+        workingTreeRelRoot: path19.resolve(cur),
+        repoCheckoutPaths: paths.map((p) => path19.resolve(p))
       };
     }
-    const next = path18.dirname(cur);
+    const next = path19.dirname(cur);
     if (next === cur) break;
     cur = next;
   }
@@ -34819,33 +35355,33 @@ function discoverLegacyBindingAscendingFromCheckout(sessionId, checkoutPath) {
 }
 function discoverSessionWorktreeOnDisk(options) {
   const { sessionId, worktreesRootPath, layout, bridgeRoot } = options;
-  if (!sessionId.trim() || !fs18.existsSync(worktreesRootPath)) return null;
+  if (!sessionId.trim() || !fs19.existsSync(worktreesRootPath)) return null;
   const preferredKey = getLauncherDirNameIfPresent(layout, bridgeRoot);
   const keys = [];
   if (preferredKey) keys.push(preferredKey);
   try {
-    for (const name of fs18.readdirSync(worktreesRootPath)) {
+    for (const name of fs19.readdirSync(worktreesRootPath)) {
       if (name.startsWith(".")) continue;
-      const p = path18.join(worktreesRootPath, name);
-      if (!fs18.statSync(p).isDirectory()) continue;
+      const p = path19.join(worktreesRootPath, name);
+      if (!fs19.statSync(p).isDirectory()) continue;
       if (name !== preferredKey) keys.push(name);
     }
   } catch {
     return null;
   }
   for (const key of keys) {
-    const layoutRoot = path18.join(worktreesRootPath, key);
-    if (!fs18.existsSync(layoutRoot) || !fs18.statSync(layoutRoot).isDirectory()) continue;
-    const sessionDir = path18.join(layoutRoot, sessionId);
+    const layoutRoot = path19.join(worktreesRootPath, key);
+    if (!fs19.existsSync(layoutRoot) || !fs19.statSync(layoutRoot).isDirectory()) continue;
+    const sessionDir = path19.join(layoutRoot, sessionId);
     const nested = tryBindingFromSessionDirectory(sessionDir);
     if (nested) return nested;
     const legacyPaths = collectWorktreeRootsNamed(layoutRoot, sessionId, 24);
     if (legacyPaths.length > 0) {
-      const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path18.resolve(legacyPaths[0]);
+      const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path19.resolve(legacyPaths[0]);
       return {
-        sessionParentPath: path18.resolve(isolated),
-        workingTreeRelRoot: path18.resolve(layoutRoot),
-        repoCheckoutPaths: legacyPaths.map((p) => path18.resolve(p))
+        sessionParentPath: path19.resolve(isolated),
+        workingTreeRelRoot: path19.resolve(layoutRoot),
+        repoCheckoutPaths: legacyPaths.map((p) => path19.resolve(p))
       };
     }
   }
@@ -34854,12 +35390,12 @@ function discoverSessionWorktreeOnDisk(options) {
 function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeRootPathOrHint, sessionId) {
   const sid = sessionId.trim();
   if (!sid) return null;
-  const hint = path18.resolve(sessionWorktreeRootPathOrHint);
-  const underHint = tryBindingFromSessionDirectory(path18.join(hint, sid));
+  const hint = path19.resolve(sessionWorktreeRootPathOrHint);
+  const underHint = tryBindingFromSessionDirectory(path19.join(hint, sid));
   if (underHint) return underHint;
   const direct = tryBindingFromSessionDirectory(hint);
   if (direct) {
-    if (path18.basename(hint) === sid && isGitDir(hint)) {
+    if (path19.basename(hint) === sid && isGitDir(hint)) {
       const legacyFromCheckout = discoverLegacyBindingAscendingFromCheckout(sid, hint);
       if (legacyFromCheckout && legacyFromCheckout.repoCheckoutPaths.length > direct.repoCheckoutPaths.length) {
         return legacyFromCheckout;
@@ -34867,24 +35403,24 @@ function discoverSessionWorktreesUnderSessionWorktreeRoot(sessionWorktreeRootPat
     }
     return direct;
   }
-  if (path18.basename(hint) === sid && isGitDir(hint)) {
+  if (path19.basename(hint) === sid && isGitDir(hint)) {
     const legacyFromCheckout = discoverLegacyBindingAscendingFromCheckout(sid, hint);
     if (legacyFromCheckout) return legacyFromCheckout;
   }
   let st;
   try {
-    st = fs18.statSync(hint);
+    st = fs19.statSync(hint);
   } catch {
     return null;
   }
   if (!st.isDirectory()) return null;
   const legacyPaths = collectWorktreeRootsNamed(hint, sid, 24);
   if (legacyPaths.length === 0) return null;
-  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path18.resolve(legacyPaths[0]);
+  const isolated = resolveIsolatedSessionParentPathFromCheckouts(legacyPaths) ?? path19.resolve(legacyPaths[0]);
   return {
-    sessionParentPath: path18.resolve(isolated),
+    sessionParentPath: path19.resolve(isolated),
     workingTreeRelRoot: hint,
-    repoCheckoutPaths: legacyPaths.map((p) => path18.resolve(p))
+    repoCheckoutPaths: legacyPaths.map((p) => path19.resolve(p))
   };
 }
 
@@ -34907,10 +35443,10 @@ var SessionWorktreeManager = class {
     this.layout = loadWorktreeLayout();
   }
   rememberSessionWorktrees(sessionId, binding) {
-    const paths = binding.repoCheckoutPaths.map((p) => path19.resolve(p));
+    const paths = binding.repoCheckoutPaths.map((p) => path20.resolve(p));
     this.sessionRepoCheckoutPaths.set(sessionId, paths);
-    this.sessionParentPathBySession.set(sessionId, path19.resolve(binding.sessionParentPath));
-    this.sessionWorkingTreeRelRootBySession.set(sessionId, path19.resolve(binding.workingTreeRelRoot));
+    this.sessionParentPathBySession.set(sessionId, path20.resolve(binding.sessionParentPath));
+    this.sessionWorkingTreeRelRootBySession.set(sessionId, path20.resolve(binding.workingTreeRelRoot));
   }
   sessionParentPathAfterRemember(sessionId) {
     return this.sessionParentPathBySession.get(sessionId);
@@ -34927,7 +35463,7 @@ var SessionWorktreeManager = class {
     const parent = this.sessionParentPathBySession.get(sessionId);
     const relRoot = this.sessionWorkingTreeRelRootBySession.get(sessionId);
     if (!parent || !relRoot) return false;
-    return path19.resolve(parent) !== path19.resolve(relRoot);
+    return path20.resolve(parent) !== path20.resolve(relRoot);
   }
   /**
    * Session parent path for `worktrees_root`: the per-session directory (new layout) or primary checkout (legacy).
@@ -34936,7 +35472,7 @@ var SessionWorktreeManager = class {
     if (!sessionId) return null;
     const sid = sessionId.trim();
     const cached2 = this.sessionParentPathBySession.get(sid);
-    if (cached2) return path19.resolve(cached2);
+    if (cached2) return path20.resolve(cached2);
     const paths = this.ensureRepoCheckoutPathsForSession(sid) ?? this.getRepoCheckoutPathsForSession(sid);
     if (!paths?.length) return null;
     return resolveIsolatedSessionParentPathFromCheckouts(paths);
@@ -34950,7 +35486,7 @@ var SessionWorktreeManager = class {
     const sid = sessionId.trim();
     const parentPathRaw = opts.sessionParentPath?.trim();
     if (parentPathRaw) {
-      const resolved = path19.resolve(parentPathRaw);
+      const resolved = path20.resolve(parentPathRaw);
       if (sid && parseSessionParent(opts.sessionParent) === "worktrees_root") {
         const diskFirst = this.tryDiscoverFromDisk(sid);
         if (diskFirst) {
@@ -34969,7 +35505,7 @@ var SessionWorktreeManager = class {
             this.rememberSessionWorktrees(sid, tryRoot);
             return this.sessionParentPathAfterRemember(sid);
           }
-          const next = path19.dirname(cur);
+          const next = path20.dirname(cur);
           if (next === cur) break;
           cur = next;
         }
@@ -35122,15 +35658,15 @@ var SessionWorktreeManager = class {
   }
 };
 function defaultWorktreesRootPath() {
-  return path19.join(os4.homedir(), ".buildautomaton", "worktrees");
+  return path20.join(os5.homedir(), ".buildautomaton", "worktrees");
 }
 
 // src/files/watch-file-index.ts
 import { watch } from "node:fs";
-import path26 from "node:path";
+import path27 from "node:path";
 
 // src/files/index/build-file-index.ts
-import path23 from "node:path";
+import path24 from "node:path";
 
 // src/runtime/yield-to-event-loop.ts
 function yieldToEventLoop() {
@@ -35138,14 +35674,14 @@ function yieldToEventLoop() {
 }
 
 // src/files/index/walk-workspace-tree.ts
-import fs19 from "node:fs";
-import path21 from "node:path";
+import fs20 from "node:fs";
+import path22 from "node:path";
 
 // src/files/index/constants.ts
-import path20 from "node:path";
-import os5 from "node:os";
+import path21 from "node:path";
+import os6 from "node:os";
 var INDEX_WORK_YIELD_EVERY = 256;
-var INDEX_DIR = path20.join(os5.homedir(), ".buildautomaton");
+var INDEX_DIR = path21.join(os6.homedir(), ".buildautomaton");
 var INDEX_HASH_LEN = 16;
 var INDEX_VERSION = 2;
 var INDEX_LOG_PREFIX = "[file-index]";
@@ -35154,20 +35690,20 @@ var INDEX_LOG_PREFIX = "[file-index]";
 function walkWorkspaceTreeSync(dir, baseDir, out) {
   let names;
   try {
-    names = fs19.readdirSync(dir);
+    names = fs20.readdirSync(dir);
   } catch {
     return;
   }
   for (const name of names) {
     if (name.startsWith(".")) continue;
-    const full = path21.join(dir, name);
+    const full = path22.join(dir, name);
     let stat3;
     try {
-      stat3 = fs19.statSync(full);
+      stat3 = fs20.statSync(full);
     } catch {
       continue;
     }
-    const relative5 = path21.relative(baseDir, full).replace(/\\/g, "/");
+    const relative5 = path22.relative(baseDir, full).replace(/\\/g, "/");
     if (stat3.isDirectory()) {
       walkWorkspaceTreeSync(full, baseDir, out);
     } else if (stat3.isFile()) {
@@ -35178,7 +35714,7 @@ function walkWorkspaceTreeSync(dir, baseDir, out) {
 async function walkWorkspaceTreeAsync(dir, baseDir, out, state) {
   let names;
   try {
-    names = await fs19.promises.readdir(dir);
+    names = await fs20.promises.readdir(dir);
   } catch {
     return;
   }
@@ -35188,14 +35724,14 @@ async function walkWorkspaceTreeAsync(dir, baseDir, out, state) {
       await yieldToEventLoop();
     }
     state.n++;
-    const full = path21.join(dir, name);
+    const full = path22.join(dir, name);
     let stat3;
     try {
-      stat3 = await fs19.promises.stat(full);
+      stat3 = await fs20.promises.stat(full);
     } catch {
       continue;
     }
-    const relative5 = path21.relative(baseDir, full).replace(/\\/g, "/");
+    const relative5 = path22.relative(baseDir, full).replace(/\\/g, "/");
     if (stat3.isDirectory()) {
       await walkWorkspaceTreeAsync(full, baseDir, out, state);
     } else if (stat3.isFile()) {
@@ -35276,22 +35812,22 @@ async function buildTrigramMapForPathsAsync(paths) {
 }
 
 // src/files/index/write-index-file.ts
-import fs20 from "node:fs";
+import fs21 from "node:fs";
 
 // src/files/index/paths.ts
-import path22 from "node:path";
+import path23 from "node:path";
 import crypto2 from "node:crypto";
 function getIndexPathForCwd(resolvedCwd) {
   const hash = crypto2.createHash("sha256").update(resolvedCwd).digest("hex").slice(0, INDEX_HASH_LEN);
-  return path22.join(INDEX_DIR, `.file-index-${hash}.json`);
+  return path23.join(INDEX_DIR, `.file-index-${hash}.json`);
 }
 
 // src/files/index/write-index-file.ts
 function writeIndexFileSync(resolvedCwd, data) {
   const indexPath = getIndexPathForCwd(resolvedCwd);
   try {
-    if (!fs20.existsSync(INDEX_DIR)) fs20.mkdirSync(INDEX_DIR, { recursive: true });
-    fs20.writeFileSync(indexPath, JSON.stringify(data), "utf8");
+    if (!fs21.existsSync(INDEX_DIR)) fs21.mkdirSync(INDEX_DIR, { recursive: true });
+    fs21.writeFileSync(indexPath, JSON.stringify(data), "utf8");
   } catch (e) {
     console.error(`${INDEX_LOG_PREFIX} Failed to write index:`, e);
   }
@@ -35299,8 +35835,8 @@ function writeIndexFileSync(resolvedCwd, data) {
 async function writeIndexFileAsync(resolvedCwd, data) {
   const indexPath = getIndexPathForCwd(resolvedCwd);
   try {
-    await fs20.promises.mkdir(INDEX_DIR, { recursive: true });
-    await fs20.promises.writeFile(indexPath, JSON.stringify(data), "utf8");
+    await fs21.promises.mkdir(INDEX_DIR, { recursive: true });
+    await fs21.promises.writeFile(indexPath, JSON.stringify(data), "utf8");
   } catch (e) {
     console.error(`${INDEX_LOG_PREFIX} Failed to write index:`, e);
   }
@@ -35314,7 +35850,7 @@ function sortPaths(paths) {
   paths.sort((a, b) => a.localeCompare(b, void 0, { sensitivity: "base" }));
 }
 function buildFileIndex(cwd) {
-  const resolved = path23.resolve(cwd);
+  const resolved = path24.resolve(cwd);
   const paths = [];
   walkWorkspaceTreeSync(resolved, resolved, paths);
   sortPaths(paths);
@@ -35324,7 +35860,7 @@ function buildFileIndex(cwd) {
   return data;
 }
 async function buildFileIndexAsync(cwd) {
-  const resolved = path23.resolve(cwd);
+  const resolved = path24.resolve(cwd);
   const paths = [];
   await walkWorkspaceTreeAsync(resolved, resolved, paths, createWalkYieldState());
   await yieldToEventLoop();
@@ -35336,13 +35872,13 @@ async function buildFileIndexAsync(cwd) {
 }
 
 // src/files/index/load-file-index.ts
-import fs21 from "node:fs";
-import path24 from "node:path";
+import fs22 from "node:fs";
+import path25 from "node:path";
 function loadFileIndex(cwd) {
-  const resolved = path24.resolve(cwd);
+  const resolved = path25.resolve(cwd);
   const indexPath = getIndexPathForCwd(resolved);
   try {
-    const raw = fs21.readFileSync(indexPath, "utf8");
+    const raw = fs22.readFileSync(indexPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed !== null && typeof parsed === "object" && Array.isArray(parsed.paths)) {
       const obj = parsed;
@@ -35361,9 +35897,9 @@ function loadFileIndex(cwd) {
 }
 
 // src/files/index/ensure-file-index.ts
-import path25 from "node:path";
+import path26 from "node:path";
 async function ensureFileIndexAsync(cwd) {
-  const resolved = path25.resolve(cwd);
+  const resolved = path26.resolve(cwd);
   const cached2 = loadFileIndex(resolved);
   if (cached2 !== null) return { data: cached2, fromCache: true };
   const data = await buildFileIndexAsync(resolved);
@@ -35446,7 +35982,7 @@ function createFsWatcher(resolved, schedule) {
   }
 }
 function startFileIndexWatcher(cwd = getBridgeRoot()) {
-  const resolved = path26.resolve(cwd);
+  const resolved = path27.resolve(cwd);
   void buildFileIndexAsync(resolved).catch((e) => {
     console.error("[file-index] Initial index build failed:", e);
   });
@@ -35473,8 +36009,8 @@ function startFileIndexWatcher(cwd = getBridgeRoot()) {
   };
 }
 
-// src/bridge/connection/create-bridge-connection.ts
-import * as path34 from "node:path";
+// src/connection/create-bridge-connection.ts
+import * as path35 from "node:path";
 
 // src/dev-servers/manager/dev-server-manager.ts
 import { rm as rm2 } from "node:fs/promises";
@@ -35518,7 +36054,7 @@ function forceKillChild(proc, log2, shortId, graceMs) {
 }
 
 // src/dev-servers/process/wire-dev-server-child-process.ts
-import fs22 from "node:fs";
+import fs23 from "node:fs";
 
 // src/dev-servers/manager/forward-pipe.ts
 function forwardChildPipe(childReadable, terminal, onData) {
@@ -35554,7 +36090,7 @@ function wireDevServerChildProcess(d) {
         d.setPollInterval(void 0);
         return;
       }
-      fs22.readFile(d.mergedLogPath, (err, buf) => {
+      fs23.readFile(d.mergedLogPath, (err, buf) => {
         if (err || (d.getSpawnGeneration() ?? 0) !== d.scheduledGen) return;
         if (buf.length <= d.mergedReadPos.value) return;
         const chunk = Buffer.from(buf.subarray(d.mergedReadPos.value));
@@ -35592,7 +36128,7 @@ ${errTail}` : ""}`);
       d.sendStatus(code === 0 || code == null ? "stopped" : "error", detail, tails);
     };
     if (mergedPath) {
-      fs22.readFile(mergedPath, (err, buf) => {
+      fs23.readFile(mergedPath, (err, buf) => {
         if (!err && buf.length > d.mergedReadPos.value) {
           const chunk = Buffer.from(buf.subarray(d.mergedReadPos.value));
           if (chunk.length > 0) {
@@ -35694,13 +36230,13 @@ function parseDevServerDefs(servers) {
 }
 
 // src/dev-servers/manager/shell-spawn/utils.ts
-import fs23 from "node:fs";
+import fs24 from "node:fs";
 function isSpawnEbadf(e) {
   return typeof e === "object" && e !== null && "code" in e && e.code === "EBADF";
 }
 function rmDirQuiet(dir) {
   try {
-    fs23.rmSync(dir, { recursive: true, force: true });
+    fs24.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -35708,7 +36244,7 @@ var cachedDevNullReadFd;
 function devNullReadFd() {
   if (cachedDevNullReadFd === void 0) {
     const devPath = process.platform === "win32" ? "nul" : "/dev/null";
-    cachedDevNullReadFd = fs23.openSync(devPath, "r");
+    cachedDevNullReadFd = fs24.openSync(devPath, "r");
   }
   return cachedDevNullReadFd;
 }
@@ -35782,15 +36318,15 @@ function trySpawnShellTruePiped(command, env, cwd, devNullFd, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-merged-log-file.ts
 import { spawn as spawn6 } from "node:child_process";
-import fs24 from "node:fs";
+import fs25 from "node:fs";
 import { tmpdir } from "node:os";
-import path27 from "node:path";
+import path28 from "node:path";
 function trySpawnMergedLogFile(command, env, cwd, signal) {
-  const tmpRoot = fs24.mkdtempSync(path27.join(tmpdir(), "ba-devsrv-log-"));
-  const logPath = path27.join(tmpRoot, "combined.log");
+  const tmpRoot = fs25.mkdtempSync(path28.join(tmpdir(), "ba-devsrv-log-"));
+  const logPath = path28.join(tmpRoot, "combined.log");
   let logFd;
   try {
-    logFd = fs24.openSync(logPath, "a");
+    logFd = fs25.openSync(logPath, "a");
   } catch {
     rmDirQuiet(tmpRoot);
     return null;
@@ -35809,7 +36345,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     } else {
       proc = spawn6("/bin/sh", ["-c", command], { env, cwd, stdio, ...signal ? { signal } : {} });
     }
-    fs24.closeSync(logFd);
+    fs25.closeSync(logFd);
     return {
       proc,
       pipedStdoutStderr: true,
@@ -35818,7 +36354,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     };
   } catch (e) {
     try {
-      fs24.closeSync(logFd);
+      fs25.closeSync(logFd);
     } catch {
     }
     rmDirQuiet(tmpRoot);
@@ -35829,22 +36365,22 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-shell-script-log-redirect.ts
 import { spawn as spawn7 } from "node:child_process";
-import fs25 from "node:fs";
+import fs26 from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path28 from "node:path";
+import path29 from "node:path";
 function shSingleQuote(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 function trySpawnShellScriptLogRedirectUnix(command, env, cwd, signal) {
-  const tmpRoot = fs25.mkdtempSync(path28.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path28.join(tmpRoot, "combined.log");
-  const innerPath = path28.join(tmpRoot, "_cmd.sh");
-  const runnerPath = path28.join(tmpRoot, "_run.sh");
+  const tmpRoot = fs26.mkdtempSync(path29.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path29.join(tmpRoot, "combined.log");
+  const innerPath = path29.join(tmpRoot, "_cmd.sh");
+  const runnerPath = path29.join(tmpRoot, "_run.sh");
   try {
-    fs25.writeFileSync(innerPath, `#!/bin/sh
+    fs26.writeFileSync(innerPath, `#!/bin/sh
 ${command}
 `);
-    fs25.writeFileSync(
+    fs26.writeFileSync(
       runnerPath,
       `#!/bin/sh
 cd ${shSingleQuote(cwd)}
@@ -35870,13 +36406,13 @@ cd ${shSingleQuote(cwd)}
   }
 }
 function trySpawnShellScriptLogRedirectWin(command, env, cwd, signal) {
-  const tmpRoot = fs25.mkdtempSync(path28.join(tmpdir2(), "ba-devsrv-sh-"));
-  const logPath = path28.join(tmpRoot, "combined.log");
-  const runnerPath = path28.join(tmpRoot, "_run.bat");
+  const tmpRoot = fs26.mkdtempSync(path29.join(tmpdir2(), "ba-devsrv-sh-"));
+  const logPath = path29.join(tmpRoot, "combined.log");
+  const runnerPath = path29.join(tmpRoot, "_run.bat");
   const q = (p) => `"${p.replace(/"/g, '""')}"`;
   const com = process.env.ComSpec || "cmd.exe";
   try {
-    fs25.writeFileSync(
+    fs26.writeFileSync(
       runnerPath,
       `@ECHO OFF\r
 CD /D ${q(cwd)}\r
@@ -36609,7 +37145,17 @@ function tryConsumeBinaryProxyBody(raw, deps) {
 
 // src/firehose/connect-firehose.ts
 function connectFirehose(options) {
-  const { firehoseServerUrl, workspaceId, bridgeName, proxyPorts, log: log2, devServerManager, onOpen, onClose } = options;
+  const {
+    firehoseServerUrl,
+    workspaceId,
+    bridgeName,
+    proxyPorts,
+    log: log2,
+    devServerManager,
+    onOpen,
+    onClose,
+    suppressWebSocketErrors
+  } = options;
   const wsUrl = buildFirehoseCliWsUrl(firehoseServerUrl);
   applyCliOutboundNetworkPreferences();
   const ws = new wrapper_default(wsUrl, buildCliWebSocketClientOptions(wsUrl));
@@ -36654,7 +37200,9 @@ function connectFirehose(options) {
   });
   ws.on("error", (err) => {
     disposeClientPing();
-    logCliWebSocketError(log2, "[Proxy and log service]", err);
+    if (!suppressWebSocketErrors?.()) {
+      logCliWebSocketError(log2, "[Proxy and log service]", err);
+    }
     if (ws.readyState === wrapper_default.CONNECTING || ws.readyState === wrapper_default.OPEN) {
       safeCloseWebSocket(ws);
     }
@@ -36669,7 +37217,7 @@ function connectFirehose(options) {
   };
 }
 
-// src/bridge/connection/attach-firehose-after-identified.ts
+// src/connection/attach-firehose-after-identified.ts
 function attachFirehoseAfterIdentified(ctx, params) {
   const { state, devServerManager, logFn } = ctx;
   function clearFirehoseReconnectTimer() {
@@ -36686,10 +37234,44 @@ function attachFirehoseAfterIdentified(ctx, params) {
       firehoseQuiet: state.firehoseQuiet
     };
   }
+  function scheduleFirehoseRetryAfterDrop(closeMeta) {
+    if (state.closedByUser) return;
+    const meta = closeMeta ?? state.lastFirehoseReconnectCloseMeta ?? void 0;
+    const delay2 = applyTieredReconnectPlanAndLog(
+      state.firehoseOutage,
+      logFn,
+      PREVIEW_TUNNEL_SERVICE_LABEL,
+      PREVIEW_TUNNEL_DISCONNECT_LEAD_IN,
+      meta?.code,
+      meta?.reason
+    );
+    armReconnectDelayTimer({
+      delayMs: delay2,
+      bumpAttempt: () => {
+        state.firehoseReconnectAttempt += 1;
+      },
+      clearTimer: clearFirehoseReconnectTimer,
+      setTimer: (id) => {
+        state.firehoseReconnectTimeout = id;
+      },
+      shouldAbortBeforeRun: () => state.closedByUser,
+      run: () => {
+        const p = state.lastFirehoseParams;
+        if (!p) return;
+        attachFirehoseAfterIdentified(ctx, p);
+      },
+      reschedule: () => {
+        scheduleFirehoseRetryAfterDrop();
+      }
+    });
+  }
   state.lastFirehoseParams = params;
   clearFirehoseReconnectTimer();
   if (state.firehoseReconnectAttempt === 0) {
-    logFn("Connecting to preview tunnel (local HTTP proxy and dev logs)\u2026");
+    try {
+      logFn("Connecting to preview tunnel (local HTTP proxy and dev logs)\u2026");
+    } catch {
+    }
   }
   state.firehoseGeneration += 1;
   const myGen = state.firehoseGeneration;
@@ -36704,47 +37286,47 @@ function attachFirehoseAfterIdentified(ctx, params) {
     proxyPorts: params.proxyPorts,
     log: logFn,
     devServerManager,
+    suppressWebSocketErrors: () => !state.closedByUser && state.firehoseOutage.startedAt != null,
     onOpen: () => {
       if (myGen !== state.firehoseGeneration) return;
-      clearFirehoseReconnectQuietOnOpen({ firehoseQuiet: state.firehoseQuiet }, logFn);
+      try {
+        clearFirehoseReconnectQuietOnOpen(
+          {
+            firehoseQuiet: state.firehoseQuiet,
+            firehoseOutage: state.firehoseOutage,
+            lastFirehoseReconnectCloseMeta: state.lastFirehoseReconnectCloseMeta
+          },
+          logFn
+        );
+      } catch {
+      }
       const logOpenAsFirehoseReconnect = state.firehoseReconnectAttempt > 0;
       state.firehoseReconnectAttempt = 0;
       if (!logOpenAsFirehoseReconnect) {
-        logFn("Connected to preview tunnel (local HTTP proxy and dev logs).");
+        try {
+          logFn("Connected to preview tunnel (local HTTP proxy and dev logs).");
+        } catch {
+        }
       }
     },
     onClose: (code, reason) => {
       if (myGen !== state.firehoseGeneration) return;
       state.firehoseHandle = null;
       if (state.closedByUser) return;
-      beginFirehoseDeferredDisconnect(firehoseCtx(), code, reason, logFn);
-      clearFirehoseReconnectTimer();
-      const delay2 = reconnectDelayMs(state.firehoseReconnectAttempt);
-      state.firehoseReconnectAttempt += 1;
-      logNextReconnectAttempt(
-        logFn,
-        PROXY_AND_LOG_SERVICE_LABEL,
-        state.firehoseQuiet,
-        delay2,
-        state.firehoseReconnectAttempt
-      );
-      state.firehoseReconnectTimeout = setTimeout(() => {
-        state.firehoseReconnectTimeout = null;
-        if (state.closedByUser) return;
-        const p = state.lastFirehoseParams;
-        if (!p) {
-          if (state.firehoseQuiet.verboseLogs) {
-            logFn(`${PROXY_AND_LOG_SERVICE_LABEL} Reconnect skipped: no stored connection parameters.`);
-          }
-          return;
-        }
-        attachFirehoseAfterIdentified(ctx, p);
-      }, delay2);
+      state.lastFirehoseReconnectCloseMeta = { code, reason };
+      try {
+        beginFirehoseDeferredDisconnect(firehoseCtx(), code, reason, logFn);
+      } catch {
+      }
+      try {
+        scheduleFirehoseRetryAfterDrop({ code, reason });
+      } catch {
+      }
     }
   });
 }
 
-// src/bridge/connection/create-bridge-identified-handler.ts
+// src/connection/create-bridge-identified-handler.ts
 function createOnBridgeIdentified(opts) {
   const { devServerManager, firehoseServerUrl, workspaceId, state, logFn } = opts;
   const firehoseCtx = { state, devServerManager, logFn };
@@ -36767,30 +37349,30 @@ function createOnBridgeIdentified(opts) {
 }
 
 // src/skills/discover-local-agent-skills.ts
-import fs26 from "node:fs";
-import path29 from "node:path";
+import fs27 from "node:fs";
+import path30 from "node:path";
 var SKILL_DISCOVERY_ROOTS = [".agents/skills", ".claude/skills", ".cursor/skills", "skills"];
 function discoverLocalSkills(cwd) {
   const out = [];
   const seenKeys = /* @__PURE__ */ new Set();
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path29.join(cwd, rel);
-    if (!fs26.existsSync(base) || !fs26.statSync(base).isDirectory()) continue;
+    const base = path30.join(cwd, rel);
+    if (!fs27.existsSync(base) || !fs27.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs26.readdirSync(base);
+      entries = fs27.readdirSync(base);
     } catch {
       continue;
     }
     for (const name of entries) {
-      const dir = path29.join(base, name);
+      const dir = path30.join(base, name);
       try {
-        if (!fs26.statSync(dir).isDirectory()) continue;
+        if (!fs27.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      const skillMd = path29.join(dir, "SKILL.md");
-      if (!fs26.existsSync(skillMd)) continue;
+      const skillMd = path30.join(dir, "SKILL.md");
+      if (!fs27.existsSync(skillMd)) continue;
       const key = `${rel}/${name}`;
       if (seenKeys.has(key)) continue;
       seenKeys.add(key);
@@ -36802,23 +37384,23 @@ function discoverLocalSkills(cwd) {
 function discoverSkillLayoutRoots(cwd) {
   const roots = [];
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path29.join(cwd, rel);
-    if (!fs26.existsSync(base) || !fs26.statSync(base).isDirectory()) continue;
+    const base = path30.join(cwd, rel);
+    if (!fs27.existsSync(base) || !fs27.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs26.readdirSync(base);
+      entries = fs27.readdirSync(base);
     } catch {
       continue;
     }
     const skills2 = [];
     for (const name of entries) {
-      const dir = path29.join(base, name);
+      const dir = path30.join(base, name);
       try {
-        if (!fs26.statSync(dir).isDirectory()) continue;
+        if (!fs27.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      if (!fs26.existsSync(path29.join(dir, "SKILL.md"))) continue;
+      if (!fs27.existsSync(path30.join(dir, "SKILL.md"))) continue;
       const relPath = `${rel}/${name}`.replace(/\\/g, "/");
       skills2.push({ name, relPath });
     }
@@ -36855,7 +37437,7 @@ async function detectLocalAgentTypes() {
   }
 }
 
-// src/bridge/connection/create-bridge-local-reports.ts
+// src/connection/create-bridge-local-reports.ts
 function createSendLocalSkillsReport(getWs, logFn) {
   return () => {
     setImmediate(() => {
@@ -36888,14 +37470,14 @@ function createReportAutoDetectedAgents(getWs, logFn) {
   };
 }
 
-// src/bridge/connection/build-bridge-url.ts
+// src/connection/build-bridge-url.ts
 function buildBridgeUrl(apiUrl, workspaceId, authToken) {
   const base = apiUrl.startsWith("https") ? apiUrl.replace(/^https/, "wss") : apiUrl.replace(/^http/, "ws");
   const params = new URLSearchParams({ workspaceId, token: authToken });
   return `${base}/ws/bridge?${params.toString()}`;
 }
 
-// src/bridge/connection/report-git-repos.ts
+// src/connection/report-git-repos.ts
 function reportGitRepos(getWs, log2) {
   setImmediate(() => {
     discoverGitRepos().then((repos) => {
@@ -36951,14 +37533,14 @@ function parseApiToBridgeMessage(data, log2) {
   return data;
 }
 
-// src/bridge/routing/handlers/auth-token.ts
+// src/routing/handlers/auth-token.ts
 var handleAuthToken = (msg, { log: log2 }) => {
   if (typeof msg.token !== "string") return;
   log2("Received auth token. Save it for future runs:");
   log2(`  export BUILDAUTOMATON_AUTH_TOKEN="${msg.token}"`);
 };
 
-// src/bridge/routing/handlers/bridge-identified.ts
+// src/routing/handlers/bridge-identified.ts
 var handleBridgeIdentified = (msg, deps) => {
   if (typeof msg.bridgeName !== "string") return;
   deps.onBridgeIdentified({
@@ -36994,13 +37576,13 @@ function handleBridgeAgentConfig(msg, { acpManager }) {
   acpManager.setPreferredAgentType(msg.agents[0].type);
 }
 
-// src/bridge/routing/handlers/agent-config.ts
+// src/routing/handlers/agent-config.ts
 var handleAgentConfigMessage = (msg, deps) => {
   handleBridgeAgentConfig(msg, deps);
 };
 
 // src/prompt-turn-queue/runner.ts
-import fs29 from "node:fs";
+import fs30 from "node:fs";
 
 // src/prompt-turn-queue/client-report.ts
 function sendPromptQueueClientReport(ws, queues) {
@@ -37010,13 +37592,13 @@ function sendPromptQueueClientReport(ws, queues) {
 }
 
 // src/prompt-turn-queue/disk-store.ts
-import fs28 from "node:fs";
+import fs29 from "node:fs";
 
 // src/prompt-turn-queue/paths.ts
 import crypto3 from "node:crypto";
-import fs27 from "node:fs";
-import path30 from "node:path";
-import os6 from "node:os";
+import fs28 from "node:fs";
+import path31 from "node:path";
+import os7 from "node:os";
 var QUEUE_KEY_HEX_64 = /^[a-f0-9]{64}$/i;
 function queueStateFileSlug(queueKey) {
   if (QUEUE_KEY_HEX_64.test(queueKey)) return queueKey.toLowerCase();
@@ -37024,15 +37606,15 @@ function queueStateFileSlug(queueKey) {
 }
 function getPromptQueuesDirectory() {
   const override = process.env.BUILDAMATON_PROMPT_QUEUES_DIR?.trim();
-  if (override) return path30.resolve(override);
-  return path30.join(os6.homedir(), ".buildautomaton", "queues");
+  if (override) return path31.resolve(override);
+  return path31.join(os7.homedir(), ".buildautomaton", "queues");
 }
 function ensurePromptQueuesDirectory() {
   const dir = getPromptQueuesDirectory();
-  if (!fs27.existsSync(dir)) fs27.mkdirSync(dir, { recursive: true });
+  if (!fs28.existsSync(dir)) fs28.mkdirSync(dir, { recursive: true });
 }
 function queueStateFilePath(queueKey) {
-  return path30.join(getPromptQueuesDirectory(), `${queueStateFileSlug(queueKey)}.json`);
+  return path31.join(getPromptQueuesDirectory(), `${queueStateFileSlug(queueKey)}.json`);
 }
 
 // src/prompt-turn-queue/disk-store.ts
@@ -37057,7 +37639,7 @@ function parsePersistedQueueFile(raw) {
 function readPersistedQueue(queueKey) {
   const p = queueStateFilePath(queueKey);
   try {
-    return parsePersistedQueueFile(fs28.readFileSync(p, "utf8"));
+    return parsePersistedQueueFile(fs29.readFileSync(p, "utf8"));
   } catch {
     return null;
   }
@@ -37065,7 +37647,7 @@ function readPersistedQueue(queueKey) {
 function writePersistedQueue(file2) {
   ensurePromptQueuesDirectory();
   const p = queueStateFilePath(file2.queueKey);
-  fs28.writeFileSync(p, JSON.stringify(file2, null, 2), "utf8");
+  fs29.writeFileSync(p, JSON.stringify(file2, null, 2), "utf8");
 }
 function mergeServerQueueSnapshot(queueKey, serverTurns) {
   const prev = readPersistedQueue(queueKey);
@@ -37123,7 +37705,7 @@ async function runLocalRevertBeforeQueuedPrompt(next, deps) {
   const tid = typeof pl.snapshotRevertTurnId === "string" && pl.snapshotRevertTurnId.trim() !== "" ? pl.snapshotRevertTurnId.trim() : next.turnId;
   const agentBase = deps.sessionWorktreeManager.getSessionWorktreeRootForSession(sid) ?? getBridgeRoot();
   const file2 = snapshotFilePath(agentBase, tid);
-  if (!fs29.existsSync(file2)) {
+  if (!fs30.existsSync(file2)) {
     deps.log(
       `[Queue] requeued_with_revert: no pre-turn snapshot for ${tid.slice(0, 8)}\u2026; continuing without revert.`
     );
@@ -37153,7 +37735,8 @@ function dispatchLocalPrompt(next, deps) {
     ...typeof pl.followUpCatalogPromptId === "string" ? { followUpCatalogPromptId: pl.followUpCatalogPromptId } : {},
     ...Array.isArray(pl.sessionChangeSummaryFilePaths) ? { sessionChangeSummaryFilePaths: pl.sessionChangeSummaryFilePaths } : {},
     ...Array.isArray(pl.sessionChangeSummaryFileSnapshots) ? { sessionChangeSummaryFileSnapshots: pl.sessionChangeSummaryFileSnapshots } : {},
-    ...typeof pl.agentType === "string" && pl.agentType.trim() ? { agentType: pl.agentType.trim() } : {}
+    ...typeof pl.agentType === "string" && pl.agentType.trim() ? { agentType: pl.agentType.trim() } : {},
+    ...pl.agentConfig != null && typeof pl.agentConfig === "object" && !Array.isArray(pl.agentConfig) && Object.keys(pl.agentConfig).length > 0 ? { agentConfig: pl.agentConfig } : {}
   };
   handleBridgePrompt(msg, deps);
 }
@@ -37345,9 +37928,9 @@ function parseChangeSummarySnapshots(raw) {
   for (const item of raw) {
     if (!item || typeof item !== "object") continue;
     const o = item;
-    const path36 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
-    if (!path36) continue;
-    const row = { path: path36 };
+    const path37 = typeof o.path === "string" && o.path.trim() !== "" ? o.path.trim() : "";
+    if (!path37) continue;
+    const row = { path: path37 };
     if (typeof o.patchContent === "string") row.patchContent = o.patchContent;
     if (typeof o.oldText === "string") row.oldText = o.oldText;
     if (typeof o.newText === "string") row.newText = o.newText;
@@ -37451,6 +38034,7 @@ function handleBridgePrompt(msg, deps) {
   const sessionParentPath = typeof msg.sessionParentPath === "string" && msg.sessionParentPath.trim() ? msg.sessionParentPath.trim() : null;
   const agentType = typeof msg.agentType === "string" && msg.agentType.trim() ? msg.agentType.trim() : void 0;
   const mode = typeof msg.mode === "string" && msg.mode.trim() ? msg.mode.trim() : void 0;
+  const agentConfig = msg.agentConfig != null && typeof msg.agentConfig === "object" && !Array.isArray(msg.agentConfig) ? msg.agentConfig : void 0;
   acpManager.logPromptReceivedFromBridge({ agentType, mode });
   async function preambleAndPrompt(resolvedCwd) {
     const effectiveCwd = resolveSessionParentPathForAgentProcess(resolvedCwd);
@@ -37486,6 +38070,7 @@ function handleBridgePrompt(msg, deps) {
       runId,
       mode,
       agentType,
+      agentConfig,
       sessionParentPath: effectiveCwd,
       sendResult: sendResult2,
       sendSessionUpdate,
@@ -37502,27 +38087,27 @@ function handleBridgePrompt(msg, deps) {
   });
 }
 
-// src/bridge/routing/handlers/prompt.ts
+// src/routing/handlers/prompt.ts
 var handlePromptMessage = (msg, deps) => {
   handleBridgePrompt(msg, deps);
 };
 
-// src/bridge/routing/handlers/prompt-queue-state.ts
+// src/routing/handlers/prompt-queue-state.ts
 var handlePromptQueueStateMessage = (msg, deps) => {
   void applyPromptQueueStateFromServer(msg, deps).catch((err) => {
     deps.log(`[Queue] applyPromptQueueStateFromServer failed: ${err instanceof Error ? err.message : String(err)}`);
   });
 };
 
-// src/agents/acp/from-bridge/handle-bridge-cursor-request-response.ts
-function handleBridgeCursorRequestResponse(msg, { acpManager }) {
+// src/agents/acp/from-bridge/handle-bridge-session-request-response.ts
+function handleBridgeSessionRequestResponse(msg, { acpManager }) {
   if (typeof msg.requestId !== "string") return;
   acpManager.resolveRequest(msg.requestId, msg.result ?? {});
 }
 
-// src/bridge/routing/handlers/cursor-request-response.ts
-var handleCursorRequestResponseMessage = (msg, deps) => {
-  handleBridgeCursorRequestResponse(msg, deps);
+// src/routing/handlers/session-request-response.ts
+var handleSessionRequestResponseMessage = (msg, deps) => {
+  handleBridgeSessionRequestResponse(msg, deps);
 };
 
 // src/skills/preview.ts
@@ -37546,8 +38131,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path36, body) {
-  const url2 = `http://127.0.0.1:${port}${path36}`;
+async function requestPreviewApi(port, secret, method, path37, body) {
+  const url2 = `http://127.0.0.1:${port}${path37}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -37559,7 +38144,7 @@ async function requestPreviewApi(port, secret, method, path36, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path36}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path37}: ${res.status}`);
   }
   return data;
 }
@@ -37709,7 +38294,7 @@ function handleSkillCall(msg, socket, log2) {
   });
 }
 
-// src/bridge/routing/handlers/skill-call.ts
+// src/routing/handlers/skill-call.ts
 var handleSkillCallMessage = (msg, { getWs, log: log2 }) => {
   const skillId = typeof msg.skillId === "string" ? msg.skillId : "";
   const operationId = typeof msg.operationId === "string" ? msg.operationId : "";
@@ -37724,15 +38309,15 @@ var handleSkillCallMessage = (msg, { getWs, log: log2 }) => {
 };
 
 // src/files/list-dir.ts
-import fs30 from "node:fs";
-import path32 from "node:path";
+import fs31 from "node:fs";
+import path33 from "node:path";
 
 // src/files/ensure-under-cwd.ts
-import path31 from "node:path";
+import path32 from "node:path";
 function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
-  const normalized = path31.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path31.resolve(cwd, normalized);
-  if (!resolved.startsWith(cwd + path31.sep) && resolved !== cwd) {
+  const normalized = path32.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path32.resolve(cwd, normalized);
+  if (!resolved.startsWith(cwd + path32.sep) && resolved !== cwd) {
     return null;
   }
   return resolved;
@@ -37746,7 +38331,7 @@ async function listDirAsync(relativePath) {
     return { error: "Path is outside working directory" };
   }
   try {
-    const names = await fs30.promises.readdir(resolved, { withFileTypes: true });
+    const names = await fs31.promises.readdir(resolved, { withFileTypes: true });
     const visible = names.filter((d) => !d.name.startsWith("."));
     const entries = [];
     for (let i = 0; i < visible.length; i++) {
@@ -37754,12 +38339,12 @@ async function listDirAsync(relativePath) {
         await yieldToEventLoop();
       }
       const d = visible[i];
-      const entryPath = path32.join(relativePath || ".", d.name).replace(/\\/g, "/");
-      const fullPath = path32.join(resolved, d.name);
+      const entryPath = path33.join(relativePath || ".", d.name).replace(/\\/g, "/");
+      const fullPath = path33.join(resolved, d.name);
       let isDir = d.isDirectory();
       if (d.isSymbolicLink()) {
         try {
-          const targetStat = await fs30.promises.stat(fullPath);
+          const targetStat = await fs31.promises.stat(fullPath);
           isDir = targetStat.isDirectory();
         } catch {
           isDir = false;
@@ -37784,25 +38369,25 @@ async function listDirAsync(relativePath) {
 }
 
 // src/files/read-file.ts
-import fs31 from "node:fs";
+import fs32 from "node:fs";
 import { StringDecoder } from "node:string_decoder";
 function resolveFilePath(relativePath) {
   const resolved = ensureUnderCwd(relativePath, getBridgeRoot());
   if (!resolved) return { error: "Path is outside working directory" };
   let real;
   try {
-    real = fs31.realpathSync(resolved);
+    real = fs32.realpathSync(resolved);
   } catch {
     real = resolved;
   }
-  const stat3 = fs31.statSync(real);
+  const stat3 = fs32.statSync(real);
   if (!stat3.isFile()) return { error: "Not a file" };
   return real;
 }
 var LINE_CHUNK_SIZE = 64 * 1024;
 function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
-  const fileSize = fs31.statSync(filePath).size;
-  const fd = fs31.openSync(filePath, "r");
+  const fileSize = fs32.statSync(filePath).size;
+  const fd = fs32.openSync(filePath, "r");
   const bufSize = 64 * 1024;
   const buf = Buffer.alloc(bufSize);
   const decoder = new StringDecoder("utf8");
@@ -37815,7 +38400,7 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
   let line0Accum = "";
   try {
     let bytesRead;
-    while (!done && (bytesRead = fs31.readSync(fd, buf, 0, bufSize, null)) > 0) {
+    while (!done && (bytesRead = fs32.readSync(fd, buf, 0, bufSize, null)) > 0) {
       const text = partial2 + decoder.write(buf.subarray(0, bytesRead));
       partial2 = "";
       let lineStart = 0;
@@ -37950,7 +38535,7 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
     }
     return { content: resultLines.join("\n"), size: fileSize };
   } finally {
-    fs31.closeSync(fd);
+    fs32.closeSync(fd);
   }
 }
 function readFile3(relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE) {
@@ -37961,8 +38546,8 @@ function readFile3(relativePath, startLine, endLine, lineOffset, lineChunkSize =
     if (hasRange) {
       return readFileRange(result, startLine, endLine, lineOffset, lineChunkSize);
     }
-    const stat3 = fs31.statSync(result);
-    const raw = fs31.readFileSync(result, "utf8");
+    const stat3 = fs32.statSync(result);
+    const raw = fs32.readFileSync(result, "utf8");
     const lines = raw.split(/\r?\n/);
     return { content: raw, totalLines: lines.length, size: stat3.size };
   } catch (err) {
@@ -38051,7 +38636,7 @@ function handleFileBrowserRequest(msg, socket, e2ee) {
   })();
 }
 
-// src/bridge/routing/handlers/file-browser-messages.ts
+// src/routing/handlers/file-browser-messages.ts
 function handleFileBrowserRequestMessage(msg, { getWs, e2ee }) {
   if (typeof msg.id !== "string" || typeof msg.path !== "string") return;
   const socket = getWs();
@@ -38069,7 +38654,7 @@ function handleFileBrowserSearchMessage(msg, { getWs, e2ee }) {
   handleFileBrowserSearch(msg, socket, e2ee);
 }
 
-// src/bridge/routing/handlers/skill-layout-request.ts
+// src/routing/handlers/skill-layout-request.ts
 function handleSkillLayoutRequest(msg, deps) {
   const socket = deps.getWs();
   const id = typeof msg.id === "string" ? msg.id : "";
@@ -38080,8 +38665,8 @@ function handleSkillLayoutRequest(msg, deps) {
 }
 
 // src/skills/install-remote-skills.ts
-import fs32 from "node:fs";
-import path33 from "node:path";
+import fs33 from "node:fs";
+import path34 from "node:path";
 function installRemoteSkills(cwd, targetDir, items) {
   const installed2 = [];
   if (!Array.isArray(items)) {
@@ -38092,15 +38677,15 @@ function installRemoteSkills(cwd, targetDir, items) {
       if (typeof item.sourceId !== "string" || typeof item.skillName !== "string" || typeof item.versionHash !== "string" || !Array.isArray(item.files)) {
         continue;
       }
-      const skillDir = path33.join(cwd, targetDir, item.skillName);
+      const skillDir = path34.join(cwd, targetDir, item.skillName);
       for (const f of item.files) {
         if (typeof f.path !== "string" || !f.text && !f.base64) continue;
-        const dest = path33.join(skillDir, f.path);
-        fs32.mkdirSync(path33.dirname(dest), { recursive: true });
+        const dest = path34.join(skillDir, f.path);
+        fs33.mkdirSync(path34.dirname(dest), { recursive: true });
         if (f.text !== void 0) {
-          fs32.writeFileSync(dest, f.text, "utf8");
+          fs33.writeFileSync(dest, f.text, "utf8");
         } else if (f.base64) {
-          fs32.writeFileSync(dest, Buffer.from(f.base64, "base64"));
+          fs33.writeFileSync(dest, Buffer.from(f.base64, "base64"));
         }
       }
       installed2.push({
@@ -38115,7 +38700,7 @@ function installRemoteSkills(cwd, targetDir, items) {
   }
 }
 
-// src/bridge/routing/handlers/install-skills.ts
+// src/routing/handlers/install-skills.ts
 var handleInstallSkillsMessage = (msg, deps) => {
   const socket = deps.getWs();
   const id = typeof msg.id === "string" ? msg.id : "";
@@ -38136,12 +38721,12 @@ var handleInstallSkillsMessage = (msg, deps) => {
   }
 };
 
-// src/bridge/routing/handlers/refresh-local-skills.ts
+// src/routing/handlers/refresh-local-skills.ts
 var handleRefreshLocalSkills = (_msg, deps) => {
   deps.sendLocalSkillsReport?.();
 };
 
-// src/bridge/routing/handlers/session-git-request.ts
+// src/routing/handlers/session-git-request.ts
 function sendResult(ws, id, payload, e2ee, encryptedFields = []) {
   if (!ws) return;
   const message = { type: "session_git_result", id, ...payload };
@@ -38227,7 +38812,7 @@ var handleSessionGitRequestMessage = (msg, deps) => {
   })();
 };
 
-// src/bridge/routing/handlers/rename-session-branch.ts
+// src/routing/handlers/rename-session-branch.ts
 var handleRenameSessionBranchMessage = (msg, deps) => {
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
   const newBranch = typeof msg.newBranch === "string" ? msg.newBranch : "";
@@ -38235,22 +38820,22 @@ var handleRenameSessionBranchMessage = (msg, deps) => {
   void deps.sessionWorktreeManager.renameSessionBranch(sessionId, newBranch);
 };
 
-// src/bridge/routing/handlers/session-archived.ts
+// src/routing/handlers/session-archived.ts
 var handleSessionArchivedMessage = (msg, deps) => {
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
   if (!sessionId) return;
   void deps.sessionWorktreeManager.removeSessionWorktrees(sessionId);
 };
 
-// src/bridge/routing/handlers/session-discarded.ts
+// src/routing/handlers/session-discarded.ts
 var handleSessionDiscardedMessage = (msg, deps) => {
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
   if (!sessionId) return;
   void deps.sessionWorktreeManager.removeSessionWorktrees(sessionId);
 };
 
-// src/bridge/routing/handlers/revert-turn-snapshot.ts
-import * as fs33 from "node:fs";
+// src/routing/handlers/revert-turn-snapshot.ts
+import * as fs34 from "node:fs";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
@@ -38262,7 +38847,7 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
     if (!s) return;
     const agentBase = sessionWorktreeManager.getSessionWorktreeRootForSession(sessionId) ?? getBridgeRoot();
     const file2 = snapshotFilePath(agentBase, turnId);
-    if (!fs33.existsSync(file2)) {
+    if (!fs34.existsSync(file2)) {
       sendWsMessage(s, {
         type: "revert_turn_snapshot_result",
         id,
@@ -38281,7 +38866,7 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
   })();
 };
 
-// src/bridge/routing/handlers/dev-server-control.ts
+// src/routing/handlers/dev-server-control.ts
 var handleDevServerControl = (msg, deps) => {
   let wire;
   try {
@@ -38296,13 +38881,13 @@ var handleDevServerControl = (msg, deps) => {
   deps.devServerManager?.handleControl(serverId, action);
 };
 
-// src/bridge/routing/handlers/dev-servers-config.ts
+// src/routing/handlers/dev-servers-config.ts
 var handleDevServersConfig = (msg, deps) => {
   const devServers = msg.devServers;
   deps.devServerManager?.applyConfig(devServers ?? []);
 };
 
-// src/bridge/routing/dispatch-bridge-message.ts
+// src/routing/dispatch-bridge-message.ts
 function dispatchBridgeMessage(msg, deps) {
   switch (msg.type) {
     case "auth_token":
@@ -38342,7 +38927,7 @@ function dispatchBridgeMessage(msg, deps) {
       handleRevertTurnSnapshotMessage(msg, deps);
       break;
     case "cursor_request_response":
-      handleCursorRequestResponseMessage(msg, deps);
+      handleSessionRequestResponseMessage(msg, deps);
       break;
     case "skill_call":
       handleSkillCallMessage(msg, deps);
@@ -38365,7 +38950,7 @@ function dispatchBridgeMessage(msg, deps) {
   }
 }
 
-// src/bridge/routing/handle-bridge-message.ts
+// src/routing/handle-bridge-message.ts
 function handleBridgeMessage(data, deps) {
   if (!deps.getWs()) return;
   const msg = parseApiToBridgeMessage(data, deps.log);
@@ -38402,7 +38987,7 @@ async function refreshBridgeTokens(params) {
   }
 }
 
-// src/bridge/connection/main-bridge-ws-lifecycle.ts
+// src/connection/main-bridge-ws-lifecycle.ts
 function createMainBridgeWebSocketLifecycle(params) {
   const {
     state,
@@ -38448,13 +39033,26 @@ function createMainBridgeWebSocketLifecycle(params) {
     }
   }
   function handleClose(code, reason) {
-    const was = state.currentWs;
-    state.currentWs = null;
-    if (was) was.removeAllListeners();
-    const willReconnect = !state.closedByUser;
-    beginMainBridgeDeferredDisconnect(state, code, reason, logFn, willReconnect);
-    if (willReconnect) {
-      scheduleMainBridgeReconnect(state, connect, logFn);
+    try {
+      const was = state.currentWs;
+      state.currentWs = null;
+      if (was) was.removeAllListeners();
+      const willReconnect = !state.closedByUser;
+      beginMainBridgeDeferredDisconnect(state, code, reason, logFn, willReconnect);
+      if (willReconnect) {
+        state.lastReconnectCloseMeta = { code, reason };
+        try {
+          scheduleMainBridgeReconnect(state, connect, logFn, { code, reason });
+        } catch {
+        }
+      }
+    } catch {
+      if (!state.closedByUser) {
+        try {
+          scheduleMainBridgeReconnect(state, connect, logFn);
+        } catch {
+        }
+      }
     }
   }
   function connect() {
@@ -38464,7 +39062,10 @@ function createMainBridgeWebSocketLifecycle(params) {
       state.reconnectTimeout = null;
     }
     if (state.reconnectAttempt === 0) {
-      logFn("Connecting to bridge service\u2026");
+      try {
+        logFn("Connecting to bridge service\u2026");
+      } catch {
+      }
     }
     const prev = state.currentWs;
     if (prev) {
@@ -38480,53 +39081,84 @@ function createMainBridgeWebSocketLifecycle(params) {
       }
       state.currentWs = null;
     }
-    const url2 = buildBridgeUrl(apiUrl, workspaceId, tokens.accessToken);
-    state.currentWs = createWsBridge({
-      url: url2,
-      clientPingIntervalMs: CLI_WEBSOCKET_CLIENT_PING_MS,
-      onAuthInvalid: () => {
-        if (authRefreshInFlight) return;
-        void (async () => {
-          authRefreshInFlight = true;
-          try {
-            if (tokens.refreshToken) {
-              const next = await refreshBridgeTokens({
-                apiUrl,
-                workspaceId,
-                refreshToken: tokens.refreshToken
-              });
-              if (next?.token && next.refreshToken) {
-                tokens.accessToken = next.token;
-                tokens.refreshToken = next.refreshToken;
-                persistTokens?.({ token: tokens.accessToken, refreshToken: tokens.refreshToken });
-                logFn("[Bridge service] Access token refreshed; reconnecting\u2026");
-                state.reconnectAttempt = 0;
-                state.logBridgeOpenAsReconnect = true;
-                authRefreshInFlight = false;
-                connect();
-                return;
+    try {
+      const url2 = buildBridgeUrl(apiUrl, workspaceId, tokens.accessToken);
+      state.currentWs = createWsBridge({
+        url: url2,
+        clientPingIntervalMs: CLI_WEBSOCKET_CLIENT_PING_MS,
+        onAuthInvalid: () => {
+          if (authRefreshInFlight) return;
+          void (async () => {
+            authRefreshInFlight = true;
+            try {
+              if (tokens.refreshToken) {
+                const next = await refreshBridgeTokens({
+                  apiUrl,
+                  workspaceId,
+                  refreshToken: tokens.refreshToken
+                });
+                if (next?.token && next.refreshToken) {
+                  tokens.accessToken = next.token;
+                  tokens.refreshToken = next.refreshToken;
+                  persistTokens?.({ token: tokens.accessToken, refreshToken: tokens.refreshToken });
+                  try {
+                    logFn("[Bridge service] Access token refreshed; reconnecting\u2026");
+                  } catch {
+                  }
+                  state.reconnectAttempt = 0;
+                  resetReconnectOutageTracker(state.mainOutage);
+                  state.lastReconnectCloseMeta = null;
+                  state.logBridgeOpenAsReconnect = true;
+                  authRefreshInFlight = false;
+                  connect();
+                  return;
+                }
               }
+              authRefreshInFlight = false;
+              state.reconnectAttempt = 0;
+              resetReconnectOutageTracker(state.mainOutage);
+              state.lastReconnectCloseMeta = null;
+              onAuthInvalid();
+            } catch {
+              authRefreshInFlight = false;
+              state.reconnectAttempt = 0;
+              resetReconnectOutageTracker(state.mainOutage);
+              state.lastReconnectCloseMeta = null;
+              onAuthInvalid();
             }
-            authRefreshInFlight = false;
-            state.reconnectAttempt = 0;
-            onAuthInvalid();
+          })();
+        },
+        onOpen: handleOpen,
+        onClose: handleClose,
+        onError: (err) => {
+          if (state.mainOutage.startedAt != null) {
+            return;
+          }
+          try {
+            logCliWebSocketError(logFn, "[Bridge service]", err);
           } catch {
-            authRefreshInFlight = false;
-            state.reconnectAttempt = 0;
-            onAuthInvalid();
           }
-        })();
-      },
-      onOpen: handleOpen,
-      onClose: handleClose,
-      onError: (err) => logCliWebSocketError(logFn, "[Bridge service]", err),
-      onMessage: (data) => handleBridgeMessage(data, messageDeps)
-    });
+        },
+        onMessage: (data) => {
+          try {
+            handleBridgeMessage(data, messageDeps);
+          } catch {
+          }
+        }
+      });
+    } catch {
+      if (!state.closedByUser && state.currentWs == null) {
+        try {
+          scheduleMainBridgeReconnect(state, connect, logFn);
+        } catch {
+        }
+      }
+    }
   }
   return { connect };
 }
 
-// src/bridge/connection/create-bridge-connection.ts
+// src/connection/create-bridge-connection.ts
 async function createBridgeConnection(options) {
   const { apiUrl, workspaceId, justAuthenticated, onAuthInvalid, persistTokens } = options;
   const firehoseServerUrl = options.firehoseServerUrl ?? options.proxyServerUrl;
@@ -38538,16 +39170,20 @@ async function createBridgeConnection(options) {
   const state = {
     closedByUser: false,
     reconnectAttempt: 0,
+    lastReconnectCloseMeta: null,
     logBridgeOpenAsReconnect: false,
     reconnectTimeout: null,
     currentWs: null,
     mainQuiet: createEmptyReconnectQuietSlot(),
+    mainOutage: createEmptyReconnectOutageTracker(),
     firehoseHandle: null,
     lastFirehoseParams: null,
     firehoseReconnectTimeout: null,
     firehoseReconnectAttempt: 0,
     firehoseGeneration: 0,
-    firehoseQuiet: createEmptyReconnectQuietSlot()
+    firehoseQuiet: createEmptyReconnectQuietSlot(),
+    firehoseOutage: createEmptyReconnectOutageTracker(),
+    lastFirehoseReconnectCloseMeta: null
   };
   const worktreesRootPath = options.worktreesRootPath ?? defaultWorktreesRootPath();
   const sessionWorktreeManager = new SessionWorktreeManager({
@@ -38584,8 +39220,8 @@ async function createBridgeConnection(options) {
     getCloudAccessToken: () => tokens.accessToken
   };
   const identifyReportedPaths = {
-    bridgeRootPath: path34.resolve(getBridgeRoot()),
-    worktreesRootPath: path34.resolve(worktreesRootPath)
+    bridgeRootPath: path35.resolve(getBridgeRoot()),
+    worktreesRootPath: path35.resolve(worktreesRootPath)
   };
   const { connect } = createMainBridgeWebSocketLifecycle({
     state,
@@ -38809,6 +39445,9 @@ function colorize(color, message) {
   return `${color}${message}${RESET}`;
 }
 async function runCliAction(program2, opts) {
+  const trace = opts.trace === true;
+  const debug2 = opts.debug === true || trace;
+  setCliLogVerbosity(trace ? "trace" : debug2 ? "debug" : "info");
   const positionalUrl = program2.args?.[0];
   const urlFromPositional = typeof positionalUrl === "string" && /^https?:\/\//i.test(positionalUrl) ? positionalUrl : void 0;
   const apiUrlFromCli = opts.apiUrl ?? urlFromPositional;
@@ -38818,9 +39457,9 @@ async function runCliAction(program2, opts) {
   const firehoseServerUrl = opts.firehoseUrl ?? opts.proxyUrl ?? process.env.BUILDAUTOMATON_FIREHOSE_URL ?? process.env.BUILDAUTOMATON_PROXY_URL ?? DEFAULT_FIREHOSE_URL;
   const bridgeRootOpt = (opts.bridgeRoot && typeof opts.bridgeRoot === "string" && opts.bridgeRoot.trim() ? opts.bridgeRoot.trim() : null) ?? (opts.cwd && typeof opts.cwd === "string" && opts.cwd.trim() ? opts.cwd.trim() : null);
   if (bridgeRootOpt) {
-    const resolvedBridgeRoot = path35.resolve(process.cwd(), bridgeRootOpt);
+    const resolvedBridgeRoot = path36.resolve(process.cwd(), bridgeRootOpt);
     try {
-      const st = fs34.statSync(resolvedBridgeRoot);
+      const st = fs35.statSync(resolvedBridgeRoot);
       if (!st.isDirectory()) {
         console.error(`Bridge root is not a directory: ${resolvedBridgeRoot}`);
         process.exit(1);
@@ -38840,7 +39479,7 @@ async function runCliAction(program2, opts) {
   );
   let worktreesRootPath;
   if (opts.worktreesRoot && opts.worktreesRoot.trim()) {
-    worktreesRootPath = path35.resolve(opts.worktreesRoot.trim());
+    worktreesRootPath = path36.resolve(opts.worktreesRoot.trim());
   }
   const e2eCertificates = opts.e2eeCertificatesDir?.trim() ? await loadOrCreateE2eCertificates(opts.e2eeCertificatesDir.trim()) : void 0;
   if (e2eCertificates) {
@@ -38900,7 +39539,7 @@ async function main() {
     "--e2ee-certificates-dir <path>",
     "Directory to load or generate E2EE keys for sessions, files, and logs",
     process.env.BUILDAUTOMATON_E2EE_CERTIFICATES_DIR
-  ).option("--no-config", "Ignore saved config at ~/.buildautomaton/config.json").action(async (opts) => runCliAction(program2, opts));
+  ).option("--no-config", "Ignore saved config at ~/.buildautomaton/config.json").option("--debug", "Print debug-level messages from the CLI").option("--trace", "Print trace-level messages (e.g. git subprocess output); implies --debug").action(async (opts) => runCliAction(program2, opts));
   await program2.parseAsync(process.argv);
 }
 main().catch((err) => {