@buildautomaton/cli 0.1.1 → 0.1.3

package/dist/index.js

@@ -2236,7 +2236,7 @@ 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 https2 = __require("https");
+    var https3 = __require("https");
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
@@ -2771,7 +2771,7 @@ var require_websocket = __commonJS({
       }
       const defaultPort = isSecure ? 443 : 80;
       const key = randomBytes(16).toString("base64");
-      const request = isSecure ? https2.request : http.request;
+      const request = isSecure ? https3.request : http.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
       opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
@@ -4065,8 +4065,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path23, errorMaps, issueData } = params;
-      const fullPath = [...path23, ...issueData.path || []];
+      const { data, path: path24, errorMaps, issueData } = params;
+      const fullPath = [...path24, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -4374,11 +4374,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path23, key) {
+      constructor(parent, value, path24, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path23;
+        this._path = path24;
         this._key = key;
       }
       get path() {
@@ -7993,10 +7993,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path23) {
-  if (!path23)
+function getElementAtPath(obj, path24) {
+  if (!path24)
     return obj;
-  return path23.reduce((acc, key) => acc?.[key], obj);
+  return path24.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -8245,11 +8245,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path23, issues) {
+function prefixIssues(path24, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path23);
+    iss.path.unshift(path24);
     return iss;
   });
 }
