@buildautomaton/cli 0.1.3 → 0.1.5

package/dist/index.js

@@ -2235,13 +2235,13 @@ var require_extension = __commonJS({
 var require_websocket = __commonJS({
   "../../node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket.js"(exports, module) {
     "use strict";
-    var EventEmitter3 = __require("events");
+    var EventEmitter2 = __require("events");
     var https3 = __require("https");
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
     var { randomBytes, createHash: createHash2 } = __require("crypto");
-    var { Duplex, Readable: Readable3 } = __require("stream");
+    var { Duplex, Readable: Readable2 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate = require_permessage_deflate();
     var Receiver2 = require_receiver();
@@ -2267,7 +2267,7 @@ var require_websocket = __commonJS({
     var protocolVersions = [8, 13];
     var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
     var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
-    var WebSocket2 = class _WebSocket extends EventEmitter3 {
+    var WebSocket2 = class _WebSocket extends EventEmitter2 {
       /**
        * Create a new `WebSocket`.
        *
@@ -3179,7 +3179,7 @@ var require_stream = __commonJS({
       };
       duplex._final = function(callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open2() {
+          ws.once("open", function open() {
             duplex._final(callback);
           });
           return;
@@ -3200,7 +3200,7 @@ var require_stream = __commonJS({
       };
       duplex._write = function(chunk, encoding, callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open2() {
+          ws.once("open", function open() {
             duplex._write(chunk, encoding, callback);
           });
           return;
@@ -3264,7 +3264,7 @@ var require_subprotocol = __commonJS({
 var require_websocket_server = __commonJS({
   "../../node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/websocket-server.js"(exports, module) {
     "use strict";
-    var EventEmitter3 = __require("events");
+    var EventEmitter2 = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
     var { createHash: createHash2 } = __require("crypto");
@@ -3277,7 +3277,7 @@ var require_websocket_server = __commonJS({
     var RUNNING = 0;
     var CLOSING = 1;
     var CLOSED = 2;
-    var WebSocketServer2 = class extends EventEmitter3 {
+    var WebSocketServer2 = class extends EventEmitter2 {
       /**
        * Create a `WebSocketServer` instance.
        *
@@ -20943,8 +20943,8 @@ var init_acp = __esm({
         this.#requestHandler = requestHandler;
         this.#notificationHandler = notificationHandler;
         this.#stream = stream;
-        this.#closedPromise = new Promise((resolve16) => {
-          this.#abortController.signal.addEventListener("abort", () => resolve16());
+        this.#closedPromise = new Promise((resolve14) => {
+          this.#abortController.signal.addEventListener("abort", () => resolve14());
         });
         this.#receive();
       }
@@ -21093,8 +21093,8 @@ var init_acp = __esm({
       }
       async sendRequest(method, params) {
         const id = this.#nextRequestId++;
-        const responsePromise = new Promise((resolve16, reject) => {
-          this.#pendingResponses.set(id, { resolve: resolve16, reject });
+        const responsePromise = new Promise((resolve14, reject) => {
+          this.#pendingResponses.set(id, { resolve: resolve14, reject });
         });
         await this.#sendMessage({ jsonrpc: "2.0", id, method, params });
         return responsePromise;
@@ -21966,12 +21966,12 @@ var require_src2 = __commonJS({
     function check2(path24, isFile, isDirectory) {
       log2(`checking %s`, path24);
       try {
-        const stat4 = fs_1.statSync(path24);
-        if (stat4.isFile() && isFile) {
+        const stat = fs_1.statSync(path24);
+        if (stat.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
         }
-        if (stat4.isDirectory() && isDirectory) {
+        if (stat.isDirectory() && isDirectory) {
           log2(`[OK] path represents a directory`);
           return true;
         }
@@ -22065,12 +22065,19 @@ var wrapper_default = import_websocket.default;
 var BRIDGE_AUTH_ERROR_HEADER = "x-bridge-auth-error";
 var BRIDGE_AUTH_ERROR_TOKEN_INVALID = "token_invalid";
 function createWsBridge(options) {
-  const { url: url2, onMessage, onOpen, onClose, onError: onError2, onAuthInvalid } = options;
+  const { url: url2, onMessage, onOpen, onClose, onError: onError2, onAuthInvalid, clientPingIntervalMs } = options;
   const wsOptions = {};
   if (url2.startsWith("wss://")) {
     wsOptions.agent = new https.Agent({ rejectUnauthorized: false });
   }
   const ws = new wrapper_default(url2, wsOptions);
+  let clientPingTimer = null;
+  function clearClientPing() {
+    if (clientPingTimer != null) {
+      clearInterval(clientPingTimer);
+      clientPingTimer = null;
+    }
+  }
   ws.on("unexpected-response", (request, response) => {
     const status = response?.statusCode ?? 0;
     const headers = response?.headers ?? {};
@@ -22080,6 +22087,17 @@ function createWsBridge(options) {
     }
   });
   ws.on("open", () => {
+    clearClientPing();
+    if (clientPingIntervalMs != null && clientPingIntervalMs > 0) {
+      clientPingTimer = setInterval(() => {
+        if (ws.readyState === wrapper_default.OPEN) {
+          try {
+            ws.ping();
+          } catch {
+          }
+        }
+      }, clientPingIntervalMs);
+    }
     onOpen?.();
   });
   ws.on("message", (raw) => {
@@ -22099,9 +22117,11 @@ function createWsBridge(options) {
     }
   });
   ws.on("close", (code, reason) => {
+    clearClientPing();
     onClose?.(code, reason.toString());
   });
   ws.on("error", (err) => {
+    clearClientPing();
     onError2?.(err);
   });
   return ws;
@@ -22115,6 +22135,18 @@ function sendWsMessage(ws, payload) {
 // src/acp/clients/acp-client.ts
 import { spawn } from "node:child_process";
 import { Readable, Writable } from "node:stream";
+
+// src/files/cwd/bridge-workspace-directory.ts
+import * as path from "node:path";
+var bridgeWorkspaceDirectory = null;
+function getBridgeWorkspaceDirectory() {
+  if (bridgeWorkspaceDirectory == null) {
+    bridgeWorkspaceDirectory = path.resolve(process.cwd());
+  }
+  return bridgeWorkspaceDirectory;
+}
+
+// src/acp/clients/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.`;
@@ -22131,15 +22163,15 @@ function toErrorMessage(err) {
 }
 async function createAcpClient(options) {
   const { ClientSideConnection: ClientSideConnection2, ndJsonStream: ndJsonStream2 } = await Promise.resolve().then(() => (init_acp(), acp_exports));
-  const { command, cwd: cwd3 = process.cwd(), onSessionUpdate } = options;
-  const isWindows2 = process.platform === "win32";
+  const { command, cwd = getBridgeWorkspaceDirectory(), onSessionUpdate } = options;
+  const isWindows = process.platform === "win32";
   const child = spawn(command[0], command.slice(1), {
-    cwd: cwd3,
+    cwd,
     stdio: ["pipe", "pipe", "inherit"],
     env: process.env,
-    shell: isWindows2
+    shell: isWindows
   });
-  return new Promise((resolve16, reject) => {
+  return new Promise((resolve14, reject) => {
     child.on("error", (err) => {
       child.kill();
       reject(new Error(formatSpawnError(err, command[0])));
@@ -22166,9 +22198,9 @@ async function createAcpClient(options) {
           capabilities: {},
           clientInfo: { name: "buildautomaton-cli", version: "0.1.0" }
         });
-        const newSessionRes = await connection.newSession({ workingDirectory: cwd3 });
+        const newSessionRes = await connection.newSession({ workingDirectory: cwd });
         const sessionId = newSessionRes.sessionId;
-        resolve16({
+        resolve14({
           sessionId,
           async sendPrompt(prompt, _options) {
             try {
@@ -22244,7 +22276,7 @@ async function proxyToLocal(request) {
     path: url2.pathname + url2.search,
     headers: request.headers
   };
-  return new Promise((resolve16) => {
+  return new Promise((resolve14) => {
     const req = mod.request(opts, (res) => {
       const chunks = [];
       res.on("data", (c) => chunks.push(c));
@@ -22255,7 +22287,7 @@ async function proxyToLocal(request) {
           if (typeof v === "string") headers[k] = v;
           else if (Array.isArray(v) && v[0]) headers[k] = v[0];
         }
-        resolve16({
+        resolve14({
           id: request.id,
           statusCode: res.statusCode ?? 0,
           headers,
@@ -22264,7 +22296,7 @@ async function proxyToLocal(request) {
       });
     });
     req.on("error", (err) => {
-      resolve16({
+      resolve14({
         id: request.id,
         statusCode: 0,
         headers: {},
@@ -22394,12 +22426,12 @@ var previewSkill = {
         const port = params.port ?? (Number(process.env[PREVIEW_PORT_ENV]) || DEFAULT_PORT);
         previewPort = port;
         previewSecret = randomSecret();
-        const isWindows2 = process.platform === "win32";
+        const isWindows = process.platform === "win32";
         const parts = command.split(/\s+/);
         const exe = parts[0];
         const args = parts.slice(1);
-        previewProcess = spawn2(isWindows2 && exe === "npm" ? "npm.cmd" : exe, args, {
-          cwd: process.cwd(),
+        previewProcess = spawn2(isWindows && exe === "npm" ? "npm.cmd" : exe, args, {
+          cwd: getBridgeWorkspaceDirectory(),
           stdio: ["ignore", "pipe", "pipe"],
           env: {
             ...process.env,
@@ -22508,11 +22540,11 @@ function logImmediate(line) {
 
 // src/config.ts
 import fs from "node:fs";
-import path from "node:path";
+import path2 from "node:path";
 import os from "node:os";
 function getConfigPath() {
-  const dir = path.join(os.homedir(), ".buildautomaton");
-  return path.join(dir, "config.json");
+  const dir = path2.join(os.homedir(), ".buildautomaton");
+  return path2.join(dir, "config.json");
 }
 function normalizeApiUrl(url2) {
   return url2.replace(/\/$/, "");
@@ -22528,7 +22560,7 @@ function readRawConfig() {
 }
 function writeConfigForApi(apiUrl, auth) {
   const p = getConfigPath();
-  const dir = path.dirname(p);
+  const dir = path2.dirname(p);
   const key = normalizeApiUrl(apiUrl);
   const prev = readRawConfig() ?? {};
   const servers = { ...prev.servers ?? {}, [key]: { ...auth } };
@@ -22537,7 +22569,7 @@ function writeConfigForApi(apiUrl, auth) {
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
     fs.writeFileSync(p, JSON.stringify(next, null, 2), "utf8");
   } catch (e) {
-    console.error("Could not save auth config:", e);
+    console.error("Could not save authentication config:", e);
   }
 }
 function clearConfigForApi(apiUrl) {
@@ -22599,6 +22631,28 @@ function openBrowser(connectionId, initialWorkspaceId, preferredBridgeName, apiU
   }
 }
 
+// src/bridge/connection/reconnect/constants.ts
+var RECONNECT_FIRST_MS = 100;
+var RECONNECT_MAX_MS = 3e4;
+var RECONNECT_QUIET_MS = 2e3;
+function reconnectDelayMs(attemptBeforeIncrement) {
+  return Math.min(RECONNECT_FIRST_MS * 2 ** attemptBeforeIncrement, RECONNECT_MAX_MS);
+}
+
+// src/bridge/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
 function describeWebSocketCloseCode(code) {
   const known = {
@@ -22627,11 +22681,122 @@ function formatWebSocketClose(label, code, reason, extra) {
   const r = reason.trim();
   const reasonPart = r ? ` reason="${r}"` : "";
   const extraPart = extra ? ` ${extra}` : "";
-  return `${label} closed: code=${code} (${describeWebSocketCloseCode(code)})${reasonPart}${extraPart}`;
+  return `${label} Disconnected: code=${code} (${describeWebSocketCloseCode(code)})${reasonPart}${extraPart}`;
+}
+
+// src/bridge/connection/reconnect/reconnect-quiet-slot.ts
+function createEmptyReconnectQuietSlot() {
+  return { timer: null, verboseLogs: false, pendingCloseLog: null };
+}
+function clearReconnectQuietTimer(quiet) {
+  if (quiet.timer != null) {
+    clearTimeout(quiet.timer);
+    quiet.timer = null;
+  }
+}
+function clearReconnectQuietOnSuccessfulConnection(quiet, log2, reconnectedMessage) {
+  clearReconnectQuietTimer(quiet);
+  quiet.pendingCloseLog = null;
+  if (quiet.verboseLogs) {
+    log2(reconnectedMessage);
+    quiet.verboseLogs = false;
+  }
+}
+function beginDeferredDisconnectForReconnect(options) {
+  const {
+    isClosedByUser,
+    quiet,
+    code,
+    reason,
+    willReconnect,
+    log: log2,
+    serviceLabel,
+    shutdownDetail,
+    reconnectingDetail,
+    quietMs = RECONNECT_QUIET_MS,
+    shouldAbortQuietWindow
+  } = options;
+  if (!willReconnect) {
+    log2(formatWebSocketClose(serviceLabel, code, reason, shutdownDetail));
+    return;
+  }
+  quiet.pendingCloseLog = { code, reason };
+  if (quiet.timer == null) {
+    quiet.timer = setTimeout(() => {
+      quiet.timer = null;
+      if (isClosedByUser()) return;
+      if (shouldAbortQuietWindow()) return;
+      if (quiet.pendingCloseLog) {
+        const { code: c, reason: r } = quiet.pendingCloseLog;
+        quiet.pendingCloseLog = null;
+        log2(formatWebSocketClose(serviceLabel, c, r, reconnectingDetail));
+      }
+      quiet.verboseLogs = true;
+    }, quietMs);
+  }
+}
+
+// src/bridge/connection/reconnect/bridge-main-reconnect.ts
+function beginMainBridgeDeferredDisconnect(state, code, reason, log2, willReconnect) {
+  beginDeferredDisconnectForReconnect({
+    isClosedByUser: () => state.closedByUser,
+    quiet: state.mainQuiet,
+    code,
+    reason,
+    willReconnect,
+    log: log2,
+    serviceLabel: "[Bridge service]",
+    shutdownDetail: "Not reconnecting (shutting down).",
+    reconnectingDetail: "Reconnecting\u2026",
+    shouldAbortQuietWindow: () => {
+      const w = state.currentWs;
+      return w != null && w.readyState === wrapper_default.OPEN;
+    }
+  });
+}
+function clearMainBridgeReconnectQuietOnOpen(state, log2) {
+  clearReconnectQuietOnSuccessfulConnection(state.mainQuiet, log2, "[Bridge service] Reconnected.");
+}
+function scheduleMainBridgeReconnect(state, connect, log2) {
+  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);
+}
+
+// src/bridge/connection/reconnect/firehose-reconnect.ts
+var PROXY_AND_LOG_SERVICE_LABEL = "[Proxy and log service]";
+function beginFirehoseDeferredDisconnect(ctx, code, reason, log2) {
+  beginDeferredDisconnectForReconnect({
+    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",
+    shouldAbortQuietWindow: () => {
+      const w = ctx.currentWs;
+      if (!w || w.readyState !== wrapper_default.OPEN) return true;
+      return ctx.firehoseHandle?.isConnected() ?? false;
+    }
+  });
+}
+function clearFirehoseReconnectQuietOnOpen(ctx, log2) {
+  clearReconnectQuietOnSuccessfulConnection(
+    ctx.firehoseQuiet,
+    log2,
+    `${PROXY_AND_LOG_SERVICE_LABEL} Reconnected.`
+  );
 }
 
 // src/auth/run-pending-auth.ts
-var PENDING_RECONNECT_MS = 2e3;
 var PENDING_KEEPALIVE_MS = 25e3;
 var BROWSER_OPEN_FALLBACK_MS = 4e3;
 function buildPendingBridgeUrl(apiUrl, connectionId) {
@@ -22650,10 +22815,35 @@ function runPendingAuth(options) {
   let hasOpenedBrowser = false;
   let resolved = false;
   let resolveAuth;
-  const authPromise = new Promise((resolve16) => {
-    resolveAuth = resolve16;
+  const authPromise = new Promise((resolve14) => {
+    resolveAuth = resolve14;
   });
+  let reconnectAttempt = 0;
+  const signInQuiet = createEmptyReconnectQuietSlot();
+  function clearQuietOnOpen() {
+    clearReconnectQuietOnSuccessfulConnection(
+      signInQuiet,
+      logFn,
+      "[Bridge service] Sign-in connection restored."
+    );
+    reconnectAttempt = 0;
+  }
+  function beginDeferredPendingCloseLog(code, reason) {
+    beginDeferredDisconnectForReconnect({
+      isClosedByUser: () => resolved,
+      quiet: signInQuiet,
+      code,
+      reason,
+      willReconnect: true,
+      log: logFn,
+      serviceLabel: "[Bridge service]",
+      shutdownDetail: "Not reconnecting (shutting down).",
+      reconnectingDetail: "Waiting for browser sign-in; reconnecting\u2026",
+      shouldAbortQuietWindow: () => ws != null && ws.readyState === wrapper_default.OPEN
+    });
+  }
   function cleanup() {
+    clearReconnectQuietTimer(signInQuiet);
     if (reconnectTimeout) {
       clearTimeout(reconnectTimeout);
       reconnectTimeout = null;
@@ -22677,6 +22867,7 @@ function runPendingAuth(options) {
     ws = createWsBridge({
       url: url2,
       onOpen: () => {
+        clearQuietOnOpen();
         sendWsMessage(ws, { type: "identify", role: "cli" });
         keepaliveInterval = setInterval(() => {
           if (resolved || !ws || ws.readyState !== 1) return;
@@ -22697,15 +22888,21 @@ function runPendingAuth(options) {
           keepaliveInterval = null;
         }
         if (resolved) return;
-        logFn(
-          formatWebSocketClose("[Bridge service]", code, reason, "pending sign-in; will reconnect in 2s")
-        );
+        beginDeferredPendingCloseLog(code, reason);
+        const delay2 = reconnectDelayMs(reconnectAttempt);
+        reconnectAttempt += 1;
+        if (signInQuiet.verboseLogs) {
+          const delayLabel = formatReconnectDelayForLog(delay2);
+          logFn(
+            `[Bridge service] Next sign-in connection attempt in ${delayLabel} (attempt ${reconnectAttempt}).`
+          );
+        }
         reconnectTimeout = setTimeout(() => {
           reconnectTimeout = null;
           connect();
-        }, PENDING_RECONNECT_MS);
+        }, delay2);
       },
-      onError: (err) => logFn(`[Bridge service] WebSocket error (pending sign-in): ${err.message}`),
+      onError: (err) => logFn(`[Bridge service] WebSocket error while waiting for sign-in: ${err.message}`),
       onMessage: (data) => {
         const msg = data;
         if (msg.type === "auth_token" && typeof msg.token === "string") {
@@ -22746,7 +22943,7 @@ function buildBridgeUrl(apiUrl, workspaceId, authToken) {
 
 // src/git/discover-repos.ts
 import * as fs2 from "node:fs";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 
 // ../../node_modules/.pnpm/simple-git@3.32.3/node_modules/simple-git/dist/esm/index.js
 var import_file_exists = __toESM(require_dist(), 1);
@@ -24008,8 +24205,8 @@ var init_git_executor_chain = __esm2({
       get cwd() {
         return this._cwd || this._executor.cwd;
       }
-      set cwd(cwd3) {
-        this._cwd = cwd3;
+      set cwd(cwd) {
+        this._cwd = cwd;
       }
       get env() {
         return this._executor.env;
@@ -24200,8 +24397,8 @@ var init_git_executor = __esm2({
     "use strict";
     init_git_executor_chain();
     GitExecutor = class {
-      constructor(cwd3, _scheduler, _plugins) {
-        this.cwd = cwd3;
+      constructor(cwd, _scheduler, _plugins) {
+        this.cwd = cwd;
         this._scheduler = _scheduler;
         this._plugins = _plugins;
         this._chain = new GitExecutorChain(this, this._scheduler, this._plugins);
@@ -27331,9 +27528,9 @@ async function isGitRepoDirectory(dirPath) {
 }
 
 // src/git/discover-repos.ts
-async function discoverGitRepos(cwd3 = process.cwd()) {
+async function discoverGitRepos(cwd = getBridgeWorkspaceDirectory()) {
   const result = [];
-  const cwdResolved = path2.resolve(cwd3);
+  const cwdResolved = path3.resolve(cwd);
   if (await isGitRepoDirectory(cwdResolved)) {
     const remoteUrl = await getRemoteOriginUrl(cwdResolved);
     result.push({ absolutePath: cwdResolved, remoteUrl });
@@ -27346,7 +27543,7 @@ async function discoverGitRepos(cwd3 = process.cwd()) {
   }
   for (const ent of entries) {
     if (!ent.isDirectory()) continue;
-    const childPath = path2.join(cwdResolved, ent.name);
+    const childPath = path3.join(cwdResolved, ent.name);
     if (await isGitRepoDirectory(childPath)) {
       const remoteUrl = await getRemoteOriginUrl(childPath);
       result.push({ absolutePath: childPath, remoteUrl });
@@ -27355,11 +27552,11 @@ async function discoverGitRepos(cwd3 = process.cwd()) {
   return result;
 }
 async function discoverGitReposUnderRoot(rootAbs) {
-  const root = path2.resolve(rootAbs);
+  const root = path3.resolve(rootAbs);
   const roots = [];
   async function walk(dir) {
     if (await isGitRepoDirectory(dir)) {
-      roots.push(path2.resolve(dir));
+      roots.push(path3.resolve(dir));
       return;
     }
     let entries;
@@ -27370,7 +27567,7 @@ async function discoverGitReposUnderRoot(rootAbs) {
     }
     for (const ent of entries) {
       if (!ent.isDirectory() || ent.name === ".git") continue;
-      await walk(path2.join(dir, ent.name));
+      await walk(path3.join(dir, ent.name));
     }
   }
   await walk(root);
@@ -27397,56 +27594,43 @@ function reportGitRepos(getWs, log2) {
         }
       }
     }).catch((err) => {
-      log2(`[Bridge service] git repo discovery failed: ${err instanceof Error ? err.message : String(err)}`);
+      log2(
+        `[Bridge service] Git repository discovery failed: ${err instanceof Error ? err.message : String(err)}`
+      );
     });
   });
 }
 
-// src/bridge/connection/schedule-reconnect.ts
-var RECONNECT_BASE_MS = 1e3;
-var RECONNECT_MAX_MS = 3e4;
-function scheduleReconnect(state, connect, log2) {
-  if (state.closedByUser || state.currentWs != null) return;
-  const delay2 = Math.min(
-    RECONNECT_BASE_MS * 2 ** state.reconnectAttempt,
-    RECONNECT_MAX_MS
-  );
-  state.reconnectAttempt += 1;
-  log2(`[Bridge service] reconnect attempt ${state.reconnectAttempt} in ${delay2 / 1e3}s\u2026`);
-  state.reconnectTimeout = setTimeout(() => {
-    state.reconnectTimeout = null;
-    connect();
-  }, delay2);
-}
-
 // src/bridge/connection/close-bridge-connection.ts
 async function closeBridgeConnection(state, acpManager, devServerManager, log2) {
   log2?.("Shutting down\u2026");
-  await new Promise((resolve16) => setImmediate(resolve16));
+  await new Promise((resolve14) => setImmediate(resolve14));
   if (devServerManager) {
     log2?.("Requesting dev server processes to stop\u2026");
     await devServerManager.shutdownAllGraceful();
   }
   state.closedByUser = true;
+  clearReconnectQuietTimer(state.mainQuiet);
+  clearReconnectQuietTimer(state.firehoseQuiet);
   if (state.reconnectTimeout != null) {
     log2?.("Cancelling reconnect timer\u2026");
     clearTimeout(state.reconnectTimeout);
     state.reconnectTimeout = null;
   }
   if (state.firehoseReconnectTimeout != null) {
-    log2?.("[Proxy and log service] cancelling reconnect timer\u2026");
+    log2?.("[Proxy and log service] Cancelling reconnect timer\u2026");
     clearTimeout(state.firehoseReconnectTimeout);
     state.firehoseReconnectTimeout = null;
   }
   if (state.firehoseHandle) {
-    log2?.("[Proxy and log service] closing connection (CLI shutdown)\u2026");
+    log2?.("[Proxy and log service] Closing connection (CLI shutdown)\u2026");
     state.firehoseHandle.close();
     state.firehoseHandle = null;
   }
   log2?.("Disconnecting local agents (ACP)\u2026");
   acpManager.disconnect();
   if (state.currentWs) {
-    log2?.("[Bridge service] closing connection (CLI shutdown)\u2026");
+    log2?.("[Bridge service] Closing connection (CLI shutdown)\u2026");
     state.currentWs.removeAllListeners();
     const wsState = state.currentWs.readyState;
     if (wsState === 1 || wsState === 2) {
@@ -27462,11 +27646,20 @@ async function closeBridgeConnection(state, acpManager, devServerManager, log2)
 }
 
 // src/git/session-git-queue.ts
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+import * as fs4 from "node:fs";
+import * as path5 from "node:path";
+
+// src/git/pre-turn-snapshot.ts
+import * as fs3 from "node:fs";
+import * as path4 from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import * as path3 from "node:path";
 var execFileAsync = promisify(execFile);
-var sessionBoundaryBySessionId = /* @__PURE__ */ new Map();
+function snapshotsDirForCwd(agentCwd) {
+  return path4.join(agentCwd, ".buildautomaton", "snapshots");
+}
 async function gitStashCreate(repoRoot, log2) {
   try {
     const { stdout } = await execFileAsync("git", ["stash", "create"], {
@@ -27475,51 +27668,149 @@ async function gitStashCreate(repoRoot, log2) {
     });
     return stdout.trim();
   } catch (e) {
-    log2(`[session-git-queue] stash create failed in ${repoRoot}: ${e instanceof Error ? e.message : String(e)}`);
+    log2(
+      `[snapshot] Git stash create failed in ${repoRoot}: ${e instanceof Error ? e.message : String(e)}`
+    );
     return "";
   }
 }
-async function captureSessionGitBoundary(options) {
-  const { sessionId, repoRoots, log: log2 } = options;
-  if (!repoRoots.length) return;
+async function gitRun(repoRoot, args, log2, label) {
+  try {
+    await execFileAsync("git", args, { cwd: repoRoot, maxBuffer: 10 * 1024 * 1024 });
+    return { ok: true };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    log2(`[snapshot] Git ${label} failed in ${repoRoot}: ${msg}`);
+    return { ok: false, error: msg };
+  }
+}
+async function resolveSnapshotRepoRoots(options) {
+  const { worktreePaths, fallbackCwd, log: log2 } = options;
+  if (worktreePaths?.length) {
+    const uniq = [...new Set(worktreePaths.map((p) => path4.resolve(p)))];
+    return uniq;
+  }
+  try {
+    const repos = await discoverGitReposUnderRoot(fallbackCwd);
+    return repos.map((r) => r.absolutePath);
+  } catch (e) {
+    log2(`[snapshot] Discover repositories failed: ${e instanceof Error ? e.message : String(e)}`);
+    return [];
+  }
+}
+async function capturePreTurnSnapshot(options) {
+  const { runId, repoRoots, agentCwd, log: log2 } = options;
+  if (!runId || !repoRoots.length) {
+    return { ok: false, error: "No git repos to snapshot" };
+  }
   const repos = [];
   for (const root of repoRoots) {
     const stashSha = await gitStashCreate(root, log2);
     repos.push({ path: root, stashSha });
   }
-  sessionBoundaryBySessionId.set(sessionId, repos);
-  log2(`[session-git-queue] boundary stash ${sessionId.slice(0, 8)}\u2026 (${repos.length} repo(s))`);
+  const dir = snapshotsDirForCwd(agentCwd);
+  try {
+    fs3.mkdirSync(dir, { recursive: true });
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  }
+  const payload = {
+    runId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    repos
+  };
+  const filePath = path4.join(dir, `${runId}.json`);
+  try {
+    fs3.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  }
+  const repoList = repos.map((r) => r.path).join(", ");
+  log2(
+    `[snapshot] Saved pre-turn snapshot ${runId.slice(0, 8)}\u2026 (${repos.length} repo(s)): ${repoList}`
+  );
+  return { ok: true, filePath, repos };
+}
+async function applyPreTurnSnapshot(filePath, log2) {
+  let data;
+  try {
+    const raw = fs3.readFileSync(filePath, "utf8");
+    data = JSON.parse(raw);
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : String(e) };
+  }
+  if (!Array.isArray(data.repos)) {
+    return { ok: false, error: "Invalid snapshot file" };
+  }
+  for (const r of data.repos) {
+    if (!r.path) continue;
+    const reset = await gitRun(r.path, ["reset", "--hard", "HEAD"], log2, "reset --hard");
+    if (!reset.ok) return reset;
+    const clean = await gitRun(r.path, ["clean", "-fd"], log2, "clean -fd");
+    if (!clean.ok) return clean;
+    if (r.stashSha) {
+      const ap = await gitRun(r.path, ["stash", "apply", r.stashSha], log2, "stash apply");
+      if (!ap.ok) return ap;
+    }
+  }
+  log2(`[snapshot] Restored pre-turn state for ${data.runId.slice(0, 8)}\u2026`);
+  return { ok: true };
+}
+function snapshotFilePath(agentCwd, runId) {
+  return path4.join(snapshotsDirForCwd(agentCwd), `${runId}.json`);
+}
+
+// src/git/session-git-queue.ts
+var execFileAsync2 = promisify2(execFile2);
+var MAX_FULL_FILE_TEXT_BYTES = 512 * 1024;
+function readWorkspaceFileAsUtf8(absPath) {
+  try {
+    const st = fs4.statSync(absPath);
+    if (!st.isFile() || st.size > MAX_FULL_FILE_TEXT_BYTES) return void 0;
+    return fs4.readFileSync(absPath, "utf8");
+  } catch {
+    return void 0;
+  }
 }
-async function collectSessionDiffAndNotify(options) {
-  const { sessionId, runId, sendSessionUpdate, log: log2 } = options;
-  const repos = sessionBoundaryBySessionId.get(sessionId);
-  if (!repos?.length) {
-    log2(`[session-git-queue] no boundary for ${sessionId.slice(0, 8)}\u2026; skip aggregate diff`);
+async function collectTurnGitDiffFromPreTurnSnapshot(options) {
+  const { sessionId, runId, agentCwd, sendSessionUpdate, log: log2 } = options;
+  const filePath = snapshotFilePath(agentCwd, runId);
+  let data;
+  try {
+    const raw = fs4.readFileSync(filePath, "utf8");
+    data = JSON.parse(raw);
+  } catch (e) {
+    log2(
+      `[session-git-queue] No pre-turn snapshot for run ${runId.slice(0, 8)}\u2026: ${e instanceof Error ? e.message : String(e)}`
+    );
     return;
   }
-  sessionBoundaryBySessionId.delete(sessionId);
-  const multiRepo = repos.length > 1;
-  for (const repo of repos) {
+  if (!Array.isArray(data.repos) || !data.repos.length) {
+    log2(`[session-git-queue] Empty repos in snapshot ${runId.slice(0, 8)}\u2026; skipping aggregate diff.`);
+    return;
+  }
+  const multiRepo = data.repos.length > 1;
+  for (const repo of data.repos) {
     if (!repo.stashSha) continue;
     let namesRaw;
     try {
-      const { stdout } = await execFileAsync("git", ["diff", "--name-only", repo.stashSha], {
+      const { stdout } = await execFileAsync2("git", ["diff", "--name-only", repo.stashSha], {
         cwd: repo.path,
         maxBuffer: 10 * 1024 * 1024
       });
       namesRaw = stdout;
     } catch (e) {
       log2(
-        `[session-git-queue] git diff --name-only failed in ${repo.path}: ${e instanceof Error ? e.message : String(e)}`
+        `[session-git-queue] Git diff --name-only failed in ${repo.path}: ${e instanceof Error ? e.message : String(e)}`
       );
       continue;
     }
     const lines = namesRaw.split("\n").map((l) => l.trim()).filter(Boolean);
-    const slug = path3.basename(repo.path).replace(/[^\w.-]+/g, "_") || "repo";
+    const slug = path5.basename(repo.path).replace(/[^\w.-]+/g, "_") || "repo";
     for (const rel of lines) {
       if (rel.includes("..")) continue;
       try {
-        const { stdout: patchContent } = await execFileAsync(
+        const { stdout: patchContent } = await execFileAsync2(
           "git",
           ["diff", "--no-color", repo.stashSha, "--", rel],
           {
@@ -27529,15 +27820,20 @@ async function collectSessionDiffAndNotify(options) {
         );
         if (!patchContent.trim()) continue;
         const displayPath = multiRepo ? `${slug}/${rel}` : rel;
+        const absFile = path5.join(repo.path, rel);
+        const newText = readWorkspaceFileAsUtf8(absFile);
         sendSessionUpdate({
           type: "session_file_change",
           sessionId,
           runId,
           path: displayPath,
-          patchContent
+          patchContent,
+          ...newText !== void 0 ? { newText } : {}
         });
       } catch (e) {
-        log2(`[session-git-queue] git diff failed for ${rel}: ${e instanceof Error ? e.message : String(e)}`);
+        log2(
+          `[session-git-queue] Git diff failed for ${rel}: ${e instanceof Error ? e.message : String(e)}`
+        );
       }
     }
   }
@@ -27551,15 +27847,21 @@ async function sendPromptToAgent(options) {
     promptId,
     sessionId,
     runId,
+    agentCwd,
     sendResult,
     sendSessionUpdate,
-    collectSessionDiffAfterTurn,
     log: log2
   } = options;
   try {
     const result = await handle.sendPrompt(promptText, {});
-    if (collectSessionDiffAfterTurn && sessionId && runId && sendSessionUpdate && result.success) {
-      await collectSessionDiffAndNotify({ sessionId, runId, sendSessionUpdate, log: log2 });
+    if (sessionId && runId && sendSessionUpdate && agentCwd && result.success) {
+      await collectTurnGitDiffFromPreTurnSnapshot({
+        sessionId,
+        runId,
+        agentCwd,
+        sendSessionUpdate,
+        log: log2
+      });
     }
     sendResult({
       type: "prompt_result",
@@ -27569,12 +27871,12 @@ async function sendPromptToAgent(options) {
       ...result
     });
     if (!result.success) {
-      log2(`[agent] ${result.error ?? "error"}`);
+      log2(`[Agent] ${result.error ?? "Error"}`);
     }
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
-    log2(`[agent] send failed: ${errMsg}`);
-    if (err instanceof Error && err.stack) log2(`[agent] ${err.stack}`);
+    log2(`[Agent] Send failed: ${errMsg}`);
+    if (err instanceof Error && err.stack) log2(`[Agent] ${err.stack}`);
     sendResult({
       type: "prompt_result",
       id: promptId,
@@ -27587,8 +27889,8 @@ async function sendPromptToAgent(options) {
 }
 
 // src/acp/ensure-acp-client.ts
-import * as fs3 from "node:fs";
-import * as path7 from "node:path";
+import * as fs5 from "node:fs";
+import * as path9 from "node:path";
 
 // src/error-message.ts
 function errorMessage(err) {
@@ -27612,27 +27914,27 @@ async function createCodexAcpClient(options) {
 }
 
 // src/acp/clients/cursor-acp-client.ts
-import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
 import { dirname } from "node:path";
 import { spawn as spawn4 } from "node:child_process";
 import * as readline from "node:readline";
 
 // src/acp/safe-fs-path.ts
-import * as path4 from "node:path";
-function resolveSafePathUnderCwd(cwd3, filePath) {
+import * as path6 from "node:path";
+function resolveSafePathUnderCwd(cwd, filePath) {
   const trimmed2 = filePath.trim();
   if (!trimmed2) return null;
-  const normalizedCwd = path4.resolve(cwd3);
-  const resolved = path4.isAbsolute(trimmed2) ? path4.normalize(trimmed2) : path4.resolve(normalizedCwd, trimmed2);
-  const rel = path4.relative(normalizedCwd, resolved);
-  if (rel.startsWith("..") || path4.isAbsolute(rel)) return null;
+  const normalizedCwd = path6.resolve(cwd);
+  const resolved = path6.isAbsolute(trimmed2) ? path6.normalize(trimmed2) : path6.resolve(normalizedCwd, trimmed2);
+  const rel = path6.relative(normalizedCwd, resolved);
+  if (rel.startsWith("..") || path6.isAbsolute(rel)) return null;
   return resolved;
 }
-function toDisplayPathRelativeToCwd(cwd3, absolutePath) {
-  const normalizedCwd = path4.resolve(cwd3);
-  const rel = path4.relative(normalizedCwd, path4.resolve(absolutePath));
-  if (!rel || rel === "") return path4.basename(absolutePath);
-  return rel.split(path4.sep).join("/");
+function toDisplayPathRelativeToCwd(cwd, absolutePath) {
+  const normalizedCwd = path6.resolve(cwd);
+  const rel = path6.relative(normalizedCwd, path6.resolve(absolutePath));
+  if (!rel || rel === "") return path6.basename(absolutePath);
+  return rel.split(path6.sep).join("/");
 }
 
 // src/files/diff/unified-diff.ts
@@ -27681,6 +27983,19 @@ function editSnippetToUnifiedDiff(filePath, oldText, newText) {
   return out.join("\n");
 }
 
+// src/acp/format-session-update-kind-for-log.ts
+var SESSION_UPDATE_KIND_LABELS = {
+  tool_call: "Tool call",
+  tool_call_update: "Tool call status",
+  agent_message_chunk: "Agent message chunk",
+  update: "Session update"
+};
+function formatSessionUpdateKindForLog(kind) {
+  const known = SESSION_UPDATE_KIND_LABELS[kind];
+  if (known) return known;
+  return kind.split("_").filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(" ");
+}
+
 // src/acp/clients/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"]);
@@ -27706,16 +28021,16 @@ function sliceLinesByRange(content, line, limit) {
   return lines.slice(start, end).join("\n");
 }
 async function createCursorAcpClient(options) {
-  const { command, cwd: cwd3 = process.cwd(), onSessionUpdate, onRequest, onFileChange } = options;
+  const { command, cwd = getBridgeWorkspaceDirectory(), onSessionUpdate, onRequest, onFileChange } = options;
   const dbgFs = process.env.BUILDAMATON_DEBUG_ACP_FS === "1";
-  const isWindows2 = process.platform === "win32";
+  const isWindows = process.platform === "win32";
   const child = spawn4(command[0], command.slice(1), {
-    cwd: cwd3,
+    cwd,
     stdio: ["pipe", "pipe", "inherit"],
     env: process.env,
-    shell: isWindows2
+    shell: isWindows
   });
-  return new Promise((resolve16, reject) => {
+  return new Promise((resolve14, reject) => {
     child.on("error", (err) => {
       child.kill();
       reject(new Error(formatSpawnError2(err, command[0])));
@@ -27768,7 +28083,10 @@ async function createCursorAcpClient(options) {
         const toolCall = update.toolCall ?? update.tool_call;
         const toolName = typeof toolCall?.name === "string" ? toolCall.name : "";
         if (dbgFs && (sessionUpdate === "tool_call" || sessionUpdate === "tool_call_update")) {
-          console.error(`[acp] recv session/update kind=${sessionUpdate} tool=${toolName || "(none)"}`);
+          const kindLabel = formatSessionUpdateKindForLog(sessionUpdate ?? "update");
+          console.error(
+            `[acp] Received session update (${kindLabel}) tool=${toolName || "(none)"}`
+          );
         }
         const isTextChunk = sessionUpdate === "agent_message_chunk" && update.content?.text;
         if (isTextChunk && update.content?.text) {
@@ -27788,14 +28106,14 @@ async function createCursorAcpClient(options) {
           if (dbgFs) {
             console.error(`[acp-fs] ${method} path=${filePath.slice(0, 200)}${filePath.length > 200 ? "\u2026" : ""}`);
           }
-          const abs = resolveSafePathUnderCwd(cwd3, filePath);
+          const abs = resolveSafePathUnderCwd(cwd, filePath);
           if (!abs) {
             if (dbgFs) console.error(`[acp-fs] ${method} rejected path (outside cwd or empty)`);
             respondJsonRpcError(id, -32602, "Invalid or disallowed path");
             return;
           }
           try {
-            let content = readFileSync(abs, "utf8");
+            let content = readFileSync3(abs, "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);
@@ -27819,7 +28137,7 @@ async function createCursorAcpClient(options) {
               `[acp-fs] ${method} path=${filePath.slice(0, 200)}${filePath.length > 200 ? "\u2026" : ""} newBytes=${newText.length}`
             );
           }
-          const abs = resolveSafePathUnderCwd(cwd3, filePath);
+          const abs = resolveSafePathUnderCwd(cwd, filePath);
           if (!abs) {
             if (dbgFs) console.error(`[acp-fs] ${method} rejected path (outside cwd or empty): ${filePath.slice(0, 120)}`);
             respondJsonRpcError(id, -32602, "Invalid or disallowed path");
@@ -27827,7 +28145,7 @@ async function createCursorAcpClient(options) {
           }
           let oldText = "";
           try {
-            oldText = readFileSync(abs, "utf8");
+            oldText = readFileSync3(abs, "utf8");
           } catch (e) {
             if (e.code !== "ENOENT") {
               respondJsonRpcError(id, -32e3, e instanceof Error ? e.message : String(e));
@@ -27835,13 +28153,13 @@ async function createCursorAcpClient(options) {
             }
           }
           try {
-            mkdirSync(dirname(abs), { recursive: true });
-            writeFileSync(abs, newText, "utf8");
+            mkdirSync2(dirname(abs), { recursive: true });
+            writeFileSync2(abs, newText, "utf8");
           } catch (e) {
             respondJsonRpcError(id, -32e3, e instanceof Error ? e.message : String(e));
             return;
           }
-          const displayPath = toDisplayPathRelativeToCwd(cwd3, abs);
+          const displayPath = toDisplayPathRelativeToCwd(cwd, abs);
           const patchContent = editSnippetToUnifiedDiff(displayPath, oldText, newText);
           onFileChange?.({ path: displayPath, oldText, newText, patchContent });
           respond(id, null);
@@ -27883,10 +28201,10 @@ async function createCursorAcpClient(options) {
           clientInfo: { name: "buildautomaton-cli", version: "0.1.0" }
         });
         await send("authenticate", { methodId: "cursor_login" });
-        const newResult = await send("session/new", { cwd: cwd3, mcpServers: [] });
+        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");
-        resolve16({
+        resolve14({
           sessionId,
           async sendPrompt(prompt, _options) {
             promptOutputBuffer = "";
@@ -27955,20 +28273,20 @@ function resolveAgentCommand(preferredAgentType) {
 
 // src/acp/session-file-change-path-kind.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync, statSync } from "node:fs";
+import { existsSync, statSync as statSync2 } from "node:fs";
 
 // src/git/get-git-repo-root-sync.ts
 import { execFileSync } from "node:child_process";
-import * as path5 from "node:path";
+import * as path7 from "node:path";
 function getGitRepoRootSync(startDir) {
   try {
     const out = execFileSync("git", ["rev-parse", "--show-toplevel"], {
-      cwd: path5.resolve(startDir),
+      cwd: path7.resolve(startDir),
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       maxBuffer: 1024 * 1024
     }).trim();
-    return out ? path5.resolve(out) : null;
+    return out ? path7.resolve(out) : null;
   } catch {
     return null;
   }
@@ -27976,65 +28294,65 @@ function getGitRepoRootSync(startDir) {
 
 // src/acp/workspace-files.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { readFileSync as readFileSync2 } from "node:fs";
-import * as path6 from "node:path";
-function resolveWorkspaceFilePath(cwd3, rawPath) {
+import { readFileSync as readFileSync4 } from "node:fs";
+import * as path8 from "node:path";
+function resolveWorkspaceFilePath(cwd, rawPath) {
   const trimmed2 = rawPath.trim();
   if (!trimmed2) return null;
-  const normalizedCwd = path6.resolve(cwd3);
-  let abs = resolveSafePathUnderCwd(cwd3, trimmed2);
+  const normalizedCwd = path8.resolve(cwd);
+  let abs = resolveSafePathUnderCwd(cwd, trimmed2);
   if (!abs) {
-    const candidate = path6.isAbsolute(trimmed2) ? path6.normalize(trimmed2) : path6.normalize(path6.resolve(normalizedCwd, trimmed2));
-    const gitRoot2 = getGitRepoRootSync(cwd3);
+    const candidate = path8.isAbsolute(trimmed2) ? path8.normalize(trimmed2) : path8.normalize(path8.resolve(normalizedCwd, trimmed2));
+    const gitRoot2 = getGitRepoRootSync(cwd);
     if (!gitRoot2) return null;
-    const rel = path6.relative(gitRoot2, candidate);
-    if (rel.startsWith("..") || path6.isAbsolute(rel)) return null;
+    const rel = path8.relative(gitRoot2, candidate);
+    if (rel.startsWith("..") || path8.isAbsolute(rel)) return null;
     abs = candidate;
   }
-  const gitRoot = getGitRepoRootSync(cwd3);
+  const gitRoot = getGitRepoRootSync(cwd);
   if (gitRoot) {
-    const relFromRoot = path6.relative(gitRoot, abs);
-    if (!relFromRoot.startsWith("..") && !path6.isAbsolute(relFromRoot)) {
-      return { abs, display: relFromRoot.split(path6.sep).join("/") };
+    const relFromRoot = path8.relative(gitRoot, abs);
+    if (!relFromRoot.startsWith("..") && !path8.isAbsolute(relFromRoot)) {
+      return { abs, display: relFromRoot.split(path8.sep).join("/") };
     }
   }
-  return { abs, display: toDisplayPathRelativeToCwd(cwd3, abs) };
+  return { abs, display: toDisplayPathRelativeToCwd(cwd, abs) };
 }
-function readUtf8WorkspaceFile(cwd3, displayPath) {
+function readUtf8WorkspaceFile(cwd, displayPath) {
   if (!displayPath || displayPath.includes("..")) return "";
-  const gitRoot = getGitRepoRootSync(cwd3);
+  const gitRoot = getGitRepoRootSync(cwd);
   if (gitRoot) {
-    const abs2 = path6.resolve(gitRoot, displayPath);
-    const rel = path6.relative(gitRoot, abs2);
-    if (!rel.startsWith("..") && !path6.isAbsolute(rel)) {
+    const abs2 = path8.resolve(gitRoot, displayPath);
+    const rel = path8.relative(gitRoot, abs2);
+    if (!rel.startsWith("..") && !path8.isAbsolute(rel)) {
       try {
-        return readFileSync2(abs2, "utf8");
+        return readFileSync4(abs2, "utf8");
       } catch {
       }
     }
   }
-  const abs = resolveSafePathUnderCwd(cwd3, displayPath);
+  const abs = resolveSafePathUnderCwd(cwd, displayPath);
   if (!abs) return "";
   try {
-    return readFileSync2(abs, "utf8");
+    return readFileSync4(abs, "utf8");
   } catch {
     return "";
   }
 }
-function tryWorkspaceDisplayToAbs(cwd3, displayPath) {
+function tryWorkspaceDisplayToAbs(cwd, displayPath) {
   if (!displayPath || displayPath.includes("..")) return null;
-  const gitRoot = getGitRepoRootSync(cwd3);
+  const gitRoot = getGitRepoRootSync(cwd);
   if (gitRoot) {
-    const abs = path6.resolve(gitRoot, displayPath);
-    const rel = path6.relative(gitRoot, abs);
-    if (!rel.startsWith("..") && !path6.isAbsolute(rel)) return abs;
+    const abs = path8.resolve(gitRoot, displayPath);
+    const rel = path8.relative(gitRoot, abs);
+    if (!rel.startsWith("..") && !path8.isAbsolute(rel)) return abs;
   }
-  return resolveSafePathUnderCwd(cwd3, displayPath);
+  return resolveSafePathUnderCwd(cwd, displayPath);
 }
-function readGitHeadBlob(cwd3, displayPath) {
+function readGitHeadBlob(cwd, displayPath) {
   if (!displayPath || displayPath.includes("..")) return "";
-  const gitRoot = getGitRepoRootSync(cwd3);
-  const execCwd = gitRoot ?? cwd3;
+  const gitRoot = getGitRepoRootSync(cwd);
+  const execCwd = gitRoot ?? cwd;
   try {
     return execFileSync2("git", ["show", `HEAD:${displayPath}`], {
       cwd: execCwd,
@@ -28047,9 +28365,9 @@ function readGitHeadBlob(cwd3, displayPath) {
 }
 
 // src/acp/session-file-change-path-kind.ts
-function gitHeadPathObjectType(cwd3, displayPath) {
+function gitHeadPathObjectType(cwd, displayPath) {
   if (!displayPath || displayPath.includes("..")) return null;
-  const gitRoot = getGitRepoRootSync(cwd3);
+  const gitRoot = getGitRepoRootSync(cwd);
   if (!gitRoot) return null;
   try {
     return execFileSync3("git", ["cat-file", "-t", `HEAD:${displayPath}`], {
@@ -28060,11 +28378,11 @@ function gitHeadPathObjectType(cwd3, displayPath) {
     return null;
   }
 }
-function getSessionFileChangeDirectoryFlags(cwd3, displayPath) {
-  const abs = tryWorkspaceDisplayToAbs(cwd3, displayPath);
+function getSessionFileChangeDirectoryFlags(cwd, displayPath) {
+  const abs = tryWorkspaceDisplayToAbs(cwd, displayPath);
   if (abs && existsSync(abs)) {
     try {
-      if (statSync(abs).isDirectory()) {
+      if (statSync2(abs).isDirectory()) {
         return { isDirectory: true, directoryRemoved: false };
       }
       return { isDirectory: false, directoryRemoved: false };
@@ -28072,7 +28390,7 @@ function getSessionFileChangeDirectoryFlags(cwd3, displayPath) {
       return { isDirectory: false, directoryRemoved: false };
     }
   }
-  if (gitHeadPathObjectType(cwd3, displayPath) === "tree") {
+  if (gitHeadPathObjectType(cwd, displayPath) === "tree") {
     return { isDirectory: true, directoryRemoved: true };
   }
   return { isDirectory: false, directoryRemoved: false };
@@ -28086,11 +28404,13 @@ function createBridgeOnFileChange(opts) {
     const sessionId = routing.sessionId;
     const send = getSendSessionUpdate();
     if (!send || !runId || !sessionId) {
-      log2(`[Bridge service] file change not forwarded path=${evt.path} (session/run not wired)`);
+      log2(
+        `[Bridge service] File change not forwarded (${evt.path}): session or run not wired to the bridge.`
+      );
       return;
     }
-    const cwd3 = process.cwd();
-    const dirFlags = getSessionFileChangeDirectoryFlags(cwd3, evt.path);
+    const cwd = getBridgeWorkspaceDirectory();
+    const dirFlags = getSessionFileChangeDirectoryFlags(cwd, evt.path);
     try {
       send({
         type: "session_file_change",
@@ -28104,7 +28424,7 @@ function createBridgeOnFileChange(opts) {
         directoryRemoved: dirFlags.directoryRemoved
       });
     } catch (err) {
-      log2(`[Bridge service] session_file_change failed ${evt.path}: ${errorMessage(err)}`);
+      log2(`[Bridge service] Session file change failed for ${evt.path}: ${errorMessage(err)}`);
     }
   };
 }
@@ -28131,7 +28451,9 @@ function createBridgeOnRequest(opts) {
         }
       });
     } catch (err) {
-      log2(`[Bridge service] ACP request forward failed (${request.method}): ${errorMessage(err)}`);
+      log2(
+        `[Bridge service] Agent protocol request forward failed (${request.method}): ${errorMessage(err)}`
+      );
     }
   };
 }
@@ -28163,12 +28485,12 @@ function extractDiffPath(o) {
 }
 
 // src/acp/hooks/extract-acp-file-diffs-from-update/push-diff.ts
-function pushDiffIfComplete(o, cwd3, out) {
+function pushDiffIfComplete(o, cwd, out) {
   const t = o.type;
   if (typeof t !== "string" || t.toLowerCase() !== "diff") return;
   const rawPath = extractDiffPath(o);
   if (!rawPath) return;
-  const resolved = resolveWorkspaceFilePath(cwd3, rawPath);
+  const resolved = resolveWorkspaceFilePath(cwd, rawPath);
   if (!resolved) return;
   const oldText = readOptionalTextField(o.oldText ?? o.old_text ?? o.before ?? o.oldContent);
   const newText = readOptionalTextField(o.newText ?? o.new_text ?? o.after ?? o.newContent);
@@ -28187,17 +28509,17 @@ var NEST_KEYS = [
   "data",
   "arguments"
 ];
-function walkValue(value, cwd3, depth, out) {
+function walkValue(value, cwd, depth, out) {
   if (depth > 12 || value == null) return;
   if (Array.isArray(value)) {
-    for (const x of value) walkValue(x, cwd3, depth + 1, out);
+    for (const x of value) walkValue(x, cwd, depth + 1, out);
     return;
   }
   if (typeof value !== "object") return;
   const o = value;
-  pushDiffIfComplete(o, cwd3, out);
+  pushDiffIfComplete(o, cwd, out);
   if (o.type === "content" && o.content != null && typeof o.content === "object") {
-    walkValue(o.content, cwd3, depth + 1, out);
+    walkValue(o.content, cwd, depth + 1, out);
   }
   for (const k of NEST_KEYS) {
     if (o.type === "content" && k === "content") continue;
@@ -28205,23 +28527,23 @@ function walkValue(value, cwd3, depth, out) {
     if (v == null) continue;
     if (k === "arguments" && typeof v === "string") {
       try {
-        walkValue(JSON.parse(v), cwd3, depth + 1, out);
+        walkValue(JSON.parse(v), cwd, depth + 1, out);
       } catch {
       }
       continue;
     }
-    walkValue(v, cwd3, depth + 1, out);
+    walkValue(v, cwd, depth + 1, out);
   }
 }
 
 // src/acp/hooks/extract-acp-file-diffs-from-update/extract.ts
-function extractAcpFileDiffsFromUpdate(update, cwd3) {
+function extractAcpFileDiffsFromUpdate(update, cwd) {
   if (!update || typeof update !== "object") return [];
   const u = update;
   const out = [];
   const content = u.content;
   if (Array.isArray(content)) {
-    for (const x of content) walkValue(x, cwd3, 0, out);
+    for (const x of content) walkValue(x, cwd, 0, out);
   }
   const byPath = /* @__PURE__ */ new Map();
   for (const d of out) byPath.set(d.path, d);
@@ -28229,18 +28551,18 @@ function extractAcpFileDiffsFromUpdate(update, cwd3) {
 }
 
 // src/acp/hooks/extract-tool-target-paths.ts
-function addPath(cwd3, raw, out) {
+function addPath(cwd, raw, out) {
   if (typeof raw !== "string") return;
   const trimmed2 = raw.trim();
   if (!trimmed2) return;
-  const resolved = resolveWorkspaceFilePath(cwd3, trimmed2);
+  const resolved = resolveWorkspaceFilePath(cwd, trimmed2);
   if (!resolved) return;
   out.add(resolved.display);
 }
-function walkLocations(cwd3, loc, out) {
+function walkLocations(cwd, loc, out) {
   if (!Array.isArray(loc)) return;
   for (const item of loc) {
-    if (item && typeof item === "object") addPath(cwd3, item.path, out);
+    if (item && typeof item === "object") addPath(cwd, item.path, out);
   }
 }
 var PATH_KEYS = [
@@ -28253,56 +28575,56 @@ var PATH_KEYS = [
   "file_path",
   "target_file"
 ];
-function collectFromObject(cwd3, obj, out, depth) {
+function collectFromObject(cwd, obj, out, depth) {
   if (depth > 10) return;
   for (const k of PATH_KEYS) {
-    if (k in obj) addPath(cwd3, obj[k], out);
+    if (k in obj) addPath(cwd, obj[k], out);
   }
   for (const v of Object.values(obj)) {
-    if (v != null && typeof v === "object") collectUnknown(cwd3, v, out, depth + 1);
+    if (v != null && typeof v === "object") collectUnknown(cwd, v, out, depth + 1);
   }
 }
-function collectUnknown(cwd3, v, out, depth) {
+function collectUnknown(cwd, v, out, depth) {
   if (depth > 10 || v == null) return;
   if (Array.isArray(v)) {
-    for (const x of v) collectUnknown(cwd3, x, out, depth + 1);
+    for (const x of v) collectUnknown(cwd, x, out, depth + 1);
     return;
   }
-  if (typeof v === "object") collectFromObject(cwd3, v, out, depth);
+  if (typeof v === "object") collectFromObject(cwd, v, out, depth);
 }
-function walkContentArray(cwd3, content, out) {
+function walkContentArray(cwd, content, out) {
   if (!Array.isArray(content)) return;
   for (const item of content) {
     if (!item || typeof item !== "object") continue;
     const o = item;
     if (typeof o.type === "string" && o.type.toLowerCase() === "diff") {
-      for (const k of PATH_KEYS) if (k in o) addPath(cwd3, o[k], out);
+      for (const k of PATH_KEYS) if (k in o) addPath(cwd, o[k], out);
     }
     if (o.type === "content" && o.content != null && typeof o.content === "object") {
       const inner = o.content;
       if (typeof inner.type === "string" && inner.type.toLowerCase() === "diff") {
-        for (const k of PATH_KEYS) if (k in inner) addPath(cwd3, inner[k], out);
+        for (const k of PATH_KEYS) if (k in inner) addPath(cwd, inner[k], out);
       }
     }
   }
 }
-function extractToolTargetDisplayPaths(update, cwd3) {
+function extractToolTargetDisplayPaths(update, cwd) {
   const out = /* @__PURE__ */ new Set();
   if (!update || typeof update !== "object") return [];
   const u = update;
-  walkLocations(cwd3, u.locations, out);
-  walkLocations(cwd3, u.fileLocations, out);
-  walkLocations(cwd3, u.file_locations, out);
+  walkLocations(cwd, u.locations, out);
+  walkLocations(cwd, u.fileLocations, out);
+  walkLocations(cwd, u.file_locations, out);
   const tc = u.toolCall ?? u.tool_call;
   if (tc && typeof tc.arguments === "string") {
     try {
       const parsed = JSON.parse(tc.arguments);
-      collectUnknown(cwd3, parsed, out, 0);
+      collectUnknown(cwd, parsed, out, 0);
     } catch {
     }
   }
-  walkContentArray(cwd3, u.content, out);
-  collectFromObject(cwd3, u, out, 0);
+  walkContentArray(cwd, u.content, out);
+  collectFromObject(cwd, u, out, 0);
   return [...out];
 }
 
@@ -28368,7 +28690,7 @@ var PathSnapshotTracker = class {
     this.beforeByToolKey.delete(toolKey);
     this.accumulatedPathsByToolKey.delete(toolKey);
   }
-  captureBeforeFromDisk(toolKey, paths, cwd3) {
+  captureBeforeFromDisk(toolKey, paths, cwd) {
     if (paths.length === 0) return;
     let m = this.beforeByToolKey.get(toolKey);
     if (!m) {
@@ -28377,10 +28699,10 @@ var PathSnapshotTracker = class {
     }
     for (const p of paths) {
       if (m.has(p)) continue;
-      m.set(p, readUtf8WorkspaceFile(cwd3, p));
+      m.set(p, readUtf8WorkspaceFile(cwd, p));
     }
   }
-  ensureBeforeFromHeadForMissing(toolKey, paths, cwd3) {
+  ensureBeforeFromHeadForMissing(toolKey, paths, cwd) {
     let m = this.beforeByToolKey.get(toolKey);
     if (!m) {
       m = /* @__PURE__ */ new Map();
@@ -28388,10 +28710,10 @@ var PathSnapshotTracker = class {
     }
     for (const p of paths) {
       if (m.has(p)) continue;
-      m.set(p, readGitHeadBlob(cwd3, p));
+      m.set(p, readGitHeadBlob(cwd, p));
     }
   }
-  flushPathSnapshots(toolKey, cwd3, sentPaths, send, runId, sessionId, log2) {
+  flushPathSnapshots(toolKey, cwd, sentPaths, send, runId, sessionId, log2) {
     const t = this.debouncers.get(toolKey);
     if (t) clearTimeout(t);
     this.debouncers.delete(toolKey);
@@ -28400,10 +28722,10 @@ var PathSnapshotTracker = class {
     this.beforeByToolKey.delete(toolKey);
     if (!send || !runId || !sessionId) return;
     for (const [displayPath, oldText] of beforeMap) {
-      const newText = readUtf8WorkspaceFile(cwd3, displayPath);
+      const newText = readUtf8WorkspaceFile(cwd, displayPath);
       if (oldText === newText) continue;
       const patchContent = editSnippetToUnifiedDiff(displayPath, oldText, newText);
-      const dirFlags = getSessionFileChangeDirectoryFlags(cwd3, displayPath);
+      const dirFlags = getSessionFileChangeDirectoryFlags(cwd, displayPath);
       try {
         send({
           type: "session_file_change",
@@ -28418,35 +28740,35 @@ var PathSnapshotTracker = class {
         });
         sentPaths.add(displayPath);
       } catch (err) {
-        log2(`[Bridge service] session_file_change failed ${displayPath}: ${errorMessage(err)}`);
+        log2(`[Bridge service] Session file change failed for ${displayPath}: ${errorMessage(err)}`);
       }
     }
   }
-  scheduleDebouncedFlush(toolKey, cwd3, sentPaths, send, runId, sessionId, log2) {
+  scheduleDebouncedFlush(toolKey, cwd, sentPaths, send, runId, sessionId, log2) {
     const prev = this.debouncers.get(toolKey);
     if (prev) clearTimeout(prev);
     this.debouncers.set(
       toolKey,
       setTimeout(() => {
         this.debouncers.delete(toolKey);
-        this.flushPathSnapshots(toolKey, cwd3, sentPaths, send, runId, sessionId, log2);
+        this.flushPathSnapshots(toolKey, cwd, sentPaths, send, runId, sessionId, log2);
       }, PATH_SNAPSHOT_DEBOUNCE_MS)
     );
   }
-  handleToolCallLifecycle(updateKind, toolKey, toolPaths, status, cwd3, sentPaths, send, runId, sessionId, log2) {
+  handleToolCallLifecycle(updateKind, toolKey, toolPaths, status, cwd, sentPaths, send, runId, sessionId, log2) {
     if (updateKind === "tool_call") {
       this.resetToolSnapshots(toolKey);
     }
     if (updateKind === "tool_call") {
-      this.captureBeforeFromDisk(toolKey, toolPaths, cwd3);
+      this.captureBeforeFromDisk(toolKey, toolPaths, cwd);
     } else if (updateKind === "tool_call_update") {
       if (isCompletedToolStatus(status)) {
-        this.ensureBeforeFromHeadForMissing(toolKey, toolPaths, cwd3);
-        this.flushPathSnapshots(toolKey, cwd3, sentPaths, send, runId, sessionId, log2);
+        this.ensureBeforeFromHeadForMissing(toolKey, toolPaths, cwd);
+        this.flushPathSnapshots(toolKey, cwd, sentPaths, send, runId, sessionId, log2);
       } else {
-        this.captureBeforeFromDisk(toolKey, toolPaths, cwd3);
+        this.captureBeforeFromDisk(toolKey, toolPaths, cwd);
         if (this.beforeByToolKey.has(toolKey)) {
-          this.scheduleDebouncedFlush(toolKey, cwd3, sentPaths, send, runId, sessionId, log2);
+          this.scheduleDebouncedFlush(toolKey, cwd, sentPaths, send, runId, sessionId, log2);
         }
       }
     }
@@ -28454,11 +28776,11 @@ var PathSnapshotTracker = class {
 };
 
 // src/acp/hooks/bridge-on-session-update/send-structured-file-changes.ts
-function sendExtractedDiffsAsSessionFileChanges(diffs, send, cwd3, sessionId, runId, sentPaths, log2) {
+function sendExtractedDiffsAsSessionFileChanges(diffs, send, cwd, sessionId, runId, sentPaths, log2) {
   for (const d of diffs) {
     try {
       const patchContent = editSnippetToUnifiedDiff(d.path, d.oldText, d.newText);
-      const dirFlags = getSessionFileChangeDirectoryFlags(cwd3, d.path);
+      const dirFlags = getSessionFileChangeDirectoryFlags(cwd, d.path);
       send({
         type: "session_file_change",
         sessionId,
@@ -28472,19 +28794,19 @@ function sendExtractedDiffsAsSessionFileChanges(diffs, send, cwd3, sessionId, ru
       });
       sentPaths.add(d.path);
     } catch (err) {
-      log2(`[Bridge service] session_file_change failed ${d.path}: ${errorMessage(err)}`);
+      log2(`[Bridge service] Session file change failed for ${d.path}: ${errorMessage(err)}`);
     }
   }
 }
-function sendGitHeadVsWorkspaceForToolPaths(mergedPaths, sentPaths, send, cwd3, sessionId, runId, log2) {
+function sendGitHeadVsWorkspaceForToolPaths(mergedPaths, sentPaths, send, cwd, sessionId, runId, log2) {
   for (const displayPath of mergedPaths) {
     if (sentPaths.has(displayPath)) continue;
-    const oldText = readGitHeadBlob(cwd3, displayPath);
-    const newText = readUtf8WorkspaceFile(cwd3, displayPath);
+    const oldText = readGitHeadBlob(cwd, displayPath);
+    const newText = readUtf8WorkspaceFile(cwd, displayPath);
     if (oldText === newText) continue;
     try {
       const patchContent = editSnippetToUnifiedDiff(displayPath, oldText, newText);
-      const dirFlags = getSessionFileChangeDirectoryFlags(cwd3, displayPath);
+      const dirFlags = getSessionFileChangeDirectoryFlags(cwd, displayPath);
       send({
         type: "session_file_change",
         sessionId,
@@ -28498,7 +28820,7 @@ function sendGitHeadVsWorkspaceForToolPaths(mergedPaths, sentPaths, send, cwd3,
       });
       sentPaths.add(displayPath);
     } catch (err) {
-      log2(`[Bridge service] session_file_change failed ${displayPath}: ${errorMessage(err)}`);
+      log2(`[Bridge service] Session file change failed for ${displayPath}: ${errorMessage(err)}`);
     }
   }
 }
@@ -28511,7 +28833,7 @@ function createBridgeOnSessionUpdate(opts) {
     const runId = routing.runId;
     const sessionId = routing.sessionId;
     pathTracker.onRunIdChanged(runId);
-    const cwd3 = process.cwd();
+    const cwd = getBridgeWorkspaceDirectory();
     const send = getSendSessionUpdate();
     const sentFileChangePaths = /* @__PURE__ */ new Set();
     const p = params;
@@ -28519,7 +28841,7 @@ function createBridgeOnSessionUpdate(opts) {
     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;
-    const toolPaths = isToolUpdate ? extractToolTargetDisplayPaths(params, cwd3) : [];
+    const toolPaths = isToolUpdate ? extractToolTargetDisplayPaths(params, cwd) : [];
     const toolKey = isToolUpdate ? pathTracker.resolveToolKey(params, updateKind) : "";
     if (updateKind === "tool_call") {
       pathTracker.resetToolSnapshots(toolKey);
@@ -28534,7 +28856,7 @@ function createBridgeOnSessionUpdate(opts) {
         toolKey,
         toolPaths,
         p.status,
-        cwd3,
+        cwd,
         sentFileChangePaths,
         deliver,
         runId ?? "",
@@ -28542,18 +28864,18 @@ function createBridgeOnSessionUpdate(opts) {
         log2
       );
     }
-    const diffs = extractAcpFileDiffsFromUpdate(params, cwd3);
+    const diffs = extractAcpFileDiffsFromUpdate(params, cwd);
     if (diffs.length > 0 && send && runId && sessionId) {
-      sendExtractedDiffsAsSessionFileChanges(diffs, send, cwd3, sessionId, runId, sentFileChangePaths, log2);
+      sendExtractedDiffsAsSessionFileChanges(diffs, send, cwd, sessionId, runId, sentFileChangePaths, log2);
     } else if (diffs.length > 0) {
       log2(
-        `[Bridge service] ACP file diff(s) not forwarded (${diffs.length}): session/run not wired to bridge`
+        `[Bridge service] Agent file diff(s) not forwarded (${diffs.length}): session or run not wired to the bridge.`
       );
     }
     if (isCompletedToolCallUpdate && send && runId && sessionId) {
       const acc = pathTracker.accumulatedPathsByToolKey.get(toolKey);
       const merged = [.../* @__PURE__ */ new Set([...acc ? [...acc] : [], ...toolPaths])];
-      sendGitHeadVsWorkspaceForToolPaths(merged, sentFileChangePaths, send, cwd3, sessionId, runId, log2);
+      sendGitHeadVsWorkspaceForToolPaths(merged, sentFileChangePaths, send, cwd, sessionId, runId, log2);
       pathTracker.accumulatedPathsByToolKey.delete(toolKey);
     }
     if (runId && send) {
@@ -28566,7 +28888,9 @@ function createBridgeOnSessionUpdate(opts) {
           payload: params
         });
       } catch (err) {
-        log2(`[Bridge service] session_update send failed (${updateKind}): ${errorMessage(err)}`);
+        log2(
+          `[Bridge service] Session update send failed (${formatSessionUpdateKindForLog(updateKind)}): ${errorMessage(err)}`
+        );
       }
     }
   };
@@ -28583,11 +28907,11 @@ function buildAcpSessionBridgeHooks(opts) {
 
 // src/acp/ensure-acp-client.ts
 async function ensureAcpClient(options) {
-  const { state, preferredAgentType, mode, cwd: cwd3, routing, sendSessionUpdate, sendRequest, log: log2 } = options;
-  const targetCwd = path7.resolve(
-    cwd3 != null && String(cwd3).trim() !== "" ? String(cwd3).trim() : process.cwd()
+  const { state, preferredAgentType, mode, cwd, routing, sendSessionUpdate, sendRequest, log: log2 } = options;
+  const targetCwd = path9.resolve(
+    cwd != null && String(cwd).trim() !== "" ? String(cwd).trim() : getBridgeWorkspaceDirectory()
   );
-  if (state.acpHandle && state.lastAcpCwd != null && path7.resolve(state.lastAcpCwd) !== path7.resolve(targetCwd)) {
+  if (state.acpHandle && state.lastAcpCwd != null && path9.resolve(state.lastAcpCwd) !== path9.resolve(targetCwd)) {
     try {
       state.acpHandle.disconnect();
     } catch {
@@ -28599,7 +28923,7 @@ async function ensureAcpClient(options) {
   const resolved = resolveAgentCommand(preferredAgentType);
   if (!resolved) {
     log2(
-      `[agent] No local agent type (${preferredAgentType === null ? "none" : `"${preferredAgentType}"`}). Send agentType on prompts or agent_config after identify.`
+      `[Agent] No local agent type (${preferredAgentType === null ? "none" : `"${preferredAgentType}"`}). Send agent type on prompts or agent configuration after identify.`
     );
     state.lastAcpStartError = "No agent type: ensure the app sends agentType on prompts or agent_config for this bridge.";
     return null;
@@ -28618,15 +28942,15 @@ async function ensureAcpClient(options) {
   if (!state.acpStartPromise) {
     let statOk = false;
     try {
-      const st = fs3.statSync(targetCwd);
+      const st = fs5.statSync(targetCwd);
       statOk = st.isDirectory();
       if (!statOk) {
         state.lastAcpStartError = `Agent cwd is not a directory: ${targetCwd}`;
-        log2(`[agent] ${state.lastAcpStartError}`);
+        log2(`[Agent] ${state.lastAcpStartError}`);
       }
     } catch {
       state.lastAcpStartError = `Agent cwd missing or inaccessible: ${targetCwd}`;
-      log2(`[agent] ${state.lastAcpStartError}`);
+      log2(`[Agent] ${state.lastAcpStartError}`);
     }
     if (!statOk) {
       return null;
@@ -28651,7 +28975,7 @@ async function ensureAcpClient(options) {
       return h;
     }).catch((err) => {
       state.lastAcpStartError = errorMessage(err);
-      log2(`[agent] failed to start: ${state.lastAcpStartError}`);
+      log2(`[Agent] Failed to start: ${state.lastAcpStartError}`);
       state.acpStartPromise = null;
       state.acpAgentKey = null;
       return null;
@@ -28687,10 +29011,9 @@ async function createAcpManager(options) {
       runId,
       mode,
       agentType,
-      cwd: cwd3,
+      cwd,
       sendResult,
-      sendSessionUpdate,
-      collectSessionDiffAfterTurn
+      sendSessionUpdate
     } = opts;
     const preferredForPrompt = agentType ?? backendFallbackAgentType ?? null;
     pendingCancelRunId = void 0;
@@ -28702,7 +29025,7 @@ async function createAcpManager(options) {
         state,
         preferredAgentType: preferredForPrompt,
         mode,
-        cwd: cwd3,
+        cwd,
         routing: promptRouting,
         sendSessionUpdate,
         sendRequest: sendSessionUpdate,
@@ -28743,9 +29066,9 @@ async function createAcpManager(options) {
         promptId,
         sessionId,
         runId,
+        agentCwd: cwd,
         sendResult,
         sendSessionUpdate,
-        collectSessionDiffAfterTurn,
         log: log2
       });
     }
@@ -28764,7 +29087,7 @@ async function createAcpManager(options) {
         await handle.cancel();
         return true;
       } catch (err) {
-        log2(`[agent] cancel failed: ${err instanceof Error ? err.message : String(err)}`);
+        log2(`[Agent] Cancel failed: ${err instanceof Error ? err.message : String(err)}`);
         return false;
       }
     }
@@ -28801,7 +29124,9 @@ var handleBridgeIdentified = (msg, deps) => {
       try {
         await deps.reportAutoDetectedAgents?.();
       } catch (e) {
-        deps.log(`[Bridge service] auto-detect agents failed: ${e instanceof Error ? e.message : String(e)}`);
+        deps.log(
+          `[Bridge service] Auto-detect agents failed: ${e instanceof Error ? e.message : String(e)}`
+        );
       }
     })();
   });
@@ -28809,7 +29134,9 @@ var handleBridgeIdentified = (msg, deps) => {
     try {
       deps.sendLocalSkillsReport?.();
     } catch (e) {
-      deps.log(`[Bridge service] local skills report failed: ${e instanceof Error ? e.message : String(e)}`);
+      deps.log(
+        `[Bridge service] Local skills report failed: ${e instanceof Error ? e.message : String(e)}`
+      );
     }
   });
 };
@@ -28826,12 +29153,12 @@ var handleAgentConfigMessage = (msg, deps) => {
 };
 
 // src/acp/from-bridge/handle-bridge-prompt.ts
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
 
 // src/git/bridge-queue-key.ts
-import * as path8 from "node:path";
+import * as path10 from "node:path";
 import { createHash } from "node:crypto";
 function normalizeCanonicalGitUrl(url2) {
   let s = url2.trim();
@@ -28859,13 +29186,13 @@ function canonicalUrlToRepoIdSync(url2) {
   return createHash("sha256").update(normalized).digest("hex").slice(0, 32);
 }
 function fallbackRepoIdFromPath(absPath) {
-  return createHash("sha256").update(path8.resolve(absPath)).digest("hex").slice(0, 32);
+  return createHash("sha256").update(path10.resolve(absPath)).digest("hex").slice(0, 32);
 }
 async function resolveBridgeQueueBindFields(options) {
   const { effectiveCwd, worktreePaths, primaryRepoRoots, log: log2 } = options;
-  const cwdAbs = worktreePaths.length > 0 ? path8.resolve(worktreePaths[0]) : path8.resolve(effectiveCwd);
+  const cwdAbs = worktreePaths.length > 0 ? path10.resolve(worktreePaths[0]) : path10.resolve(effectiveCwd);
   if (!primaryRepoRoots.length) {
-    log2("[Bridge service] prompt queue bind skipped: no git repo roots under cwd");
+    log2("[Bridge service] Prompt queue bind skipped: no Git repository roots under the working directory.");
     return null;
   }
   let primaryRoot = primaryRepoRoots[0];
@@ -28885,138 +29212,32 @@ async function resolveBridgeQueueBindFields(options) {
   return { canonicalQueueKey, repoId, cwdAbs };
 }
 
-// src/git/pre-turn-snapshot.ts
-import * as fs4 from "node:fs";
-import * as path9 from "node:path";
-import { execFile as execFile2 } from "node:child_process";
-import { promisify as promisify2 } from "node:util";
-var execFileAsync2 = promisify2(execFile2);
-function snapshotsDirForCwd(agentCwd) {
-  return path9.join(agentCwd, ".buildautomaton", "snapshots");
-}
-async function gitStashCreate2(repoRoot, log2) {
-  try {
-    const { stdout } = await execFileAsync2("git", ["stash", "create"], {
-      cwd: repoRoot,
-      maxBuffer: 10 * 1024 * 1024
-    });
-    return stdout.trim();
-  } catch (e) {
-    log2(`[snapshot] git stash create failed in ${repoRoot}: ${e instanceof Error ? e.message : String(e)}`);
-    return "";
-  }
-}
-async function gitRun(repoRoot, args, log2, label) {
-  try {
-    await execFileAsync2("git", args, { cwd: repoRoot, maxBuffer: 10 * 1024 * 1024 });
-    return { ok: true };
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
-    log2(`[snapshot] git ${label} failed in ${repoRoot}: ${msg}`);
-    return { ok: false, error: msg };
-  }
-}
-async function resolveSnapshotRepoRoots(options) {
-  const { worktreePaths, fallbackCwd, log: log2 } = options;
-  if (worktreePaths?.length) {
-    const uniq = [...new Set(worktreePaths.map((p) => path9.resolve(p)))];
-    return uniq;
-  }
+// src/acp/from-bridge/handle-bridge-prompt.ts
+var execFileAsync3 = promisify3(execFile3);
+async function readGitBranch(cwd) {
   try {
-    const repos = await discoverGitReposUnderRoot(fallbackCwd);
-    return repos.map((r) => r.absolutePath);
-  } catch (e) {
-    log2(`[snapshot] discover repos failed: ${e instanceof Error ? e.message : String(e)}`);
-    return [];
+    const { stdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd, maxBuffer: 64 * 1024 });
+    const b = stdout.trim();
+    return b || null;
+  } catch {
+    return null;
   }
 }
-async function capturePreTurnSnapshot(options) {
-  const { runId, repoRoots, agentCwd, log: log2 } = options;
-  if (!runId || !repoRoots.length) {
-    return { ok: false, error: "No git repos to snapshot" };
-  }
-  const repos = [];
-  for (const root of repoRoots) {
-    const stashSha = await gitStashCreate2(root, log2);
-    repos.push({ path: root, stashSha });
-  }
-  const dir = snapshotsDirForCwd(agentCwd);
-  try {
-    fs4.mkdirSync(dir, { recursive: true });
-  } catch (e) {
-    return { ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-  const payload = {
-    runId,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    repos
-  };
-  const filePath = path9.join(dir, `${runId}.json`);
-  try {
-    fs4.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
-  } catch (e) {
-    return { ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-  log2(`[snapshot] Saved pre-turn snapshot ${runId.slice(0, 8)}\u2026 (${repos.length} repo(s)) \u2192 ${filePath}`);
-  return { ok: true, filePath, repos };
-}
-async function applyPreTurnSnapshot(filePath, log2) {
-  let data;
-  try {
-    const raw = fs4.readFileSync(filePath, "utf8");
-    data = JSON.parse(raw);
-  } catch (e) {
-    return { ok: false, error: e instanceof Error ? e.message : String(e) };
-  }
-  if (!Array.isArray(data.repos)) {
-    return { ok: false, error: "Invalid snapshot file" };
-  }
-  for (const r of data.repos) {
-    if (!r.path) continue;
-    const reset = await gitRun(r.path, ["reset", "--hard", "HEAD"], log2, "reset --hard");
-    if (!reset.ok) return reset;
-    const clean = await gitRun(r.path, ["clean", "-fd"], log2, "clean -fd");
-    if (!clean.ok) return clean;
-    if (r.stashSha) {
-      const ap = await gitRun(r.path, ["stash", "apply", r.stashSha], log2, "stash apply");
-      if (!ap.ok) return ap;
-    }
-  }
-  log2(`[snapshot] Restored pre-turn state for ${data.runId.slice(0, 8)}\u2026`);
-  return { ok: true };
-}
-function snapshotFilePath(agentCwd, runId) {
-  return path9.join(snapshotsDirForCwd(agentCwd), `${runId}.json`);
-}
-
-// src/acp/from-bridge/handle-bridge-prompt.ts
-var execFileAsync3 = promisify3(execFile3);
-async function readGitBranch(cwd3) {
-  try {
-    const { stdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd: cwd3, maxBuffer: 64 * 1024 });
-    const b = stdout.trim();
-    return b || null;
-  } catch {
-    return null;
-  }
-}
-function handleBridgePrompt(msg, deps) {
-  const { getWs, log: log2, acpManager, sessionWorktreeManager } = deps;
-  const rawPrompt = msg.prompt;
-  const promptText = typeof rawPrompt === "string" ? rawPrompt : rawPrompt != null ? String(rawPrompt) : "";
-  if (!promptText.trim()) {
-    log2(
-      `[Bridge service] prompt ignored: empty or missing prompt field (sessionId=${typeof msg.sessionId === "string" ? msg.sessionId.slice(0, 8) : "\u2014"}\u2026 runId=${typeof msg.runId === "string" ? msg.runId.slice(0, 8) : "\u2014"}\u2026)`
-    );
-    return;
+function handleBridgePrompt(msg, deps) {
+  const { getWs, log: log2, acpManager, sessionWorktreeManager } = deps;
+  const rawPrompt = msg.prompt;
+  const promptText = typeof rawPrompt === "string" ? rawPrompt : rawPrompt != null ? String(rawPrompt) : "";
+  if (!promptText.trim()) {
+    log2(
+      `[Bridge service] Prompt ignored: empty or missing prompt text (session ${typeof msg.sessionId === "string" ? msg.sessionId.slice(0, 8) : "\u2014"}\u2026, run ${typeof msg.runId === "string" ? msg.runId.slice(0, 8) : "\u2014"}\u2026).`
+    );
+    return;
   }
   const sessionId = msg.sessionId;
   const isNewSession = msg.isNewSession === true;
   const sessionWorktreesEnabled = msg.sessionWorktreesEnabled === true;
   const agentType = typeof msg.agentType === "string" && msg.agentType.trim() ? msg.agentType.trim() : void 0;
   const runId = typeof msg.runId === "string" ? msg.runId : void 0;
-  const sessionGitQueueStart = msg.sessionGitQueueStart === true;
-  const collectSessionDiffAfterTurn = msg.collectSessionDiffAfterTurn === true;
   const sendResult = (result) => {
     const s = getWs();
     if (s) sendWsMessage(s, result);
@@ -29024,7 +29245,7 @@ function handleBridgePrompt(msg, deps) {
   const sendSessionUpdate = (payload) => {
     const s = getWs();
     if (!s) {
-      log2("[Bridge service] session_update not sent: not connected");
+      log2("[Bridge service] Session update not sent: not connected to the bridge.");
       return;
     }
     const p = payload;
@@ -29032,7 +29253,7 @@ function handleBridgePrompt(msg, deps) {
   };
   async function preambleAndPrompt(resolvedCwd) {
     const s = getWs();
-    const effectiveCwd = path10.resolve(resolvedCwd ?? process.cwd());
+    const effectiveCwd = path11.resolve(resolvedCwd ?? getBridgeWorkspaceDirectory());
     const worktreePaths = sessionWorktreeManager.getWorktreePathsForSession(sessionId) ?? [];
     const repoRoots = await resolveSnapshotRepoRoots({
       worktreePaths,
@@ -29065,9 +29286,6 @@ function handleBridgePrompt(msg, deps) {
         agentUsesWorktree: sessionWorktreeManager.usesWorktreeSession(sessionId)
       });
     }
-    if (sessionGitQueueStart && sessionId && repoRoots.length > 0) {
-      await captureSessionGitBoundary({ sessionId, repoRoots, log: log2 });
-    }
     if (s && sessionId && runId) {
       const cap = repoRoots.length > 0 ? await capturePreTurnSnapshot({ runId, repoRoots, agentCwd: effectiveCwd, log: log2 }) : { ok: false, error: "No git repos" };
       sendWsMessage(s, {
@@ -29086,12 +29304,11 @@ function handleBridgePrompt(msg, deps) {
       agentType,
       cwd: effectiveCwd,
       sendResult,
-      sendSessionUpdate,
-      collectSessionDiffAfterTurn
+      sendSessionUpdate
     });
   }
-  void sessionWorktreeManager.resolveCwdForPrompt(sessionId, { isNewSession, sessionWorktreesEnabled }).then((cwd3) => preambleAndPrompt(cwd3)).catch((err) => {
-    log2(`[agent] worktree resolve failed: ${err instanceof Error ? err.message : String(err)}`);
+  void sessionWorktreeManager.resolveCwdForPrompt(sessionId, { isNewSession, sessionWorktreesEnabled }).then((cwd) => preambleAndPrompt(cwd)).catch((err) => {
+    log2(`[Agent] Worktree resolve failed: ${err instanceof Error ? err.message : String(err)}`);
     void preambleAndPrompt(void 0);
   });
 }
@@ -29108,7 +29325,7 @@ function handleBridgeCancelRun(msg, { log: log2, acpManager }) {
   void acpManager.cancelRun(runId).then((sent) => {
     if (!sent) {
       log2(
-        `[agent] cancel ignored for run ${runId.slice(0, 8)}\u2026 (no active run or cancel not available)`
+        `[Agent] Cancel ignored for run ${runId.slice(0, 8)}\u2026 (no active run or cancel not available).`
       );
     }
   });
@@ -29136,7 +29353,7 @@ function handleSkillCall(msg, socket, log2) {
     sendWsMessage(socket, { type: "skill_result", id: msg.id, result });
   }).catch((err) => {
     sendWsMessage(socket, { type: "skill_result", id: msg.id, error: String(err) });
-    log2(`[Bridge service] skill_call failed (${msg.skillId}/${msg.operationId}): ${err}`);
+    log2(`[Bridge service] Skill invocation failed (${msg.skillId}/${msg.operationId}): ${err}`);
   });
 }
 
@@ -29153,36 +29370,35 @@ var handleSkillCallMessage = (msg, { getWs, log: log2 }) => {
 };
 
 // src/files/list-dir.ts
-import fs5 from "node:fs";
-import path12 from "node:path";
+import fs6 from "node:fs";
+import path13 from "node:path";
 
 // src/files/ensure-under-cwd.ts
-import path11 from "node:path";
-function ensureUnderCwd(relativePath, cwd3 = process.cwd()) {
-  const normalized = path11.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path11.resolve(cwd3, normalized);
-  if (!resolved.startsWith(cwd3 + path11.sep) && resolved !== cwd3) {
+import path12 from "node:path";
+function ensureUnderCwd(relativePath, cwd = getBridgeWorkspaceDirectory()) {
+  const normalized = path12.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path12.resolve(cwd, normalized);
+  if (!resolved.startsWith(cwd + path12.sep) && resolved !== cwd) {
     return null;
   }
   return resolved;
 }
 
 // src/files/list-dir.ts
-var cwd = process.cwd();
 function listDir(relativePath) {
-  const resolved = ensureUnderCwd(relativePath || ".", cwd);
+  const resolved = ensureUnderCwd(relativePath || ".", getBridgeWorkspaceDirectory());
   if (!resolved) {
     return { error: "Path is outside working directory" };
   }
   try {
-    const names = fs5.readdirSync(resolved, { withFileTypes: true });
+    const names = fs6.readdirSync(resolved, { withFileTypes: true });
     const entries = names.filter((d) => !d.name.startsWith(".")).map((d) => {
-      const entryPath = path12.join(relativePath || ".", d.name).replace(/\\/g, "/");
-      const fullPath = path12.join(resolved, d.name);
+      const entryPath = path13.join(relativePath || ".", d.name).replace(/\\/g, "/");
+      const fullPath = path13.join(resolved, d.name);
       let isDir = d.isDirectory();
       if (d.isSymbolicLink()) {
         try {
-          const targetStat = fs5.statSync(fullPath);
+          const targetStat = fs6.statSync(fullPath);
           isDir = targetStat.isDirectory();
         } catch {
           isDir = false;
@@ -29206,26 +29422,25 @@ function listDir(relativePath) {
 }
 
 // src/files/read-file.ts
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 import { StringDecoder } from "node:string_decoder";
-var cwd2 = process.cwd();
 function resolveFilePath(relativePath) {
-  const resolved = ensureUnderCwd(relativePath, cwd2);
+  const resolved = ensureUnderCwd(relativePath, getBridgeWorkspaceDirectory());
   if (!resolved) return { error: "Path is outside working directory" };
   let real;
   try {
-    real = fs6.realpathSync(resolved);
+    real = fs7.realpathSync(resolved);
   } catch {
     real = resolved;
   }
-  const stat4 = fs6.statSync(real);
-  if (!stat4.isFile()) return { error: "Not a file" };
+  const stat = fs7.statSync(real);
+  if (!stat.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 = fs6.statSync(filePath).size;
-  const fd = fs6.openSync(filePath, "r");
+  const fileSize = fs7.statSync(filePath).size;
+  const fd = fs7.openSync(filePath, "r");
   const bufSize = 64 * 1024;
   const buf = Buffer.alloc(bufSize);
   const decoder = new StringDecoder("utf8");
@@ -29238,7 +29453,7 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
   let line0Accum = "";
   try {
     let bytesRead;
-    while (!done && (bytesRead = fs6.readSync(fd, buf, 0, bufSize, null)) > 0) {
+    while (!done && (bytesRead = fs7.readSync(fd, buf, 0, bufSize, null)) > 0) {
       const text = partial2 + decoder.write(buf.subarray(0, bytesRead));
       partial2 = "";
       let lineStart = 0;
@@ -29373,7 +29588,7 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
     }
     return { content: resultLines.join("\n"), size: fileSize };
   } finally {
-    fs6.closeSync(fd);
+    fs7.closeSync(fd);
   }
 }
 function readFile(relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE) {
@@ -29384,26 +29599,26 @@ function readFile(relativePath, startLine, endLine, lineOffset, lineChunkSize =
     if (hasRange) {
       return readFileRange(result, startLine, endLine, lineOffset, lineChunkSize);
     }
-    const stat4 = fs6.statSync(result);
-    const raw = fs6.readFileSync(result, "utf8");
+    const stat = fs7.statSync(result);
+    const raw = fs7.readFileSync(result, "utf8");
     const lines = raw.split(/\r?\n/);
-    return { content: raw, totalLines: lines.length, size: stat4.size };
+    return { content: raw, totalLines: lines.length, size: stat.size };
   } catch (err) {
     return { error: err instanceof Error ? err.message : String(err) };
   }
 }
 
 // src/files/file-index.ts
-import fs7 from "node:fs";
-import path13 from "node:path";
+import fs8 from "node:fs";
+import path14 from "node:path";
 import os2 from "node:os";
 import crypto2 from "node:crypto";
-var INDEX_DIR = path13.join(os2.homedir(), ".buildautomaton");
+var INDEX_DIR = path14.join(os2.homedir(), ".buildautomaton");
 var HASH_LEN = 16;
 var INDEX_VERSION = 2;
-function getIndexPath(cwd3) {
-  const hash = crypto2.createHash("sha256").update(cwd3).digest("hex").slice(0, HASH_LEN);
-  return path13.join(INDEX_DIR, `.file-index-${hash}.json`);
+function getIndexPath(cwd) {
+  const hash = crypto2.createHash("sha256").update(cwd).digest("hex").slice(0, HASH_LEN);
+  return path14.join(INDEX_DIR, `.file-index-${hash}.json`);
 }
 function getTrigrams(s) {
   const lower = s.toLowerCase();
@@ -29441,29 +29656,29 @@ function binarySearch(arr, x) {
 function walkDir(dir, baseDir, out) {
   let names;
   try {
-    names = fs7.readdirSync(dir);
+    names = fs8.readdirSync(dir);
   } catch {
     return;
   }
   for (const name of names) {
     if (name.startsWith(".")) continue;
-    const full = path13.join(dir, name);
-    let stat4;
+    const full = path14.join(dir, name);
+    let stat;
     try {
-      stat4 = fs7.statSync(full);
+      stat = fs8.statSync(full);
     } catch {
       continue;
     }
-    const relative6 = path13.relative(baseDir, full).replace(/\\/g, "/");
-    if (stat4.isDirectory()) {
+    const relative4 = path14.relative(baseDir, full).replace(/\\/g, "/");
+    if (stat.isDirectory()) {
       walkDir(full, baseDir, out);
-    } else if (stat4.isFile()) {
-      out.push(relative6);
+    } else if (stat.isFile()) {
+      out.push(relative4);
     }
   }
 }
-function buildFileIndex(cwd3) {
-  const resolved = path13.resolve(cwd3);
+function buildFileIndex(cwd) {
+  const resolved = path14.resolve(cwd);
   const paths = [];
   walkDir(resolved, resolved, paths);
   paths.sort((a, b) => a.localeCompare(b, void 0, { sensitivity: "base" }));
@@ -29481,18 +29696,18 @@ function buildFileIndex(cwd3) {
   const data = { version: INDEX_VERSION, paths, trigramIndex };
   const indexPath = getIndexPath(resolved);
   try {
-    if (!fs7.existsSync(INDEX_DIR)) fs7.mkdirSync(INDEX_DIR, { recursive: true });
-    fs7.writeFileSync(indexPath, JSON.stringify(data), "utf8");
+    if (!fs8.existsSync(INDEX_DIR)) fs8.mkdirSync(INDEX_DIR, { recursive: true });
+    fs8.writeFileSync(indexPath, JSON.stringify(data), "utf8");
   } catch (e) {
     console.error("[file-index] Failed to write index:", e);
   }
   return data;
 }
-function loadFileIndex(cwd3) {
-  const resolved = path13.resolve(cwd3);
+function loadFileIndex(cwd) {
+  const resolved = path14.resolve(cwd);
   const indexPath = getIndexPath(resolved);
   try {
-    const raw = fs7.readFileSync(indexPath, "utf8");
+    const raw = fs8.readFileSync(indexPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed !== null && typeof parsed === "object" && Array.isArray(parsed.paths)) {
       const obj = parsed;
@@ -29509,8 +29724,8 @@ function loadFileIndex(cwd3) {
     return null;
   }
 }
-function ensureFileIndex(cwd3) {
-  const resolved = path13.resolve(cwd3);
+function ensureFileIndex(cwd) {
+  const resolved = path14.resolve(cwd);
   const cached2 = loadFileIndex(resolved);
   if (cached2 !== null) return { data: cached2, fromCache: true };
   const data = buildFileIndex(resolved);
@@ -29548,8 +29763,8 @@ function searchFileIndex(index, query, limit = 100) {
 var SEARCH_LIMIT = 100;
 function handleFileBrowserSearch(msg, socket) {
   const q = typeof msg.q === "string" ? msg.q : "";
-  const cwd3 = process.cwd();
-  const index = loadFileIndex(cwd3);
+  const cwd = getBridgeWorkspaceDirectory();
+  const index = loadFileIndex(cwd);
   if (index === null) {
     sendWsMessage(socket, {
       type: "file_browser_search_response",
@@ -29570,7 +29785,7 @@ function handleFileBrowserSearch(msg, socket) {
 function triggerFileIndexBuild() {
   setImmediate(() => {
     try {
-      ensureFileIndex(process.cwd());
+      ensureFileIndex(getBridgeWorkspaceDirectory());
     } catch (e) {
       console.error("[file-index] Background build failed:", e);
     }
@@ -29631,30 +29846,30 @@ function handleFileBrowserSearchMessage(msg, { getWs }) {
 }
 
 // src/skills/discover-local-agent-skills.ts
-import fs8 from "node:fs";
-import path14 from "node:path";
+import fs9 from "node:fs";
+import path15 from "node:path";
 var SKILL_DISCOVERY_ROOTS = [".agents/skills", ".claude/skills", ".cursor/skills", "skills"];
-function discoverLocalSkills(cwd3) {
+function discoverLocalSkills(cwd) {
   const out = [];
   const seenKeys = /* @__PURE__ */ new Set();
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path14.join(cwd3, rel);
-    if (!fs8.existsSync(base) || !fs8.statSync(base).isDirectory()) continue;
+    const base = path15.join(cwd, rel);
+    if (!fs9.existsSync(base) || !fs9.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs8.readdirSync(base);
+      entries = fs9.readdirSync(base);
     } catch {
       continue;
     }
     for (const name of entries) {
-      const dir = path14.join(base, name);
+      const dir = path15.join(base, name);
       try {
-        if (!fs8.statSync(dir).isDirectory()) continue;
+        if (!fs9.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      const skillMd = path14.join(dir, "SKILL.md");
-      if (!fs8.existsSync(skillMd)) continue;
+      const skillMd = path15.join(dir, "SKILL.md");
+      if (!fs9.existsSync(skillMd)) continue;
       const key = `${rel}/${name}`;
       if (seenKeys.has(key)) continue;
       seenKeys.add(key);
@@ -29663,26 +29878,26 @@ function discoverLocalSkills(cwd3) {
   }
   return out;
 }
-function discoverSkillLayoutRoots(cwd3) {
+function discoverSkillLayoutRoots(cwd) {
   const roots = [];
   for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path14.join(cwd3, rel);
-    if (!fs8.existsSync(base) || !fs8.statSync(base).isDirectory()) continue;
+    const base = path15.join(cwd, rel);
+    if (!fs9.existsSync(base) || !fs9.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs8.readdirSync(base);
+      entries = fs9.readdirSync(base);
     } catch {
       continue;
     }
     const skills2 = [];
     for (const name of entries) {
-      const dir = path14.join(base, name);
+      const dir = path15.join(base, name);
       try {
-        if (!fs8.statSync(dir).isDirectory()) continue;
+        if (!fs9.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      if (!fs8.existsSync(path14.join(dir, "SKILL.md"))) continue;
+      if (!fs9.existsSync(path15.join(dir, "SKILL.md"))) continue;
       const relPath = `${rel}/${name}`.replace(/\\/g, "/");
       skills2.push({ name, relPath });
     }
@@ -29697,14 +29912,14 @@ function discoverSkillLayoutRoots(cwd3) {
 function handleSkillLayoutRequest(msg, deps) {
   const socket = deps.getWs();
   const id = typeof msg.id === "string" ? msg.id : "";
-  const roots = discoverSkillLayoutRoots(process.cwd());
+  const roots = discoverSkillLayoutRoots(getBridgeWorkspaceDirectory());
   socket?.send(JSON.stringify({ type: "skill_layout_response", id, roots }));
 }
 
 // src/skills/install-remote-skills.ts
-import fs9 from "node:fs";
-import path15 from "node:path";
-function installRemoteSkills(cwd3, targetDir, items) {
+import fs10 from "node:fs";
+import path16 from "node:path";
+function installRemoteSkills(cwd, targetDir, items) {
   const installed = [];
   if (!Array.isArray(items)) {
     return { success: false, error: "Invalid items" };
@@ -29714,15 +29929,15 @@ function installRemoteSkills(cwd3, targetDir, items) {
       if (typeof item.sourceId !== "string" || typeof item.skillName !== "string" || typeof item.versionHash !== "string" || !Array.isArray(item.files)) {
         continue;
       }
-      const skillDir = path15.join(cwd3, targetDir, item.skillName);
+      const skillDir = path16.join(cwd, targetDir, item.skillName);
       for (const f of item.files) {
         if (typeof f.path !== "string" || !f.text && !f.base64) continue;
-        const dest = path15.join(skillDir, f.path);
-        fs9.mkdirSync(path15.dirname(dest), { recursive: true });
+        const dest = path16.join(skillDir, f.path);
+        fs10.mkdirSync(path16.dirname(dest), { recursive: true });
         if (f.text !== void 0) {
-          fs9.writeFileSync(dest, f.text, "utf8");
+          fs10.writeFileSync(dest, f.text, "utf8");
         } else if (f.base64) {
-          fs9.writeFileSync(dest, Buffer.from(f.base64, "base64"));
+          fs10.writeFileSync(dest, Buffer.from(f.base64, "base64"));
         }
       }
       installed.push({
@@ -29743,11 +29958,11 @@ var handleInstallSkillsMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const targetDir = typeof msg.targetDir === "string" && msg.targetDir.trim() ? msg.targetDir.trim() : ".agents/skills";
   const rawItems = msg.items;
-  const cwd3 = process.cwd();
-  const result = installRemoteSkills(cwd3, targetDir, rawItems);
+  const cwd = getBridgeWorkspaceDirectory();
+  const result = installRemoteSkills(cwd, targetDir, rawItems);
   if (!result.success) {
     const err = result.error ?? "Invalid items";
-    deps.log(`[Bridge service] install_skills failed: ${err}`);
+    deps.log(`[Bridge service] Install skills failed: ${err}`);
     socket?.send(JSON.stringify({ type: "install_skills_result", id, success: false, error: err }));
     return;
   }
@@ -29816,8 +30031,7 @@ var handleSessionDiscardedMessage = (msg, deps) => {
 };
 
 // src/bridge/routing/handlers/revert-turn-snapshot.ts
-import * as fs10 from "node:fs";
-import * as path16 from "node:path";
+import * as fs11 from "node:fs";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
@@ -29827,9 +30041,9 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
   void (async () => {
     const s = getWs();
     if (!s) return;
-    const agentBase = sessionWorktreeManager.getAgentCwdForSession(sessionId) ?? path16.resolve(process.cwd());
+    const agentBase = sessionWorktreeManager.getAgentCwdForSession(sessionId) ?? getBridgeWorkspaceDirectory();
     const file2 = snapshotFilePath(agentBase, turnId);
-    if (!fs10.existsSync(file2)) {
+    if (!fs11.existsSync(file2)) {
       sendWsMessage(s, {
         type: "revert_turn_snapshot_result",
         id,
@@ -29956,7 +30170,7 @@ import * as path20 from "node:path";
 import os4 from "node:os";
 
 // src/worktrees/prepare-new-session-worktrees.ts
-import * as fs12 from "node:fs";
+import * as fs13 from "node:fs";
 import * as path18 from "node:path";
 
 // src/git/worktree-add.ts
@@ -29966,7 +30180,7 @@ async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch) {
 }
 
 // src/worktrees/worktree-layout-file.ts
-import * as fs11 from "node:fs";
+import * as fs12 from "node:fs";
 import * as path17 from "node:path";
 import os3 from "node:os";
 var LAYOUT_FILENAME = "worktree-launcher-layout.json";
@@ -29983,8 +30197,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: [] };
@@ -29993,8 +30207,8 @@ function loadWorktreeLayout() {
 function saveWorktreeLayout(layout) {
   try {
     const dir = path17.dirname(defaultWorktreeLayoutPath());
-    fs11.mkdirSync(dir, { recursive: true });
-    fs11.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
+    fs12.mkdirSync(dir, { recursive: true });
+    fs12.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
   } catch {
   }
 }
@@ -30026,25 +30240,25 @@ async function prepareNewSessionWorktrees(options) {
   const agentMirrorRoot = path18.join(rootAbs, cwdKey);
   const repos = await discoverGitReposUnderRoot(launcherResolved);
   if (repos.length === 0) {
-    log2("[worktrees] No git repos under launcher cwd; skipping worktree creation");
+    log2("[worktrees] No Git repositories under launcher working directory; skipping worktree creation.");
     return null;
   }
   const branch = `session-${sessionId}`;
   const worktreePaths = [];
-  fs12.mkdirSync(agentMirrorRoot, { recursive: true });
+  fs13.mkdirSync(agentMirrorRoot, { recursive: true });
   for (const repo of repos) {
     let rel = path18.relative(launcherResolved, repo.absolutePath);
     if (rel.startsWith("..") || path18.isAbsolute(rel)) continue;
     const relNorm = rel === "" ? "." : rel;
     const wtPath = path18.join(agentMirrorRoot, relNorm, sessionId);
-    fs12.mkdirSync(path18.dirname(wtPath), { recursive: true });
+    fs13.mkdirSync(path18.dirname(wtPath), { recursive: true });
     try {
       await gitWorktreeAddBranch(repo.absolutePath, wtPath, branch);
-      log2(`[worktrees] Added worktree ${wtPath} (branch ${branch})`);
+      log2(`[worktrees] Added worktree ${wtPath} (branch ${branch}).`);
       worktreePaths.push(wtPath);
     } catch (e) {
       log2(
-        `[worktrees] worktree add failed for ${repo.absolutePath}: ${e instanceof Error ? e.message : String(e)}`
+        `[worktrees] Worktree add failed for ${repo.absolutePath}: ${e instanceof Error ? e.message : String(e)}`
       );
     }
   }
@@ -30066,24 +30280,26 @@ async function renameSessionWorktreeBranches(paths, newBranch, log2) {
       await gitRenameCurrentBranch(wt, safe);
       log2(`[worktrees] Renamed branch in ${wt} \u2192 ${safe}`);
     } catch (e) {
-      log2(`[worktrees] branch rename failed in ${wt}: ${e instanceof Error ? e.message : String(e)}`);
+      log2(
+        `[worktrees] Branch rename failed in ${wt}: ${e instanceof Error ? e.message : String(e)}`
+      );
     }
   }
 }
 
 // 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 fs14 from "node:fs";
 import * as path19 from "node:path";
 function resolveMainRepoFromWorktreeGitFile(wt) {
   const gitDirFile = path19.join(wt, ".git");
-  if (!fs13.existsSync(gitDirFile) || !fs13.statSync(gitDirFile).isFile()) return "";
-  const first2 = fs13.readFileSync(gitDirFile, "utf8").trim();
+  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 = path19.resolve(wt, m[1].trim());
@@ -30097,7 +30313,7 @@ async function gitWorktreeRemoveForce(worktreePath) {
   if (mainRepo) {
     await simpleGit(mainRepo).raw(["worktree", "remove", "--force", worktreePath]);
   } else {
-    fs14.rmSync(worktreePath, { recursive: true, force: true });
+    fs15.rmSync(worktreePath, { recursive: true, force: true });
   }
 }
 
@@ -30108,9 +30324,9 @@ async function removeSessionWorktrees(paths, log2) {
       await gitWorktreeRemoveForce(wt);
       log2(`[worktrees] Removed worktree ${wt}`);
     } catch (e) {
-      log2(`[worktrees] remove failed for ${wt}: ${e instanceof Error ? e.message : String(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 {
       }
     }
@@ -30174,7 +30390,7 @@ var SessionWorktreeManager = class {
     return this.bridgeWantsWorktrees;
   }
   /**
-   * Returns cwd for the agent (mirror of launcher tree), or undefined to use process.cwd().
+   * Returns cwd for the agent (mirror of launcher tree), or undefined to use the bridge workspace directory.
    */
   async resolveCwdForPrompt(sessionId, opts) {
     if (!sessionId || !this.effective() || !opts.sessionWorktreesEnabled) {
@@ -30187,7 +30403,7 @@ var SessionWorktreeManager = class {
     }
     const prep = await prepareNewSessionWorktrees({
       rootAbs: this.rootAbs,
-      launcherCwd: process.cwd(),
+      launcherCwd: getBridgeWorkspaceDirectory(),
       sessionId,
       layout: this.layout,
       log: this.log
@@ -30227,7 +30443,7 @@ var SessionWorktreeManager = class {
   }
   async commitSession(params) {
     const paths = this.sessionPaths.get(params.sessionId);
-    const targets = paths?.length ? paths : [process.cwd()];
+    const targets = paths?.length ? paths : [getBridgeWorkspaceDirectory()];
     return commitSessionWorktrees({
       paths: targets,
       branch: params.branch,
@@ -30268,1700 +30484,8 @@ async function refreshBridgeTokens(params) {
 }
 
 // src/files/watch-file-index.ts
+import { watch } from "node:fs";
 import path21 from "node:path";
-
-// ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
-import { stat as statcb } from "fs";
-import { stat as stat3, readdir as readdir2 } from "fs/promises";
-import { EventEmitter as EventEmitter2 } from "events";
-import * as sysPath2 from "path";
-
-// ../../node_modules/.pnpm/readdirp@4.1.2/node_modules/readdirp/esm/index.js
-import { stat, lstat, readdir, realpath } from "node:fs/promises";
-import { Readable as Readable2 } from "node:stream";
-import { resolve as presolve, relative as prelative, join as pjoin, sep as psep } from "node:path";
-var EntryTypes = {
-  FILE_TYPE: "files",
-  DIR_TYPE: "directories",
-  FILE_DIR_TYPE: "files_directories",
-  EVERYTHING_TYPE: "all"
-};
-var defaultOptions2 = {
-  root: ".",
-  fileFilter: (_entryInfo) => true,
-  directoryFilter: (_entryInfo) => true,
-  type: EntryTypes.FILE_TYPE,
-  lstat: false,
-  depth: 2147483648,
-  alwaysStat: false,
-  highWaterMark: 4096
-};
-Object.freeze(defaultOptions2);
-var RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
-var NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
-var ALL_TYPES = [
-  EntryTypes.DIR_TYPE,
-  EntryTypes.EVERYTHING_TYPE,
-  EntryTypes.FILE_DIR_TYPE,
-  EntryTypes.FILE_TYPE
-];
-var DIR_TYPES = /* @__PURE__ */ new Set([
-  EntryTypes.DIR_TYPE,
-  EntryTypes.EVERYTHING_TYPE,
-  EntryTypes.FILE_DIR_TYPE
-]);
-var FILE_TYPES = /* @__PURE__ */ new Set([
-  EntryTypes.EVERYTHING_TYPE,
-  EntryTypes.FILE_DIR_TYPE,
-  EntryTypes.FILE_TYPE
-]);
-var isNormalFlowError = (error40) => NORMAL_FLOW_ERRORS.has(error40.code);
-var wantBigintFsStats = process.platform === "win32";
-var emptyFn = (_entryInfo) => true;
-var normalizeFilter = (filter) => {
-  if (filter === void 0)
-    return emptyFn;
-  if (typeof filter === "function")
-    return filter;
-  if (typeof filter === "string") {
-    const fl = filter.trim();
-    return (entry) => entry.basename === fl;
-  }
-  if (Array.isArray(filter)) {
-    const trItems = filter.map((item) => item.trim());
-    return (entry) => trItems.some((f) => entry.basename === f);
-  }
-  return emptyFn;
-};
-var ReaddirpStream = class extends Readable2 {
-  constructor(options = {}) {
-    super({
-      objectMode: true,
-      autoDestroy: true,
-      highWaterMark: options.highWaterMark
-    });
-    const opts = { ...defaultOptions2, ...options };
-    const { root, type } = opts;
-    this._fileFilter = normalizeFilter(opts.fileFilter);
-    this._directoryFilter = normalizeFilter(opts.directoryFilter);
-    const statMethod = opts.lstat ? lstat : stat;
-    if (wantBigintFsStats) {
-      this._stat = (path24) => statMethod(path24, { bigint: true });
-    } else {
-      this._stat = statMethod;
-    }
-    this._maxDepth = opts.depth ?? defaultOptions2.depth;
-    this._wantsDir = type ? DIR_TYPES.has(type) : false;
-    this._wantsFile = type ? FILE_TYPES.has(type) : false;
-    this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
-    this._root = presolve(root);
-    this._isDirent = !opts.alwaysStat;
-    this._statsProp = this._isDirent ? "dirent" : "stats";
-    this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
-    this.parents = [this._exploreDir(root, 1)];
-    this.reading = false;
-    this.parent = void 0;
-  }
-  async _read(batch) {
-    if (this.reading)
-      return;
-    this.reading = true;
-    try {
-      while (!this.destroyed && batch > 0) {
-        const par = this.parent;
-        const fil = par && par.files;
-        if (fil && fil.length > 0) {
-          const { path: path24, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path24));
-          const awaited = await Promise.all(slice);
-          for (const entry of awaited) {
-            if (!entry)
-              continue;
-            if (this.destroyed)
-              return;
-            const entryType = await this._getEntryType(entry);
-            if (entryType === "directory" && this._directoryFilter(entry)) {
-              if (depth <= this._maxDepth) {
-                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
-              }
-              if (this._wantsDir) {
-                this.push(entry);
-                batch--;
-              }
-            } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
-              if (this._wantsFile) {
-                this.push(entry);
-                batch--;
-              }
-            }
-          }
-        } else {
-          const parent = this.parents.pop();
-          if (!parent) {
-            this.push(null);
-            break;
-          }
-          this.parent = await parent;
-          if (this.destroyed)
-            return;
-        }
-      }
-    } catch (error40) {
-      this.destroy(error40);
-    } finally {
-      this.reading = false;
-    }
-  }
-  async _exploreDir(path24, depth) {
-    let files;
-    try {
-      files = await readdir(path24, this._rdOptions);
-    } catch (error40) {
-      this._onError(error40);
-    }
-    return { files, depth, path: path24 };
-  }
-  async _formatEntry(dirent, path24) {
-    let entry;
-    const basename6 = this._isDirent ? dirent.name : dirent;
-    try {
-      const fullPath = presolve(pjoin(path24, basename6));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename6 };
-      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
-    } catch (err) {
-      this._onError(err);
-      return;
-    }
-    return entry;
-  }
-  _onError(err) {
-    if (isNormalFlowError(err) && !this.destroyed) {
-      this.emit("warn", err);
-    } else {
-      this.destroy(err);
-    }
-  }
-  async _getEntryType(entry) {
-    if (!entry && this._statsProp in entry) {
-      return "";
-    }
-    const stats = entry[this._statsProp];
-    if (stats.isFile())
-      return "file";
-    if (stats.isDirectory())
-      return "directory";
-    if (stats && stats.isSymbolicLink()) {
-      const full = entry.fullPath;
-      try {
-        const entryRealPath = await realpath(full);
-        const entryRealPathStats = await lstat(entryRealPath);
-        if (entryRealPathStats.isFile()) {
-          return "file";
-        }
-        if (entryRealPathStats.isDirectory()) {
-          const len = entryRealPath.length;
-          if (full.startsWith(entryRealPath) && full.substr(len, 1) === psep) {
-            const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
-            recursiveError.code = RECURSIVE_ERROR_CODE;
-            return this._onError(recursiveError);
-          }
-          return "directory";
-        }
-      } catch (error40) {
-        this._onError(error40);
-        return "";
-      }
-    }
-  }
-  _includeAsFile(entry) {
-    const stats = entry && entry[this._statsProp];
-    return stats && this._wantsEverything && !stats.isDirectory();
-  }
-};
-function readdirp(root, options = {}) {
-  let type = options.entryType || options.type;
-  if (type === "both")
-    type = EntryTypes.FILE_DIR_TYPE;
-  if (type)
-    options.type = type;
-  if (!root) {
-    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
-  } else if (typeof root !== "string") {
-    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
-  } else if (type && !ALL_TYPES.includes(type)) {
-    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
-  }
-  options.root = root;
-  return new ReaddirpStream(options);
-}
-
-// ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/handler.js
-import { watchFile, unwatchFile, watch as fs_watch } from "fs";
-import { open, stat as stat2, lstat as lstat2, realpath as fsrealpath } from "fs/promises";
-import * as sysPath from "path";
-import { type as osType } from "os";
-var STR_DATA = "data";
-var STR_END = "end";
-var STR_CLOSE = "close";
-var EMPTY_FN = () => {
-};
-var pl = process.platform;
-var isWindows = pl === "win32";
-var isMacos = pl === "darwin";
-var isLinux = pl === "linux";
-var isFreeBSD = pl === "freebsd";
-var isIBMi = osType() === "OS400";
-var EVENTS = {
-  ALL: "all",
-  READY: "ready",
-  ADD: "add",
-  CHANGE: "change",
-  ADD_DIR: "addDir",
-  UNLINK: "unlink",
-  UNLINK_DIR: "unlinkDir",
-  RAW: "raw",
-  ERROR: "error"
-};
-var EV = EVENTS;
-var THROTTLE_MODE_WATCH = "watch";
-var statMethods = { lstat: lstat2, stat: stat2 };
-var KEY_LISTENERS = "listeners";
-var KEY_ERR = "errHandlers";
-var KEY_RAW = "rawEmitters";
-var HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
-var binaryExtensions = /* @__PURE__ */ new Set([
-  "3dm",
-  "3ds",
-  "3g2",
-  "3gp",
-  "7z",
-  "a",
-  "aac",
-  "adp",
-  "afdesign",
-  "afphoto",
-  "afpub",
-  "ai",
-  "aif",
-  "aiff",
-  "alz",
-  "ape",
-  "apk",
-  "appimage",
-  "ar",
-  "arj",
-  "asf",
-  "au",
-  "avi",
-  "bak",
-  "baml",
-  "bh",
-  "bin",
-  "bk",
-  "bmp",
-  "btif",
-  "bz2",
-  "bzip2",
-  "cab",
-  "caf",
-  "cgm",
-  "class",
-  "cmx",
-  "cpio",
-  "cr2",
-  "cur",
-  "dat",
-  "dcm",
-  "deb",
-  "dex",
-  "djvu",
-  "dll",
-  "dmg",
-  "dng",
-  "doc",
-  "docm",
-  "docx",
-  "dot",
-  "dotm",
-  "dra",
-  "DS_Store",
-  "dsk",
-  "dts",
-  "dtshd",
-  "dvb",
-  "dwg",
-  "dxf",
-  "ecelp4800",
-  "ecelp7470",
-  "ecelp9600",
-  "egg",
-  "eol",
-  "eot",
-  "epub",
-  "exe",
-  "f4v",
-  "fbs",
-  "fh",
-  "fla",
-  "flac",
-  "flatpak",
-  "fli",
-  "flv",
-  "fpx",
-  "fst",
-  "fvt",
-  "g3",
-  "gh",
-  "gif",
-  "graffle",
-  "gz",
-  "gzip",
-  "h261",
-  "h263",
-  "h264",
-  "icns",
-  "ico",
-  "ief",
-  "img",
-  "ipa",
-  "iso",
-  "jar",
-  "jpeg",
-  "jpg",
-  "jpgv",
-  "jpm",
-  "jxr",
-  "key",
-  "ktx",
-  "lha",
-  "lib",
-  "lvp",
-  "lz",
-  "lzh",
-  "lzma",
-  "lzo",
-  "m3u",
-  "m4a",
-  "m4v",
-  "mar",
-  "mdi",
-  "mht",
-  "mid",
-  "midi",
-  "mj2",
-  "mka",
-  "mkv",
-  "mmr",
-  "mng",
-  "mobi",
-  "mov",
-  "movie",
-  "mp3",
-  "mp4",
-  "mp4a",
-  "mpeg",
-  "mpg",
-  "mpga",
-  "mxu",
-  "nef",
-  "npx",
-  "numbers",
-  "nupkg",
-  "o",
-  "odp",
-  "ods",
-  "odt",
-  "oga",
-  "ogg",
-  "ogv",
-  "otf",
-  "ott",
-  "pages",
-  "pbm",
-  "pcx",
-  "pdb",
-  "pdf",
-  "pea",
-  "pgm",
-  "pic",
-  "png",
-  "pnm",
-  "pot",
-  "potm",
-  "potx",
-  "ppa",
-  "ppam",
-  "ppm",
-  "pps",
-  "ppsm",
-  "ppsx",
-  "ppt",
-  "pptm",
-  "pptx",
-  "psd",
-  "pya",
-  "pyc",
-  "pyo",
-  "pyv",
-  "qt",
-  "rar",
-  "ras",
-  "raw",
-  "resources",
-  "rgb",
-  "rip",
-  "rlc",
-  "rmf",
-  "rmvb",
-  "rpm",
-  "rtf",
-  "rz",
-  "s3m",
-  "s7z",
-  "scpt",
-  "sgi",
-  "shar",
-  "snap",
-  "sil",
-  "sketch",
-  "slk",
-  "smv",
-  "snk",
-  "so",
-  "stl",
-  "suo",
-  "sub",
-  "swf",
-  "tar",
-  "tbz",
-  "tbz2",
-  "tga",
-  "tgz",
-  "thmx",
-  "tif",
-  "tiff",
-  "tlz",
-  "ttc",
-  "ttf",
-  "txz",
-  "udf",
-  "uvh",
-  "uvi",
-  "uvm",
-  "uvp",
-  "uvs",
-  "uvu",
-  "viv",
-  "vob",
-  "war",
-  "wav",
-  "wax",
-  "wbmp",
-  "wdp",
-  "weba",
-  "webm",
-  "webp",
-  "whl",
-  "wim",
-  "wm",
-  "wma",
-  "wmv",
-  "wmx",
-  "woff",
-  "woff2",
-  "wrm",
-  "wvx",
-  "xbm",
-  "xif",
-  "xla",
-  "xlam",
-  "xls",
-  "xlsb",
-  "xlsm",
-  "xlsx",
-  "xlt",
-  "xltm",
-  "xltx",
-  "xm",
-  "xmind",
-  "xpi",
-  "xpm",
-  "xwd",
-  "xz",
-  "z",
-  "zip",
-  "zipx"
-]);
-var isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
-var foreach = (val, fn) => {
-  if (val instanceof Set) {
-    val.forEach(fn);
-  } else {
-    fn(val);
-  }
-};
-var addAndConvert = (main, prop, item) => {
-  let container = main[prop];
-  if (!(container instanceof Set)) {
-    main[prop] = container = /* @__PURE__ */ new Set([container]);
-  }
-  container.add(item);
-};
-var clearItem = (cont) => (key) => {
-  const set2 = cont[key];
-  if (set2 instanceof Set) {
-    set2.clear();
-  } else {
-    delete cont[key];
-  }
-};
-var delFromSet = (main, prop, item) => {
-  const container = main[prop];
-  if (container instanceof Set) {
-    container.delete(item);
-  } else if (container === item) {
-    delete main[prop];
-  }
-};
-var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
-var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path24, options, listener, errHandler, emitRaw) {
-  const handleEvent = (rawEvent, evPath) => {
-    listener(path24);
-    emitRaw(rawEvent, evPath, { watchedPath: path24 });
-    if (evPath && path24 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path24, evPath), KEY_LISTENERS, sysPath.join(path24, evPath));
-    }
-  };
-  try {
-    return fs_watch(path24, {
-      persistent: options.persistent
-    }, handleEvent);
-  } catch (error40) {
-    errHandler(error40);
-    return void 0;
-  }
-}
-var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
-  const cont = FsWatchInstances.get(fullPath);
-  if (!cont)
-    return;
-  foreach(cont[listenerType], (listener) => {
-    listener(val1, val2, val3);
-  });
-};
-var setFsWatchListener = (path24, fullPath, options, handlers) => {
-  const { listener, errHandler, rawEmitter } = handlers;
-  let cont = FsWatchInstances.get(fullPath);
-  let watcher;
-  if (!options.persistent) {
-    watcher = createFsWatchInstance(path24, options, listener, errHandler, rawEmitter);
-    if (!watcher)
-      return;
-    return watcher.close.bind(watcher);
-  }
-  if (cont) {
-    addAndConvert(cont, KEY_LISTENERS, listener);
-    addAndConvert(cont, KEY_ERR, errHandler);
-    addAndConvert(cont, KEY_RAW, rawEmitter);
-  } else {
-    watcher = createFsWatchInstance(
-      path24,
-      options,
-      fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
-      errHandler,
-      // no need to use broadcast here
-      fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
-    );
-    if (!watcher)
-      return;
-    watcher.on(EV.ERROR, async (error40) => {
-      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
-      if (cont)
-        cont.watcherUnusable = true;
-      if (isWindows && error40.code === "EPERM") {
-        try {
-          const fd = await open(path24, "r");
-          await fd.close();
-          broadcastErr(error40);
-        } catch (err) {
-        }
-      } else {
-        broadcastErr(error40);
-      }
-    });
-    cont = {
-      listeners: listener,
-      errHandlers: errHandler,
-      rawEmitters: rawEmitter,
-      watcher
-    };
-    FsWatchInstances.set(fullPath, cont);
-  }
-  return () => {
-    delFromSet(cont, KEY_LISTENERS, listener);
-    delFromSet(cont, KEY_ERR, errHandler);
-    delFromSet(cont, KEY_RAW, rawEmitter);
-    if (isEmptySet(cont.listeners)) {
-      cont.watcher.close();
-      FsWatchInstances.delete(fullPath);
-      HANDLER_KEYS.forEach(clearItem(cont));
-      cont.watcher = void 0;
-      Object.freeze(cont);
-    }
-  };
-};
-var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path24, fullPath, options, handlers) => {
-  const { listener, rawEmitter } = handlers;
-  let cont = FsWatchFileInstances.get(fullPath);
-  const copts = cont && cont.options;
-  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
-    unwatchFile(fullPath);
-    cont = void 0;
-  }
-  if (cont) {
-    addAndConvert(cont, KEY_LISTENERS, listener);
-    addAndConvert(cont, KEY_RAW, rawEmitter);
-  } else {
-    cont = {
-      listeners: listener,
-      rawEmitters: rawEmitter,
-      options,
-      watcher: watchFile(fullPath, options, (curr, prev) => {
-        foreach(cont.rawEmitters, (rawEmitter2) => {
-          rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
-        });
-        const currmtime = curr.mtimeMs;
-        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path24, curr));
-        }
-      })
-    };
-    FsWatchFileInstances.set(fullPath, cont);
-  }
-  return () => {
-    delFromSet(cont, KEY_LISTENERS, listener);
-    delFromSet(cont, KEY_RAW, rawEmitter);
-    if (isEmptySet(cont.listeners)) {
-      FsWatchFileInstances.delete(fullPath);
-      unwatchFile(fullPath);
-      cont.options = cont.watcher = void 0;
-      Object.freeze(cont);
-    }
-  };
-};
-var NodeFsHandler = class {
-  constructor(fsW) {
-    this.fsw = fsW;
-    this._boundHandleError = (error40) => fsW._handleError(error40);
-  }
-  /**
-   * Watch file for changes with fs_watchFile or fs_watch.
-   * @param path to file or dir
-   * @param listener on fs change
-   * @returns closer for the watcher instance
-   */
-  _watchWithNodeFs(path24, listener) {
-    const opts = this.fsw.options;
-    const directory = sysPath.dirname(path24);
-    const basename6 = sysPath.basename(path24);
-    const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename6);
-    const absolutePath = sysPath.resolve(path24);
-    const options = {
-      persistent: opts.persistent
-    };
-    if (!listener)
-      listener = EMPTY_FN;
-    let closer;
-    if (opts.usePolling) {
-      const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename6) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path24, absolutePath, options, {
-        listener,
-        rawEmitter: this.fsw._emitRaw
-      });
-    } else {
-      closer = setFsWatchListener(path24, absolutePath, options, {
-        listener,
-        errHandler: this._boundHandleError,
-        rawEmitter: this.fsw._emitRaw
-      });
-    }
-    return closer;
-  }
-  /**
-   * Watch a file and emit add event if warranted.
-   * @returns closer for the watcher instance
-   */
-  _handleFile(file2, stats, initialAdd) {
-    if (this.fsw.closed) {
-      return;
-    }
-    const dirname7 = sysPath.dirname(file2);
-    const basename6 = sysPath.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname7);
-    let prevStats = stats;
-    if (parent.has(basename6))
-      return;
-    const listener = async (path24, newStats) => {
-      if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
-        return;
-      if (!newStats || newStats.mtimeMs === 0) {
-        try {
-          const newStats2 = await stat2(file2);
-          if (this.fsw.closed)
-            return;
-          const at = newStats2.atimeMs;
-          const mt = newStats2.mtimeMs;
-          if (!at || at <= mt || mt !== prevStats.mtimeMs) {
-            this.fsw._emit(EV.CHANGE, file2, newStats2);
-          }
-          if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path24);
-            prevStats = newStats2;
-            const closer2 = this._watchWithNodeFs(file2, listener);
-            if (closer2)
-              this.fsw._addPathCloser(path24, closer2);
-          } else {
-            prevStats = newStats2;
-          }
-        } catch (error40) {
-          this.fsw._remove(dirname7, basename6);
-        }
-      } else if (parent.has(basename6)) {
-        const at = newStats.atimeMs;
-        const mt = newStats.mtimeMs;
-        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
-          this.fsw._emit(EV.CHANGE, file2, newStats);
-        }
-        prevStats = newStats;
-      }
-    };
-    const closer = this._watchWithNodeFs(file2, listener);
-    if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file2)) {
-      if (!this.fsw._throttle(EV.ADD, file2, 0))
-        return;
-      this.fsw._emit(EV.ADD, file2, stats);
-    }
-    return closer;
-  }
-  /**
-   * Handle symlinks encountered while reading a dir.
-   * @param entry returned by readdirp
-   * @param directory path of dir being read
-   * @param path of this item
-   * @param item basename of this item
-   * @returns true if no more processing is needed for this entry.
-   */
-  async _handleSymlink(entry, directory, path24, item) {
-    if (this.fsw.closed) {
-      return;
-    }
-    const full = entry.fullPath;
-    const dir = this.fsw._getWatchedDir(directory);
-    if (!this.fsw.options.followSymlinks) {
-      this.fsw._incrReadyCount();
-      let linkPath;
-      try {
-        linkPath = await fsrealpath(path24);
-      } catch (e) {
-        this.fsw._emitReady();
-        return true;
-      }
-      if (this.fsw.closed)
-        return;
-      if (dir.has(item)) {
-        if (this.fsw._symlinkPaths.get(full) !== linkPath) {
-          this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path24, entry.stats);
-        }
-      } else {
-        dir.add(item);
-        this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path24, entry.stats);
-      }
-      this.fsw._emitReady();
-      return true;
-    }
-    if (this.fsw._symlinkPaths.has(full)) {
-      return true;
-    }
-    this.fsw._symlinkPaths.set(full, true);
-  }
-  _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
-    directory = sysPath.join(directory, "");
-    throttler = this.fsw._throttle("readdir", directory, 1e3);
-    if (!throttler)
-      return;
-    const previous = this.fsw._getWatchedDir(wh.path);
-    const current = /* @__PURE__ */ new Set();
-    let stream = this.fsw._readdirp(directory, {
-      fileFilter: (entry) => wh.filterPath(entry),
-      directoryFilter: (entry) => wh.filterDir(entry)
-    });
-    if (!stream)
-      return;
-    stream.on(STR_DATA, async (entry) => {
-      if (this.fsw.closed) {
-        stream = void 0;
-        return;
-      }
-      const item = entry.path;
-      let path24 = sysPath.join(directory, item);
-      current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path24, item)) {
-        return;
-      }
-      if (this.fsw.closed) {
-        stream = void 0;
-        return;
-      }
-      if (item === target || !target && !previous.has(item)) {
-        this.fsw._incrReadyCount();
-        path24 = sysPath.join(dir, sysPath.relative(dir, path24));
-        this._addToNodeFs(path24, initialAdd, wh, depth + 1);
-      }
-    }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve16, reject) => {
-      if (!stream)
-        return reject();
-      stream.once(STR_END, () => {
-        if (this.fsw.closed) {
-          stream = void 0;
-          return;
-        }
-        const wasThrottled = throttler ? throttler.clear() : false;
-        resolve16(void 0);
-        previous.getChildren().filter((item) => {
-          return item !== directory && !current.has(item);
-        }).forEach((item) => {
-          this.fsw._remove(directory, item);
-        });
-        stream = void 0;
-        if (wasThrottled)
-          this._handleRead(directory, false, wh, target, dir, depth, throttler);
-      });
-    });
-  }
-  /**
-   * Read directory to add / remove files from `@watched` list and re-read it on change.
-   * @param dir fs path
-   * @param stats
-   * @param initialAdd
-   * @param depth relative to user-supplied path
-   * @param target child path targeted for watch
-   * @param wh Common watch helpers for this path
-   * @param realpath
-   * @returns closer for the watcher instance.
-   */
-  async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath2) {
-    const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
-    const tracked = parentDir.has(sysPath.basename(dir));
-    if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
-      this.fsw._emit(EV.ADD_DIR, dir, stats);
-    }
-    parentDir.add(sysPath.basename(dir));
-    this.fsw._getWatchedDir(dir);
-    let throttler;
-    let closer;
-    const oDepth = this.fsw.options.depth;
-    if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath2)) {
-      if (!target) {
-        await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
-        if (this.fsw.closed)
-          return;
-      }
-      closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
-        if (stats2 && stats2.mtimeMs === 0)
-          return;
-        this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
-      });
-    }
-    return closer;
-  }
-  /**
-   * Handle added file, directory, or glob pattern.
-   * Delegates call to _handleFile / _handleDir after checks.
-   * @param path to file or ir
-   * @param initialAdd was the file added at watch instantiation?
-   * @param priorWh depth relative to user-supplied path
-   * @param depth Child path actually targeted for watch
-   * @param target Child path actually targeted for watch
-   */
-  async _addToNodeFs(path24, initialAdd, priorWh, depth, target) {
-    const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path24) || this.fsw.closed) {
-      ready();
-      return false;
-    }
-    const wh = this.fsw._getWatchHelpers(path24);
-    if (priorWh) {
-      wh.filterPath = (entry) => priorWh.filterPath(entry);
-      wh.filterDir = (entry) => priorWh.filterDir(entry);
-    }
-    try {
-      const stats = await statMethods[wh.statMethod](wh.watchPath);
-      if (this.fsw.closed)
-        return;
-      if (this.fsw._isIgnored(wh.watchPath, stats)) {
-        ready();
-        return false;
-      }
-      const follow = this.fsw.options.followSymlinks;
-      let closer;
-      if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path24);
-        const targetPath = follow ? await fsrealpath(path24) : path24;
-        if (this.fsw.closed)
-          return;
-        closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
-        if (this.fsw.closed)
-          return;
-        if (absPath !== targetPath && targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(absPath, targetPath);
-        }
-      } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path24) : path24;
-        if (this.fsw.closed)
-          return;
-        const parent = sysPath.dirname(wh.watchPath);
-        this.fsw._getWatchedDir(parent).add(wh.watchPath);
-        this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path24, wh, targetPath);
-        if (this.fsw.closed)
-          return;
-        if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path24), targetPath);
-        }
-      } else {
-        closer = this._handleFile(wh.watchPath, stats, initialAdd);
-      }
-      ready();
-      if (closer)
-        this.fsw._addPathCloser(path24, closer);
-      return false;
-    } catch (error40) {
-      if (this.fsw._handleError(error40)) {
-        ready();
-        return path24;
-      }
-    }
-  }
-};
-
-// ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
-var SLASH = "/";
-var SLASH_SLASH = "//";
-var ONE_DOT = ".";
-var TWO_DOTS = "..";
-var STRING_TYPE = "string";
-var BACK_SLASH_RE = /\\/g;
-var DOUBLE_SLASH_RE = /\/\//;
-var DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
-var REPLACER_RE = /^\.[/\\]/;
-function arrify(item) {
-  return Array.isArray(item) ? item : [item];
-}
-var isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
-function createPattern(matcher) {
-  if (typeof matcher === "function")
-    return matcher;
-  if (typeof matcher === "string")
-    return (string4) => matcher === string4;
-  if (matcher instanceof RegExp)
-    return (string4) => matcher.test(string4);
-  if (typeof matcher === "object" && matcher !== null) {
-    return (string4) => {
-      if (matcher.path === string4)
-        return true;
-      if (matcher.recursive) {
-        const relative6 = sysPath2.relative(matcher.path, string4);
-        if (!relative6) {
-          return false;
-        }
-        return !relative6.startsWith("..") && !sysPath2.isAbsolute(relative6);
-      }
-      return false;
-    };
-  }
-  return () => false;
-}
-function normalizePath(path24) {
-  if (typeof path24 !== "string")
-    throw new Error("string expected");
-  path24 = sysPath2.normalize(path24);
-  path24 = path24.replace(/\\/g, "/");
-  let prepend = false;
-  if (path24.startsWith("//"))
-    prepend = true;
-  const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path24.match(DOUBLE_SLASH_RE2))
-    path24 = path24.replace(DOUBLE_SLASH_RE2, "/");
-  if (prepend)
-    path24 = "/" + path24;
-  return path24;
-}
-function matchPatterns(patterns, testString, stats) {
-  const path24 = normalizePath(testString);
-  for (let index = 0; index < patterns.length; index++) {
-    const pattern = patterns[index];
-    if (pattern(path24, stats)) {
-      return true;
-    }
-  }
-  return false;
-}
-function anymatch(matchers, testString) {
-  if (matchers == null) {
-    throw new TypeError("anymatch: specify first argument");
-  }
-  const matchersArray = arrify(matchers);
-  const patterns = matchersArray.map((matcher) => createPattern(matcher));
-  if (testString == null) {
-    return (testString2, stats) => {
-      return matchPatterns(patterns, testString2, stats);
-    };
-  }
-  return matchPatterns(patterns, testString);
-}
-var unifyPaths = (paths_) => {
-  const paths = arrify(paths_).flat();
-  if (!paths.every((p) => typeof p === STRING_TYPE)) {
-    throw new TypeError(`Non-string provided as watch path: ${paths}`);
-  }
-  return paths.map(normalizePathToUnix);
-};
-var toUnix = (string4) => {
-  let str = string4.replace(BACK_SLASH_RE, SLASH);
-  let prepend = false;
-  if (str.startsWith(SLASH_SLASH)) {
-    prepend = true;
-  }
-  while (str.match(DOUBLE_SLASH_RE)) {
-    str = str.replace(DOUBLE_SLASH_RE, SLASH);
-  }
-  if (prepend) {
-    str = SLASH + str;
-  }
-  return str;
-};
-var normalizePathToUnix = (path24) => toUnix(sysPath2.normalize(toUnix(path24)));
-var normalizeIgnored = (cwd3 = "") => (path24) => {
-  if (typeof path24 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path24) ? path24 : sysPath2.join(cwd3, path24));
-  } else {
-    return path24;
-  }
-};
-var getAbsolutePath = (path24, cwd3) => {
-  if (sysPath2.isAbsolute(path24)) {
-    return path24;
-  }
-  return sysPath2.join(cwd3, path24);
-};
-var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
-var DirEntry = class {
-  constructor(dir, removeWatcher) {
-    this.path = dir;
-    this._removeWatcher = removeWatcher;
-    this.items = /* @__PURE__ */ new Set();
-  }
-  add(item) {
-    const { items } = this;
-    if (!items)
-      return;
-    if (item !== ONE_DOT && item !== TWO_DOTS)
-      items.add(item);
-  }
-  async remove(item) {
-    const { items } = this;
-    if (!items)
-      return;
-    items.delete(item);
-    if (items.size > 0)
-      return;
-    const dir = this.path;
-    try {
-      await readdir2(dir);
-    } catch (err) {
-      if (this._removeWatcher) {
-        this._removeWatcher(sysPath2.dirname(dir), sysPath2.basename(dir));
-      }
-    }
-  }
-  has(item) {
-    const { items } = this;
-    if (!items)
-      return;
-    return items.has(item);
-  }
-  getChildren() {
-    const { items } = this;
-    if (!items)
-      return [];
-    return [...items.values()];
-  }
-  dispose() {
-    this.items.clear();
-    this.path = "";
-    this._removeWatcher = EMPTY_FN;
-    this.items = EMPTY_SET;
-    Object.freeze(this);
-  }
-};
-var STAT_METHOD_F = "stat";
-var STAT_METHOD_L = "lstat";
-var WatchHelper = class {
-  constructor(path24, follow, fsw) {
-    this.fsw = fsw;
-    const watchPath = path24;
-    this.path = path24 = path24.replace(REPLACER_RE, "");
-    this.watchPath = watchPath;
-    this.fullWatchPath = sysPath2.resolve(watchPath);
-    this.dirParts = [];
-    this.dirParts.forEach((parts) => {
-      if (parts.length > 1)
-        parts.pop();
-    });
-    this.followSymlinks = follow;
-    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
-  }
-  entryPath(entry) {
-    return sysPath2.join(this.watchPath, sysPath2.relative(this.watchPath, entry.fullPath));
-  }
-  filterPath(entry) {
-    const { stats } = entry;
-    if (stats && stats.isSymbolicLink())
-      return this.filterDir(entry);
-    const resolvedPath = this.entryPath(entry);
-    return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
-  }
-  filterDir(entry) {
-    return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
-  }
-};
-var FSWatcher = class extends EventEmitter2 {
-  // Not indenting methods for history sake; for now.
-  constructor(_opts = {}) {
-    super();
-    this.closed = false;
-    this._closers = /* @__PURE__ */ new Map();
-    this._ignoredPaths = /* @__PURE__ */ new Set();
-    this._throttled = /* @__PURE__ */ new Map();
-    this._streams = /* @__PURE__ */ new Set();
-    this._symlinkPaths = /* @__PURE__ */ new Map();
-    this._watched = /* @__PURE__ */ new Map();
-    this._pendingWrites = /* @__PURE__ */ new Map();
-    this._pendingUnlinks = /* @__PURE__ */ new Map();
-    this._readyCount = 0;
-    this._readyEmitted = false;
-    const awf = _opts.awaitWriteFinish;
-    const DEF_AWF = { stabilityThreshold: 2e3, pollInterval: 100 };
-    const opts = {
-      // Defaults
-      persistent: true,
-      ignoreInitial: false,
-      ignorePermissionErrors: false,
-      interval: 100,
-      binaryInterval: 300,
-      followSymlinks: true,
-      usePolling: false,
-      // useAsync: false,
-      atomic: true,
-      // NOTE: overwritten later (depends on usePolling)
-      ..._opts,
-      // Change format
-      ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
-      awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
-    };
-    if (isIBMi)
-      opts.usePolling = true;
-    if (opts.atomic === void 0)
-      opts.atomic = !opts.usePolling;
-    const envPoll = process.env.CHOKIDAR_USEPOLLING;
-    if (envPoll !== void 0) {
-      const envLower = envPoll.toLowerCase();
-      if (envLower === "false" || envLower === "0")
-        opts.usePolling = false;
-      else if (envLower === "true" || envLower === "1")
-        opts.usePolling = true;
-      else
-        opts.usePolling = !!envLower;
-    }
-    const envInterval = process.env.CHOKIDAR_INTERVAL;
-    if (envInterval)
-      opts.interval = Number.parseInt(envInterval, 10);
-    let readyCalls = 0;
-    this._emitReady = () => {
-      readyCalls++;
-      if (readyCalls >= this._readyCount) {
-        this._emitReady = EMPTY_FN;
-        this._readyEmitted = true;
-        process.nextTick(() => this.emit(EVENTS.READY));
-      }
-    };
-    this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
-    this._boundRemove = this._remove.bind(this);
-    this.options = opts;
-    this._nodeFsHandler = new NodeFsHandler(this);
-    Object.freeze(opts);
-  }
-  _addIgnoredPath(matcher) {
-    if (isMatcherObject(matcher)) {
-      for (const ignored of this._ignoredPaths) {
-        if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
-          return;
-        }
-      }
-    }
-    this._ignoredPaths.add(matcher);
-  }
-  _removeIgnoredPath(matcher) {
-    this._ignoredPaths.delete(matcher);
-    if (typeof matcher === "string") {
-      for (const ignored of this._ignoredPaths) {
-        if (isMatcherObject(ignored) && ignored.path === matcher) {
-          this._ignoredPaths.delete(ignored);
-        }
-      }
-    }
-  }
-  // Public methods
-  /**
-   * Adds paths to be watched on an existing FSWatcher instance.
-   * @param paths_ file or file list. Other arguments are unused
-   */
-  add(paths_, _origAdd, _internal) {
-    const { cwd: cwd3 } = this.options;
-    this.closed = false;
-    this._closePromise = void 0;
-    let paths = unifyPaths(paths_);
-    if (cwd3) {
-      paths = paths.map((path24) => {
-        const absPath = getAbsolutePath(path24, cwd3);
-        return absPath;
-      });
-    }
-    paths.forEach((path24) => {
-      this._removeIgnoredPath(path24);
-    });
-    this._userIgnored = void 0;
-    if (!this._readyCount)
-      this._readyCount = 0;
-    this._readyCount += paths.length;
-    Promise.all(paths.map(async (path24) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path24, !_internal, void 0, 0, _origAdd);
-      if (res)
-        this._emitReady();
-      return res;
-    })).then((results) => {
-      if (this.closed)
-        return;
-      results.forEach((item) => {
-        if (item)
-          this.add(sysPath2.dirname(item), sysPath2.basename(_origAdd || item));
-      });
-    });
-    return this;
-  }
-  /**
-   * Close watchers or start ignoring events from specified paths.
-   */
-  unwatch(paths_) {
-    if (this.closed)
-      return this;
-    const paths = unifyPaths(paths_);
-    const { cwd: cwd3 } = this.options;
-    paths.forEach((path24) => {
-      if (!sysPath2.isAbsolute(path24) && !this._closers.has(path24)) {
-        if (cwd3)
-          path24 = sysPath2.join(cwd3, path24);
-        path24 = sysPath2.resolve(path24);
-      }
-      this._closePath(path24);
-      this._addIgnoredPath(path24);
-      if (this._watched.has(path24)) {
-        this._addIgnoredPath({
-          path: path24,
-          recursive: true
-        });
-      }
-      this._userIgnored = void 0;
-    });
-    return this;
-  }
-  /**
-   * Close watchers and remove all listeners from watched paths.
-   */
-  close() {
-    if (this._closePromise) {
-      return this._closePromise;
-    }
-    this.closed = true;
-    this.removeAllListeners();
-    const closers = [];
-    this._closers.forEach((closerList) => closerList.forEach((closer) => {
-      const promise2 = closer();
-      if (promise2 instanceof Promise)
-        closers.push(promise2);
-    }));
-    this._streams.forEach((stream) => stream.destroy());
-    this._userIgnored = void 0;
-    this._readyCount = 0;
-    this._readyEmitted = false;
-    this._watched.forEach((dirent) => dirent.dispose());
-    this._closers.clear();
-    this._watched.clear();
-    this._streams.clear();
-    this._symlinkPaths.clear();
-    this._throttled.clear();
-    this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
-    return this._closePromise;
-  }
-  /**
-   * Expose list of watched paths
-   * @returns for chaining
-   */
-  getWatched() {
-    const watchList = {};
-    this._watched.forEach((entry, dir) => {
-      const key = this.options.cwd ? sysPath2.relative(this.options.cwd, dir) : dir;
-      const index = key || ONE_DOT;
-      watchList[index] = entry.getChildren().sort();
-    });
-    return watchList;
-  }
-  emitWithAll(event, args) {
-    this.emit(event, ...args);
-    if (event !== EVENTS.ERROR)
-      this.emit(EVENTS.ALL, event, ...args);
-  }
-  // Common helpers
-  // --------------
-  /**
-   * Normalize and emit events.
-   * Calling _emit DOES NOT MEAN emit() would be called!
-   * @param event Type of event
-   * @param path File or directory path
-   * @param stats arguments to be passed with event
-   * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
-   */
-  async _emit(event, path24, stats) {
-    if (this.closed)
-      return;
-    const opts = this.options;
-    if (isWindows)
-      path24 = sysPath2.normalize(path24);
-    if (opts.cwd)
-      path24 = sysPath2.relative(opts.cwd, path24);
-    const args = [path24];
-    if (stats != null)
-      args.push(stats);
-    const awf = opts.awaitWriteFinish;
-    let pw;
-    if (awf && (pw = this._pendingWrites.get(path24))) {
-      pw.lastChange = /* @__PURE__ */ new Date();
-      return this;
-    }
-    if (opts.atomic) {
-      if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path24, [event, ...args]);
-        setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path25) => {
-            this.emit(...entry);
-            this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path25);
-          });
-        }, typeof opts.atomic === "number" ? opts.atomic : 100);
-        return this;
-      }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path24)) {
-        event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path24);
-      }
-    }
-    if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
-      const awfEmit = (err, stats2) => {
-        if (err) {
-          event = EVENTS.ERROR;
-          args[0] = err;
-          this.emitWithAll(event, args);
-        } else if (stats2) {
-          if (args.length > 1) {
-            args[1] = stats2;
-          } else {
-            args.push(stats2);
-          }
-          this.emitWithAll(event, args);
-        }
-      };
-      this._awaitWriteFinish(path24, awf.stabilityThreshold, event, awfEmit);
-      return this;
-    }
-    if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path24, 50);
-      if (isThrottled)
-        return this;
-    }
-    if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path24) : path24;
-      let stats2;
-      try {
-        stats2 = await stat3(fullPath);
-      } catch (err) {
-      }
-      if (!stats2 || this.closed)
-        return;
-      args.push(stats2);
-    }
-    this.emitWithAll(event, args);
-    return this;
-  }
-  /**
-   * Common handler for errors
-   * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
-   */
-  _handleError(error40) {
-    const code = error40 && error40.code;
-    if (error40 && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
-      this.emit(EVENTS.ERROR, error40);
-    }
-    return error40 || this.closed;
-  }
-  /**
-   * Helper utility for throttling
-   * @param actionType type being throttled
-   * @param path being acted upon
-   * @param timeout duration of time to suppress duplicate actions
-   * @returns tracking object or false if action should be suppressed
-   */
-  _throttle(actionType, path24, timeout) {
-    if (!this._throttled.has(actionType)) {
-      this._throttled.set(actionType, /* @__PURE__ */ new Map());
-    }
-    const action = this._throttled.get(actionType);
-    if (!action)
-      throw new Error("invalid throttle");
-    const actionPath = action.get(path24);
-    if (actionPath) {
-      actionPath.count++;
-      return false;
-    }
-    let timeoutObject;
-    const clear = () => {
-      const item = action.get(path24);
-      const count = item ? item.count : 0;
-      action.delete(path24);
-      clearTimeout(timeoutObject);
-      if (item)
-        clearTimeout(item.timeoutObject);
-      return count;
-    };
-    timeoutObject = setTimeout(clear, timeout);
-    const thr = { timeoutObject, clear, count: 0 };
-    action.set(path24, thr);
-    return thr;
-  }
-  _incrReadyCount() {
-    return this._readyCount++;
-  }
-  /**
-   * Awaits write operation to finish.
-   * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
-   * @param path being acted upon
-   * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
-   * @param event
-   * @param awfEmit Callback to be called when ready for event to be emitted.
-   */
-  _awaitWriteFinish(path24, threshold, event, awfEmit) {
-    const awf = this.options.awaitWriteFinish;
-    if (typeof awf !== "object")
-      return;
-    const pollInterval = awf.pollInterval;
-    let timeoutHandler;
-    let fullPath = path24;
-    if (this.options.cwd && !sysPath2.isAbsolute(path24)) {
-      fullPath = sysPath2.join(this.options.cwd, path24);
-    }
-    const now = /* @__PURE__ */ new Date();
-    const writes = this._pendingWrites;
-    function awaitWriteFinishFn(prevStat) {
-      statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path24)) {
-          if (err && err.code !== "ENOENT")
-            awfEmit(err);
-          return;
-        }
-        const now2 = Number(/* @__PURE__ */ new Date());
-        if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path24).lastChange = now2;
-        }
-        const pw = writes.get(path24);
-        const df = now2 - pw.lastChange;
-        if (df >= threshold) {
-          writes.delete(path24);
-          awfEmit(void 0, curStat);
-        } else {
-          timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
-        }
-      });
-    }
-    if (!writes.has(path24)) {
-      writes.set(path24, {
-        lastChange: now,
-        cancelWait: () => {
-          writes.delete(path24);
-          clearTimeout(timeoutHandler);
-          return event;
-        }
-      });
-      timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
-    }
-  }
-  /**
-   * Determines whether user has asked to ignore this path.
-   */
-  _isIgnored(path24, stats) {
-    if (this.options.atomic && DOT_RE.test(path24))
-      return true;
-    if (!this._userIgnored) {
-      const { cwd: cwd3 } = this.options;
-      const ign = this.options.ignored;
-      const ignored = (ign || []).map(normalizeIgnored(cwd3));
-      const ignoredPaths = [...this._ignoredPaths];
-      const list = [...ignoredPaths.map(normalizeIgnored(cwd3)), ...ignored];
-      this._userIgnored = anymatch(list, void 0);
-    }
-    return this._userIgnored(path24, stats);
-  }
-  _isntIgnored(path24, stat4) {
-    return !this._isIgnored(path24, stat4);
-  }
-  /**
-   * Provides a set of common helpers and properties relating to symlink handling.
-   * @param path file or directory pattern being watched
-   */
-  _getWatchHelpers(path24) {
-    return new WatchHelper(path24, this.options.followSymlinks, this);
-  }
-  // Directory helpers
-  // -----------------
-  /**
-   * Provides directory tracking objects
-   * @param directory path of the directory
-   */
-  _getWatchedDir(directory) {
-    const dir = sysPath2.resolve(directory);
-    if (!this._watched.has(dir))
-      this._watched.set(dir, new DirEntry(dir, this._boundRemove));
-    return this._watched.get(dir);
-  }
-  // File helpers
-  // ------------
-  /**
-   * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
-   */
-  _hasReadPermissions(stats) {
-    if (this.options.ignorePermissionErrors)
-      return true;
-    return Boolean(Number(stats.mode) & 256);
-  }
-  /**
-   * Handles emitting unlink events for
-   * files and directories, and via recursion, for
-   * files and directories within directories that are unlinked
-   * @param directory within which the following item is located
-   * @param item      base path of item/directory
-   */
-  _remove(directory, item, isDirectory) {
-    const path24 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path24);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path24) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path24, 100))
-      return;
-    if (!isDirectory && this._watched.size === 1) {
-      this.add(directory, item, true);
-    }
-    const wp = this._getWatchedDir(path24);
-    const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path24, nested));
-    const parent = this._getWatchedDir(directory);
-    const wasTracked = parent.has(item);
-    parent.remove(item);
-    if (this._symlinkPaths.has(fullPath)) {
-      this._symlinkPaths.delete(fullPath);
-    }
-    let relPath = path24;
-    if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path24);
-    if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
-      const event = this._pendingWrites.get(relPath).cancelWait();
-      if (event === EVENTS.ADD)
-        return;
-    }
-    this._watched.delete(path24);
-    this._watched.delete(fullPath);
-    const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path24))
-      this._emit(eventName, path24);
-    this._closePath(path24);
-  }
-  /**
-   * Closes all watchers for a path
-   */
-  _closePath(path24) {
-    this._closeFile(path24);
-    const dir = sysPath2.dirname(path24);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path24));
-  }
-  /**
-   * Closes only file-specific watchers
-   */
-  _closeFile(path24) {
-    const closers = this._closers.get(path24);
-    if (!closers)
-      return;
-    closers.forEach((closer) => closer());
-    this._closers.delete(path24);
-  }
-  _addPathCloser(path24, closer) {
-    if (!closer)
-      return;
-    let list = this._closers.get(path24);
-    if (!list) {
-      list = [];
-      this._closers.set(path24, list);
-    }
-    list.push(closer);
-  }
-  _readdirp(root, opts) {
-    if (this.closed)
-      return;
-    const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
-    let stream = readdirp(root, options);
-    this._streams.add(stream);
-    stream.once(STR_CLOSE, () => {
-      stream = void 0;
-    });
-    stream.once(STR_END, () => {
-      if (stream) {
-        this._streams.delete(stream);
-        stream = void 0;
-      }
-    });
-    return stream;
-  }
-};
-function watch(paths, options = {}) {
-  const watcher = new FSWatcher(options);
-  watcher.add(paths);
-  return watcher;
-}
-var esm_default = { watch, FSWatcher };
-
-// src/files/watch-file-index.ts
 var DEBOUNCE_MS = 900;
 function shouldIgnoreRelative(rel) {
   const n = rel.replace(/\\/g, "/");
@@ -31970,8 +30494,43 @@ function shouldIgnoreRelative(rel) {
   if (n.includes("/.buildautomaton/") || n.startsWith(".buildautomaton/")) return true;
   return false;
 }
-function startFileIndexWatcher(cwd3 = process.cwd()) {
-  const resolved = path21.resolve(cwd3);
+function attachWatchErrorLog(w) {
+  w.on("error", (err) => {
+    console.error("[file-index] File watcher error:", err);
+  });
+}
+function createFsWatcher(resolved, schedule) {
+  const onEvent = (_event, filename) => {
+    if (filename != null) {
+      const rel = typeof filename === "string" ? filename.replace(/\\/g, "/") : filename.toString("utf8").replace(/\\/g, "/");
+      if (shouldIgnoreRelative(rel)) return;
+    }
+    schedule();
+  };
+  try {
+    const w = watch(resolved, { recursive: true }, onEvent);
+    attachWatchErrorLog(w);
+    return w;
+  } catch (e) {
+    const code = typeof e === "object" && e !== null && "code" in e ? e.code : void 0;
+    if (code === "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM") {
+      console.warn(
+        "[file-index] Recursive file watching is unavailable on this platform; using non-recursive watch (Node 20+ on Linux enables recursive). Nested file changes may be missed until you upgrade."
+      );
+      const w = watch(resolved, { recursive: false }, onEvent);
+      attachWatchErrorLog(w);
+      return w;
+    }
+    throw e;
+  }
+}
+function startFileIndexWatcher(cwd = getBridgeWorkspaceDirectory()) {
+  const resolved = path21.resolve(cwd);
+  try {
+    buildFileIndex(resolved);
+  } catch (e) {
+    console.error("[file-index] Initial index build failed:", e);
+  }
   let timer = null;
   const runRebuild = () => {
     try {
@@ -31987,27 +30546,13 @@ function startFileIndexWatcher(cwd3 = process.cwd()) {
       runRebuild();
     }, DEBOUNCE_MS);
   };
-  const watcher = esm_default.watch(".", {
-    cwd: resolved,
-    ignoreInitial: true,
-    persistent: true,
-    ignored: (p) => {
-      const rel = path21.isAbsolute(p) ? path21.relative(resolved, p).replace(/\\/g, "/") : p.replace(/\\/g, "/");
-      return shouldIgnoreRelative(rel || ".");
-    },
-    awaitWriteFinish: { stabilityThreshold: 250, pollInterval: 100 }
-  });
-  watcher.on("add", schedule);
-  watcher.on("change", schedule);
-  watcher.on("unlink", schedule);
-  watcher.on("addDir", schedule);
-  watcher.on("unlinkDir", schedule);
+  const watcher = createFsWatcher(resolved, schedule);
   return () => {
     if (timer) {
       clearTimeout(timer);
       timer = null;
     }
-    void watcher.close();
+    watcher.close();
   };
 }
 
@@ -32031,18 +30576,20 @@ function sendDevServerStatus(getWs, serverId, status, options) {
 
 // src/dev-servers/process/terminate-child-process.ts
 async function sigtermAndWaitForExit(proc, graceMs, log2, shortId) {
-  const exited = new Promise((resolve16) => {
-    proc.once("exit", () => resolve16());
+  const exited = new Promise((resolve14) => {
+    proc.once("exit", () => resolve14());
   });
-  log2(`[dev-server] Sending SIGTERM to ${shortId} (pid=${proc.pid ?? "?"})\u2026`);
+  log2(`[dev-server] Sending SIGTERM to ${shortId} (pid=${proc.pid ?? "?"}).`);
   try {
     proc.kill("SIGTERM");
   } catch {
   }
-  await Promise.race([exited, new Promise((resolve16) => setTimeout(resolve16, graceMs))]);
+  await Promise.race([exited, new Promise((resolve14) => setTimeout(resolve14, graceMs))]);
 }
 function forceKillChild(proc, log2, shortId, graceMs) {
-  log2(`[dev-server] ${shortId} did not exit within ${graceMs}ms; sending SIGKILL (pid=${proc.pid ?? "?"})\u2026`);
+  log2(
+    `[dev-server] ${shortId} did not exit within ${graceMs}ms; sending SIGKILL (pid=${proc.pid ?? "?"}).`
+  );
   proc.removeAllListeners();
   try {
     proc.kill("SIGKILL");
@@ -32051,7 +30598,7 @@ function forceKillChild(proc, log2, shortId, graceMs) {
 }
 
 // src/dev-servers/process/wire-dev-server-child-process.ts
-import fs16 from "node:fs";
+import fs17 from "node:fs";
 
 // src/dev-servers/manager/forward-pipe.ts
 function forwardChildPipe(childReadable, terminal, onData) {
@@ -32087,7 +30634,7 @@ function wireDevServerChildProcess(d) {
         d.setPollInterval(void 0);
         return;
       }
-      fs16.readFile(d.mergedLogPath, (err, buf) => {
+      fs17.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));
@@ -32112,7 +30659,7 @@ function wireDevServerChildProcess(d) {
         d.rmMergedCleanupDir(cleanupDir);
       }
       if (signal) {
-        d.log(`[dev-server] ${title} stopped (signal ${String(signal)})`);
+        d.log(`[dev-server] ${title} stopped (signal: ${String(signal)}).`);
       } else if (code !== null && code !== 0) {
         const errTail = d.stderrTail.getTail().slice(-3).join("\n");
         d.log(`[dev-server] ${title} exited with code ${code}${errTail ? `
@@ -32125,7 +30672,7 @@ ${errTail}` : ""}`);
       d.sendStatus(code === 0 || code == null ? "stopped" : "error", detail, tails);
     };
     if (mergedPath) {
-      fs16.readFile(mergedPath, (err, buf) => {
+      fs17.readFile(mergedPath, (err, buf) => {
         if (!err && buf.length > d.mergedReadPos.value) {
           const chunk = Buffer.from(buf.subarray(d.mergedReadPos.value));
           if (chunk.length > 0) {
@@ -32227,13 +30774,13 @@ function parseDevServerDefs(servers) {
 }
 
 // src/dev-servers/manager/shell-spawn/utils.ts
-import fs17 from "node:fs";
+import fs18 from "node:fs";
 function isSpawnEbadf(e) {
   return typeof e === "object" && e !== null && "code" in e && e.code === "EBADF";
 }
 function rmDirQuiet(dir) {
   try {
-    fs17.rmSync(dir, { recursive: true, force: true });
+    fs18.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -32241,7 +30788,7 @@ var cachedDevNullReadFd;
 function devNullReadFd() {
   if (cachedDevNullReadFd === void 0) {
     const devPath = process.platform === "win32" ? "nul" : "/dev/null";
-    cachedDevNullReadFd = fs17.openSync(devPath, "r");
+    cachedDevNullReadFd = fs18.openSync(devPath, "r");
   }
   return cachedDevNullReadFd;
 }
@@ -32251,7 +30798,7 @@ function pipedStdoutStderrFor(attemptStdio) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-piped-via-sh.ts
 import { spawn as spawn5 } from "node:child_process";
-function trySpawnPipedViaSh(command, env, cwd3, signal) {
+function trySpawnPipedViaSh(command, env, cwd, signal) {
   const attempts = [
     { stdio: [devNullReadFd(), "pipe", "pipe"], endStdin: false },
     { stdio: ["ignore", "pipe", "pipe"], endStdin: true },
@@ -32262,7 +30809,7 @@ function trySpawnPipedViaSh(command, env, cwd3, signal) {
     const attempt = attempts[i];
     const opts = {
       env,
-      cwd: cwd3,
+      cwd,
       stdio: attempt.stdio,
       ...signal ? { signal } : {}
     };
@@ -32294,11 +30841,11 @@ function trySpawnPipedViaSh(command, env, cwd3, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-shell-true-piped.ts
 import { spawn as spawn6 } from "node:child_process";
-function trySpawnShellTruePiped(command, env, cwd3, devNullFd, signal) {
+function trySpawnShellTruePiped(command, env, cwd, devNullFd, signal) {
   try {
     const opts = {
       env,
-      cwd: cwd3,
+      cwd,
       stdio: [devNullFd, "pipe", "pipe"],
       shell: true,
       ...signal ? { signal } : {}
@@ -32315,15 +30862,15 @@ function trySpawnShellTruePiped(command, env, cwd3, devNullFd, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-merged-log-file.ts
 import { spawn as spawn7 } from "node:child_process";
-import fs18 from "node:fs";
+import fs19 from "node:fs";
 import { tmpdir } from "node:os";
 import path22 from "node:path";
-function trySpawnMergedLogFile(command, env, cwd3, signal) {
-  const tmpRoot = fs18.mkdtempSync(path22.join(tmpdir(), "ba-devsrv-log-"));
+function trySpawnMergedLogFile(command, env, cwd, signal) {
+  const tmpRoot = fs19.mkdtempSync(path22.join(tmpdir(), "ba-devsrv-log-"));
   const logPath = path22.join(tmpRoot, "combined.log");
   let logFd;
   try {
-    logFd = fs18.openSync(logPath, "a");
+    logFd = fs19.openSync(logPath, "a");
   } catch {
     rmDirQuiet(tmpRoot);
     return null;
@@ -32334,15 +30881,15 @@ function trySpawnMergedLogFile(command, env, cwd3, signal) {
     if (process.platform === "win32") {
       proc = spawn7(process.env.ComSpec || "cmd.exe", ["/d", "/s", "/c", command], {
         env,
-        cwd: cwd3,
+        cwd,
         stdio,
         windowsHide: true,
         ...signal ? { signal } : {}
       });
     } else {
-      proc = spawn7("/bin/sh", ["-c", command], { env, cwd: cwd3, stdio, ...signal ? { signal } : {} });
+      proc = spawn7("/bin/sh", ["-c", command], { env, cwd, stdio, ...signal ? { signal } : {} });
     }
-    fs18.closeSync(logFd);
+    fs19.closeSync(logFd);
     return {
       proc,
       pipedStdoutStderr: true,
@@ -32351,7 +30898,7 @@ function trySpawnMergedLogFile(command, env, cwd3, signal) {
     };
   } catch (e) {
     try {
-      fs18.closeSync(logFd);
+      fs19.closeSync(logFd);
     } catch {
     }
     rmDirQuiet(tmpRoot);
@@ -32362,25 +30909,25 @@ function trySpawnMergedLogFile(command, env, cwd3, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-shell-script-log-redirect.ts
 import { spawn as spawn8 } from "node:child_process";
-import fs19 from "node:fs";
+import fs20 from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import path23 from "node:path";
 function shSingleQuote(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
-function trySpawnShellScriptLogRedirectUnix(command, env, cwd3, signal) {
-  const tmpRoot = fs19.mkdtempSync(path23.join(tmpdir2(), "ba-devsrv-sh-"));
+function trySpawnShellScriptLogRedirectUnix(command, env, cwd, signal) {
+  const tmpRoot = fs20.mkdtempSync(path23.join(tmpdir2(), "ba-devsrv-sh-"));
   const logPath = path23.join(tmpRoot, "combined.log");
   const innerPath = path23.join(tmpRoot, "_cmd.sh");
   const runnerPath = path23.join(tmpRoot, "_run.sh");
   try {
-    fs19.writeFileSync(innerPath, `#!/bin/sh
+    fs20.writeFileSync(innerPath, `#!/bin/sh
 ${command}
 `);
-    fs19.writeFileSync(
+    fs20.writeFileSync(
       runnerPath,
       `#!/bin/sh
-cd ${shSingleQuote(cwd3)}
+cd ${shSingleQuote(cwd)}
 /bin/sh ${shSingleQuote(innerPath)} >>${shSingleQuote(logPath)} 2>&1
 `
     );
@@ -32402,17 +30949,17 @@ cd ${shSingleQuote(cwd3)}
     throw e;
   }
 }
-function trySpawnShellScriptLogRedirectWin(command, env, cwd3, signal) {
-  const tmpRoot = fs19.mkdtempSync(path23.join(tmpdir2(), "ba-devsrv-sh-"));
+function trySpawnShellScriptLogRedirectWin(command, env, cwd, signal) {
+  const tmpRoot = fs20.mkdtempSync(path23.join(tmpdir2(), "ba-devsrv-sh-"));
   const logPath = path23.join(tmpRoot, "combined.log");
   const runnerPath = path23.join(tmpRoot, "_run.bat");
   const q = (p) => `"${p.replace(/"/g, '""')}"`;
   const com = process.env.ComSpec || "cmd.exe";
   try {
-    fs19.writeFileSync(
+    fs20.writeFileSync(
       runnerPath,
       `@ECHO OFF\r
-CD /D ${q(cwd3)}\r
+CD /D ${q(cwd)}\r
 ${command} >> ${q(logPath)} 2>&1\r
 `
     );
@@ -32438,10 +30985,10 @@ ${command} >> ${q(logPath)} 2>&1\r
 
 // src/dev-servers/manager/shell-spawn/try-spawn-inherit.ts
 import { spawn as spawn9 } from "node:child_process";
-function trySpawnInheritStdio(command, env, cwd3, signal) {
+function trySpawnInheritStdio(command, env, cwd, signal) {
   const opts = {
     env,
-    cwd: cwd3,
+    cwd,
     stdio: "inherit",
     ...signal ? { signal } : {}
   };
@@ -32457,27 +31004,27 @@ function trySpawnInheritStdio(command, env, cwd3, signal) {
 }
 
 // src/dev-servers/manager/shell-spawn/shell-spawn.ts
-function shellSpawn(command, env, cwd3, options) {
+function shellSpawn(command, env, cwd, options) {
   const signal = options?.signal;
-  const piped = trySpawnPipedViaSh(command, env, cwd3, signal);
+  const piped = trySpawnPipedViaSh(command, env, cwd, signal);
   if (piped.ok) {
     return piped.result;
   }
   let lastErr = piped.lastErr;
-  const shellTrueProc = trySpawnShellTruePiped(command, env, cwd3, devNullReadFd(), signal);
+  const shellTrueProc = trySpawnShellTruePiped(command, env, cwd, devNullReadFd(), signal);
   if (shellTrueProc) {
     return { proc: shellTrueProc, pipedStdoutStderr: true };
   }
-  const fileCapture = trySpawnMergedLogFile(command, env, cwd3, signal);
+  const fileCapture = trySpawnMergedLogFile(command, env, cwd, signal);
   if (fileCapture) {
     return fileCapture;
   }
-  const scriptCapture = process.platform === "win32" ? trySpawnShellScriptLogRedirectWin(command, env, cwd3, signal) : trySpawnShellScriptLogRedirectUnix(command, env, cwd3, signal);
+  const scriptCapture = process.platform === "win32" ? trySpawnShellScriptLogRedirectWin(command, env, cwd, signal) : trySpawnShellScriptLogRedirectUnix(command, env, cwd, signal);
   if (scriptCapture) {
     return scriptCapture;
   }
   try {
-    return trySpawnInheritStdio(command, env, cwd3, signal);
+    return trySpawnInheritStdio(command, env, cwd, signal);
   } catch (e) {
     throw lastErr instanceof Error ? lastErr : e instanceof Error ? e : new Error(String(e));
   }
@@ -32535,9 +31082,11 @@ var DevServerManager = class {
   abortControllersByServerId = /* @__PURE__ */ new Map();
   getWs;
   log;
+  getBridgeCwd;
   constructor(options) {
     this.getWs = options.getWs;
     this.log = options.log;
+    this.getBridgeCwd = options.getBridgeCwd ?? (() => process.cwd());
   }
   attachFirehose(send) {
     this.firehoseSend = send;
@@ -32661,7 +31210,7 @@ var DevServerManager = class {
     this.sendStatus(serverId, "starting", void 0, emptyTails());
     const ac = new AbortController();
     this.abortControllersByServerId.set(serverId, ac);
-    const cwd3 = process.cwd();
+    const cwd = this.getBridgeCwd();
     const childEnv = envForSpawn(process.env, def.env, def.ports);
     const cmd = substituteCommand(def.command.trim(), childEnv);
     const title = def.name.trim() || serverId.slice(0, 8);
@@ -32676,7 +31225,7 @@ var DevServerManager = class {
       let mergedLogPath;
       let mergedCleanupDir;
       try {
-        const spawned = shellSpawn(cmd, childEnv, cwd3, {
+        const spawned = shellSpawn(cmd, childEnv, cwd, {
           signal: ac.signal
         });
         proc = spawned.proc;
@@ -32685,7 +31234,7 @@ var DevServerManager = class {
         mergedCleanupDir = spawned.mergedLogCleanupDir;
       } catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        this.log(`[dev-server] ${title} failed to start: ${msg}`);
+        this.log(`[dev-server] Failed to start ${title}: ${msg}`);
         this.abortControllersByServerId.delete(serverId);
         this.sendStatus(serverId, "error", msg, emptyTails());
         return;
@@ -32810,7 +31359,7 @@ function startStreamingProxy(ws, log2, pr) {
     },
     onEnd: () => sendWsMessage(ws, { type: "proxy_result_end", id: pr.id }),
     onError: (error40) => {
-      log2(`[Proxy and log service] streaming preview failed: ${error40}`);
+      log2(`[Proxy and log service] Streaming preview failed: ${error40}`);
       sendWsMessage(ws, { type: "proxy_result_error", id: pr.id, error: error40 });
     }
   });
@@ -32883,11 +31432,11 @@ var handleProxyMessage = (msg, deps) => {
     return;
   }
   void proxyToLocal(pr).then((res) => {
-    if (res.error) deps.log(`[Proxy and log service] preview proxy failed: ${res.error}`);
+    if (res.error) deps.log(`[Proxy and log service] Preview proxy failed: ${res.error}`);
     sendWsMessage(deps.ws, { type: "proxy_result", ...res, id: pr.id });
   }).catch((err) => {
     deps.log(
-      `[Proxy and log service] preview proxy failed: ${err instanceof Error ? err.message : String(err)}`
+      `[Proxy and log service] Preview proxy failed: ${err instanceof Error ? err.message : String(err)}`
     );
     sendWsMessage(deps.ws, { type: "proxy_result", id: pr.id, error: String(err) });
   });
@@ -32924,6 +31473,7 @@ function tryConsumeBinaryProxyBody(raw, deps) {
 }
 
 // src/firehose/connect-firehose.ts
+var FIREHOSE_CLIENT_PING_MS = 25e3;
 function connectFirehose(options) {
   const { firehoseServerUrl, workspaceId, bridgeName, proxyPorts, log: log2, devServerManager, onOpen, onClose } = options;
   const wsUrl = buildFirehoseCliWsUrl(firehoseServerUrl);
@@ -32932,6 +31482,13 @@ function connectFirehose(options) {
     wsOptions.agent = new https2.Agent({ rejectUnauthorized: false });
   }
   const ws = new wrapper_default(wsUrl, wsOptions);
+  let clientPingTimer = null;
+  function clearClientPing() {
+    if (clientPingTimer != null) {
+      clearInterval(clientPingTimer);
+      clientPingTimer = null;
+    }
+  }
   const firehoseSend = (payload) => {
     sendWsMessage(ws, payload);
   };
@@ -32944,6 +31501,15 @@ function connectFirehose(options) {
     startStreamingProxy: (pr) => startStreamingProxy(ws, log2, pr)
   };
   ws.on("open", () => {
+    clearClientPing();
+    clientPingTimer = setInterval(() => {
+      if (ws.readyState === wrapper_default.OPEN) {
+        try {
+          ws.ping();
+        } catch {
+        }
+      }
+    }, FIREHOSE_CLIENT_PING_MS);
     onOpen?.();
     devServerManager.attachFirehose(firehoseSend);
     sendWsMessage(ws, { type: "identify", workspaceId, bridgeName, proxyPorts });
@@ -32961,35 +31527,30 @@ function connectFirehose(options) {
     });
   });
   ws.on("close", (code, reason) => {
+    clearClientPing();
     devServerManager.detachFirehose();
-    log2(
-      formatWebSocketClose(
-        "[Proxy and log service]",
-        code,
-        typeof reason === "string" ? reason : reason.toString(),
-        "reconnects automatically if the bridge service stays connected"
-      )
-    );
-    onClose?.();
+    const reasonStr = typeof reason === "string" ? reason : reason.toString();
+    onClose?.(code, reasonStr);
   });
   ws.on("error", (err) => {
+    clearClientPing();
     log2(`[Proxy and log service] WebSocket error: ${err.message}`);
   });
   return {
     close() {
+      clearClientPing();
       devServerManager.detachFirehose();
       try {
         ws.removeAllListeners();
         ws.close();
       } catch {
       }
-    }
+    },
+    isConnected: () => ws.readyState === wrapper_default.OPEN
   };
 }
 
 // src/bridge/connection/create-bridge-identified-handler.ts
-var FH_RECONNECT_BASE_MS = 2e3;
-var FH_RECONNECT_MAX_MS = 3e4;
 function createOnBridgeIdentified(opts) {
   const { sessionWorktreeManager, devServerManager, firehoseServerUrl, workspaceId, state, logFn } = opts;
   function clearFirehoseReconnectTimer() {
@@ -32998,6 +31559,14 @@ function createOnBridgeIdentified(opts) {
       state.firehoseReconnectTimeout = null;
     }
   }
+  function firehoseCtx() {
+    return {
+      closedByUser: state.closedByUser,
+      currentWs: state.currentWs,
+      firehoseHandle: state.firehoseHandle,
+      firehoseQuiet: state.firehoseQuiet
+    };
+  }
   function attachFirehose(params) {
     state.lastFirehoseParams = params;
     clearFirehoseReconnectTimer();
@@ -33016,37 +31585,52 @@ function createOnBridgeIdentified(opts) {
       devServerManager,
       onOpen: () => {
         if (myGen !== state.firehoseGeneration) return;
+        clearFirehoseReconnectQuietOnOpen({ firehoseQuiet: state.firehoseQuiet }, logFn);
+        const logOpenAsFirehoseReconnect = state.firehoseReconnectAttempt > 0;
         state.firehoseReconnectAttempt = 0;
+        if (logOpenAsFirehoseReconnect) {
+          logFn("[Proxy and log service] reconnected.");
+        }
       },
-      onClose: () => {
+      onClose: (code, reason) => {
         if (myGen !== state.firehoseGeneration) return;
         state.firehoseHandle = null;
         if (state.closedByUser) return;
         const main = state.currentWs;
         if (!main || main.readyState !== wrapper_default.OPEN) {
-          logFn("[Proxy and log service] not reconnecting: bridge service socket is not open");
+          logFn(
+            `${PROXY_AND_LOG_SERVICE_LABEL} Not reconnecting preview and log stream: main bridge connection is not open.`
+          );
           return;
         }
+        beginFirehoseDeferredDisconnect(firehoseCtx(), code, reason, logFn);
         clearFirehoseReconnectTimer();
-        const delay2 = Math.min(
-          FH_RECONNECT_BASE_MS * 2 ** state.firehoseReconnectAttempt,
-          FH_RECONNECT_MAX_MS
-        );
+        const delay2 = reconnectDelayMs(state.firehoseReconnectAttempt);
         state.firehoseReconnectAttempt += 1;
-        logFn(
-          `[Proxy and log service] reconnect attempt ${state.firehoseReconnectAttempt} in ${delay2 / 1e3}s\u2026`
+        logNextReconnectAttempt(
+          logFn,
+          PROXY_AND_LOG_SERVICE_LABEL,
+          state.firehoseQuiet,
+          delay2,
+          state.firehoseReconnectAttempt
         );
         state.firehoseReconnectTimeout = setTimeout(() => {
           state.firehoseReconnectTimeout = null;
           if (state.closedByUser) return;
           const w = state.currentWs;
           if (!w || w.readyState !== wrapper_default.OPEN) {
-            logFn("[Proxy and log service] reconnect skipped: bridge service socket closed");
+            if (state.firehoseQuiet.verboseLogs) {
+              logFn(
+                `${PROXY_AND_LOG_SERVICE_LABEL} Reconnect skipped: main bridge connection closed before preview stream could reconnect.`
+              );
+            }
             return;
           }
           const p = state.lastFirehoseParams;
           if (!p) {
-            logFn("[Proxy and log service] reconnect skipped: no stored connection params");
+            if (state.firehoseQuiet.verboseLogs) {
+              logFn(`${PROXY_AND_LOG_SERVICE_LABEL} Reconnect skipped: no stored connection parameters.`);
+            }
             return;
           }
           attachFirehose(p);
@@ -33129,10 +31713,12 @@ function createSendLocalSkillsReport(getWs, logFn) {
     try {
       const socket = getWs();
       if (!socket || socket.readyState !== wrapper_default.OPEN) return;
-      const skills2 = discoverLocalSkills(process.cwd());
+      const skills2 = discoverLocalSkills(getBridgeWorkspaceDirectory());
       socket.send(JSON.stringify({ type: "local_skills", skills: skills2 }));
     } catch (e) {
-      logFn(`[Bridge service] local_skills report failed: ${e instanceof Error ? e.message : String(e)}`);
+      logFn(
+        `[Bridge service] Local skills report failed: ${e instanceof Error ? e.message : String(e)}`
+      );
     }
   };
 }
@@ -33145,12 +31731,15 @@ function createReportAutoDetectedAgents(getWs, logFn) {
         sendWsMessage(socket, { type: "auto_detected_agents_report", agentTypes: types });
       }
     } catch (e) {
-      logFn(`[Bridge service] auto_detected_agents report failed: ${e instanceof Error ? e.message : String(e)}`);
+      logFn(
+        `[Bridge service] Auto-detected agents report failed: ${e instanceof Error ? e.message : String(e)}`
+      );
     }
   };
 }
 
 // src/bridge/connection/create-bridge-connection.ts
+var BRIDGE_CLIENT_PING_MS = 25e3;
 async function createBridgeConnection(options) {
   const { apiUrl, workspaceId, justAuthenticated, onAuthInvalid, persistTokens } = options;
   const firehoseServerUrl = options.firehoseServerUrl ?? options.proxyServerUrl;
@@ -33161,13 +31750,16 @@ async function createBridgeConnection(options) {
   const state = {
     closedByUser: false,
     reconnectAttempt: 0,
+    logBridgeOpenAsReconnect: false,
     reconnectTimeout: null,
     currentWs: null,
+    mainQuiet: createEmptyReconnectQuietSlot(),
     firehoseHandle: null,
     lastFirehoseParams: null,
     firehoseReconnectTimeout: null,
     firehoseReconnectAttempt: 0,
-    firehoseGeneration: 0
+    firehoseGeneration: 0,
+    firehoseQuiet: createEmptyReconnectQuietSlot()
   };
   const worktreesRootAbs = options.worktreesRootAbs ?? defaultWorktreesRootAbs();
   const sessionWorktreeManager = new SessionWorktreeManager({
@@ -33179,7 +31771,7 @@ async function createBridgeConnection(options) {
   function getWs() {
     return state.currentWs;
   }
-  const devServerManager = new DevServerManager({ getWs, log: logFn });
+  const devServerManager = new DevServerManager({ getWs, log: logFn, getBridgeCwd: getBridgeWorkspaceDirectory });
   const onBridgeIdentified = createOnBridgeIdentified({
     sessionWorktreeManager,
     devServerManager,
@@ -33191,7 +31783,13 @@ async function createBridgeConnection(options) {
   const sendLocalSkillsReport = createSendLocalSkillsReport(getWs, logFn);
   const reportAutoDetectedAgents = createReportAutoDetectedAgents(getWs, logFn);
   function handleOpen() {
+    const logOpenAsPostRefreshReconnect = state.logBridgeOpenAsReconnect;
+    clearMainBridgeReconnectQuietOnOpen(state, logFn);
     state.reconnectAttempt = 0;
+    state.logBridgeOpenAsReconnect = false;
+    if (logOpenAsPostRefreshReconnect) {
+      logFn("[Bridge service] reconnected.");
+    }
     const socket = getWs();
     if (socket) {
       sendWsMessage(socket, { type: "identify", role: "cli" });
@@ -33208,11 +31806,9 @@ async function createBridgeConnection(options) {
     state.currentWs = null;
     if (was) was.removeAllListeners();
     const willReconnect = !state.closedByUser;
-    logFn(
-      formatWebSocketClose("[Bridge service]", code, reason, willReconnect ? "will schedule reconnect" : "not reconnecting (CLI shutting down)")
-    );
+    beginMainBridgeDeferredDisconnect(state, code, reason, logFn, willReconnect);
     if (willReconnect) {
-      scheduleReconnect(state, connect, logFn);
+      scheduleMainBridgeReconnect(state, connect, logFn);
     }
   }
   const messageDeps = {
@@ -33227,6 +31823,10 @@ async function createBridgeConnection(options) {
   };
   function connect() {
     if (state.closedByUser) return;
+    if (state.reconnectTimeout != null) {
+      clearTimeout(state.reconnectTimeout);
+      state.reconnectTimeout = null;
+    }
     const prev = state.currentWs;
     if (prev) {
       prev.removeAllListeners();
@@ -33239,6 +31839,7 @@ async function createBridgeConnection(options) {
     const url2 = buildBridgeUrl(apiUrl, workspaceId, accessToken);
     state.currentWs = createWsBridge({
       url: url2,
+      clientPingIntervalMs: BRIDGE_CLIENT_PING_MS,
       onAuthInvalid: () => {
         if (authRefreshInFlight) return;
         void (async () => {
@@ -33250,8 +31851,9 @@ async function createBridgeConnection(options) {
                 accessToken = next.token;
                 refreshTok = next.refreshToken;
                 persistTokens?.({ token: accessToken, refreshToken: refreshTok });
-                logFn("[Bridge service] access token refreshed; reconnecting\u2026");
+                logFn("[Bridge service] Access token refreshed; reconnecting\u2026");
                 state.reconnectAttempt = 0;
+                state.logBridgeOpenAsReconnect = true;
                 authRefreshInFlight = false;
                 connect();
                 return;
@@ -33274,7 +31876,7 @@ async function createBridgeConnection(options) {
     });
   }
   connect();
-  const stopFileIndexWatcher = startFileIndexWatcher(process.cwd());
+  const stopFileIndexWatcher = startFileIndexWatcher(getBridgeWorkspaceDirectory());
   return {
     close: async () => {
       stopFileIndexWatcher();
@@ -33347,7 +31949,7 @@ async function runBridge(options) {
       });
     },
     onAuthInvalid: () => {
-      log("[Bridge service] token invalid or revoked; re-authenticating\u2026");
+      log("[Bridge service] Access token invalid or revoked; re-authenticating\u2026");
       clearConfigForApi(apiUrl);
       void handle.close().then(() => {
         void runBridge({ apiUrl, firehoseServerUrl, worktreesRootAbs });
@@ -33381,9 +31983,4 @@ export {
   runPendingAuth,
   sendWsMessage
 };
-/*! Bundled license information:
-
-chokidar/esm/index.js:
-  (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
-*/
 //# sourceMappingURL=index.js.map