@buildautomaton/cli 0.1.5 → 0.1.6

package/dist/index.js

@@ -21966,12 +21966,12 @@ var require_src2 = __commonJS({
     function check2(path24, isFile, isDirectory) {
       log2(`checking %s`, path24);
       try {
-        const stat = fs_1.statSync(path24);
-        if (stat.isFile() && isFile) {
+        const stat2 = fs_1.statSync(path24);
+        if (stat2.isFile() && isFile) {
           log2(`[OK] path represents a file`);
           return true;
         }
-        if (stat.isDirectory() && isDirectory) {
+        if (stat2.isDirectory() && isDirectory) {
           log2(`[OK] path represents a directory`);
           return true;
         }
@@ -22061,14 +22061,30 @@ var import_websocket = __toESM(require_websocket(), 1);
 var import_websocket_server = __toESM(require_websocket_server(), 1);
 var wrapper_default = import_websocket.default;
 
+// src/net/apply-cli-outbound-network-prefs.ts
+import dns from "node:dns";
+var applied = false;
+function applyCliOutboundNetworkPreferences() {
+  if (applied) return;
+  applied = true;
+  try {
+    dns.setDefaultResultOrder("ipv4first");
+  } catch {
+  }
+}
+
 // src/bridge/connection/create-ws-bridge.ts
 var BRIDGE_AUTH_ERROR_HEADER = "x-bridge-auth-error";
 var BRIDGE_AUTH_ERROR_TOKEN_INVALID = "token_invalid";
 function createWsBridge(options) {
   const { url: url2, onMessage, onOpen, onClose, onError: onError2, onAuthInvalid, clientPingIntervalMs } = options;
-  const wsOptions = {};
+  applyCliOutboundNetworkPreferences();
+  const wsOptions = {
+    perMessageDeflate: false,
+    family: 4
+  };
   if (url2.startsWith("wss://")) {
-    wsOptions.agent = new https.Agent({ rejectUnauthorized: false });
+    wsOptions.agent = new https.Agent({ rejectUnauthorized: false, family: 4 });
   }
   const ws = new wrapper_default(url2, wsOptions);
   let clientPingTimer = null;
@@ -22132,10 +22148,58 @@ function sendWsMessage(ws, payload) {
   }
 }
 
-// src/acp/clients/acp-client.ts
+// src/acp/clients/sdk-stdio-acp-client.ts
 import { spawn } from "node:child_process";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
 import { Readable, Writable } from "node:stream";
 
+// src/files/diff/unified-diff.ts
+function computeLineDiff(oldText, newText) {
+  const oldLines = oldText.split("\n");
+  const newLines = newText.split("\n");
+  const m = oldLines.length;
+  const n = newLines.length;
+  const dp = Array(m + 1);
+  for (let i2 = 0; i2 <= m; i2++) dp[i2] = Array(n + 1).fill(0);
+  for (let i2 = 1; i2 <= m; i2++) {
+    for (let j2 = 1; j2 <= n; j2++) {
+      if (oldLines[i2 - 1] === newLines[j2 - 1]) {
+        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
+      } else {
+        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+      }
+    }
+  }
+  const result = [];
+  let i = m;
+  let j = n;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
+      result.unshift({ type: "context", line: oldLines[i - 1] });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      result.unshift({ type: "add", line: newLines[j - 1] });
+      j--;
+    } else {
+      result.unshift({ type: "remove", line: oldLines[i - 1] });
+      i--;
+    }
+  }
+  return result;
+}
+function editSnippetToUnifiedDiff(filePath, oldText, newText) {
+  const lines = computeLineDiff(oldText, newText);
+  const out = [`--- ${filePath}`, `+++ ${filePath}`];
+  for (const d of lines) {
+    if (d.type === "add") out.push(`+${d.line}`);
+    else if (d.type === "remove") out.push(`-${d.line}`);
+    else out.push(` ${d.line}`);
+  }
+  return out.join("\n");
+}
+
 // src/files/cwd/bridge-workspace-directory.ts
 import * as path from "node:path";
 var bridgeWorkspaceDirectory = null;
@@ -22146,7 +22210,25 @@ function getBridgeWorkspaceDirectory() {
   return bridgeWorkspaceDirectory;
 }
 
-// src/acp/clients/acp-client.ts
+// src/acp/safe-fs-path.ts
+import * as path2 from "node:path";
+function resolveSafePathUnderCwd(cwd, filePath) {
+  const trimmed2 = filePath.trim();
+  if (!trimmed2) return null;
+  const normalizedCwd = path2.resolve(cwd);
+  const resolved = path2.isAbsolute(trimmed2) ? path2.normalize(trimmed2) : path2.resolve(normalizedCwd, trimmed2);
+  const rel = path2.relative(normalizedCwd, resolved);
+  if (rel.startsWith("..") || path2.isAbsolute(rel)) return null;
+  return resolved;
+}
+function toDisplayPathRelativeToCwd(cwd, absolutePath) {
+  const normalizedCwd = path2.resolve(cwd);
+  const rel = path2.relative(normalizedCwd, path2.resolve(absolutePath));
+  if (!rel || rel === "") return path2.basename(absolutePath);
+  return rel.split(path2.sep).join("/");
+}
+
+// src/acp/clients/sdk-stdio-acp-client.ts
 function formatSpawnError(err, command) {
   if (err.code === "ENOENT") {
     return `Command "${command}" not found. Install the agent (e.g. Cursor CLI) or add it to PATH.`;
@@ -22161,9 +22243,26 @@ function toErrorMessage(err) {
   if (err != null && typeof err === "object") return JSON.stringify(err);
   return String(err);
 }
-async function createAcpClient(options) {
-  const { ClientSideConnection: ClientSideConnection2, ndJsonStream: ndJsonStream2 } = await Promise.resolve().then(() => (init_acp(), acp_exports));
-  const { command, cwd = getBridgeWorkspaceDirectory(), onSessionUpdate } = options;
+function sliceFileContentRange(content, line, limit) {
+  if (line == null && limit == null) return content;
+  const lines = content.split("\n");
+  const start = line != null && line > 0 ? line - 1 : 0;
+  const end = limit != null && limit > 0 ? start + limit : lines.length;
+  return lines.slice(start, end).join("\n");
+}
+function bridgePayloadFromSdkSessionNotification(params) {
+  return { sessionId: params.sessionId, ...params.update };
+}
+async function createSdkStdioAcpClient(options) {
+  const { ClientSideConnection: ClientSideConnection2, ndJsonStream: ndJsonStream2, PROTOCOL_VERSION: PROTOCOL_VERSION2 } = await Promise.resolve().then(() => (init_acp(), acp_exports));
+  const {
+    command,
+    cwd = getBridgeWorkspaceDirectory(),
+    onSessionUpdate,
+    onFileChange,
+    killSubprocessAfterCancelMs,
+    onAgentSubprocessExit
+  } = options;
   const isWindows = process.platform === "win32";
   const child = spawn(command[0], command.slice(1), {
     cwd,
@@ -22171,6 +22270,9 @@ async function createAcpClient(options) {
     env: process.env,
     shell: isWindows
   });
+  child.once("close", (code, signal) => {
+    onAgentSubprocessExit?.({ code, signal });
+  });
   return new Promise((resolve14, reject) => {
     child.on("error", (err) => {
       child.kill();
@@ -22182,11 +22284,43 @@ async function createAcpClient(options) {
         const readable = Readable.toWeb(child.stdout);
         const stream = ndJsonStream2(writable, readable);
         const client = (_agent) => ({
-          async requestPermission(_params) {
-            return { outcome: "approved" };
+          async requestPermission(params) {
+            const opt = params?.options?.[0];
+            if (opt && typeof opt.optionId === "string") {
+              return { outcome: { outcome: "selected", optionId: opt.optionId } };
+            }
+            return { outcome: { outcome: "cancelled" } };
+          },
+          async readTextFile(params) {
+            const abs = resolveSafePathUnderCwd(cwd, params.path);
+            if (!abs) throw new Error("Invalid or disallowed path");
+            try {
+              let content = readFileSync(abs, "utf8");
+              content = sliceFileContentRange(content, params.line, params.limit);
+              return { content };
+            } catch (e) {
+              if (e.code === "ENOENT") return { content: "" };
+              throw e;
+            }
+          },
+          async writeTextFile(params) {
+            const abs = resolveSafePathUnderCwd(cwd, params.path);
+            if (!abs) throw new Error("Invalid or disallowed path");
+            let oldText = "";
+            try {
+              oldText = readFileSync(abs, "utf8");
+            } catch (e) {
+              if (e.code !== "ENOENT") throw e;
+            }
+            mkdirSync(dirname(abs), { recursive: true });
+            writeFileSync(abs, params.content, "utf8");
+            const displayPath = toDisplayPathRelativeToCwd(cwd, abs);
+            const patchContent = editSnippetToUnifiedDiff(displayPath, oldText, params.content);
+            onFileChange?.({ path: displayPath, oldText, newText: params.content, patchContent });
+            return {};
           },
           async sessionUpdate(params) {
-            onSessionUpdate?.(params);
+            onSessionUpdate?.(bridgePayloadFromSdkSessionNotification(params));
           }
         });
         const connection = new ClientSideConnection2(client, stream);
@@ -22194,11 +22328,13 @@ async function createAcpClient(options) {
           child.kill();
         });
         await connection.initialize({
-          protocolVersion: "0.1.0",
-          capabilities: {},
+          protocolVersion: PROTOCOL_VERSION2,
+          clientCapabilities: {
+            fs: { readTextFile: true, writeTextFile: true }
+          },
           clientInfo: { name: "buildautomaton-cli", version: "0.1.0" }
         });
-        const newSessionRes = await connection.newSession({ workingDirectory: cwd });
+        const newSessionRes = await connection.newSession({ cwd, mcpServers: [] });
         const sessionId = newSessionRes.sessionId;
         resolve14({
           sessionId,
@@ -22206,7 +22342,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";
@@ -22224,9 +22360,17 @@ async function createAcpClient(options) {
             }
           },
           async cancel() {
-            const conn = connection;
-            if (typeof conn.cancel === "function") {
-              await conn.cancel({ sessionId });
+            try {
+              await connection.cancel({ sessionId });
+            } catch {
+            }
+            if (killSubprocessAfterCancelMs != null && killSubprocessAfterCancelMs >= 0) {
+              const t = setTimeout(() => {
+                if (child.exitCode == null && child.signalCode == null) {
+                  child.kill("SIGTERM");
+                }
+              }, killSubprocessAfterCancelMs);
+              t.unref?.();
             }
           },
           resolveRequest() {
@@ -22540,11 +22684,11 @@ function logImmediate(line) {
 
 // src/config.ts
 import fs from "node:fs";
-import path2 from "node:path";
+import path3 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 = path3.join(os.homedir(), ".buildautomaton");
+  return path3.join(dir, "config.json");
 }
 function normalizeApiUrl(url2) {
   return url2.replace(/\/$/, "");
@@ -22560,7 +22704,7 @@ function readRawConfig() {
 }
 function writeConfigForApi(apiUrl, auth) {
   const p = getConfigPath();
-  const dir = path2.dirname(p);
+  const dir = path3.dirname(p);
   const key = normalizeApiUrl(apiUrl);
   const prev = readRawConfig() ?? {};
   const servers = { ...prev.servers ?? {}, [key]: { ...auth } };
@@ -22755,7 +22899,7 @@ function beginMainBridgeDeferredDisconnect(state, code, reason, log2, willReconn
   });
 }
 function clearMainBridgeReconnectQuietOnOpen(state, log2) {
-  clearReconnectQuietOnSuccessfulConnection(state.mainQuiet, log2, "[Bridge service] Reconnected.");
+  clearReconnectQuietOnSuccessfulConnection(state.mainQuiet, log2, "Bridge connection restored.");
 }
 function scheduleMainBridgeReconnect(state, connect, log2) {
   if (state.closedByUser || state.currentWs != null) return;
@@ -22792,7 +22936,7 @@ function clearFirehoseReconnectQuietOnOpen(ctx, log2) {
   clearReconnectQuietOnSuccessfulConnection(
     ctx.firehoseQuiet,
     log2,
-    `${PROXY_AND_LOG_SERVICE_LABEL} Reconnected.`
+    "Preview tunnel restored (local HTTP proxy and dev logs)."
   );
 }
 
@@ -22943,7 +23087,7 @@ function buildBridgeUrl(apiUrl, workspaceId, authToken) {
 
 // src/git/discover-repos.ts
 import * as fs2 from "node:fs";
-import * as path3 from "node:path";
+import * as path4 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);
@@ -22952,7 +23096,7 @@ var import_promise_deferred = __toESM(require_dist2(), 1);
 var import_promise_deferred2 = __toESM(require_dist2(), 1);
 import { Buffer as Buffer2 } from "node:buffer";
 import { spawn as spawn3 } from "child_process";
-import { normalize } from "node:path";
+import { normalize as normalize2 } from "node:path";
 import { EventEmitter } from "node:events";
 var __defProp2 = Object.defineProperty;
 var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -26255,7 +26399,7 @@ var init_branch = __esm2({
 });
 function toPath(input) {
   const path24 = input.trim().replace(/^["']|["']$/g, "");
-  return path24 && normalize(path24);
+  return path24 && normalize2(path24);
 }
 var parseCheckIgnore;
 var init_CheckIgnore = __esm2({
@@ -27530,7 +27674,7 @@ async function isGitRepoDirectory(dirPath) {
 // src/git/discover-repos.ts
 async function discoverGitRepos(cwd = getBridgeWorkspaceDirectory()) {
   const result = [];
-  const cwdResolved = path3.resolve(cwd);
+  const cwdResolved = path4.resolve(cwd);
   if (await isGitRepoDirectory(cwdResolved)) {
     const remoteUrl = await getRemoteOriginUrl(cwdResolved);
     result.push({ absolutePath: cwdResolved, remoteUrl });
@@ -27543,7 +27687,7 @@ async function discoverGitRepos(cwd = getBridgeWorkspaceDirectory()) {
   }
   for (const ent of entries) {
     if (!ent.isDirectory()) continue;
-    const childPath = path3.join(cwdResolved, ent.name);
+    const childPath = path4.join(cwdResolved, ent.name);
     if (await isGitRepoDirectory(childPath)) {
       const remoteUrl = await getRemoteOriginUrl(childPath);
       result.push({ absolutePath: childPath, remoteUrl });
@@ -27552,11 +27696,11 @@ async function discoverGitRepos(cwd = getBridgeWorkspaceDirectory()) {
   return result;
 }
 async function discoverGitReposUnderRoot(rootAbs) {
-  const root = path3.resolve(rootAbs);
+  const root = path4.resolve(rootAbs);
   const roots = [];
   async function walk(dir) {
     if (await isGitRepoDirectory(dir)) {
-      roots.push(path3.resolve(dir));
+      roots.push(path4.resolve(dir));
       return;
     }
     let entries;
@@ -27567,7 +27711,7 @@ async function discoverGitReposUnderRoot(rootAbs) {
     }
     for (const ent of entries) {
       if (!ent.isDirectory() || ent.name === ".git") continue;
-      await walk(path3.join(dir, ent.name));
+      await walk(path4.join(dir, ent.name));
     }
   }
   await walk(root);
@@ -27603,34 +27747,31 @@ function reportGitRepos(getWs, log2) {
 
 // src/bridge/connection/close-bridge-connection.ts
 async function closeBridgeConnection(state, acpManager, devServerManager, log2) {
-  log2?.("Shutting down\u2026");
+  const say = log2 ?? logImmediate;
+  say("Cleaning up connections\u2026");
   await new Promise((resolve14) => setImmediate(resolve14));
-  if (devServerManager) {
-    log2?.("Requesting dev server processes to stop\u2026");
-    await devServerManager.shutdownAllGraceful();
-  }
   state.closedByUser = true;
   clearReconnectQuietTimer(state.mainQuiet);
   clearReconnectQuietTimer(state.firehoseQuiet);
   if (state.reconnectTimeout != null) {
-    log2?.("Cancelling reconnect timer\u2026");
+    say("Cancelling bridge reconnect timer\u2026");
     clearTimeout(state.reconnectTimeout);
     state.reconnectTimeout = null;
   }
   if (state.firehoseReconnectTimeout != null) {
-    log2?.("[Proxy and log service] Cancelling reconnect timer\u2026");
+    say("Cancelling preview tunnel reconnect timer\u2026");
     clearTimeout(state.firehoseReconnectTimeout);
     state.firehoseReconnectTimeout = null;
   }
   if (state.firehoseHandle) {
-    log2?.("[Proxy and log service] Closing connection (CLI shutdown)\u2026");
+    say("Closing preview tunnel (local HTTP proxy and dev logs)\u2026");
     state.firehoseHandle.close();
     state.firehoseHandle = null;
   }
-  log2?.("Disconnecting local agents (ACP)\u2026");
+  say("Disconnecting local agent\u2026");
   acpManager.disconnect();
   if (state.currentWs) {
-    log2?.("[Bridge service] Closing connection (CLI shutdown)\u2026");
+    say("Closing bridge connection to the cloud\u2026");
     state.currentWs.removeAllListeners();
     const wsState = state.currentWs.readyState;
     if (wsState === 1 || wsState === 2) {
@@ -27643,22 +27784,27 @@ async function closeBridgeConnection(state, acpManager, devServerManager, log2)
     }
     state.currentWs = null;
   }
+  if (devServerManager) {
+    say("Stopping local dev server processes\u2026");
+    await devServerManager.shutdownAllGraceful();
+  }
+  say("Shutdown complete.");
 }
 
 // src/git/session-git-queue.ts
 import { execFile as execFile2 } from "node:child_process";
+import { readFile, stat } from "node:fs/promises";
 import { promisify as promisify2 } from "node:util";
-import * as fs4 from "node:fs";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 
 // src/git/pre-turn-snapshot.ts
 import * as fs3 from "node:fs";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
 function snapshotsDirForCwd(agentCwd) {
-  return path4.join(agentCwd, ".buildautomaton", "snapshots");
+  return path5.join(agentCwd, ".buildautomaton", "snapshots");
 }
 async function gitStashCreate(repoRoot, log2) {
   try {
@@ -27687,7 +27833,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) => path4.resolve(p)))];
+    const uniq = [...new Set(worktreePaths.map((p) => path5.resolve(p)))];
     return uniq;
   }
   try {
@@ -27719,7 +27865,7 @@ async function capturePreTurnSnapshot(options) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     repos
   };
-  const filePath = path4.join(dir, `${runId}.json`);
+  const filePath = path5.join(dir, `${runId}.json`);
   try {
     fs3.writeFileSync(filePath, JSON.stringify(payload, null, 2), "utf8");
   } catch (e) {
@@ -27757,17 +27903,17 @@ async function applyPreTurnSnapshot(filePath, log2) {
   return { ok: true };
 }
 function snapshotFilePath(agentCwd, runId) {
-  return path4.join(snapshotsDirForCwd(agentCwd), `${runId}.json`);
+  return path5.join(snapshotsDirForCwd(agentCwd), `${runId}.json`);
 }
 
 // src/git/session-git-queue.ts
 var execFileAsync2 = promisify2(execFile2);
 var MAX_FULL_FILE_TEXT_BYTES = 512 * 1024;
-function readWorkspaceFileAsUtf8(absPath) {
+async function readWorkspaceFileAsUtf8(absPath) {
   try {
-    const st = fs4.statSync(absPath);
+    const st = await stat(absPath);
     if (!st.isFile() || st.size > MAX_FULL_FILE_TEXT_BYTES) return void 0;
-    return fs4.readFileSync(absPath, "utf8");
+    return await readFile(absPath, "utf8");
   } catch {
     return void 0;
   }
@@ -27777,7 +27923,7 @@ async function collectTurnGitDiffFromPreTurnSnapshot(options) {
   const filePath = snapshotFilePath(agentCwd, runId);
   let data;
   try {
-    const raw = fs4.readFileSync(filePath, "utf8");
+    const raw = await readFile(filePath, "utf8");
     data = JSON.parse(raw);
   } catch (e) {
     log2(
@@ -27806,7 +27952,7 @@ async function collectTurnGitDiffFromPreTurnSnapshot(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 = path6.basename(repo.path).replace(/[^\w.-]+/g, "_") || "repo";
     for (const rel of lines) {
       if (rel.includes("..")) continue;
       try {
@@ -27820,8 +27966,8 @@ async function collectTurnGitDiffFromPreTurnSnapshot(options) {
         );
         if (!patchContent.trim()) continue;
         const displayPath = multiRepo ? `${slug}/${rel}` : rel;
-        const absFile = path5.join(repo.path, rel);
-        const newText = readWorkspaceFileAsUtf8(absFile);
+        const absFile = path6.join(repo.path, rel);
+        const newText = await readWorkspaceFileAsUtf8(absFile);
         sendSessionUpdate({
           type: "session_file_change",
           sessionId,
@@ -27876,7 +28022,6 @@ async function sendPromptToAgent(options) {
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     log2(`[Agent] Send failed: ${errMsg}`);
-    if (err instanceof Error && err.stack) log2(`[Agent] ${err.stack}`);
     sendResult({
       type: "prompt_result",
       id: promptId,
@@ -27889,7 +28034,7 @@ async function sendPromptToAgent(options) {
 }
 
 // src/acp/ensure-acp-client.ts
-import * as fs5 from "node:fs";
+import * as fs4 from "node:fs";
 import * as path9 from "node:path";
 
 // src/error-message.ts
@@ -27908,81 +28053,38 @@ function isCodexAcpCommand(command) {
   const i = command.indexOf("@zed-industries/codex-acp");
   return i >= 0 && (i === 0 || command[i - 1] === "npx" || command[i - 1] === "bunx");
 }
+function buildCodexAcpSpawnCommand(base, _sessionMode) {
+  return [...base];
+}
 async function createCodexAcpClient(options) {
-  const command = options.command?.length && options.command.some((a) => a.includes("codex-acp")) ? options.command : [...DEFAULT_CODEX_ACP_COMMAND];
-  return createAcpClient({ ...options, command });
+  const base = options.command?.length && options.command.some((a) => a.includes("codex-acp")) ? options.command : [...DEFAULT_CODEX_ACP_COMMAND];
+  const command = buildCodexAcpSpawnCommand(base, options.sessionMode);
+  return createSdkStdioAcpClient({ ...options, command });
+}
+
+// src/acp/clients/claude-code-acp-client.ts
+function buildClaudeCodeAcpSpawnCommand(base, sessionMode) {
+  if (!sessionMode) return [...base];
+  const m = sessionMode.trim();
+  if (m === "plan") return [...base, "--permission-mode", "plan"];
+  return [...base];
+}
+async function createClaudeCodeAcpClient(options) {
+  const command = buildClaudeCodeAcpSpawnCommand(options.command, options.sessionMode);
+  return createSdkStdioAcpClient({
+    ...options,
+    command,
+    /** Claude-based agents sometimes ignore `session/cancel`; unblocks stop / stuck prompt. */
+    killSubprocessAfterCancelMs: options.killSubprocessAfterCancelMs ?? 1e3
+  });
 }
 
 // src/acp/clients/cursor-acp-client.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
-import { dirname } from "node:path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
 import { spawn as spawn4 } from "node:child_process";
 import * as readline from "node:readline";
 
-// src/acp/safe-fs-path.ts
-import * as path6 from "node:path";
-function resolveSafePathUnderCwd(cwd, filePath) {
-  const trimmed2 = filePath.trim();
-  if (!trimmed2) return null;
-  const normalizedCwd = path6.resolve(cwd);
-  const resolved = path6.isAbsolute(trimmed2) ? path6.normalize(trimmed2) : path6.resolve(normalizedCwd, trimmed2);
-  const rel = path6.relative(normalizedCwd, resolved);
-  if (rel.startsWith("..") || path6.isAbsolute(rel)) return null;
-  return resolved;
-}
-function toDisplayPathRelativeToCwd(cwd, absolutePath) {
-  const normalizedCwd = path6.resolve(cwd);
-  const rel = path6.relative(normalizedCwd, path6.resolve(absolutePath));
-  if (!rel || rel === "") return path6.basename(absolutePath);
-  return rel.split(path6.sep).join("/");
-}
-
-// src/files/diff/unified-diff.ts
-function computeLineDiff(oldText, newText) {
-  const oldLines = oldText.split("\n");
-  const newLines = newText.split("\n");
-  const m = oldLines.length;
-  const n = newLines.length;
-  const dp = Array(m + 1);
-  for (let i2 = 0; i2 <= m; i2++) dp[i2] = Array(n + 1).fill(0);
-  for (let i2 = 1; i2 <= m; i2++) {
-    for (let j2 = 1; j2 <= n; j2++) {
-      if (oldLines[i2 - 1] === newLines[j2 - 1]) {
-        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
-      } else {
-        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
-      }
-    }
-  }
-  const result = [];
-  let i = m;
-  let j = n;
-  while (i > 0 || j > 0) {
-    if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
-      result.unshift({ type: "context", line: oldLines[i - 1] });
-      i--;
-      j--;
-    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
-      result.unshift({ type: "add", line: newLines[j - 1] });
-      j--;
-    } else {
-      result.unshift({ type: "remove", line: oldLines[i - 1] });
-      i--;
-    }
-  }
-  return result;
-}
-function editSnippetToUnifiedDiff(filePath, oldText, newText) {
-  const lines = computeLineDiff(oldText, newText);
-  const out = [`--- ${filePath}`, `+++ ${filePath}`];
-  for (const d of lines) {
-    if (d.type === "add") out.push(`+${d.line}`);
-    else if (d.type === "remove") out.push(`-${d.line}`);
-    else out.push(` ${d.line}`);
-  }
-  return out.join("\n");
-}
-
 // src/acp/format-session-update-kind-for-log.ts
 var SESSION_UPDATE_KIND_LABELS = {
   tool_call: "Tool call",
@@ -28020,8 +28122,15 @@ function sliceLinesByRange(content, line, limit) {
   const end = limit != null && limit > 0 ? start + limit : lines.length;
   return lines.slice(start, end).join("\n");
 }
+function buildCursorAcpSpawnCommand(base, sessionMode) {
+  if (!sessionMode) return [...base];
+  const m = sessionMode.trim();
+  if (m !== "ask" && m !== "plan") return [...base];
+  return [...base, "--mode", m];
+}
 async function createCursorAcpClient(options) {
-  const { command, cwd = getBridgeWorkspaceDirectory(), onSessionUpdate, onRequest, onFileChange } = options;
+  const command = buildCursorAcpSpawnCommand(options.command, options.sessionMode);
+  const { cwd = getBridgeWorkspaceDirectory(), onSessionUpdate, onRequest, onFileChange } = options;
   const dbgFs = process.env.BUILDAMATON_DEBUG_ACP_FS === "1";
   const isWindows = process.platform === "win32";
   const child = spawn4(command[0], command.slice(1), {
@@ -28153,8 +28262,8 @@ async function createCursorAcpClient(options) {
             }
           }
           try {
-            mkdirSync2(dirname(abs), { recursive: true });
-            writeFileSync2(abs, newText, "utf8");
+            mkdirSync3(dirname2(abs), { recursive: true });
+            writeFileSync3(abs, newText, "utf8");
           } catch (e) {
             respondJsonRpcError(id, -32e3, e instanceof Error ? e.message : String(e));
             return;
@@ -28252,8 +28361,20 @@ async function createCursorAcpClient(options) {
 var AGENT_TYPE_DEFAULT_COMMANDS = {
   "cursor-cli": ["agent", "acp"],
   "codex-acp": [...DEFAULT_CODEX_ACP_COMMAND],
-  "claude-code": ["npx", "--yes", "@anthropic-ai/claude-code"]
+  /** ACP stdio agent; `@anthropic-ai/claude-code` is the interactive CLI and does not speak ACP on stdout. */
+  "claude-code": ["npx", "--yes", "@agentclientprotocol/claude-agent-acp"]
 };
+var AGENT_TYPE_DISPLAY_NAMES = {
+  "cursor-cli": "Cursor",
+  "codex-acp": "Codex",
+  "claude-code": "Claude Code"
+};
+function getAgentTypeDisplayName(agentType) {
+  if (agentType == null || agentType === "") return "Unknown agent";
+  const known = AGENT_TYPE_DISPLAY_NAMES[agentType];
+  if (known) return known;
+  return agentType.split(/[-_]/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(" ");
+}
 function useCursorAcp(agentType, command) {
   if (agentType === "cursor-cli") return true;
   return command[0] === "agent" && command[1] === "acp";
@@ -28266,14 +28387,33 @@ 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 : createAcpClient;
-  const label = preferredAgentType;
-  return { command, label, createClient };
+  if (useCursorAcp(preferredAgentType, command)) {
+    return {
+      command,
+      label: preferredAgentType,
+      createClient: createCursorAcpClient,
+      spawnCommandForSession: (sessionMode) => buildCursorAcpSpawnCommand(command, sessionMode)
+    };
+  }
+  if (useCodexAcp(preferredAgentType, command)) {
+    return {
+      command,
+      label: preferredAgentType,
+      createClient: createCodexAcpClient,
+      spawnCommandForSession: (sessionMode) => buildCodexAcpSpawnCommand(command, sessionMode)
+    };
+  }
+  return {
+    command,
+    label: preferredAgentType,
+    createClient: createClaudeCodeAcpClient,
+    spawnCommandForSession: (sessionMode) => buildClaudeCodeAcpSpawnCommand(command, sessionMode)
+  };
 }
 
 // src/acp/session-file-change-path-kind.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync, statSync as statSync2 } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 
 // src/git/get-git-repo-root-sync.ts
 import { execFileSync } from "node:child_process";
@@ -28382,7 +28522,7 @@ function getSessionFileChangeDirectoryFlags(cwd, displayPath) {
   const abs = tryWorkspaceDisplayToAbs(cwd, displayPath);
   if (abs && existsSync(abs)) {
     try {
-      if (statSync2(abs).isDirectory()) {
+      if (statSync(abs).isDirectory()) {
         return { isDirectory: true, directoryRemoved: false };
       }
       return { isDirectory: false, directoryRemoved: false };
@@ -28928,7 +29068,8 @@ async function ensureAcpClient(options) {
     state.lastAcpStartError = "No agent type: ensure the app sends agentType on prompts or agent_config for this bridge.";
     return null;
   }
-  const agentKey = `${resolved.label}::${resolved.command.join("\0")}`;
+  const fullCmd = resolved.spawnCommandForSession(mode);
+  const agentKey = `${resolved.label}::${fullCmd.join("\0")}`;
   if (state.acpHandle && state.acpAgentKey !== agentKey) {
     try {
       state.acpHandle.disconnect();
@@ -28942,7 +29083,7 @@ async function ensureAcpClient(options) {
   if (!state.acpStartPromise) {
     let statOk = false;
     try {
-      const st = fs5.statSync(targetCwd);
+      const st = fs4.statSync(targetCwd);
       statOk = st.isDirectory();
       if (!statOk) {
         state.lastAcpStartError = `Agent cwd is not a directory: ${targetCwd}`;
@@ -28955,8 +29096,6 @@ async function ensureAcpClient(options) {
     if (!statOk) {
       return null;
     }
-    const modeFlag = mode && ["ask", "plan"].includes(mode) ? ["--mode", mode] : [];
-    const fullCmd = [...resolved.command, ...modeFlag];
     const hooks = buildAcpSessionBridgeHooks({
       routing,
       getSendSessionUpdate: () => sendSessionUpdate,
@@ -28964,8 +29103,15 @@ async function ensureAcpClient(options) {
       log: log2
     });
     state.acpStartPromise = resolved.createClient({
-      command: fullCmd,
+      command: resolved.command,
+      sessionMode: mode,
       cwd: targetCwd,
+      onAgentSubprocessExit: () => {
+        state.acpHandle = null;
+        state.acpStartPromise = null;
+        state.acpAgentKey = null;
+        state.lastAcpStartError = "Agent subprocess exited";
+      },
       ...hooks
     }).then((h) => {
       state.lastAcpStartError = null;
@@ -29003,6 +29149,14 @@ async function createAcpManager(options) {
       backendFallbackAgentType = agentType;
     }
   }
+  function logPromptReceivedFromBridge(opts) {
+    const { agentType, mode } = opts;
+    const preferredForPrompt = agentType ?? backendFallbackAgentType ?? null;
+    const modeLabel = typeof mode === "string" && mode.trim() !== "" ? mode.trim() : "not set";
+    log2(
+      `[Agent] Prompt received (${getAgentTypeDisplayName(preferredForPrompt)}, mode: ${modeLabel})`
+    );
+  }
   function handlePrompt(opts) {
     const {
       promptText,
@@ -29083,6 +29237,7 @@ async function createAcpManager(options) {
     if (promptRouting.runId !== runId) return false;
     const handle = state.acpHandle;
     if (handle?.cancel) {
+      log2("[Agent] Stop requested");
       try {
         await handle.cancel();
         return true;
@@ -29091,6 +29246,7 @@ async function createAcpManager(options) {
         return false;
       }
     }
+    log2("[Agent] Stop requested (agent still starting)");
     pendingCancelRunId = runId;
     return true;
   }
@@ -29103,7 +29259,14 @@ async function createAcpManager(options) {
     state.acpStartPromise = null;
     state.acpAgentKey = null;
   }
-  return { setPreferredAgentType, handlePrompt, cancelRun, resolveRequest, disconnect };
+  return {
+    setPreferredAgentType,
+    logPromptReceivedFromBridge,
+    handlePrompt,
+    cancelRun,
+    resolveRequest,
+    disconnect
+  };
 }
 
 // src/bridge/routing/handlers/auth-token.ts
@@ -29238,6 +29401,8 @@ function handleBridgePrompt(msg, deps) {
   const sessionWorktreesEnabled = msg.sessionWorktreesEnabled === true;
   const agentType = typeof msg.agentType === "string" && msg.agentType.trim() ? msg.agentType.trim() : void 0;
   const runId = typeof msg.runId === "string" ? msg.runId : void 0;
+  const mode = typeof msg.mode === "string" && msg.mode.trim() ? msg.mode.trim() : void 0;
+  acpManager.logPromptReceivedFromBridge({ agentType, mode });
   const sendResult = (result) => {
     const s = getWs();
     if (s) sendWsMessage(s, result);
@@ -29300,7 +29465,7 @@ function handleBridgePrompt(msg, deps) {
       promptId: msg.id,
       sessionId,
       runId,
-      mode: msg.mode,
+      mode,
       agentType,
       cwd: effectiveCwd,
       sendResult,
@@ -29370,7 +29535,7 @@ var handleSkillCallMessage = (msg, { getWs, log: log2 }) => {
 };
 
 // src/files/list-dir.ts
-import fs6 from "node:fs";
+import fs5 from "node:fs";
 import path13 from "node:path";
 
 // src/files/ensure-under-cwd.ts
@@ -29391,14 +29556,14 @@ function listDir(relativePath) {
     return { error: "Path is outside working directory" };
   }
   try {
-    const names = fs6.readdirSync(resolved, { withFileTypes: true });
+    const names = fs5.readdirSync(resolved, { withFileTypes: true });
     const entries = names.filter((d) => !d.name.startsWith(".")).map((d) => {
       const entryPath = path13.join(relativePath || ".", d.name).replace(/\\/g, "/");
       const fullPath = path13.join(resolved, d.name);
       let isDir = d.isDirectory();
       if (d.isSymbolicLink()) {
         try {
-          const targetStat = fs6.statSync(fullPath);
+          const targetStat = fs5.statSync(fullPath);
           isDir = targetStat.isDirectory();
         } catch {
           isDir = false;
@@ -29422,25 +29587,25 @@ function listDir(relativePath) {
 }
 
 // src/files/read-file.ts
-import fs7 from "node:fs";
+import fs6 from "node:fs";
 import { StringDecoder } from "node:string_decoder";
 function resolveFilePath(relativePath) {
   const resolved = ensureUnderCwd(relativePath, getBridgeWorkspaceDirectory());
   if (!resolved) return { error: "Path is outside working directory" };
   let real;
   try {
-    real = fs7.realpathSync(resolved);
+    real = fs6.realpathSync(resolved);
   } catch {
     real = resolved;
   }
-  const stat = fs7.statSync(real);
-  if (!stat.isFile()) return { error: "Not a file" };
+  const stat2 = fs6.statSync(real);
+  if (!stat2.isFile()) return { error: "Not a file" };
   return real;
 }
 var LINE_CHUNK_SIZE = 64 * 1024;
 function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
-  const fileSize = fs7.statSync(filePath).size;
-  const fd = fs7.openSync(filePath, "r");
+  const fileSize = fs6.statSync(filePath).size;
+  const fd = fs6.openSync(filePath, "r");
   const bufSize = 64 * 1024;
   const buf = Buffer.alloc(bufSize);
   const decoder = new StringDecoder("utf8");
@@ -29453,7 +29618,7 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
   let line0Accum = "";
   try {
     let bytesRead;
-    while (!done && (bytesRead = fs7.readSync(fd, buf, 0, bufSize, null)) > 0) {
+    while (!done && (bytesRead = fs6.readSync(fd, buf, 0, bufSize, null)) > 0) {
       const text = partial2 + decoder.write(buf.subarray(0, bytesRead));
       partial2 = "";
       let lineStart = 0;
@@ -29588,10 +29753,10 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
     }
     return { content: resultLines.join("\n"), size: fileSize };
   } finally {
-    fs7.closeSync(fd);
+    fs6.closeSync(fd);
   }
 }
-function readFile(relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE) {
+function readFile2(relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE) {
   try {
     const result = resolveFilePath(relativePath);
     if (typeof result === "object") return result;
@@ -29599,17 +29764,17 @@ function readFile(relativePath, startLine, endLine, lineOffset, lineChunkSize =
     if (hasRange) {
       return readFileRange(result, startLine, endLine, lineOffset, lineChunkSize);
     }
-    const stat = fs7.statSync(result);
-    const raw = fs7.readFileSync(result, "utf8");
+    const stat2 = fs6.statSync(result);
+    const raw = fs6.readFileSync(result, "utf8");
     const lines = raw.split(/\r?\n/);
-    return { content: raw, totalLines: lines.length, size: stat.size };
+    return { content: raw, totalLines: lines.length, size: stat2.size };
   } catch (err) {
     return { error: err instanceof Error ? err.message : String(err) };
   }
 }
 
 // src/files/file-index.ts
-import fs8 from "node:fs";
+import fs7 from "node:fs";
 import path14 from "node:path";
 import os2 from "node:os";
 import crypto2 from "node:crypto";
@@ -29656,23 +29821,23 @@ function binarySearch(arr, x) {
 function walkDir(dir, baseDir, out) {
   let names;
   try {
-    names = fs8.readdirSync(dir);
+    names = fs7.readdirSync(dir);
   } catch {
     return;
   }
   for (const name of names) {
     if (name.startsWith(".")) continue;
     const full = path14.join(dir, name);
-    let stat;
+    let stat2;
     try {
-      stat = fs8.statSync(full);
+      stat2 = fs7.statSync(full);
     } catch {
       continue;
     }
     const relative4 = path14.relative(baseDir, full).replace(/\\/g, "/");
-    if (stat.isDirectory()) {
+    if (stat2.isDirectory()) {
       walkDir(full, baseDir, out);
-    } else if (stat.isFile()) {
+    } else if (stat2.isFile()) {
       out.push(relative4);
     }
   }
@@ -29696,8 +29861,8 @@ function buildFileIndex(cwd) {
   const data = { version: INDEX_VERSION, paths, trigramIndex };
   const indexPath = getIndexPath(resolved);
   try {
-    if (!fs8.existsSync(INDEX_DIR)) fs8.mkdirSync(INDEX_DIR, { recursive: true });
-    fs8.writeFileSync(indexPath, JSON.stringify(data), "utf8");
+    if (!fs7.existsSync(INDEX_DIR)) fs7.mkdirSync(INDEX_DIR, { recursive: true });
+    fs7.writeFileSync(indexPath, JSON.stringify(data), "utf8");
   } catch (e) {
     console.error("[file-index] Failed to write index:", e);
   }
@@ -29707,7 +29872,7 @@ function loadFileIndex(cwd) {
   const resolved = path14.resolve(cwd);
   const indexPath = getIndexPath(resolved);
   try {
-    const raw = fs8.readFileSync(indexPath, "utf8");
+    const raw = fs7.readFileSync(indexPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed !== null && typeof parsed === "object" && Array.isArray(parsed.paths)) {
       const obj = parsed;
@@ -29811,7 +29976,7 @@ function handleFileBrowserRequest(msg, socket) {
     const endLine = typeof msg.endLine === "number" ? msg.endLine : void 0;
     const lineOffset = typeof msg.lineOffset === "number" ? msg.lineOffset : void 0;
     const lineChunkSize = typeof msg.lineChunkSize === "number" ? msg.lineChunkSize : void 0;
-    const result = readFile(reqPath, startLine, endLine, lineOffset, lineChunkSize);
+    const result = readFile2(reqPath, startLine, endLine, lineOffset, lineChunkSize);
     if ("error" in result) {
       sendWsMessage(socket, { type: "file_browser_response", id: msg.id, error: result.error });
     } else {
@@ -29846,7 +30011,7 @@ function handleFileBrowserSearchMessage(msg, { getWs }) {
 }
 
 // src/skills/discover-local-agent-skills.ts
-import fs9 from "node:fs";
+import fs8 from "node:fs";
 import path15 from "node:path";
 var SKILL_DISCOVERY_ROOTS = [".agents/skills", ".claude/skills", ".cursor/skills", "skills"];
 function discoverLocalSkills(cwd) {
@@ -29854,22 +30019,22 @@ function discoverLocalSkills(cwd) {
   const seenKeys = /* @__PURE__ */ new Set();
   for (const rel of SKILL_DISCOVERY_ROOTS) {
     const base = path15.join(cwd, rel);
-    if (!fs9.existsSync(base) || !fs9.statSync(base).isDirectory()) continue;
+    if (!fs8.existsSync(base) || !fs8.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs9.readdirSync(base);
+      entries = fs8.readdirSync(base);
     } catch {
       continue;
     }
     for (const name of entries) {
       const dir = path15.join(base, name);
       try {
-        if (!fs9.statSync(dir).isDirectory()) continue;
+        if (!fs8.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
       const skillMd = path15.join(dir, "SKILL.md");
-      if (!fs9.existsSync(skillMd)) continue;
+      if (!fs8.existsSync(skillMd)) continue;
       const key = `${rel}/${name}`;
       if (seenKeys.has(key)) continue;
       seenKeys.add(key);
@@ -29882,10 +30047,10 @@ function discoverSkillLayoutRoots(cwd) {
   const roots = [];
   for (const rel of SKILL_DISCOVERY_ROOTS) {
     const base = path15.join(cwd, rel);
-    if (!fs9.existsSync(base) || !fs9.statSync(base).isDirectory()) continue;
+    if (!fs8.existsSync(base) || !fs8.statSync(base).isDirectory()) continue;
     let entries = [];
     try {
-      entries = fs9.readdirSync(base);
+      entries = fs8.readdirSync(base);
     } catch {
       continue;
     }
@@ -29893,11 +30058,11 @@ function discoverSkillLayoutRoots(cwd) {
     for (const name of entries) {
       const dir = path15.join(base, name);
       try {
-        if (!fs9.statSync(dir).isDirectory()) continue;
+        if (!fs8.statSync(dir).isDirectory()) continue;
       } catch {
         continue;
       }
-      if (!fs9.existsSync(path15.join(dir, "SKILL.md"))) continue;
+      if (!fs8.existsSync(path15.join(dir, "SKILL.md"))) continue;
       const relPath = `${rel}/${name}`.replace(/\\/g, "/");
       skills2.push({ name, relPath });
     }
@@ -29917,7 +30082,7 @@ function handleSkillLayoutRequest(msg, deps) {
 }
 
 // src/skills/install-remote-skills.ts
-import fs10 from "node:fs";
+import fs9 from "node:fs";
 import path16 from "node:path";
 function installRemoteSkills(cwd, targetDir, items) {
   const installed = [];
@@ -29933,11 +30098,11 @@ function installRemoteSkills(cwd, targetDir, items) {
       for (const f of item.files) {
         if (typeof f.path !== "string" || !f.text && !f.base64) continue;
         const dest = path16.join(skillDir, f.path);
-        fs10.mkdirSync(path16.dirname(dest), { recursive: true });
+        fs9.mkdirSync(path16.dirname(dest), { recursive: true });
         if (f.text !== void 0) {
-          fs10.writeFileSync(dest, f.text, "utf8");
+          fs9.writeFileSync(dest, f.text, "utf8");
         } else if (f.base64) {
-          fs10.writeFileSync(dest, Buffer.from(f.base64, "base64"));
+          fs9.writeFileSync(dest, Buffer.from(f.base64, "base64"));
         }
       }
       installed.push({
@@ -30031,7 +30196,7 @@ var handleSessionDiscardedMessage = (msg, deps) => {
 };
 
 // src/bridge/routing/handlers/revert-turn-snapshot.ts
-import * as fs11 from "node:fs";
+import * as fs10 from "node:fs";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
@@ -30043,7 +30208,7 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
     if (!s) return;
     const agentBase = sessionWorktreeManager.getAgentCwdForSession(sessionId) ?? getBridgeWorkspaceDirectory();
     const file2 = snapshotFilePath(agentBase, turnId);
-    if (!fs11.existsSync(file2)) {
+    if (!fs10.existsSync(file2)) {
       sendWsMessage(s, {
         type: "revert_turn_snapshot_result",
         id,
@@ -30144,25 +30309,12 @@ function dispatchBridgeMessage(msg, deps) {
 }
 
 // src/bridge/routing/handle-bridge-message.ts
-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;
-  const type = msg.type;
-  if (typeof type === "string" && DEFERRED_INBOUND_TYPES.has(type)) {
-    setImmediate(() => {
-      dispatchBridgeMessage(msg, deps);
-    });
-    return;
-  }
-  dispatchBridgeMessage(msg, deps);
+  if (!deps.getWs()) return;
+  setImmediate(() => {
+    dispatchBridgeMessage(msg, deps);
+  });
 }
 
 // src/worktrees/session-worktree-manager.ts
@@ -30170,7 +30322,7 @@ import * as path20 from "node:path";
 import os4 from "node:os";
 
 // src/worktrees/prepare-new-session-worktrees.ts
-import * as fs13 from "node:fs";
+import * as fs12 from "node:fs";
 import * as path18 from "node:path";
 
 // src/git/worktree-add.ts
@@ -30180,7 +30332,7 @@ async function gitWorktreeAddBranch(mainRepoPath, worktreePath, branch) {
 }
 
 // src/worktrees/worktree-layout-file.ts
-import * as fs12 from "node:fs";
+import * as fs11 from "node:fs";
 import * as path17 from "node:path";
 import os3 from "node:os";
 var LAYOUT_FILENAME = "worktree-launcher-layout.json";
@@ -30197,8 +30349,8 @@ function normalizeLoadedLayout(raw) {
 function loadWorktreeLayout() {
   try {
     const p = defaultWorktreeLayoutPath();
-    if (!fs12.existsSync(p)) return { launcherCwds: [] };
-    const raw = JSON.parse(fs12.readFileSync(p, "utf8"));
+    if (!fs11.existsSync(p)) return { launcherCwds: [] };
+    const raw = JSON.parse(fs11.readFileSync(p, "utf8"));
     return normalizeLoadedLayout(raw);
   } catch {
     return { launcherCwds: [] };
@@ -30207,8 +30359,8 @@ function loadWorktreeLayout() {
 function saveWorktreeLayout(layout) {
   try {
     const dir = path17.dirname(defaultWorktreeLayoutPath());
-    fs12.mkdirSync(dir, { recursive: true });
-    fs12.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
+    fs11.mkdirSync(dir, { recursive: true });
+    fs11.writeFileSync(defaultWorktreeLayoutPath(), JSON.stringify(layout, null, 2), "utf8");
   } catch {
   }
 }
@@ -30245,13 +30397,13 @@ async function prepareNewSessionWorktrees(options) {
   }
   const branch = `session-${sessionId}`;
   const worktreePaths = [];
-  fs13.mkdirSync(agentMirrorRoot, { recursive: true });
+  fs12.mkdirSync(agentMirrorRoot, { recursive: true });
   for (const repo of repos) {
     let rel = path18.relative(launcherResolved, repo.absolutePath);
     if (rel.startsWith("..") || path18.isAbsolute(rel)) continue;
     const relNorm = rel === "" ? "." : rel;
     const wtPath = path18.join(agentMirrorRoot, relNorm, sessionId);
-    fs13.mkdirSync(path18.dirname(wtPath), { recursive: true });
+    fs12.mkdirSync(path18.dirname(wtPath), { recursive: true });
     try {
       await gitWorktreeAddBranch(repo.absolutePath, wtPath, branch);
       log2(`[worktrees] Added worktree ${wtPath} (branch ${branch}).`);
@@ -30288,18 +30440,18 @@ async function renameSessionWorktreeBranches(paths, newBranch, log2) {
 }
 
 // src/worktrees/remove-session-worktrees.ts
-import * as fs16 from "node:fs";
+import * as fs15 from "node:fs";
 
 // src/git/worktree-remove.ts
-import * as fs15 from "node:fs";
+import * as fs14 from "node:fs";
 
 // src/git/resolve-main-repo-from-git-file.ts
-import * as fs14 from "node:fs";
+import * as fs13 from "node:fs";
 import * as path19 from "node:path";
 function resolveMainRepoFromWorktreeGitFile(wt) {
   const gitDirFile = path19.join(wt, ".git");
-  if (!fs14.existsSync(gitDirFile) || !fs14.statSync(gitDirFile).isFile()) return "";
-  const first2 = fs14.readFileSync(gitDirFile, "utf8").trim();
+  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 = path19.resolve(wt, m[1].trim());
@@ -30313,7 +30465,7 @@ async function gitWorktreeRemoveForce(worktreePath) {
   if (mainRepo) {
     await simpleGit(mainRepo).raw(["worktree", "remove", "--force", worktreePath]);
   } else {
-    fs15.rmSync(worktreePath, { recursive: true, force: true });
+    fs14.rmSync(worktreePath, { recursive: true, force: true });
   }
 }
 
@@ -30326,7 +30478,7 @@ async function removeSessionWorktrees(paths, log2) {
     } catch (e) {
       log2(`[worktrees] Remove failed for ${wt}: ${e instanceof Error ? e.message : String(e)}`);
       try {
-        fs16.rmSync(wt, { recursive: true, force: true });
+        fs15.rmSync(wt, { recursive: true, force: true });
       } catch {
       }
     }
@@ -30598,7 +30750,7 @@ function forceKillChild(proc, log2, shortId, graceMs) {
 }
 
 // src/dev-servers/process/wire-dev-server-child-process.ts
-import fs17 from "node:fs";
+import fs16 from "node:fs";
 
 // src/dev-servers/manager/forward-pipe.ts
 function forwardChildPipe(childReadable, terminal, onData) {
@@ -30634,7 +30786,7 @@ function wireDevServerChildProcess(d) {
         d.setPollInterval(void 0);
         return;
       }
-      fs17.readFile(d.mergedLogPath, (err, buf) => {
+      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));
@@ -30672,7 +30824,7 @@ ${errTail}` : ""}`);
       d.sendStatus(code === 0 || code == null ? "stopped" : "error", detail, tails);
     };
     if (mergedPath) {
-      fs17.readFile(mergedPath, (err, buf) => {
+      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) {
@@ -30774,13 +30926,13 @@ function parseDevServerDefs(servers) {
 }
 
 // src/dev-servers/manager/shell-spawn/utils.ts
-import fs18 from "node:fs";
+import fs17 from "node:fs";
 function isSpawnEbadf(e) {
   return typeof e === "object" && e !== null && "code" in e && e.code === "EBADF";
 }
 function rmDirQuiet(dir) {
   try {
-    fs18.rmSync(dir, { recursive: true, force: true });
+    fs17.rmSync(dir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -30788,7 +30940,7 @@ var cachedDevNullReadFd;
 function devNullReadFd() {
   if (cachedDevNullReadFd === void 0) {
     const devPath = process.platform === "win32" ? "nul" : "/dev/null";
-    cachedDevNullReadFd = fs18.openSync(devPath, "r");
+    cachedDevNullReadFd = fs17.openSync(devPath, "r");
   }
   return cachedDevNullReadFd;
 }
@@ -30862,15 +31014,15 @@ function trySpawnShellTruePiped(command, env, cwd, devNullFd, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-merged-log-file.ts
 import { spawn as spawn7 } from "node:child_process";
-import fs19 from "node:fs";
+import fs18 from "node:fs";
 import { tmpdir } from "node:os";
 import path22 from "node:path";
 function trySpawnMergedLogFile(command, env, cwd, signal) {
-  const tmpRoot = fs19.mkdtempSync(path22.join(tmpdir(), "ba-devsrv-log-"));
+  const tmpRoot = fs18.mkdtempSync(path22.join(tmpdir(), "ba-devsrv-log-"));
   const logPath = path22.join(tmpRoot, "combined.log");
   let logFd;
   try {
-    logFd = fs19.openSync(logPath, "a");
+    logFd = fs18.openSync(logPath, "a");
   } catch {
     rmDirQuiet(tmpRoot);
     return null;
@@ -30889,7 +31041,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     } else {
       proc = spawn7("/bin/sh", ["-c", command], { env, cwd, stdio, ...signal ? { signal } : {} });
     }
-    fs19.closeSync(logFd);
+    fs18.closeSync(logFd);
     return {
       proc,
       pipedStdoutStderr: true,
@@ -30898,7 +31050,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     };
   } catch (e) {
     try {
-      fs19.closeSync(logFd);
+      fs18.closeSync(logFd);
     } catch {
     }
     rmDirQuiet(tmpRoot);
@@ -30909,22 +31061,22 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
 
 // src/dev-servers/manager/shell-spawn/try-spawn-shell-script-log-redirect.ts
 import { spawn as spawn8 } from "node:child_process";
-import fs20 from "node:fs";
+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, cwd, signal) {
-  const tmpRoot = fs20.mkdtempSync(path23.join(tmpdir2(), "ba-devsrv-sh-"));
+  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 {
-    fs20.writeFileSync(innerPath, `#!/bin/sh
+    fs19.writeFileSync(innerPath, `#!/bin/sh
 ${command}
 `);
-    fs20.writeFileSync(
+    fs19.writeFileSync(
       runnerPath,
       `#!/bin/sh
 cd ${shSingleQuote(cwd)}
@@ -30950,13 +31102,13 @@ cd ${shSingleQuote(cwd)}
   }
 }
 function trySpawnShellScriptLogRedirectWin(command, env, cwd, signal) {
-  const tmpRoot = fs20.mkdtempSync(path23.join(tmpdir2(), "ba-devsrv-sh-"));
+  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 {
-    fs20.writeFileSync(
+    fs19.writeFileSync(
       runnerPath,
       `@ECHO OFF\r
 CD /D ${q(cwd)}\r
@@ -31310,7 +31462,9 @@ var DevServerManager = class {
   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`);
+    this.log(
+      `[dev-server] Stopping ${pairs.length} local dev server process${pairs.length === 1 ? "" : "es"}\u2026`
+    );
     await Promise.all(pairs.map(([serverId, proc]) => this.gracefulTerminateOrUnknown(serverId, proc)));
   }
   async gracefulTerminateOrUnknown(serverId, proc) {
@@ -31477,9 +31631,10 @@ var FIREHOSE_CLIENT_PING_MS = 25e3;
 function connectFirehose(options) {
   const { firehoseServerUrl, workspaceId, bridgeName, proxyPorts, log: log2, devServerManager, onOpen, onClose } = options;
   const wsUrl = buildFirehoseCliWsUrl(firehoseServerUrl);
-  const wsOptions = { perMessageDeflate: false };
+  applyCliOutboundNetworkPreferences();
+  const wsOptions = { perMessageDeflate: false, family: 4 };
   if (wsUrl.startsWith("wss://")) {
-    wsOptions.agent = new https2.Agent({ rejectUnauthorized: false });
+    wsOptions.agent = new https2.Agent({ rejectUnauthorized: false, family: 4 });
   }
   const ws = new wrapper_default(wsUrl, wsOptions);
   let clientPingTimer = null;
@@ -31515,16 +31670,14 @@ function connectFirehose(options) {
     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 {
-      }
-    });
+    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) => {
     clearClientPing();
@@ -31570,6 +31723,9 @@ function createOnBridgeIdentified(opts) {
   function attachFirehose(params) {
     state.lastFirehoseParams = params;
     clearFirehoseReconnectTimer();
+    if (state.firehoseReconnectAttempt === 0) {
+      logFn("Connecting to preview tunnel (local HTTP proxy and dev logs)\u2026");
+    }
     state.firehoseGeneration += 1;
     const myGen = state.firehoseGeneration;
     if (state.firehoseHandle) {
@@ -31588,8 +31744,8 @@ function createOnBridgeIdentified(opts) {
         clearFirehoseReconnectQuietOnOpen({ firehoseQuiet: state.firehoseQuiet }, logFn);
         const logOpenAsFirehoseReconnect = state.firehoseReconnectAttempt > 0;
         state.firehoseReconnectAttempt = 0;
-        if (logOpenAsFirehoseReconnect) {
-          logFn("[Proxy and log service] reconnected.");
+        if (!logOpenAsFirehoseReconnect) {
+          logFn("Connected to preview tunnel (local HTTP proxy and dev logs).");
         }
       },
       onClose: (code, reason) => {
@@ -31678,6 +31834,7 @@ var CHECKS = {
       return false;
     }
   },
+  /** Bridge spawns `@agentclientprotocol/claude-agent-acp` via npx; detection is “Claude toolchain likely present”. */
   "claude-code": async () => {
     try {
       await execFileAsync4("which", ["claude"], { timeout: 4e3 });
@@ -31787,8 +31944,8 @@ async function createBridgeConnection(options) {
     clearMainBridgeReconnectQuietOnOpen(state, logFn);
     state.reconnectAttempt = 0;
     state.logBridgeOpenAsReconnect = false;
-    if (logOpenAsPostRefreshReconnect) {
-      logFn("[Bridge service] reconnected.");
+    if (!logOpenAsPostRefreshReconnect) {
+      logFn("Connected to bridge service.");
     }
     const socket = getWs();
     if (socket) {
@@ -31827,6 +31984,9 @@ async function createBridgeConnection(options) {
       clearTimeout(state.reconnectTimeout);
       state.reconnectTimeout = null;
     }
+    if (state.reconnectAttempt === 0) {
+      logFn("Connecting to bridge service\u2026");
+    }
     const prev = state.currentWs;
     if (prev) {
       prev.removeAllListeners();
@@ -31899,15 +32059,17 @@ async function runBridge(options) {
       onAuth: (_auth) => {
       }
     });
-    const onSignal2 = (signal) => {
-      logImmediate(`Received ${signal}; shutting down\u2026`);
+    const onSignal2 = (kind) => {
+      logImmediate(
+        kind === "interrupt" ? "Keyboard interrupt (Ctrl+C) \u2014 stopping\u2026" : "Stop requested \u2014 shutting down\u2026"
+      );
       setImmediate(() => {
         handle2.close();
         process.exit(0);
       });
     };
-    const onSigInt2 = () => onSignal2("SIGINT");
-    const onSigTerm2 = () => onSignal2("SIGTERM");
+    const onSigInt2 = () => onSignal2("interrupt");
+    const onSigTerm2 = () => onSignal2("stop");
     process.on("SIGINT", onSigInt2);
     process.on("SIGTERM", onSigTerm2);
     const auth = await handle2.authPromise;
@@ -31956,22 +32118,24 @@ async function runBridge(options) {
       });
     }
   });
-  const onSignal = (signal) => {
-    logImmediate(`Received ${signal}; shutting down\u2026`);
+  const onSignal = (kind) => {
+    logImmediate(
+      kind === "interrupt" ? "Keyboard interrupt (Ctrl+C) \u2014 stopping\u2026" : "Stop requested \u2014 shutting down\u2026"
+    );
     setImmediate(() => {
       void handle.close().then(() => {
         process.exit(0);
       });
     });
   };
-  const onSigInt = () => onSignal("SIGINT");
-  const onSigTerm = () => onSignal("SIGTERM");
+  const onSigInt = () => onSignal("interrupt");
+  const onSigTerm = () => onSignal("stop");
   process.on("SIGINT", onSigInt);
   process.on("SIGTERM", onSigTerm);
 }
 export {
   callSkill,
-  createAcpClient,
+  createSdkStdioAcpClient as createAcpClient,
   createBridgeConnection,
   createWsBridge,
   getSkill,