@@ -8438,7 +8438,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path23 = []) => {
+  const processError = (error41, path24 = []) => {
     var _a2, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -8448,7 +8448,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path23, ...issue2.path];
+        const fullpath = [...path24, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -8478,9 +8478,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path23) {
+function toDotPath(path24) {
   const segs = [];
-  for (const seg of path23) {
+  for (const seg of path24) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -21963,10 +21963,10 @@ var require_src2 = __commonJS({
     var fs_1 = __require("fs");
     var debug_1 = __importDefault(require_src());
     var log2 = debug_1.default("@kwsites/file-exists");
-    function check2(path23, isFile, isDirectory) {
-      log2(`checking %s`, path23);
+    function check2(path24, isFile, isDirectory) {
+      log2(`checking %s`, path24);
       try {
-        const stat4 = fs_1.statSync(path23);
+        const stat4 = fs_1.statSync(path24);
         if (stat4.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
@@ -21986,8 +21986,8 @@ var require_src2 = __commonJS({
         throw e;
       }
     }
-    function exists2(path23, type = exports.READABLE) {
-      return check2(path23, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
+    function exists2(path24, type = exports.READABLE) {
+      return check2(path24, (type & exports.FILE) > 0, (type & exports.FOLDER) > 0);
     }
     exports.exists = exists2;
     exports.FILE = 1;
@@ -22114,48 +22114,24 @@ function sendWsMessage(ws, payload) {
 
 // src/acp/clients/acp-client.ts
 import { spawn } from "node:child_process";
-import path from "node:path";
 import { Readable, Writable } from "node:stream";
-
-// src/acp/format-acp-rpc-error.ts
-function formatAcpRpcError(err) {
-  if (err instanceof Error) return err.message;
-  if (err != null && typeof err === "object") {
-    const o = err;
-    if (typeof o.message === "string") {
-      const code = typeof o.code === "number" ? ` (code ${o.code})` : "";
-      return `${o.message}${code}`;
-    }
-  }
-  if (typeof err === "string") return err;
-  try {
-    return JSON.stringify(err);
-  } catch {
-    return String(err);
-  }
-}
-function isAcpAuthenticationRequiredError(err) {
-  if (err == null || typeof err !== "object") return false;
-  const o = err;
-  if (o.code === -32e3 && typeof o.message === "string") {
-    const m2 = o.message.toLowerCase();
-    if (m2.includes("authentication") || m2.includes("auth")) return true;
-  }
-  const m = typeof o.message === "string" ? o.message.toLowerCase() : "";
-  return m.includes("authentication required") || m.includes("auth_required");
-}
-
-// 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.`;
   }
   return err.message || String(err);
 }
+function toErrorMessage(err) {
+  if (err instanceof Error) return err.message;
+  if (err != null && typeof err === "object" && "message" in err)
+    return String(err.message);
+  if (typeof err === "string") return err;
+  if (err != null && typeof err === "object") return JSON.stringify(err);
+  return String(err);
+}
 async function createAcpClient(options) {
-  const { ClientSideConnection: ClientSideConnection2, ndJsonStream: ndJsonStream2, PROTOCOL_VERSION: PROTOCOL_VERSION2 } = await Promise.resolve().then(() => (init_acp(), acp_exports));
+  const { ClientSideConnection: ClientSideConnection2, ndJsonStream: ndJsonStream2 } = await Promise.resolve().then(() => (init_acp(), acp_exports));
   const { command, cwd: cwd3 = process.cwd(), onSessionUpdate } = options;
-  const sessionCwd = path.resolve(cwd3);
   const isWindows2 = process.platform === "win32";
   const child = spawn(command[0], command.slice(1), {
     cwd: cwd3,
@@ -22186,13 +22162,11 @@ async function createAcpClient(options) {
           child.kill();
         });
         await connection.initialize({
-          protocolVersion: PROTOCOL_VERSION2,
+          protocolVersion: "0.1.0",
+          capabilities: {},
           clientInfo: { name: "buildautomaton-cli", version: "0.1.0" }
         });
-        const newSessionRes = await connection.newSession({
-          cwd: sessionCwd,
-          mcpServers: []
-        });
+        const newSessionRes = await connection.newSession({ workingDirectory: cwd3 });
         const sessionId = newSessionRes.sessionId;
         resolve16({
           sessionId,
@@ -22200,7 +22174,7 @@ async function createAcpClient(options) {
             try {
               const response = await connection.prompt({
                 sessionId,
-                prompt: [{ type: "text", text: prompt }]
+                prompt: { type: "text", text: prompt }
               });
               const r = response;
               const cancelled = (r?.stopReason ?? "").toLowerCase() === "cancelled";
@@ -22213,8 +22187,7 @@ async function createAcpClient(options) {
             } catch (err) {
               return {
                 success: false,
-                error: formatAcpRpcError(err),
-                ...isAcpAuthenticationRequiredError(err) ? { authRequired: true } : {}
+                error: err instanceof Error ? err.message : String(err)
               };
             }
           },
@@ -22232,13 +22205,13 @@ async function createAcpClient(options) {
         });
       } catch (err) {
         child.kill();
-        reject(new Error(formatAcpRpcError(err)));
+        reject(new Error(toErrorMessage(err)));
       }
     })();
   });
 }
 
-// src/proxy/local-proxy.ts
+// src/firehose/proxy/local-proxy.ts
 var ALLOWED_HOSTS = ["localhost", "127.0.0.1", "::1"];
 function isAllowedHost(host) {
   const h = host.replace(/^\[|\]$/g, "");
@@ -22366,8 +22339,8 @@ function randomSecret() {
   }
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
-async function requestPreviewApi(port, secret, method, path23, body) {
-  const url2 = `http://127.0.0.1:${port}${path23}`;
+async function requestPreviewApi(port, secret, method, path24, body) {
+  const url2 = `http://127.0.0.1:${port}${path24}`;
   const headers = {
     [PREVIEW_SECRET_HEADER]: secret,
     "Content-Type": "application/json"
@@ -22379,7 +22352,7 @@ async function requestPreviewApi(port, secret, method, path23, body) {
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {
-    throw new Error(data?.error ?? `Preview API ${method} ${path23}: ${res.status}`);
+    throw new Error(data?.error ?? `Preview API ${method} ${path24}: ${res.status}`);
   }
   return data;
 }
@@ -22527,14 +22500,19 @@ function log(line) {
   const time3 = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
   console.log(`[${time3}] ${line}`);
 }
+function logImmediate(line) {
+  const time3 = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+  process.stdout.write(`[${time3}] ${line}
+`);
+}
 
 // src/config.ts
 import fs from "node:fs";
-import path2 from "node:path";
+import path from "node:path";
 import os from "node:os";
 function getConfigPath() {
-  const dir = path2.join(os.homedir(), ".buildautomaton");
-  return path2.join(dir, "config.json");
+  const dir = path.join(os.homedir(), ".buildautomaton");
+  return path.join(dir, "config.json");
 }
 function normalizeApiUrl(url2) {
   return url2.replace(/\/$/, "");
@@ -22550,7 +22528,7 @@ function readRawConfig() {
 }
 function writeConfigForApi(apiUrl, auth) {
   const p = getConfigPath();
-  const dir = path2.dirname(p);
+  const dir = path.dirname(p);
   const key = normalizeApiUrl(apiUrl);
   const prev = readRawConfig() ?? {};
   const servers = { ...prev.servers ?? {}, [key]: { ...auth } };
@@ -22621,11 +22599,41 @@ function openBrowser(connectionId, initialWorkspaceId, preferredBridgeName, apiU
   }
 }
 
+// src/bridge/connection/ws-close-diagnostics.ts
+function describeWebSocketCloseCode(code) {
+  const known = {
+    1e3: "normal closure",
+    1001: "going away",
+    1002: "protocol error",
+    1003: "unsupported data",
+    1005: "no status (reserved)",
+    1006: "abnormal closure \u2014 often network loss, proxy, or idle timeout (no close frame)",
+    1007: "invalid payload data",
+    1008: "policy violation",
+    1009: "message too big",
+    1010: "mandatory extension",
+    1011: "internal server error",
+    1012: "service restart",
+    1013: "try again later",
+    1014: "bad gateway",
+    1015: "TLS handshake failed"
+  };
+  if (known[code]) return known[code];
+  if (code >= 3e3 && code <= 3999) return "registered (framework)";
+  if (code >= 4e3 && code <= 4999) return "application-specific";
+  return "non-standard";
+}
+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}`;
+}
+
 // src/auth/run-pending-auth.ts
 var PENDING_RECONNECT_MS = 2e3;
 var PENDING_KEEPALIVE_MS = 25e3;
 var BROWSER_OPEN_FALLBACK_MS = 4e3;
-var WAITING_REMINDER_MS = 15e3;
 function buildPendingBridgeUrl(apiUrl, connectionId) {
   const base = apiUrl.startsWith("https") ? apiUrl.replace(/^https/, "wss") : apiUrl.replace(/^http/, "ws");
   const params = new URLSearchParams({ connectionId });
@@ -22638,7 +22646,6 @@ function runPendingAuth(options) {
   let reconnectTimeout = null;
   let keepaliveInterval = null;
   let browserFallback = null;
-  let waitingReminderInterval = null;
   const connectionId = crypto.randomUUID();
   let hasOpenedBrowser = false;
   let resolved = false;
@@ -22659,10 +22666,6 @@ function runPendingAuth(options) {
       clearInterval(keepaliveInterval);
       keepaliveInterval = null;
     }
-    if (waitingReminderInterval) {
-      clearInterval(waitingReminderInterval);
-      waitingReminderInterval = null;
-    }
     if (ws) {
       ws.removeAllListeners();
       ws.close();
@@ -22674,7 +22677,6 @@ function runPendingAuth(options) {
     ws = createWsBridge({
       url: url2,
       onOpen: () => {
-        logFn("WebSocket connected (pending auth)");
         sendWsMessage(ws, { type: "identify", role: "cli" });
         keepaliveInterval = setInterval(() => {
           if (resolved || !ws || ws.readyState !== 1) return;
@@ -22694,21 +22696,21 @@ function runPendingAuth(options) {
           clearInterval(keepaliveInterval);
           keepaliveInterval = null;
         }
-        logFn(`WebSocket closed: ${code} ${reason}`);
         if (resolved) return;
-        logFn("Reconnecting in 2s\u2026");
+        logFn(
+          formatWebSocketClose("[Bridge service]", code, reason, "pending sign-in; will reconnect in 2s")
+        );
         reconnectTimeout = setTimeout(() => {
           reconnectTimeout = null;
           connect();
         }, PENDING_RECONNECT_MS);
       },
-      onError: (err) => logFn(`WebSocket error: ${err.message}`),
+      onError: (err) => logFn(`[Bridge service] WebSocket error (pending sign-in): ${err.message}`),
       onMessage: (data) => {
         const msg = data;
         if (msg.type === "auth_token" && typeof msg.token === "string") {
           resolved = true;
           const workspaceId = typeof msg.workspaceId === "string" ? msg.workspaceId : "";
-          logFn("Received auth token; reconnecting as bridge for workspace\u2026");
           cleanup();
           const refreshToken = typeof msg.refreshToken === "string" ? msg.refreshToken : void 0;
           const result = { workspaceId, token: msg.token, refreshToken };
@@ -22718,7 +22720,6 @@ function runPendingAuth(options) {
       }
     });
   }
-  logFn("Connecting to backend (pending auth)\u2026");
   browserFallback = setTimeout(() => {
     browserFallback = null;
     if (!hasOpenedBrowser) {
@@ -22726,10 +22727,6 @@ function runPendingAuth(options) {
       openBrowser(connectionId, initialWorkspaceId, preferredBridgeName, apiUrl, logFn);
     }
   }, BROWSER_OPEN_FALLBACK_MS);
-  waitingReminderInterval = setInterval(() => {
-    if (resolved) return;
-    logFn("Waiting for you to link the CLI in the browser\u2026");
-  }, WAITING_REMINDER_MS);
   connect();
   return {
     close: () => {
@@ -22740,69 +22737,6 @@ function runPendingAuth(options) {
   };
 }
 
-// src/skills/discover-local-agent-skills.ts
-import fs2 from "node:fs";
-import path3 from "node:path";
-var SKILL_DISCOVERY_ROOTS = [".agents/skills", ".claude/skills", ".cursor/skills", "skills"];
-function discoverLocalSkills(cwd3) {
-  const out = [];
-  const seenKeys = /* @__PURE__ */ new Set();
-  for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path3.join(cwd3, rel);
-    if (!fs2.existsSync(base) || !fs2.statSync(base).isDirectory()) continue;
-    let entries = [];
-    try {
-      entries = fs2.readdirSync(base);
-    } catch {
-      continue;
-    }
-    for (const name of entries) {
-      const dir = path3.join(base, name);
-      try {
-        if (!fs2.statSync(dir).isDirectory()) continue;
-      } catch {
-        continue;
-      }
-      const skillMd = path3.join(dir, "SKILL.md");
-      if (!fs2.existsSync(skillMd)) continue;
-      const key = `${rel}/${name}`;
-      if (seenKeys.has(key)) continue;
-      seenKeys.add(key);
-      out.push({ skillKey: name, path: `${rel}/${name}`.replace(/\\/g, "/") });
-    }
-  }
-  return out;
-}
-function discoverSkillLayoutRoots(cwd3) {
-  const roots = [];
-  for (const rel of SKILL_DISCOVERY_ROOTS) {
-    const base = path3.join(cwd3, rel);
-    if (!fs2.existsSync(base) || !fs2.statSync(base).isDirectory()) continue;
-    let entries = [];
-    try {
-      entries = fs2.readdirSync(base);
-    } catch {
-      continue;
-    }
-    const skills2 = [];
-    for (const name of entries) {
-      const dir = path3.join(base, name);
-      try {
-        if (!fs2.statSync(dir).isDirectory()) continue;
-      } catch {
-        continue;
-      }
-      if (!fs2.existsSync(path3.join(dir, "SKILL.md"))) continue;
-      const relPath = `${rel}/${name}`.replace(/\\/g, "/");
-      skills2.push({ name, relPath });
-    }
-    if (skills2.length > 0) {
-      roots.push({ path: rel.replace(/\\/g, "/"), skills: skills2 });
-    }
-  }
-  return roots;
-}
-
 // src/bridge/connection/build-bridge-url.ts
 function buildBridgeUrl(apiUrl, workspaceId, authToken) {
   const base = apiUrl.startsWith("https") ? apiUrl.replace(/^https/, "wss") : apiUrl.replace(/^http/, "ws");
@@ -22811,8 +22745,8 @@ function buildBridgeUrl(apiUrl, workspaceId, authToken) {
 }
 
 // src/git/discover-repos.ts
-import * as fs3 from "node:fs";
-import * as path4 from "node:path";
+import * as fs2 from "node:fs";
+import * as path2 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);
@@ -22851,8 +22785,8 @@ function pathspec(...paths) {
   cache.set(key, paths);
   return key;
 }
-function isPathSpec(path23) {
-  return path23 instanceof String && cache.has(path23);
+function isPathSpec(path24) {
+  return path24 instanceof String && cache.has(path24);
 }
 function toPaths(pathSpec) {
   return cache.get(pathSpec) || [];
@@ -22941,8 +22875,8 @@ function toLinesWithContent(input = "", trimmed2 = true, separator = "\n") {
 function forEachLineWithContent(input, callback) {
   return toLinesWithContent(input, true).map((line) => callback(line));
 }
-function folderExists(path23) {
-  return (0, import_file_exists.exists)(path23, import_file_exists.FOLDER);
+function folderExists(path24) {
+  return (0, import_file_exists.exists)(path24, import_file_exists.FOLDER);
 }
 function append(target, item) {
   if (Array.isArray(target)) {
@@ -23346,8 +23280,8 @@ function checkIsRepoRootTask() {
     commands,
     format: "utf-8",
     onError,
-    parser(path23) {
-      return /^\.(git)?$/.test(path23.trim());
+    parser(path24) {
+      return /^\.(git)?$/.test(path24.trim());
     }
   };
 }
@@ -23781,11 +23715,11 @@ function parseGrep(grep) {
   const paths = /* @__PURE__ */ new Set();
   const results = {};
   forEachLineWithContent(grep, (input) => {
-    const [path23, line, preview] = input.split(NULL);
-    paths.add(path23);
-    (results[path23] = results[path23] || []).push({
+    const [path24, line, preview] = input.split(NULL);
+    paths.add(path24);
+    (results[path24] = results[path24] || []).push({
       line: asNumber(line),
-      path: path23,
+      path: path24,
       preview
     });
   });
@@ -24550,14 +24484,14 @@ var init_hash_object = __esm2({
     init_task();
   }
 });
-function parseInit(bare, path23, text) {
+function parseInit(bare, path24, text) {
   const response = String(text).trim();
   let result;
   if (result = initResponseRegex.exec(response)) {
-    return new InitSummary(bare, path23, false, result[1]);
+    return new InitSummary(bare, path24, false, result[1]);
   }
   if (result = reInitResponseRegex.exec(response)) {
-    return new InitSummary(bare, path23, true, result[1]);
+    return new InitSummary(bare, path24, true, result[1]);
   }
   let gitDir = "";
   const tokens = response.split(" ");
@@ -24568,7 +24502,7 @@ function parseInit(bare, path23, text) {
       break;
     }
   }
-  return new InitSummary(bare, path23, /^re/i.test(response), gitDir);
+  return new InitSummary(bare, path24, /^re/i.test(response), gitDir);
 }
 var InitSummary;
 var initResponseRegex;
@@ -24577,9 +24511,9 @@ var init_InitSummary = __esm2({
   "src/lib/responses/InitSummary.ts"() {
     "use strict";
     InitSummary = class {
-      constructor(bare, path23, existing, gitDir) {
+      constructor(bare, path24, existing, gitDir) {
         this.bare = bare;
-        this.path = path23;
+        this.path = path24;
         this.existing = existing;
         this.gitDir = gitDir;
       }
@@ -24591,7 +24525,7 @@ var init_InitSummary = __esm2({
 function hasBareCommand(command) {
   return command.includes(bareCommand);
 }
-function initTask(bare = false, path23, customArgs) {
+function initTask(bare = false, path24, customArgs) {
   const commands = ["init", ...customArgs];
   if (bare && !hasBareCommand(commands)) {
     commands.splice(1, 0, bareCommand);
@@ -24600,7 +24534,7 @@ function initTask(bare = false, path23, customArgs) {
     commands,
     format: "utf-8",
     parser(text) {
-      return parseInit(commands.includes("--bare"), path23, text);
+      return parseInit(commands.includes("--bare"), path24, text);
     }
   };
 }
@@ -25416,12 +25350,12 @@ var init_FileStatusSummary = __esm2({
     "use strict";
     fromPathRegex = /^(.+)\0(.+)$/;
     FileStatusSummary = class {
-      constructor(path23, index, working_dir) {
-        this.path = path23;
+      constructor(path24, index, working_dir) {
+        this.path = path24;
         this.index = index;
         this.working_dir = working_dir;
         if (index === "R" || working_dir === "R") {
-          const detail = fromPathRegex.exec(path23) || [null, path23, path23];
+          const detail = fromPathRegex.exec(path24) || [null, path24, path24];
           this.from = detail[2] || "";
           this.path = detail[1] || "";
         }
@@ -25452,14 +25386,14 @@ function splitLine(result, lineStr) {
     default:
       return;
   }
-  function data(index, workingDir, path23) {
+  function data(index, workingDir, path24) {
     const raw = `${index}${workingDir}`;
     const handler = parsers6.get(raw);
     if (handler) {
-      handler(result, path23);
+      handler(result, path24);
     }
     if (raw !== "##" && raw !== "!!") {
-      result.files.push(new FileStatusSummary(path23, index, workingDir));
+      result.files.push(new FileStatusSummary(path24, index, workingDir));
     }
   }
 }
@@ -25768,9 +25702,9 @@ var init_simple_git_api = __esm2({
           next
         );
       }
-      hashObject(path23, write) {
+      hashObject(path24, write) {
         return this._runTask(
-          hashObjectTask(path23, write === true),
+          hashObjectTask(path24, write === true),
           trailingFunctionArgument(arguments)
         );
       }
@@ -26123,8 +26057,8 @@ var init_branch = __esm2({
   }
 });
 function toPath(input) {
-  const path23 = input.trim().replace(/^["']|["']$/g, "");
-  return path23 && normalize(path23);
+  const path24 = input.trim().replace(/^["']|["']$/g, "");
+  return path24 && normalize(path24);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -26438,8 +26372,8 @@ __export2(sub_module_exports, {
   subModuleTask: () => subModuleTask,
   updateSubModuleTask: () => updateSubModuleTask
 });
-function addSubModuleTask(repo, path23) {
-  return subModuleTask(["add", repo, path23]);
+function addSubModuleTask(repo, path24) {
+  return subModuleTask(["add", repo, path24]);
 }
 function initSubModuleTask(customArgs) {
   return subModuleTask(["init", ...customArgs]);
@@ -26772,8 +26706,8 @@ var require_git = __commonJS2({
       }
       return this._runTask(straightThroughStringTask2(command, this._trimmed), next);
     };
-    Git2.prototype.submoduleAdd = function(repo, path23, then) {
-      return this._runTask(addSubModuleTask2(repo, path23), trailingFunctionArgument2(arguments));
+    Git2.prototype.submoduleAdd = function(repo, path24, then) {
+      return this._runTask(addSubModuleTask2(repo, path24), trailingFunctionArgument2(arguments));
     };
     Git2.prototype.submoduleUpdate = function(args, then) {
       return this._runTask(
@@ -27399,20 +27333,20 @@ async function isGitRepoDirectory(dirPath) {
 // src/git/discover-repos.ts
 async function discoverGitRepos(cwd3 = process.cwd()) {
   const result = [];
-  const cwdResolved = path4.resolve(cwd3);
+  const cwdResolved = path2.resolve(cwd3);
   if (await isGitRepoDirectory(cwdResolved)) {
     const remoteUrl = await getRemoteOriginUrl(cwdResolved);
     result.push({ absolutePath: cwdResolved, remoteUrl });
   }
   let entries;
   try {
-    entries = fs3.readdirSync(cwdResolved, { withFileTypes: true });
+    entries = fs2.readdirSync(cwdResolved, { withFileTypes: true });
   } catch {
     return result;
   }
   for (const ent of entries) {
     if (!ent.isDirectory()) continue;
-    const childPath = path4.join(cwdResolved, ent.name);
+    const childPath = path2.join(cwdResolved, ent.name);
     if (await isGitRepoDirectory(childPath)) {
       const remoteUrl = await getRemoteOriginUrl(childPath);
       result.push({ absolutePath: childPath, remoteUrl });
@@ -27421,22 +27355,22 @@ async function discoverGitRepos(cwd3 = process.cwd()) {
   return result;
 }
 async function discoverGitReposUnderRoot(rootAbs) {
-  const root = path4.resolve(rootAbs);
+  const root = path2.resolve(rootAbs);
   const roots = [];
   async function walk(dir) {
     if (await isGitRepoDirectory(dir)) {
-      roots.push(path4.resolve(dir));
+      roots.push(path2.resolve(dir));
       return;
     }
     let entries;
     try {
-      entries = fs3.readdirSync(dir, { withFileTypes: true });
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const ent of entries) {
       if (!ent.isDirectory() || ent.name === ".git") continue;
-      await walk(path4.join(dir, ent.name));
+      await walk(path2.join(dir, ent.name));
     }
   }
   await walk(root);
@@ -27460,11 +27394,10 @@ function reportGitRepos(getWs, log2) {
             type: "git_repos",
             repos: repos.map((r) => ({ absolutePath: r.absolutePath, remoteUrl: r.remoteUrl }))
           });
-          log2(`Reported ${repos.length} git repo(s) to bridge`);
         }
       }
     }).catch((err) => {
-      log2(`Git repo discovery failed: ${err instanceof Error ? err.message : String(err)}`);
+      log2(`[Bridge service] git repo discovery failed: ${err instanceof Error ? err.message : String(err)}`);
     });
   });
 }
@@ -27479,7 +27412,7 @@ function scheduleReconnect(state, connect, log2) {
     RECONNECT_MAX_MS
   );
   state.reconnectAttempt += 1;
-  log2(`Reconnecting in ${delay2 / 1e3}s\u2026`);
+  log2(`[Bridge service] reconnect attempt ${state.reconnectAttempt} in ${delay2 / 1e3}s\u2026`);
   state.reconnectTimeout = setTimeout(() => {
     state.reconnectTimeout = null;
     connect();
@@ -27487,18 +27420,33 @@ function scheduleReconnect(state, connect, log2) {
 }
 
 // src/bridge/connection/close-bridge-connection.ts
-function closeBridgeConnection(state, acpManager) {
+async function closeBridgeConnection(state, acpManager, devServerManager, log2) {
+  log2?.("Shutting down\u2026");
+  await new Promise((resolve16) => setImmediate(resolve16));
+  if (devServerManager) {
+    log2?.("Requesting dev server processes to stop\u2026");
+    await devServerManager.shutdownAllGraceful();
+  }
   state.closedByUser = true;
   if (state.reconnectTimeout != null) {
+    log2?.("Cancelling reconnect timer\u2026");
     clearTimeout(state.reconnectTimeout);
     state.reconnectTimeout = null;
   }
-  if (state.proxyHandle) {
-    state.proxyHandle.close();
-    state.proxyHandle = null;
+  if (state.firehoseReconnectTimeout != null) {
+    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");
+    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");
     state.currentWs.removeAllListeners();
     const wsState = state.currentWs.readyState;
     if (wsState === 1 || wsState === 2) {
@@ -27513,119 +27461,10 @@ function closeBridgeConnection(state, acpManager) {
   }
 }
 
-// src/proxy/connect-proxy.ts
-var PROXY_ID_BYTES = 36;
-function buildProxyWsUrl(proxyServerUrl) {
-  const base = proxyServerUrl.startsWith("https") ? proxyServerUrl.replace(/^https/, "wss") : proxyServerUrl.replace(/^http/, "ws");
-  return `${base.replace(/\/$/, "")}/ws`;
-}
-function connectProxy(options) {
-  const { proxyServerUrl, workspaceId, bridgeName, proxyPorts, log: log2, onClose } = options;
-  const proxyUrl = buildProxyWsUrl(proxyServerUrl);
-  log2(`Proxy: connecting to ${proxyUrl} (workspace: ${workspaceId}, bridge: ${bridgeName}, ports: [${proxyPorts.join(", ")}])`);
-  const ws = new wrapper_default(proxyUrl);
-  const pendingProxyBody = /* @__PURE__ */ new Map();
-  function startStreamingProxy(pr) {
-    proxyToLocalStreaming(pr, {
-      onStart: (statusCode, headers) => {
-        const forwardedHeaders = { ...headers };
-        const ce = "content-encoding";
-        const cl = "content-length";
-        const keys = Object.keys(forwardedHeaders).filter(
-          (k) => k.toLowerCase() !== ce && k.toLowerCase() !== cl
-        );
-        const filtered = {};
-        for (const k of keys) if (forwardedHeaders[k] != null) filtered[k] = forwardedHeaders[k];
-        sendWsMessage(ws, { type: "proxy_result_start", id: pr.id, statusCode, headers: filtered });
-      },
-      onChunk: (chunk) => {
-        const idBuf = Buffer.from(pr.id, "utf8");
-        ws.send(Buffer.concat([idBuf, Buffer.from(chunk)]), { binary: true });
-      },
-      onEnd: () => sendWsMessage(ws, { type: "proxy_result_end", id: pr.id }),
-      onError: (error40) => {
-        log2(`[proxy] ${pr.id.slice(0, 8)}\u2026 (stream) -> error: ${error40}`);
-        sendWsMessage(ws, { type: "proxy_result_error", id: pr.id, error: error40 });
-      }
-    });
-  }
-  ws.on("open", () => {
-    sendWsMessage(ws, { type: "identify", workspaceId, bridgeName, proxyPorts });
-  });
-  ws.on("message", (raw) => {
-    if (Buffer.isBuffer(raw) && raw.length >= PROXY_ID_BYTES) {
-      const id = raw.slice(0, PROXY_ID_BYTES).toString("utf8");
-      const pending = pendingProxyBody.get(id);
-      if (pending) {
-        pendingProxyBody.delete(id);
-        const body = raw.slice(PROXY_ID_BYTES);
-        startStreamingProxy({
-          ...pending.pr,
-          body: body.length > 0 ? new Uint8Array(body) : void 0
-        });
-        return;
-      }
-    }
-    try {
-      const data = JSON.parse(Buffer.isBuffer(raw) ? raw.toString("utf8") : String(raw));
-      if (data.type === "proxy" && data.proxy && typeof data.proxy === "object") {
-        const pr = data.proxy;
-        if (pr.streamResponse) {
-          const bodyLength = pr.bodyLength ?? 0;
-          if (bodyLength > 0) {
-            pendingProxyBody.set(pr.id, {
-              pr: {
-                id: pr.id,
-                method: pr.method,
-                url: pr.url,
-                headers: pr.headers,
-                streamResponse: true
-              }
-            });
-          } else {
-            startStreamingProxy({
-              id: pr.id,
-              method: pr.method,
-              url: pr.url,
-              headers: pr.headers,
-              streamResponse: true
-            });
-          }
-        } else {
-          proxyToLocal(pr).then((res) => {
-            if (res.error) log2(`[proxy] ${pr.id.slice(0, 8)}\u2026 -> error: ${res.error}`);
-            sendWsMessage(ws, { type: "proxy_result", ...res, id: pr.id });
-          }).catch((err) => {
-            log2(`[proxy] ${pr.id.slice(0, 8)}\u2026 -> error: ${err instanceof Error ? err.message : String(err)}`);
-            sendWsMessage(ws, { type: "proxy_result", id: pr.id, error: String(err) });
-          });
-        }
-      }
-    } catch {
-    }
-  });
-  ws.on("close", (_code, reason) => {
-    if (reason?.length) log2(`Proxy: WebSocket closed (reason: ${reason.toString()})`);
-    onClose?.();
-  });
-  ws.on("error", (err) => {
-    log2(`Proxy: WebSocket error connecting to ${proxyUrl}: ${err.message}`);
-  });
-  return {
-    close() {
-      try {
-        ws.removeAllListeners();
-        ws.close();
-      } catch {
-      }
-    }
-  };
-}
-
 // src/git/session-git-queue.ts
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import * as path5 from "node:path";
+import * as path3 from "node:path";
 var execFileAsync = promisify(execFile);
 var sessionBoundaryBySessionId = /* @__PURE__ */ new Map();
 async function gitStashCreate(repoRoot, log2) {
@@ -27676,7 +27515,7 @@ async function collectSessionDiffAndNotify(options) {
       continue;
     }
     const lines = namesRaw.split("\n").map((l) => l.trim()).filter(Boolean);
-    const slug = path5.basename(repo.path).replace(/[^\w.-]+/g, "_") || "repo";
+    const slug = path3.basename(repo.path).replace(/[^\w.-]+/g, "_") || "repo";
     for (const rel of lines) {
       if (rel.includes("..")) continue;
       try {
@@ -27715,10 +27554,8 @@ async function sendPromptToAgent(options) {
     sendResult,
     sendSessionUpdate,
     collectSessionDiffAfterTurn,
-    agentType,
     log: log2
   } = options;
-  log2("[prompt] Sending to agent\u2026");
   try {
     const result = await handle.sendPrompt(promptText, {});
     if (collectSessionDiffAfterTurn && sessionId && runId && sendSessionUpdate && result.success) {
@@ -27729,41 +27566,29 @@ async function sendPromptToAgent(options) {
       id: promptId,
       ...sessionId ? { sessionId } : {},
       ...runId ? { runId } : {},
-      success: result.success,
-      ...typeof result.stopReason === "string" ? { stopReason: result.stopReason } : {},
-      ...typeof result.output === "string" ? { output: result.output } : {},
-      ...typeof result.error === "string" ? { error: result.error } : {},
-      ...result.authRequired ? { authRequired: true } : {},
-      ...agentType ? { agentType } : {}
-    });
-    if (result.success) {
-      const out = result.output ?? "";
-      const preview = out.length > 400 ? out.slice(0, 400) + "\u2026" : out;
-      log2(`[prompt] Done; sent response (${out.length} chars)`);
-      if (preview) log2(`[prompt] Response: ${preview}`);
-    } else {
-      log2(`[prompt] Agent error: ${result.error ?? "(unknown)"}`);
+      ...result
+    });
+    if (!result.success) {
+      log2(`[agent] ${result.error ?? "error"}`);
     }
   } catch (err) {
-    const errMsg = formatAcpRpcError(err);
-    const authRequired = isAcpAuthenticationRequiredError(err);
-    log2(`[prompt] Send failed: ${errMsg}`);
-    if (err instanceof Error && err.stack) log2(`[prompt] ${err.stack}`);
+    const errMsg = err instanceof Error ? err.message : String(err);
+    log2(`[agent] send failed: ${errMsg}`);
+    if (err instanceof Error && err.stack) log2(`[agent] ${err.stack}`);
     sendResult({
       type: "prompt_result",
       id: promptId,
       ...sessionId ? { sessionId } : {},
       ...runId ? { runId } : {},
       success: false,
-      error: errMsg,
-      ...authRequired ? { authRequired: true } : {},
-      ...agentType ? { agentType } : {}
+      error: errMsg
     });
   }
 }
 
 // src/acp/ensure-acp-client.ts
-import * as path9 from "node:path";
+import * as fs3 from "node:fs";
+import * as path7 from "node:path";
 
 // src/error-message.ts
 function errorMessage(err) {
@@ -27775,17 +27600,6 @@ function errorMessage(err) {
   return String(err);
 }
 
-// src/acp/clients/claude-agent-acp-client.ts
-var DEFAULT_CLAUDE_AGENT_ACP_COMMAND = ["npx", "--yes", "@agentclientprotocol/claude-agent-acp"];
-function isClaudeAgentAcpCommand(command) {
-  const i = command.indexOf("@agentclientprotocol/claude-agent-acp");
-  return i >= 0 && (i === 0 || command[i - 1] === "npx" || command[i - 1] === "bunx");
-}
-async function createClaudeAgentAcpClient(options) {
-  const command = options.command?.length && options.command.some((a) => a.includes("claude-agent-acp")) ? options.command : [...DEFAULT_CLAUDE_AGENT_ACP_COMMAND];
-  return createAcpClient({ ...options, command });
-}
-
 // src/acp/clients/codex-acp-client.ts
 var DEFAULT_CODEX_ACP_COMMAND = ["npx", "--yes", "@zed-industries/codex-acp"];
 function isCodexAcpCommand(command) {
@@ -27804,21 +27618,21 @@ import { spawn as spawn4 } from "node:child_process";
 import * as readline from "node:readline";
 
 // src/acp/safe-fs-path.ts
-import * as path6 from "node:path";
+import * as path4 from "node:path";
 function resolveSafePathUnderCwd(cwd3, filePath) {
   const trimmed2 = filePath.trim();
   if (!trimmed2) return null;
-  const normalizedCwd = path6.resolve(cwd3);
-  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;
+  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;
   return resolved;
 }
 function toDisplayPathRelativeToCwd(cwd3, absolutePath) {
-  const normalizedCwd = path6.resolve(cwd3);
-  const rel = path6.relative(normalizedCwd, path6.resolve(absolutePath));
-  if (!rel || rel === "") return path6.basename(absolutePath);
-  return rel.split(path6.sep).join("/");
+  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("/");
 }
 
 // src/files/diff/unified-diff.ts
@@ -28120,7 +27934,7 @@ async function createCursorAcpClient(options) {
 var AGENT_TYPE_DEFAULT_COMMANDS = {
   "cursor-cli": ["agent", "acp"],
   "codex-acp": [...DEFAULT_CODEX_ACP_COMMAND],
-  "claude-code": [...DEFAULT_CLAUDE_AGENT_ACP_COMMAND]
+  "claude-code": ["npx", "--yes", "@anthropic-ai/claude-code"]
 };
 function useCursorAcp(agentType, command) {
   if (agentType === "cursor-cli") return true;
@@ -28130,17 +27944,12 @@ function useCodexAcp(agentType, command) {
   if (agentType === "codex-acp") return true;
   return isCodexAcpCommand(command);
 }
-function useClaudeAgentAcp(agentType, command) {
-  if (agentType === "claude-code") return true;
-  return isClaudeAgentAcpCommand(command);
-}
-function resolveAgentCommand(agentCommand, preferredAgentType) {
-  const explicitCmd = agentCommand?.length ? agentCommand : void 0;
-  const typeCmd = preferredAgentType ? AGENT_TYPE_DEFAULT_COMMANDS[preferredAgentType] : void 0;
-  const command = explicitCmd ?? typeCmd;
+function resolveAgentCommand(preferredAgentType) {
+  if (!preferredAgentType) return null;
+  const command = AGENT_TYPE_DEFAULT_COMMANDS[preferredAgentType];
   if (!command?.length) return null;
-  const createClient = useCursorAcp(preferredAgentType, command) ? createCursorAcpClient : useCodexAcp(preferredAgentType, command) ? createCodexAcpClient : useClaudeAgentAcp(preferredAgentType, command) ? createClaudeAgentAcpClient : createAcpClient;
-  const label = preferredAgentType ?? "--agent";
+  const createClient = useCursorAcp(preferredAgentType, command) ? createCursorAcpClient : useCodexAcp(preferredAgentType, command) ? createCodexAcpClient : createAcpClient;
+  const label = preferredAgentType;
   return { command, label, createClient };
 }
 
@@ -28150,16 +27959,16 @@ import { existsSync, statSync } from "node:fs";
 
 // src/git/get-git-repo-root-sync.ts
 import { execFileSync } from "node:child_process";
-import * as path7 from "node:path";
+import * as path5 from "node:path";
 function getGitRepoRootSync(startDir) {
   try {
     const out = execFileSync("git", ["rev-parse", "--show-toplevel"], {
-      cwd: path7.resolve(startDir),
+      cwd: path5.resolve(startDir),
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       maxBuffer: 1024 * 1024
     }).trim();
-    return out ? path7.resolve(out) : null;
+    return out ? path5.resolve(out) : null;
   } catch {
     return null;
   }
@@ -28168,25 +27977,25 @@ 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 path8 from "node:path";
+import * as path6 from "node:path";
 function resolveWorkspaceFilePath(cwd3, rawPath) {
   const trimmed2 = rawPath.trim();
   if (!trimmed2) return null;
-  const normalizedCwd = path8.resolve(cwd3);
+  const normalizedCwd = path6.resolve(cwd3);
   let abs = resolveSafePathUnderCwd(cwd3, trimmed2);
   if (!abs) {
-    const candidate = path8.isAbsolute(trimmed2) ? path8.normalize(trimmed2) : path8.normalize(path8.resolve(normalizedCwd, trimmed2));
+    const candidate = path6.isAbsolute(trimmed2) ? path6.normalize(trimmed2) : path6.normalize(path6.resolve(normalizedCwd, trimmed2));
     const gitRoot2 = getGitRepoRootSync(cwd3);
     if (!gitRoot2) return null;
-    const rel = path8.relative(gitRoot2, candidate);
-    if (rel.startsWith("..") || path8.isAbsolute(rel)) return null;
+    const rel = path6.relative(gitRoot2, candidate);
+    if (rel.startsWith("..") || path6.isAbsolute(rel)) return null;
     abs = candidate;
   }
   const gitRoot = getGitRepoRootSync(cwd3);
   if (gitRoot) {
-    const relFromRoot = path8.relative(gitRoot, abs);
-    if (!relFromRoot.startsWith("..") && !path8.isAbsolute(relFromRoot)) {
-      return { abs, display: relFromRoot.split(path8.sep).join("/") };
+    const relFromRoot = path6.relative(gitRoot, abs);
+    if (!relFromRoot.startsWith("..") && !path6.isAbsolute(relFromRoot)) {
+      return { abs, display: relFromRoot.split(path6.sep).join("/") };
     }
   }
   return { abs, display: toDisplayPathRelativeToCwd(cwd3, abs) };
@@ -28195,9 +28004,9 @@ function readUtf8WorkspaceFile(cwd3, displayPath) {
   if (!displayPath || displayPath.includes("..")) return "";
   const gitRoot = getGitRepoRootSync(cwd3);
   if (gitRoot) {
-    const abs2 = path8.resolve(gitRoot, displayPath);
-    const rel = path8.relative(gitRoot, abs2);
-    if (!rel.startsWith("..") && !path8.isAbsolute(rel)) {
+    const abs2 = path6.resolve(gitRoot, displayPath);
+    const rel = path6.relative(gitRoot, abs2);
+    if (!rel.startsWith("..") && !path6.isAbsolute(rel)) {
       try {
         return readFileSync2(abs2, "utf8");
       } catch {
@@ -28216,9 +28025,9 @@ function tryWorkspaceDisplayToAbs(cwd3, displayPath) {
   if (!displayPath || displayPath.includes("..")) return null;
   const gitRoot = getGitRepoRootSync(cwd3);
   if (gitRoot) {
-    const abs = path8.resolve(gitRoot, displayPath);
-    const rel = path8.relative(gitRoot, abs);
-    if (!rel.startsWith("..") && !path8.isAbsolute(rel)) return abs;
+    const abs = path6.resolve(gitRoot, displayPath);
+    const rel = path6.relative(gitRoot, abs);
+    if (!rel.startsWith("..") && !path6.isAbsolute(rel)) return abs;
   }
   return resolveSafePathUnderCwd(cwd3, displayPath);
 }
@@ -28277,7 +28086,7 @@ function createBridgeOnFileChange(opts) {
     const sessionId = routing.sessionId;
     const send = getSendSessionUpdate();
     if (!send || !runId || !sessionId) {
-      log2(`[file-change] ACP fs/write dropped path=${evt.path} (bridge or session/run not wired)`);
+      log2(`[Bridge service] file change not forwarded path=${evt.path} (session/run not wired)`);
       return;
     }
     const cwd3 = process.cwd();
@@ -28295,7 +28104,7 @@ function createBridgeOnFileChange(opts) {
         directoryRemoved: dirFlags.directoryRemoved
       });
     } catch (err) {
-      log2(`[file-change] session_file_change (fs/write) failed ${evt.path}: ${errorMessage(err)}`);
+      log2(`[Bridge service] session_file_change failed ${evt.path}: ${errorMessage(err)}`);
     }
   };
 }
@@ -28322,7 +28131,7 @@ function createBridgeOnRequest(opts) {
         }
       });
     } catch (err) {
-      log2(`[bridge] ACP request forward failed ${request.method}: ${errorMessage(err)}`);
+      log2(`[Bridge service] ACP request forward failed (${request.method}): ${errorMessage(err)}`);
     }
   };
 }
@@ -28512,11 +28321,6 @@ function isCompletedToolStatus(status) {
   const s = status.toLowerCase();
   return s === "completed" || s === "complete" || s === "succeeded" || s === "success";
 }
-function isTerminalToolStatus(status) {
-  if (typeof status !== "string") return false;
-  const s = status.toLowerCase();
-  return isCompletedToolStatus(status) || s === "failed" || s === "cancelled" || s === "canceled";
-}
 function accumulateToolPaths(toolKey, paths, acc) {
   if (!toolKey || paths.length === 0) return;
   let s = acc.get(toolKey);
@@ -28614,7 +28418,7 @@ var PathSnapshotTracker = class {
         });
         sentPaths.add(displayPath);
       } catch (err) {
-        log2(`[file-change] session_file_change (path snapshot) failed ${displayPath}: ${errorMessage(err)}`);
+        log2(`[Bridge service] session_file_change failed ${displayPath}: ${errorMessage(err)}`);
       }
     }
   }
@@ -28668,7 +28472,7 @@ function sendExtractedDiffsAsSessionFileChanges(diffs, send, cwd3, sessionId, ru
       });
       sentPaths.add(d.path);
     } catch (err) {
-      log2(`[file-change] session_file_change (ACP diff) failed ${d.path}: ${errorMessage(err)}`);
+      log2(`[Bridge service] session_file_change failed ${d.path}: ${errorMessage(err)}`);
     }
   }
 }
@@ -28694,7 +28498,7 @@ function sendGitHeadVsWorkspaceForToolPaths(mergedPaths, sentPaths, send, cwd3,
       });
       sentPaths.add(displayPath);
     } catch (err) {
-      log2(`[file-change] session_file_change (git fallback) failed ${displayPath}: ${errorMessage(err)}`);
+      log2(`[Bridge service] session_file_change failed ${displayPath}: ${errorMessage(err)}`);
     }
   }
 }
@@ -28742,7 +28546,9 @@ function createBridgeOnSessionUpdate(opts) {
     if (diffs.length > 0 && send && runId && sessionId) {
       sendExtractedDiffsAsSessionFileChanges(diffs, send, cwd3, sessionId, runId, sentFileChangePaths, log2);
     } else if (diffs.length > 0) {
-      log2(`[file-change] ACP structured diff(s) dropped (${diffs.length}): bridge or session/run not wired`);
+      log2(
+        `[Bridge service] ACP file diff(s) not forwarded (${diffs.length}): session/run not wired to bridge`
+      );
     }
     if (isCompletedToolCallUpdate && send && runId && sessionId) {
       const acc = pathTracker.accumulatedPathsByToolKey.get(toolKey);
@@ -28760,7 +28566,7 @@ function createBridgeOnSessionUpdate(opts) {
           payload: params
         });
       } catch (err) {
-        log2(`[bridge] session_update send failed kind=${updateKind}: ${errorMessage(err)}`);
+        log2(`[Bridge service] session_update send failed (${updateKind}): ${errorMessage(err)}`);
       }
     }
   };
@@ -28777,9 +28583,11 @@ function buildAcpSessionBridgeHooks(opts) {
 
 // src/acp/ensure-acp-client.ts
 async function ensureAcpClient(options) {
-  const { state, agentCommand, preferredAgentType, mode, cwd: cwd3, routing, sendSessionUpdate, sendRequest, log: log2 } = options;
-  const targetCwd = cwd3 ?? process.cwd();
-  if (state.acpHandle && state.lastAcpCwd != null && path9.resolve(state.lastAcpCwd) !== path9.resolve(targetCwd)) {
+  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()
+  );
+  if (state.acpHandle && state.lastAcpCwd != null && path7.resolve(state.lastAcpCwd) !== path7.resolve(targetCwd)) {
     try {
       state.acpHandle.disconnect();
     } catch {
@@ -28788,9 +28596,12 @@ async function ensureAcpClient(options) {
     state.acpStartPromise = null;
     state.acpAgentKey = null;
   }
-  const resolved = resolveAgentCommand(agentCommand, preferredAgentType);
+  const resolved = resolveAgentCommand(preferredAgentType);
   if (!resolved) {
-    log2("[prompt] No agent type from backend; use --agent or add local agents on this bridge in the app");
+    log2(
+      `[agent] No local agent type (${preferredAgentType === null ? "none" : `"${preferredAgentType}"`}). Send agentType on prompts or agent_config after identify.`
+    );
+    state.lastAcpStartError = "No agent type: ensure the app sends agentType on prompts or agent_config for this bridge.";
     return null;
   }
   const agentKey = `${resolved.label}::${resolved.command.join("\0")}`;
@@ -28805,9 +28616,23 @@ async function ensureAcpClient(options) {
   }
   if (state.acpHandle) return state.acpHandle;
   if (!state.acpStartPromise) {
+    let statOk = false;
+    try {
+      const st = fs3.statSync(targetCwd);
+      statOk = st.isDirectory();
+      if (!statOk) {
+        state.lastAcpStartError = `Agent cwd is not a directory: ${targetCwd}`;
+        log2(`[agent] ${state.lastAcpStartError}`);
+      }
+    } catch {
+      state.lastAcpStartError = `Agent cwd missing or inaccessible: ${targetCwd}`;
+      log2(`[agent] ${state.lastAcpStartError}`);
+    }
+    if (!statOk) {
+      return null;
+    }
     const modeFlag = mode && ["ask", "plan"].includes(mode) ? ["--mode", mode] : [];
     const fullCmd = [...resolved.command, ...modeFlag];
-    log2(`[prompt] Starting agent (${resolved.label}) on first request\u2026`);
     const hooks = buildAcpSessionBridgeHooks({
       routing,
       getSendSessionUpdate: () => sendSessionUpdate,
@@ -28823,11 +28648,10 @@ async function ensureAcpClient(options) {
       state.acpHandle = h;
       state.lastAcpCwd = targetCwd;
       state.acpAgentKey = agentKey;
-      log2(`ACP client connected (${resolved.label})`);
       return h;
     }).catch((err) => {
       state.lastAcpStartError = errorMessage(err);
-      log2(`ACP client failed: ${state.lastAcpStartError}`);
+      log2(`[agent] failed to start: ${state.lastAcpStartError}`);
       state.acpStartPromise = null;
       state.acpAgentKey = null;
       return null;
@@ -28838,7 +28662,7 @@ async function ensureAcpClient(options) {
 
 // src/acp/create-acp-manager.ts
 async function createAcpManager(options) {
-  const { agentCommand, log: log2 } = options;
+  const { log: log2 } = options;
   const state = {
     acpHandle: null,
     acpStartPromise: null,
@@ -28853,7 +28677,6 @@ async function createAcpManager(options) {
   function setPreferredAgentType(agentType) {
     if (!backendFallbackAgentType) {
       backendFallbackAgentType = agentType;
-      log2(`Agent type from backend (fallback): ${backendFallbackAgentType}`);
     }
   }
   function handlePrompt(opts) {
@@ -28869,7 +28692,7 @@ async function createAcpManager(options) {
       sendSessionUpdate,
       collectSessionDiffAfterTurn
     } = opts;
-    const preferredForPrompt = agentType ?? backendFallbackAgentType;
+    const preferredForPrompt = agentType ?? backendFallbackAgentType ?? null;
     pendingCancelRunId = void 0;
     promptRouting.sessionId = sessionId;
     promptRouting.runId = runId;
@@ -28877,7 +28700,6 @@ async function createAcpManager(options) {
     async function run() {
       const handle = await ensureAcpClient({
         state,
-        agentCommand,
         preferredAgentType: preferredForPrompt,
         mode,
         cwd: cwd3,
@@ -28893,7 +28715,7 @@ async function createAcpManager(options) {
           ...sessionId ? { sessionId } : {},
           ...runId ? { runId } : {},
           success: false,
-          error: state.lastAcpStartError || "No agent configured. Register local agents on this bridge in the app, or use --agent for a fixed CLI command."
+          error: state.lastAcpStartError || "No agent configured. Register local agents on this bridge in the app."
         });
         return;
       }
@@ -28921,7 +28743,6 @@ async function createAcpManager(options) {
         promptId,
         sessionId,
         runId,
-        agentType: preferredForPrompt,
         sendResult,
         sendSessionUpdate,
         collectSessionDiffAfterTurn,
@@ -28941,15 +28762,13 @@ async function createAcpManager(options) {
     if (handle?.cancel) {
       try {
         await handle.cancel();
-        log2(`[prompt] ACP session/cancel sent for run ${runId.slice(0, 8)}\u2026`);
         return true;
       } catch (err) {
-        log2(`[prompt] Cancel failed: ${err instanceof Error ? err.message : String(err)}`);
+        log2(`[agent] cancel failed: ${err instanceof Error ? err.message : String(err)}`);
         return false;
       }
     }
     pendingCancelRunId = runId;
-    log2(`[prompt] Cancel queued for run ${runId.slice(0, 8)}\u2026 (agent still starting)`);
     return true;
   }
   function resolveRequest(requestId, result) {
@@ -28964,57 +28783,55 @@ async function createAcpManager(options) {
   return { setPreferredAgentType, handlePrompt, cancelRun, resolveRequest, disconnect };
 }
 
-// src/bridge/routing/message-router.ts
-function createMessageRouter() {
-  const handlers = /* @__PURE__ */ new Map();
-  return {
-    register(type, handler) {
-      handlers.set(type, handler);
-    },
-    dispatch(msg, deps) {
-      const type = msg.type;
-      if (!type) return;
-      const handler = handlers.get(type);
-      if (handler) handler(msg, deps);
-    }
-  };
-}
-
 // src/bridge/routing/handlers/auth-token.ts
 var handleAuthToken = (msg, { log: log2 }) => {
-  if (typeof msg.token !== "string") return false;
+  if (typeof msg.token !== "string") return;
   log2("Received auth token. Save it for future runs:");
   log2(`  export BUILDAMATON_AUTH_TOKEN="${msg.token}"`);
-  return true;
 };
 
 // src/bridge/routing/handlers/bridge-identified.ts
-var handleBridgeIdentified = (msg, { onBridgeIdentified, sendLocalSkillsReport }) => {
-  if (typeof msg.bridgeName !== "string") return false;
-  onBridgeIdentified(
+var handleBridgeIdentified = (msg, deps) => {
+  if (typeof msg.bridgeName !== "string") return;
+  deps.onBridgeIdentified(
     msg
   );
-  sendLocalSkillsReport?.();
-  return true;
+  setImmediate(() => {
+    void (async () => {
+      try {
+        await deps.reportAutoDetectedAgents?.();
+      } catch (e) {
+        deps.log(`[Bridge service] auto-detect agents failed: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    })();
+  });
+  setImmediate(() => {
+    try {
+      deps.sendLocalSkillsReport?.();
+    } catch (e) {
+      deps.log(`[Bridge service] local skills report failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  });
 };
 
 // src/acp/from-bridge/handle-bridge-agent-config.ts
 function handleBridgeAgentConfig(msg, { acpManager }) {
-  if (!Array.isArray(msg.agents) || msg.agents.length === 0) return false;
+  if (!Array.isArray(msg.agents) || msg.agents.length === 0) return;
   acpManager.setPreferredAgentType(msg.agents[0].type);
-  return true;
 }
 
 // src/bridge/routing/handlers/agent-config.ts
-var handleAgentConfigMessage = (msg, deps) => handleBridgeAgentConfig(msg, deps);
+var handleAgentConfigMessage = (msg, deps) => {
+  handleBridgeAgentConfig(msg, deps);
+};
 
 // src/acp/from-bridge/handle-bridge-prompt.ts
-import * as path12 from "node:path";
+import * as path10 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 path10 from "node:path";
+import * as path8 from "node:path";
 import { createHash } from "node:crypto";
 function normalizeCanonicalGitUrl(url2) {
   let s = url2.trim();
@@ -29042,13 +28859,13 @@ function canonicalUrlToRepoIdSync(url2) {
   return createHash("sha256").update(normalized).digest("hex").slice(0, 32);
 }
 function fallbackRepoIdFromPath(absPath) {
-  return createHash("sha256").update(path10.resolve(absPath)).digest("hex").slice(0, 32);
+  return createHash("sha256").update(path8.resolve(absPath)).digest("hex").slice(0, 32);
 }
 async function resolveBridgeQueueBindFields(options) {
   const { effectiveCwd, worktreePaths, primaryRepoRoots, log: log2 } = options;
-  const cwdAbs = worktreePaths.length > 0 ? path10.resolve(worktreePaths[0]) : path10.resolve(effectiveCwd);
+  const cwdAbs = worktreePaths.length > 0 ? path8.resolve(worktreePaths[0]) : path8.resolve(effectiveCwd);
   if (!primaryRepoRoots.length) {
-    log2("[bridge-queue] bind skipped: no git repo roots");
+    log2("[Bridge service] prompt queue bind skipped: no git repo roots under cwd");
     return null;
   }
   let primaryRoot = primaryRepoRoots[0];
@@ -29070,12 +28887,12 @@ async function resolveBridgeQueueBindFields(options) {
 
 // src/git/pre-turn-snapshot.ts
 import * as fs4 from "node:fs";
-import * as path11 from "node:path";
+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 path11.join(agentCwd, ".buildautomaton", "snapshots");
+  return path9.join(agentCwd, ".buildautomaton", "snapshots");
 }
 async function gitStashCreate2(repoRoot, log2) {
   try {
@@ -29102,7 +28919,7 @@ async function gitRun(repoRoot, args, log2, label) {
 async function resolveSnapshotRepoRoots(options) {
   const { worktreePaths, fallbackCwd, log: log2 } = options;
   if (worktreePaths?.length) {
-    const uniq = [...new Set(worktreePaths.map((p) => path11.resolve(p)))];
+    const uniq = [...new Set(worktreePaths.map((p) => path9.resolve(p)))];
     return uniq;
   }
   try {
@@ -29134,7 +28951,7 @@ async function capturePreTurnSnapshot(options) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     repos
   };
-  const filePath = path11.join(dir, `${runId}.json`);
+  const filePath = path9.join(dir, `${runId}.json`);
   try {
     fs4.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
   } catch (e) {
@@ -29169,7 +28986,7 @@ async function applyPreTurnSnapshot(filePath, log2) {
   return { ok: true };
 }
 function snapshotFilePath(agentCwd, runId) {
-  return path11.join(snapshotsDirForCwd(agentCwd), `${runId}.json`);
+  return path9.join(snapshotsDirForCwd(agentCwd), `${runId}.json`);
 }
 
 // src/acp/from-bridge/handle-bridge-prompt.ts
@@ -29184,13 +29001,15 @@ async function readGitBranch(cwd3) {
   }
 }
 function handleBridgePrompt(msg, deps) {
-  if (!msg.prompt) return false;
   const { getWs, log: log2, acpManager, sessionWorktreeManager } = deps;
-  const promptText = msg.prompt;
-  const mode = msg.mode || "agent";
-  log2(
-    `[prompt] Received (mode=${mode}): ${String(promptText).slice(0, 80)}${String(promptText).length > 80 ? "\u2026" : ""}${msg.runId ? ` (runId: ${msg.runId.slice(0, 8)}\u2026)` : ""}`
-  );
+  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;
+  }
   const sessionId = msg.sessionId;
   const isNewSession = msg.isNewSession === true;
   const sessionWorktreesEnabled = msg.sessionWorktreesEnabled === true;
@@ -29205,31 +29024,15 @@ function handleBridgePrompt(msg, deps) {
   const sendSessionUpdate = (payload) => {
     const s = getWs();
     if (!s) {
-      log2("[bridge] session_update skipped: WebSocket to API not connected");
+      log2("[Bridge service] session_update not sent: not connected");
       return;
     }
     const p = payload;
-    if (p.type === "session_file_change" && typeof p.path === "string") {
-      log2(
-        `[bridge\u2192ws] session_file_change runId=${p.runId?.slice(0, 8) ?? "?"}\u2026 path=${p.path}`
-      );
-    } else if (p.type === "session_update" && (p.kind === "tool_call_update" || p.kind === "tool_call")) {
-      const inner = p.payload && typeof p.payload === "object" ? p.payload : null;
-      const status = inner?.status;
-      if (isTerminalToolStatus(status)) {
-        const tc = inner?.toolCall ?? inner?.tool_call;
-        const toolName = typeof tc?.name === "string" ? tc.name : "";
-        const st = typeof status === "string" ? status : String(status);
-        log2(
-          `[bridge\u2192ws] tool finished runId=${p.runId?.slice(0, 8) ?? "?"}\u2026 tool=${toolName || "?"} status=${st}`
-        );
-      }
-    }
     sendWsMessage(s, payload);
   };
   async function preambleAndPrompt(resolvedCwd) {
     const s = getWs();
-    const effectiveCwd = path12.resolve(resolvedCwd ?? process.cwd());
+    const effectiveCwd = path10.resolve(resolvedCwd ?? process.cwd());
     const worktreePaths = sessionWorktreeManager.getWorktreePathsForSession(sessionId) ?? [];
     const repoRoots = await resolveSnapshotRepoRoots({
       worktreePaths,
@@ -29281,84 +29084,84 @@ function handleBridgePrompt(msg, deps) {
       runId,
       mode: msg.mode,
       agentType,
-      cwd: resolvedCwd,
+      cwd: effectiveCwd,
       sendResult,
       sendSessionUpdate,
       collectSessionDiffAfterTurn
     });
   }
   void sessionWorktreeManager.resolveCwdForPrompt(sessionId, { isNewSession, sessionWorktreesEnabled }).then((cwd3) => preambleAndPrompt(cwd3)).catch((err) => {
-    log2(`[prompt] worktree resolve failed: ${err instanceof Error ? err.message : String(err)}`);
+    log2(`[agent] worktree resolve failed: ${err instanceof Error ? err.message : String(err)}`);
     void preambleAndPrompt(void 0);
   });
-  return true;
 }
 
 // src/bridge/routing/handlers/prompt.ts
-var handlePromptMessage = (msg, deps) => handleBridgePrompt(msg, deps);
+var handlePromptMessage = (msg, deps) => {
+  handleBridgePrompt(msg, deps);
+};
 
 // src/acp/from-bridge/handle-bridge-cancel-run.ts
 function handleBridgeCancelRun(msg, { log: log2, acpManager }) {
   const runId = msg.runId;
-  if (!runId) return false;
+  if (!runId) return;
   void acpManager.cancelRun(runId).then((sent) => {
     if (!sent) {
       log2(
-        `[prompt] Cancel requested for run ${runId.slice(0, 8)}\u2026 but no matching active run or ACP cancel not available`
+        `[agent] cancel ignored for run ${runId.slice(0, 8)}\u2026 (no active run or cancel not available)`
       );
     }
   });
-  return true;
 }
 
 // src/bridge/routing/handlers/cancel-run.ts
-var handleCancelRunMessage = (msg, deps) => handleBridgeCancelRun(msg, deps);
+var handleCancelRunMessage = (msg, deps) => {
+  handleBridgeCancelRun(msg, deps);
+};
 
 // src/acp/from-bridge/handle-bridge-cursor-request-response.ts
-function handleBridgeCursorRequestResponse(msg, { acpManager, log: log2 }) {
-  if (typeof msg.requestId !== "string") return false;
+function handleBridgeCursorRequestResponse(msg, { acpManager }) {
+  if (typeof msg.requestId !== "string") return;
   acpManager.resolveRequest(msg.requestId, msg.result ?? {});
-  log2(`[prompt] Resolved Cursor request ${msg.requestId}`);
-  return true;
 }
 
 // src/bridge/routing/handlers/cursor-request-response.ts
-var handleCursorRequestResponseMessage = (msg, deps) => handleBridgeCursorRequestResponse(msg, deps);
+var handleCursorRequestResponseMessage = (msg, deps) => {
+  handleBridgeCursorRequestResponse(msg, deps);
+};
 
 // src/skills/handle-skill-call.ts
 function handleSkillCall(msg, socket, log2) {
   callSkill(msg.skillId, msg.operationId, msg.params ?? {}).then((result) => {
     sendWsMessage(socket, { type: "skill_result", id: msg.id, result });
-    log2(`Skill ${msg.skillId}/${msg.operationId} ok`);
   }).catch((err) => {
     sendWsMessage(socket, { type: "skill_result", id: msg.id, error: String(err) });
-    log2(`Skill error: ${err}`);
+    log2(`[Bridge service] skill_call failed (${msg.skillId}/${msg.operationId}): ${err}`);
   });
 }
 
 // src/bridge/routing/handlers/skill-call.ts
 var handleSkillCallMessage = (msg, { getWs, log: log2 }) => {
-  if (!msg.skillId || msg.operationId === void 0) return false;
+  if (!msg.skillId || msg.operationId === void 0) return;
   const socket = getWs();
-  if (!socket) return false;
+  if (!socket) return;
   handleSkillCall(
     msg,
     socket,
     log2
   );
-  return true;
 };
 
 // src/files/list-dir.ts
 import fs5 from "node:fs";
-import path14 from "node:path";
+import path12 from "node:path";
 
 // src/files/ensure-under-cwd.ts
-import path13 from "node:path";
+import path11 from "node:path";
 function ensureUnderCwd(relativePath, cwd3 = process.cwd()) {
-  const normalized = path13.normalize(relativePath).replace(/^(\.\/)+/, "");
-  const resolved = path13.resolve(cwd3, normalized);
-  if (!resolved.startsWith(cwd3 + path13.sep) && resolved !== cwd3) {
+  const normalized = path11.normalize(relativePath).replace(/^(\.\/)+/, "");
+  const resolved = path11.resolve(cwd3, normalized);
+  if (!resolved.startsWith(cwd3 + path11.sep) && resolved !== cwd3) {
     return null;
   }
   return resolved;
@@ -29374,8 +29177,8 @@ function listDir(relativePath) {
   try {
     const names = fs5.readdirSync(resolved, { withFileTypes: true });
     const entries = names.filter((d) => !d.name.startsWith(".")).map((d) => {
-      const entryPath = path14.join(relativePath || ".", d.name).replace(/\\/g, "/");
-      const fullPath = path14.join(resolved, d.name);
+      const entryPath = path12.join(relativePath || ".", d.name).replace(/\\/g, "/");
+      const fullPath = path12.join(resolved, d.name);
       let isDir = d.isDirectory();
       if (d.isSymbolicLink()) {
         try {
@@ -29592,15 +29395,15 @@ function readFile(relativePath, startLine, endLine, lineOffset, lineChunkSize =
 
 // src/files/file-index.ts
 import fs7 from "node:fs";
-import path15 from "node:path";
+import path13 from "node:path";
 import os2 from "node:os";
 import crypto2 from "node:crypto";
-var INDEX_DIR = path15.join(os2.homedir(), ".buildautomaton");
+var INDEX_DIR = path13.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 path15.join(INDEX_DIR, `.file-index-${hash}.json`);
+  return path13.join(INDEX_DIR, `.file-index-${hash}.json`);
 }
 function getTrigrams(s) {
   const lower = s.toLowerCase();
@@ -29644,14 +29447,14 @@ function walkDir(dir, baseDir, out) {
   }
   for (const name of names) {
     if (name.startsWith(".")) continue;
-    const full = path15.join(dir, name);
+    const full = path13.join(dir, name);
     let stat4;
     try {
       stat4 = fs7.statSync(full);
     } catch {
       continue;
     }
-    const relative6 = path15.relative(baseDir, full).replace(/\\/g, "/");
+    const relative6 = path13.relative(baseDir, full).replace(/\\/g, "/");
     if (stat4.isDirectory()) {
       walkDir(full, baseDir, out);
     } else if (stat4.isFile()) {
@@ -29660,7 +29463,7 @@ function walkDir(dir, baseDir, out) {
   }
 }
 function buildFileIndex(cwd3) {
-  const resolved = path15.resolve(cwd3);
+  const resolved = path13.resolve(cwd3);
   const paths = [];
   walkDir(resolved, resolved, paths);
   paths.sort((a, b) => a.localeCompare(b, void 0, { sensitivity: "base" }));
@@ -29686,7 +29489,7 @@ function buildFileIndex(cwd3) {
   return data;
 }
 function loadFileIndex(cwd3) {
-  const resolved = path15.resolve(cwd3);
+  const resolved = path13.resolve(cwd3);
   const indexPath = getIndexPath(resolved);
   try {
     const raw = fs7.readFileSync(indexPath, "utf8");
@@ -29707,7 +29510,7 @@ function loadFileIndex(cwd3) {
   }
 }
 function ensureFileIndex(cwd3) {
-  const resolved = path15.resolve(cwd3);
+  const resolved = path13.resolve(cwd3);
   const cached2 = loadFileIndex(resolved);
   if (cached2 !== null) return { data: cached2, fromCache: true };
   const data = buildFileIndex(resolved);
@@ -29810,62 +29613,116 @@ function handleFileBrowserRequest(msg, socket) {
   }
 }
 
-// src/skills/handle-skill-layout-request.ts
-var handleSkillLayoutRequest = (msg, deps) => {
-  if (msg.type !== "skill_layout_request") return false;
-  const socket = deps.getWs();
-  const id = typeof msg.id === "string" ? msg.id : "";
-  const roots = discoverSkillLayoutRoots(process.cwd());
-  socket?.send(JSON.stringify({ type: "skill_layout_response", id, roots }));
-  return true;
-};
-
-// src/bridge/routing/handlers/register-file-browser-handlers.ts
+// src/bridge/routing/handlers/file-browser-messages.ts
 function handleFileBrowserRequestMessage(msg, { getWs }) {
-  if (typeof msg.id !== "string" || typeof msg.path !== "string") return false;
+  if (typeof msg.id !== "string" || typeof msg.path !== "string") return;
   const socket = getWs();
-  if (!socket) return false;
+  if (!socket) return;
   handleFileBrowserRequest(
     msg,
     socket
   );
-  return true;
 }
 function handleFileBrowserSearchMessage(msg, { getWs }) {
-  if (typeof msg.id !== "string") return false;
+  if (typeof msg.id !== "string") return;
   const socket = getWs();
-  if (!socket) return false;
+  if (!socket) return;
   handleFileBrowserSearch(msg, socket);
-  return true;
-}
-function registerFileBrowserHandlers(router2) {
-  router2.register("file_browser_request", handleFileBrowserRequestMessage);
-  router2.register("file_browser_search", handleFileBrowserSearchMessage);
-  router2.register("skill_layout_request", handleSkillLayoutRequest);
 }
 
-// src/skills/install-remote-skills.ts
+// src/skills/discover-local-agent-skills.ts
 import fs8 from "node:fs";
-import path16 from "node:path";
-function installRemoteSkills(cwd3, targetDir, items) {
-  const installed = [];
-  if (!Array.isArray(items)) {
-    return { success: false, error: "Invalid items" };
-  }
-  try {
-    for (const item of items) {
-      if (typeof item.sourceId !== "string" || typeof item.skillName !== "string" || typeof item.versionHash !== "string" || !Array.isArray(item.files)) {
+import path14 from "node:path";
+var SKILL_DISCOVERY_ROOTS = [".agents/skills", ".claude/skills", ".cursor/skills", "skills"];
+function discoverLocalSkills(cwd3) {
+  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;
+    let entries = [];
+    try {
+      entries = fs8.readdirSync(base);
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      const dir = path14.join(base, name);
+      try {
+        if (!fs8.statSync(dir).isDirectory()) continue;
+      } catch {
         continue;
       }
-      const skillDir = path16.join(cwd3, targetDir, item.skillName);
+      const skillMd = path14.join(dir, "SKILL.md");
+      if (!fs8.existsSync(skillMd)) continue;
+      const key = `${rel}/${name}`;
+      if (seenKeys.has(key)) continue;
+      seenKeys.add(key);
+      out.push({ skillKey: name, path: `${rel}/${name}`.replace(/\\/g, "/") });
+    }
+  }
+  return out;
+}
+function discoverSkillLayoutRoots(cwd3) {
+  const roots = [];
+  for (const rel of SKILL_DISCOVERY_ROOTS) {
+    const base = path14.join(cwd3, rel);
+    if (!fs8.existsSync(base) || !fs8.statSync(base).isDirectory()) continue;
+    let entries = [];
+    try {
+      entries = fs8.readdirSync(base);
+    } catch {
+      continue;
+    }
+    const skills2 = [];
+    for (const name of entries) {
+      const dir = path14.join(base, name);
+      try {
+        if (!fs8.statSync(dir).isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      if (!fs8.existsSync(path14.join(dir, "SKILL.md"))) continue;
+      const relPath = `${rel}/${name}`.replace(/\\/g, "/");
+      skills2.push({ name, relPath });
+    }
+    if (skills2.length > 0) {
+      roots.push({ path: rel.replace(/\\/g, "/"), skills: skills2 });
+    }
+  }
+  return roots;
+}
+
+// src/bridge/routing/handlers/skill-layout-request.ts
+function handleSkillLayoutRequest(msg, deps) {
+  const socket = deps.getWs();
+  const id = typeof msg.id === "string" ? msg.id : "";
+  const roots = discoverSkillLayoutRoots(process.cwd());
+  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) {
+  const installed = [];
+  if (!Array.isArray(items)) {
+    return { success: false, error: "Invalid items" };
+  }
+  try {
+    for (const item of 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);
       for (const f of item.files) {
         if (typeof f.path !== "string" || !f.text && !f.base64) continue;
-        const dest = path16.join(skillDir, f.path);
-        fs8.mkdirSync(path16.dirname(dest), { recursive: true });
+        const dest = path15.join(skillDir, f.path);
+        fs9.mkdirSync(path15.dirname(dest), { recursive: true });
         if (f.text !== void 0) {
-          fs8.writeFileSync(dest, f.text, "utf8");
+          fs9.writeFileSync(dest, f.text, "utf8");
         } else if (f.base64) {
-          fs8.writeFileSync(dest, Buffer.from(f.base64, "base64"));
+          fs9.writeFileSync(dest, Buffer.from(f.base64, "base64"));
         }
       }
       installed.push({
@@ -29882,7 +29739,6 @@ function installRemoteSkills(cwd3, targetDir, items) {
 
 // src/bridge/routing/handlers/install-skills.ts
 var handleInstallSkillsMessage = (msg, deps) => {
-  if (msg.type !== "install_skills") return false;
   const socket = deps.getWs();
   const id = typeof msg.id === "string" ? msg.id : "";
   const targetDir = typeof msg.targetDir === "string" && msg.targetDir.trim() ? msg.targetDir.trim() : ".agents/skills";
@@ -29891,30 +29747,27 @@ var handleInstallSkillsMessage = (msg, deps) => {
   const result = installRemoteSkills(cwd3, targetDir, rawItems);
   if (!result.success) {
     const err = result.error ?? "Invalid items";
-    deps.log(`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 true;
+    return;
   }
-  deps.log(`Installed ${result.installed?.length ?? 0} remote skill(s) into ${targetDir}`);
   socket?.send(JSON.stringify({ type: "install_skills_result", id, success: true, installed: result.installed }));
-  return true;
 };
 
 // src/bridge/routing/handlers/refresh-local-skills.ts
 var handleRefreshLocalSkills = (_msg, deps) => {
   deps.sendLocalSkillsReport?.();
-  return true;
 };
 
 // src/bridge/routing/handlers/commit-session-request.ts
 var handleCommitSessionRequestMessage = (msg, deps) => {
-  if (msg.type !== "commit_session_request" || typeof msg.id !== "string") return false;
+  if (typeof msg.id !== "string") return;
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
   const branch = typeof msg.branch === "string" ? msg.branch : "";
   const message = typeof msg.message === "string" ? msg.message : "";
   const push = msg.push === true;
   const endSession = msg.endSession === true;
-  if (!sessionId || !branch || !message) return false;
+  if (!sessionId || !branch || !message) return;
   void deps.sessionWorktreeManager.commitSession({ sessionId, branch, message, push }).then((r) => {
     const s = deps.getWs();
     if (s) {
@@ -29938,53 +29791,45 @@ var handleCommitSessionRequestMessage = (msg, deps) => {
       });
     }
   });
-  return true;
 };
 
 // src/bridge/routing/handlers/rename-session-branch.ts
 var handleRenameSessionBranchMessage = (msg, deps) => {
-  if (msg.type !== "rename_session_branch") return false;
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
   const newBranch = typeof msg.newBranch === "string" ? msg.newBranch : "";
-  if (!sessionId || !newBranch) return false;
+  if (!sessionId || !newBranch) return;
   void deps.sessionWorktreeManager.renameSessionBranch(sessionId, newBranch);
-  return true;
 };
 
 // src/bridge/routing/handlers/session-archived.ts
 var handleSessionArchivedMessage = (msg, deps) => {
-  if (msg.type !== "session_archived") return false;
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
-  if (!sessionId) return false;
+  if (!sessionId) return;
   void deps.sessionWorktreeManager.removeSessionWorktrees(sessionId);
-  return true;
 };
 
 // src/bridge/routing/handlers/session-discarded.ts
 var handleSessionDiscardedMessage = (msg, deps) => {
-  if (msg.type !== "session_discarded") return false;
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
-  if (!sessionId) return false;
+  if (!sessionId) return;
   void deps.sessionWorktreeManager.removeSessionWorktrees(sessionId);
-  return true;
 };
 
 // src/bridge/routing/handlers/revert-turn-snapshot.ts
-import * as fs9 from "node:fs";
-import * as path17 from "node:path";
+import * as fs10 from "node:fs";
+import * as path16 from "node:path";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
-  if (msg.type !== "revert_turn_snapshot") return false;
   const id = typeof msg.id === "string" ? msg.id : "";
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
   const turnId = typeof msg.turnId === "string" ? msg.turnId : "";
-  if (!id || !sessionId || !turnId) return true;
+  if (!id || !sessionId || !turnId) return;
   const { getWs, log: log2, sessionWorktreeManager } = deps;
   void (async () => {
     const s = getWs();
     if (!s) return;
-    const agentBase = sessionWorktreeManager.getAgentCwdForSession(sessionId) ?? path17.resolve(process.cwd());
+    const agentBase = sessionWorktreeManager.getAgentCwdForSession(sessionId) ?? path16.resolve(process.cwd());
     const file2 = snapshotFilePath(agentBase, turnId);
-    if (!fs9.existsSync(file2)) {
+    if (!fs10.existsSync(file2)) {
       sendWsMessage(s, {
         type: "revert_turn_snapshot_result",
         id,
@@ -30001,40 +29846,118 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
       ...res.error ? { error: res.error } : {}
     });
   })();
-  return true;
 };
 
+// src/bridge/routing/handlers/dev-server-control.ts
+var handleDevServerControl = (msg, deps) => {
+  const serverId = typeof msg.serverId === "string" ? msg.serverId : "";
+  const action = msg.action === "start" || msg.action === "stop" ? msg.action : null;
+  if (!serverId || !action) return;
+  deps.devServerManager?.handleControl(serverId, action);
+};
+
+// src/bridge/routing/handlers/dev-servers-config.ts
+var handleDevServersConfig = (msg, deps) => {
+  const devServers = msg.devServers;
+  deps.devServerManager?.applyConfig(devServers ?? []);
+};
+
+// src/bridge/routing/dispatch-bridge-message.ts
+function dispatchBridgeMessage(msg, deps) {
+  const type = msg.type;
+  if (typeof type !== "string") return;
+  switch (type) {
+    case "auth_token":
+      handleAuthToken(msg, deps);
+      break;
+    case "bridge_identified":
+      handleBridgeIdentified(msg, deps);
+      break;
+    case "dev_servers_config":
+      handleDevServersConfig(msg, deps);
+      break;
+    case "server_control":
+      handleDevServerControl(msg, deps);
+      break;
+    case "agent_config":
+      handleAgentConfigMessage(msg, deps);
+      break;
+    case "prompt":
+      handlePromptMessage(msg, deps);
+      break;
+    case "commit_session_request":
+      handleCommitSessionRequestMessage(msg, deps);
+      break;
+    case "rename_session_branch":
+      handleRenameSessionBranchMessage(msg, deps);
+      break;
+    case "session_archived":
+      handleSessionArchivedMessage(msg, deps);
+      break;
+    case "session_discarded":
+      handleSessionDiscardedMessage(msg, deps);
+      break;
+    case "revert_turn_snapshot":
+      handleRevertTurnSnapshotMessage(msg, deps);
+      break;
+    case "cancel_run":
+      handleCancelRunMessage(msg, deps);
+      break;
+    case "cursor_request_response":
+      handleCursorRequestResponseMessage(msg, deps);
+      break;
+    case "skill_call":
+      handleSkillCallMessage(msg, deps);
+      break;
+    case "file_browser_request":
+      handleFileBrowserRequestMessage(msg, deps);
+      break;
+    case "file_browser_search":
+      handleFileBrowserSearchMessage(msg, deps);
+      break;
+    case "skill_layout_request":
+      handleSkillLayoutRequest(msg, deps);
+      break;
+    case "install_skills":
+      handleInstallSkillsMessage(msg, deps);
+      break;
+    case "refresh_local_skills":
+      handleRefreshLocalSkills(msg, deps);
+      break;
+    default:
+      deps.log?.(`[Bridge service] unhandled message type: ${type}`);
+  }
+}
+
 // src/bridge/routing/handle-bridge-message.ts
-var router = createMessageRouter();
-router.register("auth_token", handleAuthToken);
-router.register("bridge_identified", handleBridgeIdentified);
-router.register("agent_config", handleAgentConfigMessage);
-router.register("prompt", handlePromptMessage);
-router.register("commit_session_request", handleCommitSessionRequestMessage);
-router.register("rename_session_branch", handleRenameSessionBranchMessage);
-router.register("session_archived", handleSessionArchivedMessage);
-router.register("session_discarded", handleSessionDiscardedMessage);
-router.register("revert_turn_snapshot", handleRevertTurnSnapshotMessage);
-router.register("cancel_run", handleCancelRunMessage);
-router.register("cursor_request_response", handleCursorRequestResponseMessage);
-router.register("skill_call", handleSkillCallMessage);
-registerFileBrowserHandlers(router);
-router.register("install_skills", handleInstallSkillsMessage);
-router.register("refresh_local_skills", handleRefreshLocalSkills);
+var DEFERRED_INBOUND_TYPES = /* @__PURE__ */ new Set([
+  "server_control",
+  "prompt",
+  "install_skills",
+  "refresh_local_skills",
+  "dev_servers_config"
+]);
 function handleBridgeMessage(data, deps) {
   const msg = data;
   const socket = deps.getWs();
   if (!socket) return;
-  router.dispatch(msg, deps);
+  const type = msg.type;
+  if (typeof type === "string" && DEFERRED_INBOUND_TYPES.has(type)) {
+    setImmediate(() => {
+      dispatchBridgeMessage(msg, deps);
+    });
+    return;
+  }
+  dispatchBridgeMessage(msg, deps);
 }
 
 // src/worktrees/session-worktree-manager.ts
-import * as path21 from "node:path";
+import * as path20 from "node:path";
 import os4 from "node:os";
 
 // src/worktrees/prepare-new-session-worktrees.ts
-import * as fs11 from "node:fs";
-import * as path19 from "node:path";
+import * as fs12 from "node:fs";
+import * as path18 from "node:path";
 
 // src/git/worktree-add.ts
 async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch) {
@@ -30043,12 +29966,12 @@ async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch) {
 }
 
 // src/worktrees/worktree-layout-file.ts
-import * as fs10 from "node:fs";
-import * as path18 from "node:path";
+import * as fs11 from "node:fs";
+import * as path17 from "node:path";
 import os3 from "node:os";
 var LAYOUT_FILENAME = "worktree-launcher-layout.json";
 function defaultWorktreeLayoutPath() {
-  return path18.join(os3.homedir(), ".buildautomaton", LAYOUT_FILENAME);
+  return path17.join(os3.homedir(), ".buildautomaton", LAYOUT_FILENAME);
 }
 function normalizeLoadedLayout(raw) {
   if (raw && typeof raw === "object" && "launcherCwds" in raw) {
@@ -30060,8 +29983,8 @@ function normalizeLoadedLayout(raw) {
 function loadWorktreeLayout() {
   try {
     const p = defaultWorktreeLayoutPath();
-    if (!fs10.existsSync(p)) return { launcherCwds: [] };
-    const raw = JSON.parse(fs10.readFileSync(p, "utf8"));
+    if (!fs11.existsSync(p)) return { launcherCwds: [] };
+    const raw = JSON.parse(fs11.readFileSync(p, "utf8"));
     return normalizeLoadedLayout(raw);
   } catch {
     return { launcherCwds: [] };
@@ -30069,18 +29992,18 @@ function loadWorktreeLayout() {
 }
 function saveWorktreeLayout(layout) {
   try {
-    const dir = path18.dirname(defaultWorktreeLayoutPath());
-    fs10.mkdirSync(dir, { recursive: true });
-    fs10.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
+    const dir = path17.dirname(defaultWorktreeLayoutPath());
+    fs11.mkdirSync(dir, { recursive: true });
+    fs11.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
   } catch {
   }
 }
 function baseNameSafe(abs) {
-  return path18.basename(abs).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
+  return path17.basename(abs).replace(/[^a-zA-Z0-9._-]+/g, "-") || "cwd";
 }
 function allocateDirNameForLauncherCwd(layout, launcherCwdAbs) {
-  const norm = path18.resolve(launcherCwdAbs);
-  const existing = layout.launcherCwds.find((e) => path18.resolve(e.absolutePath) === norm);
+  const norm = path17.resolve(launcherCwdAbs);
+  const existing = layout.launcherCwds.find((e) => path17.resolve(e.absolutePath) === norm);
   if (existing) return existing.dirName;
   const base = baseNameSafe(norm);
   const used = new Set(layout.launcherCwds.map((e) => e.dirName));
@@ -30098,9 +30021,9 @@ function allocateDirNameForLauncherCwd(layout, launcherCwdAbs) {
 // src/worktrees/prepare-new-session-worktrees.ts
 async function prepareNewSessionWorktrees(options) {
   const { rootAbs, launcherCwd, sessionId, layout, log: log2 } = options;
-  const launcherResolved = path19.resolve(launcherCwd);
+  const launcherResolved = path18.resolve(launcherCwd);
   const cwdKey = allocateDirNameForLauncherCwd(layout, launcherResolved);
-  const agentMirrorRoot = path19.join(rootAbs, cwdKey);
+  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");
@@ -30108,13 +30031,13 @@ async function prepareNewSessionWorktrees(options) {
   }
   const branch = `session-${sessionId}`;
   const worktreePaths = [];
-  fs11.mkdirSync(agentMirrorRoot, { recursive: true });
+  fs12.mkdirSync(agentMirrorRoot, { recursive: true });
   for (const repo of repos) {
-    let rel = path19.relative(launcherResolved, repo.absolutePath);
-    if (rel.startsWith("..") || path19.isAbsolute(rel)) continue;
+    let rel = path18.relative(launcherResolved, repo.absolutePath);
+    if (rel.startsWith("..") || path18.isAbsolute(rel)) continue;
     const relNorm = rel === "" ? "." : rel;
-    const wtPath = path19.join(agentMirrorRoot, relNorm, sessionId);
-    fs11.mkdirSync(path19.dirname(wtPath), { recursive: true });
+    const wtPath = path18.join(agentMirrorRoot, relNorm, sessionId);
+    fs12.mkdirSync(path18.dirname(wtPath), { recursive: true });
     try {
       await gitWorktreeAddBranch(repo.absolutePath, wtPath, branch);
       log2(`[worktrees] Added worktree ${wtPath} (branch ${branch})`);
@@ -30149,23 +30072,23 @@ async function renameSessionWorktreeBranches(paths, newBranch, log2) {
 }
 
 // src/worktrees/remove-session-worktrees.ts
-import * as fs14 from "node:fs";
+import * as fs15 from "node:fs";
 
 // src/git/worktree-remove.ts
-import * as fs13 from "node:fs";
+import * as fs14 from "node:fs";
 
 // src/git/resolve-main-repo-from-git-file.ts
-import * as fs12 from "node:fs";
-import * as path20 from "node:path";
+import * as fs13 from "node:fs";
+import * as path19 from "node:path";
 function resolveMainRepoFromWorktreeGitFile(wt) {
-  const gitDirFile = path20.join(wt, ".git");
-  if (!fs12.existsSync(gitDirFile) || !fs12.statSync(gitDirFile).isFile()) return "";
-  const first2 = fs12.readFileSync(gitDirFile, "utf8").trim();
+  const gitDirFile = path19.join(wt, ".git");
+  if (!fs13.existsSync(gitDirFile) || !fs13.statSync(gitDirFile).isFile()) return "";
+  const first2 = fs13.readFileSync(gitDirFile, "utf8").trim();
   const m = first2.match(/^gitdir:\s*(.+)$/im);
   if (!m) return "";
-  const gitWorktreePath = path20.resolve(wt, m[1].trim());
-  const gitDir = path20.dirname(path20.dirname(gitWorktreePath));
-  return path20.dirname(gitDir);
+  const gitWorktreePath = path19.resolve(wt, m[1].trim());
+  const gitDir = path19.dirname(path19.dirname(gitWorktreePath));
+  return path19.dirname(gitDir);
 }
 
 // src/git/worktree-remove.ts
@@ -30174,7 +30097,7 @@ async function gitWorktreeRemoveForce(worktreePath) {
   if (mainRepo) {
     await simpleGit(mainRepo).raw(["worktree", "remove", "--force", worktreePath]);
   } else {
-    fs13.rmSync(worktreePath, { recursive: true, force: true });
+    fs14.rmSync(worktreePath, { recursive: true, force: true });
   }
 }
 
@@ -30187,7 +30110,7 @@ async function removeSessionWorktrees(paths, log2) {
     } catch (e) {
       log2(`[worktrees] remove failed for ${wt}: ${e instanceof Error ? e.message : String(e)}`);
       try {
-        fs14.rmSync(wt, { recursive: true, force: true });
+        fs15.rmSync(wt, { recursive: true, force: true });
       } catch {
       }
     }
@@ -30199,10 +30122,21 @@ async function gitCommitAllIfDirty(repoDir, message, options) {
   const g = simpleGit(repoDir);
   const st = await g.status();
   if (!st.files?.length) return;
+  const branch = options.branch.trim();
+  if (!branch) {
+    throw new Error("Branch name is required");
+  }
+  const branches = await g.branchLocal();
+  const localNames = new Set(branches.all.map((b) => b.replace(/^\*\s*/, "").trim()));
+  if (!localNames.has(branch)) {
+    await g.checkoutLocalBranch(branch);
+  } else {
+    await g.checkout(branch);
+  }
   await g.add(".");
   await g.commit(message);
   if (options.push) {
-    await g.push("origin", options.branch);
+    await g.push(["-u", "origin", branch]);
   }
 }
 
@@ -30248,7 +30182,7 @@ var SessionWorktreeManager = class {
     }
     if (!opts.isNewSession) {
       const agentCwd = this.sessionAgentCwd.get(sessionId);
-      if (agentCwd) return path21.resolve(agentCwd);
+      if (agentCwd) return path20.resolve(agentCwd);
       return void 0;
     }
     const prep = await prepareNewSessionWorktrees({
@@ -30261,7 +30195,7 @@ var SessionWorktreeManager = class {
     if (!prep) return void 0;
     this.sessionPaths.set(sessionId, prep.worktreePaths);
     this.sessionAgentCwd.set(sessionId, prep.agentCwd);
-    return path21.resolve(prep.agentCwd);
+    return path20.resolve(prep.agentCwd);
   }
   async renameSessionBranch(sessionId, newBranch) {
     const paths = this.sessionPaths.get(sessionId);
@@ -30282,7 +30216,7 @@ var SessionWorktreeManager = class {
   getAgentCwdForSession(sessionId) {
     if (!sessionId) return null;
     const c = this.sessionAgentCwd.get(sessionId);
-    return c ? path21.resolve(c) : null;
+    return c ? path20.resolve(c) : null;
   }
   async removeSessionWorktrees(sessionId) {
     const paths = this.sessionPaths.get(sessionId);
@@ -30303,7 +30237,7 @@ var SessionWorktreeManager = class {
   }
 };
 function defaultWorktreesRootAbs() {
-  return path21.join(os4.homedir(), ".buildautomaton", "worktrees");
+  return path20.join(os4.homedir(), ".buildautomaton", "worktrees");
 }
 
 // src/auth/refresh-bridge-tokens.ts
@@ -30334,7 +30268,7 @@ async function refreshBridgeTokens(params) {
 }
 
 // src/files/watch-file-index.ts
-import path22 from "node:path";
+import path21 from "node:path";
 
 // ../../node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/index.js
 import { stat as statcb } from "fs";
@@ -30412,7 +30346,7 @@ var ReaddirpStream = class extends Readable2 {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path23) => statMethod(path23, { bigint: true });
+      this._stat = (path24) => statMethod(path24, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -30437,8 +30371,8 @@ var ReaddirpStream = class extends Readable2 {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path23, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path23));
+          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)
@@ -30478,20 +30412,20 @@ var ReaddirpStream = class extends Readable2 {
       this.reading = false;
     }
   }
-  async _exploreDir(path23, depth) {
+  async _exploreDir(path24, depth) {
     let files;
     try {
-      files = await readdir(path23, this._rdOptions);
+      files = await readdir(path24, this._rdOptions);
     } catch (error40) {
       this._onError(error40);
     }
-    return { files, depth, path: path23 };
+    return { files, depth, path: path24 };
   }
-  async _formatEntry(dirent, path23) {
+  async _formatEntry(dirent, path24) {
     let entry;
     const basename6 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path23, basename6));
+      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) {
@@ -30891,16 +30825,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path23, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path24, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path23);
-    emitRaw(rawEvent, evPath, { watchedPath: path23 });
-    if (evPath && path23 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path23, evPath), KEY_LISTENERS, sysPath.join(path23, 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(path23, {
+    return fs_watch(path24, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error40) {
@@ -30916,12 +30850,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path23, fullPath, options, handlers) => {
+var setFsWatchListener = (path24, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path23, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path24, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -30932,7 +30866,7 @@ var setFsWatchListener = (path23, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path23,
+      path24,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -30947,7 +30881,7 @@ var setFsWatchListener = (path23, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error40.code === "EPERM") {
         try {
-          const fd = await open(path23, "r");
+          const fd = await open(path24, "r");
           await fd.close();
           broadcastErr(error40);
         } catch (err) {
@@ -30978,7 +30912,7 @@ var setFsWatchListener = (path23, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path23, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path24, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -31000,7 +30934,7 @@ var setFsWatchFileListener = (path23, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path23, curr));
+          foreach(cont.listeners, (listener2) => listener2(path24, curr));
         }
       })
     };
@@ -31028,13 +30962,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path23, listener) {
+  _watchWithNodeFs(path24, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path23);
-    const basename6 = sysPath.basename(path23);
+    const directory = sysPath.dirname(path24);
+    const basename6 = sysPath.basename(path24);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename6);
-    const absolutePath = sysPath.resolve(path23);
+    const absolutePath = sysPath.resolve(path24);
     const options = {
       persistent: opts.persistent
     };
@@ -31044,12 +30978,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename6) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path23, absolutePath, options, {
+      closer = setFsWatchFileListener(path24, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path23, absolutePath, options, {
+      closer = setFsWatchListener(path24, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -31071,7 +31005,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename6))
       return;
-    const listener = async (path23, newStats) => {
+    const listener = async (path24, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -31085,11 +31019,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file2, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path23);
+            this.fsw._closeFile(path24);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file2, listener);
             if (closer2)
-              this.fsw._addPathCloser(path23, closer2);
+              this.fsw._addPathCloser(path24, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -31121,7 +31055,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path23, item) {
+  async _handleSymlink(entry, directory, path24, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -31131,7 +31065,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path23);
+        linkPath = await fsrealpath(path24);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -31141,12 +31075,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path23, entry.stats);
+          this.fsw._emit(EV.CHANGE, path24, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path23, entry.stats);
+        this.fsw._emit(EV.ADD, path24, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -31175,9 +31109,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path23 = sysPath.join(directory, item);
+      let path24 = sysPath.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path23, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path24, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -31186,8 +31120,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path23 = sysPath.join(dir, sysPath.relative(dir, path23));
-        this._addToNodeFs(path23, initialAdd, wh, depth + 1);
+        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) => {
@@ -31256,13 +31190,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path23, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path24, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path23) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path24) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path23);
+    const wh = this.fsw._getWatchHelpers(path24);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -31278,8 +31212,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path23);
-        const targetPath = follow ? await fsrealpath(path23) : path23;
+        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);
@@ -31289,29 +31223,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path23) : path23;
+        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, path23, wh, targetPath);
+        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(path23), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path24), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path23, closer);
+        this.fsw._addPathCloser(path24, closer);
       return false;
     } catch (error40) {
       if (this.fsw._handleError(error40)) {
         ready();
-        return path23;
+        return path24;
       }
     }
   }
@@ -31354,26 +31288,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path23) {
-  if (typeof path23 !== "string")
+function normalizePath(path24) {
+  if (typeof path24 !== "string")
     throw new Error("string expected");
-  path23 = sysPath2.normalize(path23);
-  path23 = path23.replace(/\\/g, "/");
+  path24 = sysPath2.normalize(path24);
+  path24 = path24.replace(/\\/g, "/");
   let prepend = false;
-  if (path23.startsWith("//"))
+  if (path24.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path23.match(DOUBLE_SLASH_RE2))
-    path23 = path23.replace(DOUBLE_SLASH_RE2, "/");
+  while (path24.match(DOUBLE_SLASH_RE2))
+    path24 = path24.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path23 = "/" + path23;
-  return path23;
+    path24 = "/" + path24;
+  return path24;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path23 = normalizePath(testString);
+  const path24 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path23, stats)) {
+    if (pattern(path24, stats)) {
       return true;
     }
   }
@@ -31413,19 +31347,19 @@ var toUnix = (string4) => {
   }
   return str;
 };
-var normalizePathToUnix = (path23) => toUnix(sysPath2.normalize(toUnix(path23)));
-var normalizeIgnored = (cwd3 = "") => (path23) => {
-  if (typeof path23 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path23) ? path23 : sysPath2.join(cwd3, path23));
+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 path23;
+    return path24;
   }
 };
-var getAbsolutePath = (path23, cwd3) => {
-  if (sysPath2.isAbsolute(path23)) {
-    return path23;
+var getAbsolutePath = (path24, cwd3) => {
+  if (sysPath2.isAbsolute(path24)) {
+    return path24;
   }
-  return sysPath2.join(cwd3, path23);
+  return sysPath2.join(cwd3, path24);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -31480,10 +31414,10 @@ var DirEntry = class {
 var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 var WatchHelper = class {
-  constructor(path23, follow, fsw) {
+  constructor(path24, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path23;
-    this.path = path23 = path23.replace(REPLACER_RE, "");
+    const watchPath = path24;
+    this.path = path24 = path24.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -31605,20 +31539,20 @@ var FSWatcher = class extends EventEmitter2 {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd3) {
-      paths = paths.map((path23) => {
-        const absPath = getAbsolutePath(path23, cwd3);
+      paths = paths.map((path24) => {
+        const absPath = getAbsolutePath(path24, cwd3);
         return absPath;
       });
     }
-    paths.forEach((path23) => {
-      this._removeIgnoredPath(path23);
+    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 (path23) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path23, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path24) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path24, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -31640,17 +31574,17 @@ var FSWatcher = class extends EventEmitter2 {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd: cwd3 } = this.options;
-    paths.forEach((path23) => {
-      if (!sysPath2.isAbsolute(path23) && !this._closers.has(path23)) {
+    paths.forEach((path24) => {
+      if (!sysPath2.isAbsolute(path24) && !this._closers.has(path24)) {
         if (cwd3)
-          path23 = sysPath2.join(cwd3, path23);
-        path23 = sysPath2.resolve(path23);
+          path24 = sysPath2.join(cwd3, path24);
+        path24 = sysPath2.resolve(path24);
       }
-      this._closePath(path23);
-      this._addIgnoredPath(path23);
-      if (this._watched.has(path23)) {
+      this._closePath(path24);
+      this._addIgnoredPath(path24);
+      if (this._watched.has(path24)) {
         this._addIgnoredPath({
-          path: path23,
+          path: path24,
           recursive: true
         });
       }
@@ -31714,38 +31648,38 @@ var FSWatcher = class extends EventEmitter2 {
    * @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, path23, stats) {
+  async _emit(event, path24, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path23 = sysPath2.normalize(path23);
+      path24 = sysPath2.normalize(path24);
     if (opts.cwd)
-      path23 = sysPath2.relative(opts.cwd, path23);
-    const args = [path23];
+      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(path23))) {
+    if (awf && (pw = this._pendingWrites.get(path24))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path23, [event, ...args]);
+        this._pendingUnlinks.set(path24, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path24) => {
+          this._pendingUnlinks.forEach((entry, path25) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path24);
+            this._pendingUnlinks.delete(path25);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path23)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path24)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path23);
+        this._pendingUnlinks.delete(path24);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -31763,16 +31697,16 @@ var FSWatcher = class extends EventEmitter2 {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path23, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path24, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path23, 50);
+      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, path23) : path23;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path24) : path24;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -31803,23 +31737,23 @@ var FSWatcher = class extends EventEmitter2 {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path23, timeout) {
+  _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(path23);
+    const actionPath = action.get(path24);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path23);
+      const item = action.get(path24);
       const count = item ? item.count : 0;
-      action.delete(path23);
+      action.delete(path24);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -31827,7 +31761,7 @@ var FSWatcher = class extends EventEmitter2 {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path23, thr);
+    action.set(path24, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -31841,44 +31775,44 @@ var FSWatcher = class extends EventEmitter2 {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path23, threshold, event, awfEmit) {
+  _awaitWriteFinish(path24, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path23;
-    if (this.options.cwd && !sysPath2.isAbsolute(path23)) {
-      fullPath = sysPath2.join(this.options.cwd, path23);
+    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(path23)) {
+        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(path23).lastChange = now2;
+          writes.get(path24).lastChange = now2;
         }
-        const pw = writes.get(path23);
+        const pw = writes.get(path24);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path23);
+          writes.delete(path24);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path23)) {
-      writes.set(path23, {
+    if (!writes.has(path24)) {
+      writes.set(path24, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path23);
+          writes.delete(path24);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -31889,8 +31823,8 @@ var FSWatcher = class extends EventEmitter2 {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path23, stats) {
-    if (this.options.atomic && DOT_RE.test(path23))
+  _isIgnored(path24, stats) {
+    if (this.options.atomic && DOT_RE.test(path24))
       return true;
     if (!this._userIgnored) {
       const { cwd: cwd3 } = this.options;
@@ -31900,17 +31834,17 @@ var FSWatcher = class extends EventEmitter2 {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd3)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path23, stats);
+    return this._userIgnored(path24, stats);
   }
-  _isntIgnored(path23, stat4) {
-    return !this._isIgnored(path23, stat4);
+  _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(path23) {
-    return new WatchHelper(path23, this.options.followSymlinks, this);
+  _getWatchHelpers(path24) {
+    return new WatchHelper(path24, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -31942,63 +31876,63 @@ var FSWatcher = class extends EventEmitter2 {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path23 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path23);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path23) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path23, 100))
+    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(path23);
+    const wp = this._getWatchedDir(path24);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path23, nested));
+    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 = path23;
+    let relPath = path24;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path23);
+      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(path23);
+    this._watched.delete(path24);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path23))
-      this._emit(eventName, path23);
-    this._closePath(path23);
+    if (wasTracked && !this._isIgnored(path24))
+      this._emit(eventName, path24);
+    this._closePath(path24);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path23) {
-    this._closeFile(path23);
-    const dir = sysPath2.dirname(path23);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path23));
+  _closePath(path24) {
+    this._closeFile(path24);
+    const dir = sysPath2.dirname(path24);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path24));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path23) {
-    const closers = this._closers.get(path23);
+  _closeFile(path24) {
+    const closers = this._closers.get(path24);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path23);
+    this._closers.delete(path24);
   }
-  _addPathCloser(path23, closer) {
+  _addPathCloser(path24, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path23);
+    let list = this._closers.get(path24);
     if (!list) {
       list = [];
-      this._closers.set(path23, list);
+      this._closers.set(path24, list);
     }
     list.push(closer);
   }
@@ -32037,7 +31971,7 @@ function shouldIgnoreRelative(rel) {
   return false;
 }
 function startFileIndexWatcher(cwd3 = process.cwd()) {
-  const resolved = path22.resolve(cwd3);
+  const resolved = path21.resolve(cwd3);
   let timer = null;
   const runRebuild = () => {
     try {
@@ -32058,7 +31992,7 @@ function startFileIndexWatcher(cwd3 = process.cwd()) {
     ignoreInitial: true,
     persistent: true,
     ignored: (p) => {
-      const rel = path22.isAbsolute(p) ? path22.relative(resolved, p).replace(/\\/g, "/") : p.replace(/\\/g, "/");
+      const rel = path21.isAbsolute(p) ? path21.relative(resolved, p).replace(/\\/g, "/") : p.replace(/\\/g, "/");
       return shouldIgnoreRelative(rel || ".");
     },
     awaitWriteFinish: { stabilityThreshold: 250, pollInterval: 100 }
@@ -32077,9 +32011,1149 @@ function startFileIndexWatcher(cwd3 = process.cwd()) {
   };
 }
 
+// src/dev-servers/manager/dev-server-manager.ts
+import { rm } from "node:fs/promises";
+
+// src/dev-servers/process/send-server-status.ts
+function sendDevServerStatus(getWs, serverId, status, options) {
+  const payload = { type: "server_status", serverId, status };
+  if (options?.detail) payload.detail = options.detail;
+  if (options?.tails) {
+    payload.stdoutTail = options.tails.stdout;
+    payload.stderrTail = options.tails.stderr;
+  }
+  setImmediate(() => {
+    const ws = getWs();
+    if (!ws) return;
+    sendWsMessage(ws, payload);
+  });
+}
+
+// src/dev-servers/process/terminate-child-process.ts
+async function sigtermAndWaitForExit(proc, graceMs, log2, shortId) {
+  const exited = new Promise((resolve16) => {
+    proc.once("exit", () => resolve16());
+  });
+  log2(`[dev-server] Sending SIGTERM to ${shortId} (pid=${proc.pid ?? "?"})\u2026`);
+  try {
+    proc.kill("SIGTERM");
+  } catch {
+  }
+  await Promise.race([exited, new Promise((resolve16) => setTimeout(resolve16, graceMs))]);
+}
+function forceKillChild(proc, log2, shortId, graceMs) {
+  log2(`[dev-server] ${shortId} did not exit within ${graceMs}ms; sending SIGKILL (pid=${proc.pid ?? "?"})\u2026`);
+  proc.removeAllListeners();
+  try {
+    proc.kill("SIGKILL");
+  } catch {
+  }
+}
+
+// src/dev-servers/process/wire-dev-server-child-process.ts
+import fs16 from "node:fs";
+
+// src/dev-servers/manager/forward-pipe.ts
+function forwardChildPipe(childReadable, terminal, onData) {
+  if (!childReadable) return;
+  childReadable.on("data", (chunk) => {
+    onData(chunk);
+    if (!terminal || terminal.writableEnded) return;
+    const ok = terminal.write(chunk);
+    if (!ok) {
+      childReadable.pause();
+      terminal.once("drain", () => {
+        childReadable.resume();
+      });
+    }
+  });
+}
+
+// src/dev-servers/process/wire-dev-server-child-process.ts
+function wireDevServerChildProcess(d) {
+  const { proc, serverId, title } = d;
+  forwardChildPipe(proc.stdout, null, (chunk) => {
+    d.stdoutTail.push(chunk);
+    d.pushRemoteLogChunk(serverId, "stdout", chunk);
+  });
+  forwardChildPipe(proc.stderr, null, (chunk) => {
+    d.stderrTail.push(chunk);
+    d.pushRemoteLogChunk(serverId, "stderr", chunk);
+  });
+  if (d.mergedLogPath && d.mergedCleanupDir) {
+    const pollIv = setInterval(() => {
+      if ((d.getSpawnGeneration() ?? 0) !== d.scheduledGen) {
+        clearInterval(pollIv);
+        d.setPollInterval(void 0);
+        return;
+      }
+      fs16.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));
+        d.mergedReadPos.value = buf.length;
+        if (chunk.length === 0) return;
+        d.stdoutTail.push(chunk);
+        d.pushRemoteLogChunk(serverId, "stdout", chunk);
+      });
+    }, 100);
+    d.setPollInterval(pollIv);
+  }
+  proc.on("exit", (code, signal) => {
+    const poll = d.getPollInterval();
+    if (poll) {
+      clearInterval(poll);
+      d.setPollInterval(void 0);
+    }
+    const cleanupDir = d.mergedCleanupDir;
+    const mergedPath = d.mergedLogPath;
+    const finishExit = () => {
+      if (cleanupDir) {
+        d.rmMergedCleanupDir(cleanupDir);
+      }
+      if (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 ? `
+${errTail}` : ""}`);
+      }
+      d.detachProcessFromManager();
+      const tails = { stdout: d.stdoutTail.getTail(), stderr: d.stderrTail.getTail() };
+      d.clearTailBuffers();
+      const detail = signal ? `signal=${String(signal)}` : code != null && code !== 0 ? `exit=${code}` : void 0;
+      d.sendStatus(code === 0 || code == null ? "stopped" : "error", detail, tails);
+    };
+    if (mergedPath) {
+      fs16.readFile(mergedPath, (err, buf) => {
+        if (!err && buf.length > d.mergedReadPos.value) {
+          const chunk = Buffer.from(buf.subarray(d.mergedReadPos.value));
+          if (chunk.length > 0) {
+            d.stdoutTail.push(chunk);
+            d.pushRemoteLogChunk(serverId, "stdout", chunk);
+          }
+        }
+        finishExit();
+      });
+    } else {
+      finishExit();
+    }
+  });
+  proc.on("error", (err) => {
+    const poll = d.getPollInterval();
+    if (poll) {
+      clearInterval(poll);
+      d.setPollInterval(void 0);
+    }
+    const cleanupDir = d.mergedCleanupDir;
+    if (cleanupDir) {
+      d.rmMergedCleanupDir(cleanupDir);
+    }
+    d.detachProcessFromManager();
+    const tails = { stdout: d.stdoutTail.getTail(), stderr: d.stderrTail.getTail() };
+    d.clearTailBuffers();
+    const msg = err instanceof Error ? err.message : String(err);
+    const errno = typeof err === "object" && err && "code" in err ? String(err.code) : "";
+    d.log(`[dev-server] ${title} process error: ${msg}${errno ? ` (${errno})` : ""}`);
+    d.sendStatus("error", msg, tails);
+  });
+}
+
+// src/dev-servers/manager/dev-server-env.ts
+function substituteCommand(cmd, env) {
+  return cmd.replace(/\$\{([^}]+)\}/g, (_, key) => env[key] != null ? String(env[key]) : "");
+}
+function envForSpawn(base, userEnv, ports) {
+  const userKeys = new Set(
+    userEnv.map((e) => e.name.trim()).filter((name) => Boolean(name))
+  );
+  const out = {};
+  for (const key of Object.keys(base)) {
+    const v = base[key];
+    if (typeof v === "string") {
+      out[key] = v;
+    }
+  }
+  for (const { name, value } of userEnv) {
+    if (name) out[name] = value;
+  }
+  ports.forEach((p, i) => {
+    out[`PORT.${i}`] = String(p);
+  });
+  if (ports.length > 0) {
+    out.PORTS = ports.join(",");
+  }
+  if (!userKeys.has("NO_COLOR")) {
+    delete out.NO_COLOR;
+  }
+  if (out.FORCE_COLOR === void 0) {
+    out.FORCE_COLOR = "1";
+  }
+  if (out.CLICOLOR_FORCE === void 0) {
+    out.CLICOLOR_FORCE = "1";
+  }
+  return out;
+}
+
+// src/dev-servers/manager/parse-config.ts
+function parseDevServerDefs(servers) {
+  const out = [];
+  if (!Array.isArray(servers)) return out;
+  for (const s of servers) {
+    if (!s || typeof s !== "object") continue;
+    const o = s;
+    const serverId = typeof o.serverId === "string" ? o.serverId : "";
+    if (!serverId) continue;
+    const envRaw = o.env;
+    const env = Array.isArray(envRaw) ? envRaw.map((e) => {
+      if (!e || typeof e !== "object") return null;
+      const r = e;
+      return {
+        name: typeof r.name === "string" ? r.name : "",
+        value: typeof r.value === "string" ? r.value : ""
+      };
+    }).filter((e) => e != null && e.name.length > 0) : [];
+    const portsRaw = o.ports;
+    const ports = Array.isArray(portsRaw) ? portsRaw.filter((p) => typeof p === "number" && Number.isInteger(p) && p > 0 && p < 65536) : [];
+    out.push({
+      serverId,
+      name: typeof o.name === "string" ? o.name : "",
+      command: typeof o.command === "string" ? o.command : "",
+      env,
+      ports
+    });
+  }
+  return out;
+}
+
+// src/dev-servers/manager/shell-spawn/utils.ts
+import fs17 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 });
+  } catch {
+  }
+}
+var cachedDevNullReadFd;
+function devNullReadFd() {
+  if (cachedDevNullReadFd === void 0) {
+    const devPath = process.platform === "win32" ? "nul" : "/dev/null";
+    cachedDevNullReadFd = fs17.openSync(devPath, "r");
+  }
+  return cachedDevNullReadFd;
+}
+function pipedStdoutStderrFor(attemptStdio) {
+  return attemptStdio !== "inherit" && Array.isArray(attemptStdio) && attemptStdio[1] === "pipe" && attemptStdio[2] === "pipe";
+}
+
+// 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) {
+  const attempts = [
+    { stdio: [devNullReadFd(), "pipe", "pipe"], endStdin: false },
+    { stdio: ["ignore", "pipe", "pipe"], endStdin: true },
+    { stdio: ["pipe", "pipe", "pipe"], endStdin: true }
+  ];
+  let lastErr;
+  for (let i = 0; i < attempts.length; i++) {
+    const attempt = attempts[i];
+    const opts = {
+      env,
+      cwd: cwd3,
+      stdio: attempt.stdio,
+      ...signal ? { signal } : {}
+    };
+    try {
+      let proc;
+      if (process.platform === "win32") {
+        opts.windowsHide = true;
+        const com = process.env.ComSpec || "cmd.exe";
+        proc = spawn5(com, ["/d", "/s", "/c", command], opts);
+      } else {
+        proc = spawn5("/bin/sh", ["-c", command], opts);
+      }
+      if (attempt.endStdin) {
+        proc.stdin?.end();
+      }
+      return {
+        ok: true,
+        result: { proc, pipedStdoutStderr: pipedStdoutStderrFor(attempt.stdio) }
+      };
+    } catch (e) {
+      lastErr = e;
+      if (!isSpawnEbadf(e)) throw e;
+      if (i < attempts.length - 1) continue;
+      break;
+    }
+  }
+  return { ok: false, lastErr };
+}
+
+// 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) {
+  try {
+    const opts = {
+      env,
+      cwd: cwd3,
+      stdio: [devNullFd, "pipe", "pipe"],
+      shell: true,
+      ...signal ? { signal } : {}
+    };
+    if (process.platform === "win32") {
+      opts.windowsHide = true;
+    }
+    return spawn6(command, opts);
+  } catch (e) {
+    if (isSpawnEbadf(e)) return null;
+    throw e;
+  }
+}
+
+// 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 { 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-"));
+  const logPath = path22.join(tmpRoot, "combined.log");
+  let logFd;
+  try {
+    logFd = fs18.openSync(logPath, "a");
+  } catch {
+    rmDirQuiet(tmpRoot);
+    return null;
+  }
+  const stdio = ["ignore", logFd, logFd];
+  try {
+    let proc;
+    if (process.platform === "win32") {
+      proc = spawn7(process.env.ComSpec || "cmd.exe", ["/d", "/s", "/c", command], {
+        env,
+        cwd: cwd3,
+        stdio,
+        windowsHide: true,
+        ...signal ? { signal } : {}
+      });
+    } else {
+      proc = spawn7("/bin/sh", ["-c", command], { env, cwd: cwd3, stdio, ...signal ? { signal } : {} });
+    }
+    fs18.closeSync(logFd);
+    return {
+      proc,
+      pipedStdoutStderr: true,
+      mergedLogPath: logPath,
+      mergedLogCleanupDir: tmpRoot
+    };
+  } catch (e) {
+    try {
+      fs18.closeSync(logFd);
+    } catch {
+    }
+    rmDirQuiet(tmpRoot);
+    if (isSpawnEbadf(e)) return null;
+    throw e;
+  }
+}
+
+// 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 { 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-"));
+  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
+${command}
+`);
+    fs19.writeFileSync(
+      runnerPath,
+      `#!/bin/sh
+cd ${shSingleQuote(cwd3)}
+/bin/sh ${shSingleQuote(innerPath)} >>${shSingleQuote(logPath)} 2>&1
+`
+    );
+    const proc = spawn8("/bin/sh", [runnerPath], {
+      env,
+      cwd: tmpRoot,
+      stdio: "ignore",
+      ...signal ? { signal } : {}
+    });
+    return {
+      proc,
+      pipedStdoutStderr: true,
+      mergedLogPath: logPath,
+      mergedLogCleanupDir: tmpRoot
+    };
+  } catch (e) {
+    rmDirQuiet(tmpRoot);
+    if (isSpawnEbadf(e)) return null;
+    throw e;
+  }
+}
+function trySpawnShellScriptLogRedirectWin(command, env, cwd3, signal) {
+  const tmpRoot = fs19.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(
+      runnerPath,
+      `@ECHO OFF\r
+CD /D ${q(cwd3)}\r
+${command} >> ${q(logPath)} 2>&1\r
+`
+    );
+    const proc = spawn8(com, ["/d", "/s", "/c", q(runnerPath)], {
+      env,
+      cwd: tmpRoot,
+      stdio: "ignore",
+      windowsHide: true,
+      ...signal ? { signal } : {}
+    });
+    return {
+      proc,
+      pipedStdoutStderr: true,
+      mergedLogPath: logPath,
+      mergedLogCleanupDir: tmpRoot
+    };
+  } catch (e) {
+    rmDirQuiet(tmpRoot);
+    if (isSpawnEbadf(e)) return null;
+    throw e;
+  }
+}
+
+// src/dev-servers/manager/shell-spawn/try-spawn-inherit.ts
+import { spawn as spawn9 } from "node:child_process";
+function trySpawnInheritStdio(command, env, cwd3, signal) {
+  const opts = {
+    env,
+    cwd: cwd3,
+    stdio: "inherit",
+    ...signal ? { signal } : {}
+  };
+  let proc;
+  if (process.platform === "win32") {
+    opts.windowsHide = true;
+    const com = process.env.ComSpec || "cmd.exe";
+    proc = spawn9(com, ["/d", "/s", "/c", command], opts);
+  } else {
+    proc = spawn9("/bin/sh", ["-c", command], opts);
+  }
+  return { proc, pipedStdoutStderr: false };
+}
+
+// src/dev-servers/manager/shell-spawn/shell-spawn.ts
+function shellSpawn(command, env, cwd3, options) {
+  const signal = options?.signal;
+  const piped = trySpawnPipedViaSh(command, env, cwd3, signal);
+  if (piped.ok) {
+    return piped.result;
+  }
+  let lastErr = piped.lastErr;
+  const shellTrueProc = trySpawnShellTruePiped(command, env, cwd3, devNullReadFd(), signal);
+  if (shellTrueProc) {
+    return { proc: shellTrueProc, pipedStdoutStderr: true };
+  }
+  const fileCapture = trySpawnMergedLogFile(command, env, cwd3, signal);
+  if (fileCapture) {
+    return fileCapture;
+  }
+  const scriptCapture = process.platform === "win32" ? trySpawnShellScriptLogRedirectWin(command, env, cwd3, signal) : trySpawnShellScriptLogRedirectUnix(command, env, cwd3, signal);
+  if (scriptCapture) {
+    return scriptCapture;
+  }
+  try {
+    return trySpawnInheritStdio(command, env, cwd3, signal);
+  } catch (e) {
+    throw lastErr instanceof Error ? lastErr : e instanceof Error ? e : new Error(String(e));
+  }
+}
+
+// src/dev-servers/manager/stream-tail.ts
+var MAX_TAIL_LINES = 80;
+var MAX_LINE_CHARS = 8192;
+var MAX_PENDING_CHARS = 65536;
+function truncateLine(s) {
+  return s.length > MAX_LINE_CHARS ? `${s.slice(0, MAX_LINE_CHARS)}\u2026` : s;
+}
+var StreamTail = class {
+  pending = "";
+  lines = [];
+  push(chunk) {
+    this.pending += chunk.toString("utf8");
+    if (this.pending.length > MAX_PENDING_CHARS) {
+      this.pending = this.pending.slice(-MAX_PENDING_CHARS);
+    }
+    const parts = this.pending.split("\n");
+    this.pending = parts.pop() ?? "";
+    if (this.pending.length > MAX_PENDING_CHARS) {
+      this.pending = this.pending.slice(-MAX_PENDING_CHARS);
+    }
+    for (const line of parts) {
+      this.lines.push(truncateLine(line));
+      if (this.lines.length > MAX_TAIL_LINES) this.lines.shift();
+    }
+  }
+  /** Up to last 80 lines; any incomplete final line (no trailing newline) is included as the last entry. */
+  getTail() {
+    const out = [...this.lines];
+    if (this.pending !== "") {
+      out.push(truncateLine(this.pending));
+    }
+    if (out.length > MAX_TAIL_LINES) return out.slice(-MAX_TAIL_LINES);
+    return out;
+  }
+};
+
+// src/dev-servers/manager/dev-server-manager.ts
+var BRIDGE_SHUTDOWN_GRACE_MS = 8e3;
+var emptyTails = () => ({ stdout: [], stderr: [] });
+var DevServerManager = class {
+  defsById = /* @__PURE__ */ new Map();
+  processes = /* @__PURE__ */ new Map();
+  streamTailsByServerId = /* @__PURE__ */ new Map();
+  spawnGenerationByServerId = /* @__PURE__ */ new Map();
+  pipedCaptureByServerId = /* @__PURE__ */ new Map();
+  logViewerRefCountByServerId = /* @__PURE__ */ new Map();
+  firehoseSend = null;
+  mergedLogPollByServerId = /* @__PURE__ */ new Map();
+  mergedLogCleanupDirByServerId = /* @__PURE__ */ new Map();
+  abortControllersByServerId = /* @__PURE__ */ new Map();
+  getWs;
+  log;
+  constructor(options) {
+    this.getWs = options.getWs;
+    this.log = options.log;
+  }
+  attachFirehose(send) {
+    this.firehoseSend = send;
+  }
+  detachFirehose() {
+    this.firehoseSend = null;
+    this.logViewerRefCountByServerId.clear();
+  }
+  handleFirehoseLogViewerOpen(serverId, _viewerId) {
+    const next = (this.logViewerRefCountByServerId.get(serverId) ?? 0) + 1;
+    this.logViewerRefCountByServerId.set(serverId, next);
+    this.sendSnapshotToFirehose(serverId, _viewerId);
+  }
+  handleFirehoseLogViewerClose(serverId, _viewerId) {
+    const n = (this.logViewerRefCountByServerId.get(serverId) ?? 0) - 1;
+    if (n <= 0) this.logViewerRefCountByServerId.delete(serverId);
+    else this.logViewerRefCountByServerId.set(serverId, n);
+  }
+  sendSnapshotToFirehose(serverId, viewerId) {
+    const tails = this.streamTailsByServerId.get(serverId);
+    const payload = {
+      type: "log_snapshot",
+      serverId,
+      viewerId,
+      stdoutTail: tails?.stdout.getTail() ?? [],
+      stderrTail: tails?.stderr.getTail() ?? []
+    };
+    setImmediate(() => {
+      const send = this.firehoseSend;
+      if (!send) return;
+      send(payload);
+    });
+  }
+  pushRemoteLogChunk(serverId, stream, chunk) {
+    if ((this.logViewerRefCountByServerId.get(serverId) ?? 0) <= 0) return;
+    if (!this.pipedCaptureByServerId.get(serverId)) return;
+    const send = this.firehoseSend;
+    if (!send) return;
+    const text = chunk.toString("utf8");
+    setImmediate(() => {
+      if (!this.firehoseSend) return;
+      this.firehoseSend({
+        type: "log_chunk",
+        serverId,
+        stream,
+        text
+      });
+    });
+  }
+  applyConfig(servers) {
+    this.defsById.clear();
+    for (const d of parseDevServerDefs(servers)) {
+      this.defsById.set(d.serverId, d);
+    }
+  }
+  snapshotTails(serverId) {
+    const t = this.streamTailsByServerId.get(serverId);
+    if (!t) return { stdout: [], stderr: [] };
+    return { stdout: t.stdout.getTail(), stderr: t.stderr.getTail() };
+  }
+  clearTails(serverId) {
+    this.streamTailsByServerId.delete(serverId);
+  }
+  sendStatus(serverId, status, detail, tails) {
+    sendDevServerStatus(this.getWs, serverId, status, { detail, tails });
+  }
+  bumpGeneration(serverId) {
+    const nextGen = (this.spawnGenerationByServerId.get(serverId) ?? 0) + 1;
+    this.spawnGenerationByServerId.set(serverId, nextGen);
+  }
+  clearPoll(serverId) {
+    const poll = this.mergedLogPollByServerId.get(serverId);
+    if (poll) {
+      clearInterval(poll);
+      this.mergedLogPollByServerId.delete(serverId);
+    }
+  }
+  abortSpawn(serverId) {
+    this.abortControllersByServerId.get(serverId)?.abort();
+    this.abortControllersByServerId.delete(serverId);
+  }
+  stop(serverId) {
+    const tails = this.snapshotTails(serverId);
+    if (this.processes.has(serverId)) {
+      this.sendStatus(serverId, "stopping", void 0, tails);
+    }
+    this.bumpGeneration(serverId);
+    this.abortSpawn(serverId);
+    this.clearPoll(serverId);
+    const proc = this.processes.get(serverId);
+    if (proc) {
+      proc.removeAllListeners();
+      try {
+        proc.kill("SIGTERM");
+      } catch {
+      }
+      this.processes.delete(serverId);
+    }
+    this.clearTails(serverId);
+    this.pipedCaptureByServerId.delete(serverId);
+    const mergedDir = this.mergedLogCleanupDirByServerId.get(serverId);
+    if (mergedDir) {
+      this.mergedLogCleanupDirByServerId.delete(serverId);
+      void rm(mergedDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+    this.sendStatus(serverId, "stopped", void 0, tails);
+  }
+  start(serverId) {
+    const def = this.defsById.get(serverId);
+    if (!def) {
+      this.log(`[dev-server] Unknown server id ${serverId.slice(0, 8)}\u2026`);
+      this.sendStatus(serverId, "error", "Unknown server", emptyTails());
+      return;
+    }
+    if (!def.command.trim()) {
+      this.sendStatus(serverId, "idle", "No command configured", emptyTails());
+      return;
+    }
+    this.stop(serverId);
+    this.sendStatus(serverId, "starting", void 0, emptyTails());
+    const ac = new AbortController();
+    this.abortControllersByServerId.set(serverId, ac);
+    const cwd3 = process.cwd();
+    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);
+    this.log(`[dev-server] Starting ${title}: ${cmd.slice(0, 120)}${cmd.length > 120 ? "\u2026" : ""}`);
+    const scheduledGen = this.spawnGenerationByServerId.get(serverId) ?? 0;
+    setImmediate(() => {
+      if ((this.spawnGenerationByServerId.get(serverId) ?? 0) !== scheduledGen) {
+        return;
+      }
+      let proc;
+      let pipedStdoutStderr;
+      let mergedLogPath;
+      let mergedCleanupDir;
+      try {
+        const spawned = shellSpawn(cmd, childEnv, cwd3, {
+          signal: ac.signal
+        });
+        proc = spawned.proc;
+        pipedStdoutStderr = spawned.pipedStdoutStderr;
+        mergedLogPath = spawned.mergedLogPath;
+        mergedCleanupDir = spawned.mergedLogCleanupDir;
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        this.log(`[dev-server] ${title} failed to start: ${msg}`);
+        this.abortControllersByServerId.delete(serverId);
+        this.sendStatus(serverId, "error", msg, emptyTails());
+        return;
+      }
+      if ((this.spawnGenerationByServerId.get(serverId) ?? 0) !== scheduledGen) {
+        try {
+          proc.removeAllListeners();
+          proc.kill("SIGTERM");
+        } catch {
+        }
+        return;
+      }
+      if (!pipedStdoutStderr) {
+        this.log(`[dev-server] ${title} running (inherited stdio; bridge log preview disabled)`);
+      } else if (mergedLogPath && mergedCleanupDir) {
+        this.log(
+          `[dev-server] ${title} running (logs captured via temp file; open the browser log viewer for live output)`
+        );
+      }
+      this.pipedCaptureByServerId.set(serverId, pipedStdoutStderr);
+      const stdoutTail = new StreamTail();
+      const stderrTail = new StreamTail();
+      this.streamTailsByServerId.set(serverId, { stdout: stdoutTail, stderr: stderrTail });
+      if (mergedLogPath && mergedCleanupDir) {
+        this.mergedLogCleanupDirByServerId.set(serverId, mergedCleanupDir);
+      }
+      const mergedReadPos = { value: 0 };
+      this.processes.set(serverId, proc);
+      wireDevServerChildProcess({
+        serverId,
+        title,
+        proc,
+        mergedLogPath,
+        mergedCleanupDir,
+        mergedReadPos,
+        scheduledGen,
+        getSpawnGeneration: () => this.spawnGenerationByServerId.get(serverId) ?? 0,
+        log: this.log,
+        stdoutTail,
+        stderrTail,
+        pushRemoteLogChunk: (sid, stream, chunk) => this.pushRemoteLogChunk(sid, stream, chunk),
+        sendStatus: (status, detail, tails) => this.sendStatus(serverId, status, detail, tails),
+        setPollInterval: (iv) => {
+          if (iv) this.mergedLogPollByServerId.set(serverId, iv);
+          else this.mergedLogPollByServerId.delete(serverId);
+        },
+        getPollInterval: () => this.mergedLogPollByServerId.get(serverId),
+        detachProcessFromManager: () => {
+          this.processes.delete(serverId);
+          this.pipedCaptureByServerId.delete(serverId);
+          this.abortControllersByServerId.delete(serverId);
+          this.mergedLogCleanupDirByServerId.delete(serverId);
+        },
+        rmMergedCleanupDir: (dir) => {
+          void rm(dir, { recursive: true, force: true }).catch(() => {
+          });
+        },
+        clearTailBuffers: () => this.clearTails(serverId)
+      });
+      this.sendStatus(serverId, "running", `pid=${proc.pid ?? "?"}`, {
+        stdout: stdoutTail.getTail(),
+        stderr: stderrTail.getTail()
+      });
+    });
+  }
+  handleControl(serverId, action) {
+    if (action === "stop") {
+      this.stop(serverId);
+      return;
+    }
+    this.start(serverId);
+  }
+  async shutdownAllGraceful() {
+    const pairs = [...this.processes.entries()];
+    if (pairs.length === 0) return;
+    this.log(`[dev-server] Stopping ${pairs.length} dev server process(es) (bridge shutting down)\u2026`);
+    await Promise.all(pairs.map(([serverId, proc]) => this.gracefulTerminateOrUnknown(serverId, proc)));
+  }
+  async gracefulTerminateOrUnknown(serverId, proc) {
+    const shortId = `${serverId.slice(0, 8)}\u2026`;
+    await sigtermAndWaitForExit(proc, BRIDGE_SHUTDOWN_GRACE_MS, this.log, shortId);
+    if (!this.processes.has(serverId) || this.processes.get(serverId) !== proc) {
+      return;
+    }
+    this.bumpGeneration(serverId);
+    forceKillChild(proc, this.log, shortId, BRIDGE_SHUTDOWN_GRACE_MS);
+    this.processes.delete(serverId);
+    this.clearPoll(serverId);
+    this.pipedCaptureByServerId.delete(serverId);
+    const mergedDir = this.mergedLogCleanupDirByServerId.get(serverId);
+    if (mergedDir) {
+      this.mergedLogCleanupDirByServerId.delete(serverId);
+      void rm(mergedDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+    const tails = this.snapshotTails(serverId);
+    this.clearTails(serverId);
+    this.sendStatus(serverId, "unknown", "Bridge closed before process exited", tails);
+  }
+};
+
+// src/firehose/connect-firehose.ts
+import https2 from "node:https";
+
+// src/firehose/proxy/start-streaming-proxy.ts
+function startStreamingProxy(ws, log2, pr) {
+  proxyToLocalStreaming(pr, {
+    onStart: (statusCode, headers) => {
+      const forwardedHeaders = { ...headers };
+      const ce = "content-encoding";
+      const cl = "content-length";
+      const keys = Object.keys(forwardedHeaders).filter(
+        (k) => k.toLowerCase() !== ce && k.toLowerCase() !== cl
+      );
+      const filtered = {};
+      for (const k of keys) if (forwardedHeaders[k] != null) filtered[k] = forwardedHeaders[k];
+      sendWsMessage(ws, { type: "proxy_result_start", id: pr.id, statusCode, headers: filtered });
+    },
+    onChunk: (chunk) => {
+      const idBuf = Buffer.from(pr.id, "utf8");
+      ws.send(Buffer.concat([idBuf, Buffer.from(chunk)]), { binary: true });
+    },
+    onEnd: () => sendWsMessage(ws, { type: "proxy_result_end", id: pr.id }),
+    onError: (error40) => {
+      log2(`[Proxy and log service] streaming preview failed: ${error40}`);
+      sendWsMessage(ws, { type: "proxy_result_error", id: pr.id, error: error40 });
+    }
+  });
+}
+
+// src/firehose/build-cli-ws-url.ts
+function buildFirehoseCliWsUrl(baseUrl) {
+  const base = baseUrl.startsWith("https") ? baseUrl.replace(/^https/, "wss") : baseUrl.replace(/^http/, "ws");
+  return `${base.replace(/\/$/, "")}/ws`;
+}
+
+// src/firehose/routing/firehose-message-router.ts
+function createFirehoseMessageRouter() {
+  const handlers = /* @__PURE__ */ new Map();
+  return {
+    register(type, handler) {
+      handlers.set(type, handler);
+    },
+    dispatch(msg, deps) {
+      const type = msg.type;
+      if (!type) return;
+      const handler = handlers.get(type);
+      if (handler) handler(msg, deps);
+    }
+  };
+}
+
+// src/firehose/routing/handlers/dev-server-logs-viewer-open.ts
+var handleDevServerLogsViewerOpen = (msg, deps) => {
+  const serverId = typeof msg.serverId === "string" ? msg.serverId : "";
+  const viewerId = typeof msg.viewerId === "string" ? msg.viewerId : "";
+  if (!serverId || !viewerId) return;
+  deps.devServerManager.handleFirehoseLogViewerOpen(serverId, viewerId);
+};
+
+// src/firehose/routing/handlers/dev-server-logs-viewer-close.ts
+var handleDevServerLogsViewerClose = (msg, deps) => {
+  const serverId = typeof msg.serverId === "string" ? msg.serverId : "";
+  const viewerId = typeof msg.viewerId === "string" ? msg.viewerId : "";
+  if (!serverId || !viewerId) return;
+  deps.devServerManager.handleFirehoseLogViewerClose(serverId, viewerId);
+};
+
+// src/firehose/routing/handlers/proxy-message.ts
+var handleProxyMessage = (msg, deps) => {
+  const proxy = msg.proxy;
+  if (!proxy || typeof proxy !== "object") return;
+  const pr = proxy;
+  if (pr.streamResponse) {
+    const bodyLength = pr.bodyLength ?? 0;
+    if (bodyLength > 0) {
+      deps.pendingProxyBody.set(pr.id, {
+        pr: {
+          id: pr.id,
+          method: pr.method,
+          url: pr.url,
+          headers: pr.headers,
+          streamResponse: true
+        }
+      });
+    } else {
+      deps.startStreamingProxy({
+        id: pr.id,
+        method: pr.method,
+        url: pr.url,
+        headers: pr.headers,
+        streamResponse: true
+      });
+    }
+    return;
+  }
+  void proxyToLocal(pr).then((res) => {
+    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)}`
+    );
+    sendWsMessage(deps.ws, { type: "proxy_result", id: pr.id, error: String(err) });
+  });
+};
+
+// src/firehose/routing/handlers/identified.ts
+var handleFirehoseIdentified = (_msg, _deps) => {
+};
+
+// src/firehose/routing/dispatch-firehose-message.ts
+var router = createFirehoseMessageRouter();
+router.register("identified", handleFirehoseIdentified);
+router.register("log_viewer_open", handleDevServerLogsViewerOpen);
+router.register("log_viewer_close", handleDevServerLogsViewerClose);
+router.register("proxy", handleProxyMessage);
+function dispatchFirehoseJsonMessage(msg, deps) {
+  router.dispatch(msg, deps);
+}
+
+// src/firehose/routing/try-consume-binary-proxy-body.ts
+var PROXY_ID_BYTES = 36;
+function tryConsumeBinaryProxyBody(raw, deps) {
+  if (raw.length < PROXY_ID_BYTES) return false;
+  const id = raw.slice(0, PROXY_ID_BYTES).toString("utf8");
+  const pending = deps.pendingProxyBody.get(id);
+  if (!pending) return false;
+  deps.pendingProxyBody.delete(id);
+  const body = raw.slice(PROXY_ID_BYTES);
+  deps.startStreamingProxy({
+    ...pending.pr,
+    body: body.length > 0 ? new Uint8Array(body) : void 0
+  });
+  return true;
+}
+
+// src/firehose/connect-firehose.ts
+function connectFirehose(options) {
+  const { firehoseServerUrl, workspaceId, bridgeName, proxyPorts, log: log2, devServerManager, onOpen, onClose } = options;
+  const wsUrl = buildFirehoseCliWsUrl(firehoseServerUrl);
+  const wsOptions = { perMessageDeflate: false };
+  if (wsUrl.startsWith("wss://")) {
+    wsOptions.agent = new https2.Agent({ rejectUnauthorized: false });
+  }
+  const ws = new wrapper_default(wsUrl, wsOptions);
+  const firehoseSend = (payload) => {
+    sendWsMessage(ws, payload);
+  };
+  const pendingProxyBody = /* @__PURE__ */ new Map();
+  const deps = {
+    ws,
+    log: log2,
+    devServerManager,
+    pendingProxyBody,
+    startStreamingProxy: (pr) => startStreamingProxy(ws, log2, pr)
+  };
+  ws.on("open", () => {
+    onOpen?.();
+    devServerManager.attachFirehose(firehoseSend);
+    sendWsMessage(ws, { type: "identify", workspaceId, bridgeName, proxyPorts });
+  });
+  ws.on("message", (raw) => {
+    setImmediate(() => {
+      if (Buffer.isBuffer(raw) && tryConsumeBinaryProxyBody(raw, deps)) {
+        return;
+      }
+      try {
+        const text = Buffer.isBuffer(raw) ? raw.toString("utf8") : String(raw);
+        dispatchFirehoseJsonMessage(JSON.parse(text), deps);
+      } catch {
+      }
+    });
+  });
+  ws.on("close", (code, reason) => {
+    devServerManager.detachFirehose();
+    log2(
+      formatWebSocketClose(
+        "[Proxy and log service]",
+        code,
+        typeof reason === "string" ? reason : reason.toString(),
+        "reconnects automatically if the bridge service stays connected"
+      )
+    );
+    onClose?.();
+  });
+  ws.on("error", (err) => {
+    log2(`[Proxy and log service] WebSocket error: ${err.message}`);
+  });
+  return {
+    close() {
+      devServerManager.detachFirehose();
+      try {
+        ws.removeAllListeners();
+        ws.close();
+      } catch {
+      }
+    }
+  };
+}
+
+// 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() {
+    if (state.firehoseReconnectTimeout != null) {
+      clearTimeout(state.firehoseReconnectTimeout);
+      state.firehoseReconnectTimeout = null;
+    }
+  }
+  function attachFirehose(params) {
+    state.lastFirehoseParams = params;
+    clearFirehoseReconnectTimer();
+    state.firehoseGeneration += 1;
+    const myGen = state.firehoseGeneration;
+    if (state.firehoseHandle) {
+      state.firehoseHandle.close();
+      state.firehoseHandle = null;
+    }
+    state.firehoseHandle = connectFirehose({
+      firehoseServerUrl: params.firehoseServerUrl,
+      workspaceId: params.workspaceId,
+      bridgeName: params.bridgeName,
+      proxyPorts: params.proxyPorts,
+      log: logFn,
+      devServerManager,
+      onOpen: () => {
+        if (myGen !== state.firehoseGeneration) return;
+        state.firehoseReconnectAttempt = 0;
+      },
+      onClose: () => {
+        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");
+          return;
+        }
+        clearFirehoseReconnectTimer();
+        const delay2 = Math.min(
+          FH_RECONNECT_BASE_MS * 2 ** state.firehoseReconnectAttempt,
+          FH_RECONNECT_MAX_MS
+        );
+        state.firehoseReconnectAttempt += 1;
+        logFn(
+          `[Proxy and log service] reconnect attempt ${state.firehoseReconnectAttempt} in ${delay2 / 1e3}s\u2026`
+        );
+        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");
+            return;
+          }
+          const p = state.lastFirehoseParams;
+          if (!p) {
+            logFn("[Proxy and log service] reconnect skipped: no stored connection params");
+            return;
+          }
+          attachFirehose(p);
+        }, delay2);
+      }
+    });
+  }
+  return (msg) => {
+    sessionWorktreeManager.setBridgeSessionWorktrees(msg.sessionWorktreesEnabled === true);
+    const bridgeName = msg.bridgeName;
+    const proxyPorts = Array.isArray(msg.proxyPorts) ? msg.proxyPorts : [];
+    const devServers = msg.devServers ?? [];
+    setImmediate(() => {
+      devServerManager.applyConfig(devServers);
+      if (!firehoseServerUrl || typeof bridgeName !== "string" || !bridgeName) return;
+      state.firehoseReconnectAttempt = 0;
+      attachFirehose({
+        firehoseServerUrl,
+        workspaceId,
+        bridgeName,
+        proxyPorts
+      });
+    });
+  };
+}
+
+// src/dev-servers/detect-local-agent-types.ts
+import { execFile as execFile4 } from "node:child_process";
+import { promisify as promisify4 } from "node:util";
+var execFileAsync4 = promisify4(execFile4);
+var CHECKS = {
+  "cursor-cli": async () => {
+    try {
+      await execFileAsync4("which", ["agent"], { timeout: 4e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  "codex-acp": async () => {
+    try {
+      await execFileAsync4("which", ["codex"], { timeout: 4e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  "claude-code": async () => {
+    try {
+      await execFileAsync4("which", ["claude"], { timeout: 4e3 });
+      return true;
+    } catch {
+      try {
+        await execFileAsync4("npx", ["--yes", "@anthropic-ai/claude-code", "--version"], { timeout: 25e3 });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  }
+};
+async function detectLocalAgentTypes() {
+  try {
+    const out = [];
+    for (const [type, check2] of Object.entries(CHECKS)) {
+      try {
+        if (await check2()) out.push(type);
+      } catch {
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+
+// src/bridge/connection/create-bridge-local-reports.ts
+function createSendLocalSkillsReport(getWs, logFn) {
+  return () => {
+    try {
+      const socket = getWs();
+      if (!socket || socket.readyState !== wrapper_default.OPEN) return;
+      const skills2 = discoverLocalSkills(process.cwd());
+      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)}`);
+    }
+  };
+}
+function createReportAutoDetectedAgents(getWs, logFn) {
+  return async () => {
+    try {
+      const types = await detectLocalAgentTypes();
+      const socket = getWs();
+      if (socket && socket.readyState === wrapper_default.OPEN) {
+        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)}`);
+    }
+  };
+}
+
 // src/bridge/connection/create-bridge-connection.ts
 async function createBridgeConnection(options) {
-  const { apiUrl, workspaceId, proxyServerUrl, agentCommand, justAuthenticated, onAuthInvalid, persistTokens } = options;
+  const { apiUrl, workspaceId, justAuthenticated, onAuthInvalid, persistTokens } = options;
+  const firehoseServerUrl = options.firehoseServerUrl ?? options.proxyServerUrl;
   const logFn = options.log ?? log;
   let accessToken = options.authToken;
   let refreshTok = options.refreshToken;
@@ -32089,25 +33163,37 @@ async function createBridgeConnection(options) {
     reconnectAttempt: 0,
     reconnectTimeout: null,
     currentWs: null,
-    proxyHandle: null
+    firehoseHandle: null,
+    lastFirehoseParams: null,
+    firehoseReconnectTimeout: null,
+    firehoseReconnectAttempt: 0,
+    firehoseGeneration: 0
   };
   const worktreesRootAbs = options.worktreesRootAbs ?? defaultWorktreesRootAbs();
   const sessionWorktreeManager = new SessionWorktreeManager({
     worktreesRootAbs,
     log: logFn
   });
-  const acpManager = await createAcpManager({ agentCommand, log: logFn });
-  const skills2 = getSkills();
-  logFn(`Skills: ${skills2.map((s) => s.id).join(", ")}`);
-  logFn("Connected to backend. Press Ctrl+C to exit.");
+  const acpManager = await createAcpManager({ log: logFn });
+  logFn("CLI running. Press Ctrl+C to exit.");
   function getWs() {
     return state.currentWs;
   }
+  const devServerManager = new DevServerManager({ getWs, log: logFn });
+  const onBridgeIdentified = createOnBridgeIdentified({
+    sessionWorktreeManager,
+    devServerManager,
+    firehoseServerUrl,
+    workspaceId,
+    state,
+    logFn
+  });
+  const sendLocalSkillsReport = createSendLocalSkillsReport(getWs, logFn);
+  const reportAutoDetectedAgents = createReportAutoDetectedAgents(getWs, logFn);
   function handleOpen() {
     state.reconnectAttempt = 0;
     const socket = getWs();
     if (socket) {
-      logFn("WebSocket connected");
       sendWsMessage(socket, { type: "identify", role: "cli" });
       reportGitRepos(getWs, logFn);
     }
@@ -32121,49 +33207,23 @@ async function createBridgeConnection(options) {
     const was = state.currentWs;
     state.currentWs = null;
     if (was) was.removeAllListeners();
-    logFn(`WebSocket closed: ${code} ${reason}`);
-    if (!state.closedByUser) {
+    const willReconnect = !state.closedByUser;
+    logFn(
+      formatWebSocketClose("[Bridge service]", code, reason, willReconnect ? "will schedule reconnect" : "not reconnecting (CLI shutting down)")
+    );
+    if (willReconnect) {
       scheduleReconnect(state, connect, logFn);
     }
   }
-  function onBridgeIdentified(msg) {
-    sessionWorktreeManager.setBridgeSessionWorktrees(msg.sessionWorktreesEnabled === true);
-    const bridgeName = msg.bridgeName;
-    const proxyPorts = Array.isArray(msg.proxyPorts) ? msg.proxyPorts : [];
-    if (proxyServerUrl && bridgeName) {
-      logFn(`Proxy: setting up connection (server=${proxyServerUrl}, bridge=${bridgeName}, ports=[${proxyPorts.join(", ")}])`);
-      if (state.proxyHandle) {
-        state.proxyHandle.close();
-        state.proxyHandle = null;
-      }
-      state.proxyHandle = connectProxy({
-        proxyServerUrl,
-        workspaceId,
-        bridgeName,
-        proxyPorts,
-        log: logFn,
-        onClose: () => {
-          if (state.proxyHandle) state.proxyHandle = null;
-        }
-      });
-    }
-  }
-  function sendLocalSkillsReport() {
-    const socket = getWs();
-    if (!socket || socket.readyState !== wrapper_default.OPEN) return;
-    const skills3 = discoverLocalSkills(process.cwd());
-    socket.send(JSON.stringify({ type: "local_skills", skills: skills3 }));
-    if (skills3.length > 0) {
-      logFn(`Local agent skills (cwd): ${skills3.map((s) => s.path).join(", ")}`);
-    }
-  }
   const messageDeps = {
     getWs,
     log: logFn,
     acpManager,
     sessionWorktreeManager,
     onBridgeIdentified,
-    sendLocalSkillsReport
+    sendLocalSkillsReport,
+    reportAutoDetectedAgents,
+    devServerManager
   };
   function connect() {
     if (state.closedByUser) return;
@@ -32177,7 +33237,6 @@ async function createBridgeConnection(options) {
       state.currentWs = null;
     }
     const url2 = buildBridgeUrl(apiUrl, workspaceId, accessToken);
-    logFn(`Connecting to backend at ${apiUrl}`);
     state.currentWs = createWsBridge({
       url: url2,
       onAuthInvalid: () => {
@@ -32191,7 +33250,7 @@ async function createBridgeConnection(options) {
                 accessToken = next.token;
                 refreshTok = next.refreshToken;
                 persistTokens?.({ token: accessToken, refreshToken: refreshTok });
-                logFn("Bridge access token refreshed; reconnecting\u2026");
+                logFn("[Bridge service] access token refreshed; reconnecting\u2026");
                 state.reconnectAttempt = 0;
                 authRefreshInFlight = false;
                 connect();
@@ -32210,23 +33269,24 @@ async function createBridgeConnection(options) {
       },
       onOpen: handleOpen,
       onClose: handleClose,
-      onError: (err) => logFn(`WebSocket error: ${err.message}`),
+      onError: (err) => logFn(`[Bridge service] WebSocket error: ${err.message}`),
       onMessage: (data) => handleBridgeMessage(data, messageDeps)
     });
   }
   connect();
   const stopFileIndexWatcher = startFileIndexWatcher(process.cwd());
   return {
-    close: () => {
+    close: async () => {
       stopFileIndexWatcher();
-      closeBridgeConnection(state, acpManager);
+      await closeBridgeConnection(state, acpManager, devServerManager, logFn);
     }
   };
 }
 
 // src/run-bridge.ts
 async function runBridge(options) {
-  const { apiUrl, workspaceId, authToken, refreshToken, proxyServerUrl, agentCommand, bridgeName, justAuthenticated, worktreesRootAbs } = options;
+  const { apiUrl, workspaceId, authToken, refreshToken, bridgeName, justAuthenticated, worktreesRootAbs } = options;
+  const firehoseServerUrl = options.firehoseServerUrl ?? options.proxyServerUrl;
   const hasAuth = workspaceId && authToken;
   if (!hasAuth) {
     const handle2 = runPendingAuth({
@@ -32237,15 +33297,20 @@ async function runBridge(options) {
       onAuth: (_auth) => {
       }
     });
-    const onSignal2 = () => {
-      handle2.close();
-      process.exit(0);
+    const onSignal2 = (signal) => {
+      logImmediate(`Received ${signal}; shutting down\u2026`);
+      setImmediate(() => {
+        handle2.close();
+        process.exit(0);
+      });
     };
-    process.on("SIGINT", onSignal2);
-    process.on("SIGTERM", onSignal2);
+    const onSigInt2 = () => onSignal2("SIGINT");
+    const onSigTerm2 = () => onSignal2("SIGTERM");
+    process.on("SIGINT", onSigInt2);
+    process.on("SIGTERM", onSigTerm2);
     const auth = await handle2.authPromise;
-    process.off("SIGINT", onSignal2);
-    process.off("SIGTERM", onSignal2);
+    process.off("SIGINT", onSigInt2);
+    process.off("SIGTERM", onSigTerm2);
     handle2.close();
     if (!auth) return;
     writeConfigForApi(apiUrl, {
@@ -32258,8 +33323,7 @@ async function runBridge(options) {
       workspaceId: auth.workspaceId,
       authToken: auth.token,
       refreshToken: auth.refreshToken,
-      proxyServerUrl,
-      agentCommand,
+      firehoseServerUrl,
       bridgeName,
       justAuthenticated: true,
       worktreesRootAbs
@@ -32271,8 +33335,7 @@ async function runBridge(options) {
     workspaceId,
     authToken,
     refreshToken,
-    proxyServerUrl,
-    agentCommand,
+    firehoseServerUrl,
     justAuthenticated,
     worktreesRootAbs,
     log,
@@ -32284,18 +33347,25 @@ async function runBridge(options) {
       });
     },
     onAuthInvalid: () => {
-      log("Stored token was invalid or revoked and could not be refreshed. Re-authenticating\u2026");
+      log("[Bridge service] token invalid or revoked; re-authenticating\u2026");
       clearConfigForApi(apiUrl);
-      handle.close();
-      void runBridge({ apiUrl, proxyServerUrl, agentCommand, worktreesRootAbs });
+      void handle.close().then(() => {
+        void runBridge({ apiUrl, firehoseServerUrl, worktreesRootAbs });
+      });
     }
   });
-  const onSignal = () => {
-    handle.close();
-    process.exit(0);
+  const onSignal = (signal) => {
+    logImmediate(`Received ${signal}; shutting down\u2026`);
+    setImmediate(() => {
+      void handle.close().then(() => {
+        process.exit(0);
+      });
+    });
   };
-  process.on("SIGINT", onSignal);
-  process.on("SIGTERM", onSignal);
+  const onSigInt = () => onSignal("SIGINT");
+  const onSigTerm = () => onSignal("SIGTERM");
+  process.on("SIGINT", onSigInt);
+  process.on("SIGTERM", onSigTerm);
 }
 export {
   callSkill,