npm - @buildautomaton/cli - Versions diffs - 0.1.5 → 0.1.7 - Mend

@buildautomaton/cli 0.1.5 → 0.1.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.js CHANGED Viewed

@@ -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,336 @@ function sendWsMessage(ws, payload) {
   }
 }
-// src/acp/clients/acp-client.ts
+// ../types/dist/index.js
+init_zod();
+init_zod();
+init_zod();
+init_zod();
+init_zod();
+init_zod();
+init_zod();
+init_zod();
+init_zod();
+init_zod();
+init_zod();
+init_zod();
+var WorkItemStatusSchema = external_exports.enum(["backlog", "in-progress", "completed"]);
+var WorkItemProgressSchema = external_exports.object({
+  remainingCriteria: external_exports.array(external_exports.string()).default([]),
+  openQuestions: external_exports.array(external_exports.string()).default([]),
+  assignedTo: external_exports.enum(["agent", "human-product", "human-expert"]).optional()
+});
+var ChangeSchema = external_exports.object({
+  id: external_exports.string(),
+  description: external_exports.string(),
+  buildingBlockId: external_exports.string(),
+  buildingBlockType: external_exports.enum(["function", "workflow", "connector", "ui-component", "app-fragment", "application", "project"]),
+  action: external_exports.enum(["create", "update", "split", "combine"])
+});
+var CompletionCriterionSchema = external_exports.object({
+  id: external_exports.string(),
+  description: external_exports.string(),
+  type: external_exports.enum(["write-code", "write-tests", "verify-tests", "other"]),
+  verified: external_exports.boolean().default(false)
+});
+var WorkItemPrioritySchema = external_exports.enum(["low", "medium", "high", "critical"]);
+var IterationPhaseSchema = external_exports.enum(["analysis", "implementation", "verify", "reprioritize", "completed"]);
+var WorkItemDependencySchema = external_exports.object({
+  type: external_exports.enum(["work-item"]),
+  id: external_exports.string()
+});
+var WorkItemSchema = external_exports.object({
+  id: external_exports.string(),
+  sessionId: external_exports.string().optional(),
+  summary: external_exports.string().optional(),
+  description: external_exports.string(),
+  status: WorkItemStatusSchema,
+  buildingBlockId: external_exports.string().optional(),
+  buildingBlockType: external_exports.enum(["function", "workflow", "connector", "ui-component", "app-fragment", "application", "project"]),
+  changes: external_exports.array(ChangeSchema).default([]),
+  completionCriteria: external_exports.array(CompletionCriterionSchema).default([]),
+  priority: WorkItemPrioritySchema.default("medium"),
+  dependencies: external_exports.array(WorkItemDependencySchema).default([]),
+  assignedToUserId: external_exports.string().optional()
+});
+var UserWorkspaceProfileSchema = external_exports.object({
+  id: external_exports.string(),
+  workspaceId: external_exports.string(),
+  userId: external_exports.string(),
+  roleDescription: external_exports.string().optional(),
+  expertiseAreas: external_exports.array(external_exports.string()),
+  preferences: external_exports.record(external_exports.unknown()).optional(),
+  learnings: external_exports.array(external_exports.string())
+});
+var WorkspaceOwnerInfoSchema = external_exports.object({
+  ownerId: external_exports.string(),
+  ownerName: external_exports.string().optional(),
+  ownerEmail: external_exports.string().optional(),
+  ownerProfilePictureUrl: external_exports.string().optional()
+});
+var WorkspaceRuntimeEntrySchema = external_exports.object({
+  workspaceId: external_exports.string(),
+  path: external_exports.string(),
+  name: external_exports.string().optional(),
+  owner: WorkspaceOwnerInfoSchema.optional(),
+  isOwner: external_exports.boolean().optional()
+});
+var ProjectContextSchema = external_exports.object({
+  projectId: external_exports.string(),
+  context: external_exports.record(external_exports.unknown()).default({}),
+  updatedAt: external_exports.string()
+});
+var WebSocketMessageTypeSchema = external_exports.enum([
+  "plan-update",
+  "work-item-update",
+  "work-item-added",
+  "work-item-removed",
+  "project-processing-start",
+  "project-processing-update",
+  "project-processing-complete",
+  "project-processing-error",
+  "file-tool-request",
+  "file-tool-response",
+  "file-generated"
+]);
+var WebSocketMessageSchema = external_exports.object({
+  type: WebSocketMessageTypeSchema,
+  contextId: external_exports.string().optional(),
+  data: external_exports.any().optional(),
+  error: external_exports.string().optional()
+});
+var CheckpointKindSchema = external_exports.enum(["daily", "weekly", "overall"]);
+var CheckpointSummarySchema = external_exports.object({
+  id: external_exports.string(),
+  kind: CheckpointKindSchema,
+  /** ISO date for daily (YYYY-MM-DD), ISO week for weekly, null for overall */
+  periodKey: external_exports.string().nullable(),
+  summary: external_exports.string(),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string()
+});
+var ThreadMetaSchema = external_exports.object({
+  threadId: external_exports.string(),
+  workspaceId: external_exports.string(),
+  /** External source (e.g. slack, discord); null if internal-only */
+  externalSource: external_exports.string().nullable(),
+  /** Id in the external system (e.g. channel_id + thread_ts) */
+  externalId: external_exports.string().nullable(),
+  title: external_exports.string().optional(),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string()
+});
+var ThreadMessageSchema = external_exports.object({
+  messageId: external_exports.string(),
+  threadId: external_exports.string(),
+  /** Role: user, assistant, system */
+  role: external_exports.enum(["user", "assistant", "system"]),
+  content: external_exports.string(),
+  /** Optional reference to a ContentItem (e.g. doc, Notion page) */
+  contentItemId: external_exports.string().nullable(),
+  /** External message id if synced from external chat */
+  externalId: external_exports.string().nullable(),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string()
+});
+var ThreadCheckpointSummarySchema = CheckpointSummarySchema.extend({
+  threadId: external_exports.string()
+});
+var ContentSourceSchema = external_exports.enum(["notion", "doc", "slack_thread", "other"]);
+var ContentItemMetaSchema = external_exports.object({
+  contentId: external_exports.string(),
+  workspaceId: external_exports.string(),
+  source: ContentSourceSchema,
+  /** Id in the external system (e.g. Notion page id, doc url) */
+  externalId: external_exports.string(),
+  /** If source is slack_thread, points to Thread DO id */
+  threadId: external_exports.string().nullable(),
+  title: external_exports.string().optional(),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string()
+});
+var ContentStorageRefSchema = external_exports.object({
+  storageKey: external_exports.string(),
+  /** Optional: mime type or format hint */
+  contentType: external_exports.string().optional()
+});
+var ContentCheckpointSummarySchema = CheckpointSummarySchema.extend({
+  contentId: external_exports.string()
+});
+var StoryMetaSchema = external_exports.object({
+  storyId: external_exports.string(),
+  workspaceId: external_exports.string(),
+  title: external_exports.string(),
+  /** feature | bug | epic */
+  kind: external_exports.enum(["feature", "bug", "epic"]).default("feature"),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string()
+});
+var StoryContentItemRefSchema = external_exports.object({
+  id: external_exports.string(),
+  storyId: external_exports.string(),
+  contentItemId: external_exports.string(),
+  /** Snapshot summary when added to story (or updated) */
+  summary: external_exports.string(),
+  orderIndex: external_exports.number().default(0),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string()
+});
+var StoryCheckpointSummarySchema = CheckpointSummarySchema.extend({
+  storyId: external_exports.string()
+});
+var SessionMetaSchema = external_exports.object({
+  sessionId: external_exports.string(),
+  workspaceId: external_exports.string(),
+  title: external_exports.string().optional(),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string()
+});
+var SessionPromptSchema = external_exports.object({
+  id: external_exports.string(),
+  sessionId: external_exports.string(),
+  /** text | resource */
+  type: external_exports.enum(["text", "resource"]).default("text"),
+  text: external_exports.string().optional(),
+  resourceUri: external_exports.string().optional(),
+  createdAt: external_exports.string()
+});
+var SessionResponseSchema = external_exports.object({
+  id: external_exports.string(),
+  sessionId: external_exports.string(),
+  promptId: external_exports.string(),
+  /** message | completion */
+  kind: external_exports.enum(["message", "completion"]),
+  content: external_exports.string().optional(),
+  /** For completion: stopReason etc. */
+  stopReason: external_exports.string().optional(),
+  createdAt: external_exports.string()
+});
+var SessionToolCallSchema = external_exports.object({
+  id: external_exports.string(),
+  sessionId: external_exports.string(),
+  promptId: external_exports.string(),
+  name: external_exports.string(),
+  params: external_exports.record(external_exports.unknown()).optional(),
+  result: external_exports.record(external_exports.unknown()).optional(),
+  createdAt: external_exports.string()
+});
+var SessionThreadRefSchema = external_exports.object({
+  sessionId: external_exports.string(),
+  threadId: external_exports.string(),
+  addedAt: external_exports.string()
+});
+var ArtifactMetaSchema = external_exports.object({
+  artifactId: external_exports.string(),
+  workspaceId: external_exports.string(),
+  /** Slug for permalink: /workspaces/:wid/artifacts/:slug */
+  permalinkSlug: external_exports.string(),
+  title: external_exports.string(),
+  /** e.g. summary_report, build_log */
+  type: external_exports.string().default("report"),
+  /** Optional session that produced this artifact */
+  sessionId: external_exports.string().nullable(),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string()
+});
+var TemplateMetaSchema = external_exports.object({
+  templateId: external_exports.string(),
+  workspaceId: external_exports.string(),
+  name: external_exports.string(),
+  /** e.g. summary_report, build_log */
+  artifactType: external_exports.string().optional(),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string()
+});
+var GitRepoMetaSchema = external_exports.object({
+  /** Stable id for the repo (e.g. hash of normalized canonical URL). Used for DO idFromName. */
+  repoId: external_exports.string(),
+  /** Canonical external URL (e.g. https://github.com/org/repo). Normalize before storing. */
+  canonicalUrl: external_exports.string().url(),
+  /** Optional workspace this repo was first linked in. */
+  workspaceId: external_exports.string().nullable(),
+  displayName: external_exports.string().optional(),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string()
+});
+var LOCAL_AGENT_AUTH_ERROR_HINTS = {
+  "kiro-acp": [/not logged in/i, /kiro-cli\s+login/i, /log in with kiro-cli/i],
+  "cursor-cli": [/cursor_login/i, /authenticate.*cursor/i, /not logged in.*cursor/i, /run:\s*agent\s+login/i],
+  "codex-acp": [
+    /authentication failed/i,
+    /not authenticated/i,
+    /invalid.*api key/i,
+    /sign in.*openai/i,
+    /login.*openai/i,
+    /unauthorized/i
+  ],
+  "claude-code": [
+    /ANTHROPIC_API_KEY/i,
+    /not authenticated/i,
+    /authentication failed/i,
+    /claude\s+login/i,
+    /please run.*claude.*login/i
+  ]
+};
+function localAgentErrorSuggestsAuth(agentType, errorText) {
+  if (agentType == null || agentType === "" || errorText == null || !String(errorText).trim()) return false;
+  const hints = LOCAL_AGENT_AUTH_ERROR_HINTS[agentType];
+  if (!hints?.length) return false;
+  return hints.some((re) => re.test(String(errorText)));
+}
+// src/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,47 +22488,217 @@ 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/agent-stderr-capture.ts
+var STDERR_CAPTURE_MAX = 48e3;
+function createStderrCapture(child) {
+  const chunks = [];
+  let total = 0;
+  return {
+    append(chunk) {
+      try {
+        process.stderr.write(chunk);
+      } catch {
+      }
+      if (total >= STDERR_CAPTURE_MAX) return;
+      const n = Math.min(chunk.length, STDERR_CAPTURE_MAX - total);
+      if (n <= 0) return;
+      chunks.push(n === chunk.length ? chunk : chunk.subarray(0, n));
+      total += n;
+    },
+    getText() {
+      return Buffer.concat(chunks).toString("utf8").trim();
+    }
+  };
+}
+function formatJsonRpcStyleError(err) {
+  if (err instanceof Error) return err.message;
+  if (err != null && typeof err === "object") {
+    const o = err;
+    const msg = typeof o.message === "string" ? o.message : null;
+    const code = o.code != null ? String(o.code) : "";
+    if (msg) return code ? `[${code}] ${msg}` : msg;
+  }
+  if (typeof err === "string") return err;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+function mergeErrorWithStderr(primary, stderrText) {
+  const s = stderrText.trim();
+  const p = (primary ?? "").trim();
+  if (!s) return p;
+  if (!p) return s;
+  if (p.includes(s) || s.includes(p)) return p.length >= s.length ? p : s;
+  return `${p}
+${s}`;
+}
+// src/acp/clients/kiro-sdk-ext-notifications.ts
+function createKiroSdkExtNotificationHandler(options) {
+  const { onSessionUpdate } = options;
+  return async (method, params) => {
+    if (method === "_kiro.dev/metadata") {
+      const p = params && typeof params === "object" ? params : {};
+      const pct = p.contextUsagePercentage;
+      if (typeof pct !== "number" || !Number.isFinite(pct) || !onSessionUpdate) return;
+      onSessionUpdate({
+        sessionUpdate: "context_usage",
+        contextUsagePercentage: pct
+      });
+      return;
+    }
+  };
+}
+// src/acp/clients/sdk-stdio-ext-notifications.ts
+var noopExtNotification = async () => {
+};
+function createSdkStdioExtNotificationHandler(options) {
+  const { backendAgentType, onSessionUpdate } = options;
+  switch (backendAgentType) {
+    case "kiro-acp":
+      return createKiroSdkExtNotificationHandler({ onSessionUpdate });
+    default:
+      return noopExtNotification;
+  }
+}
+// src/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.`;
   }
   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);
+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 createAcpClient(options) {
-  const { ClientSideConnection: ClientSideConnection2, ndJsonStream: ndJsonStream2 } = await Promise.resolve().then(() => (init_acp(), acp_exports));
-  const { command, cwd = getBridgeWorkspaceDirectory(), onSessionUpdate } = options;
+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(),
+    backendAgentType,
+    onSessionUpdate,
+    onFileChange,
+    killSubprocessAfterCancelMs,
+    onAgentSubprocessExit
+  } = options;
   const isWindows = process.platform === "win32";
   const child = spawn(command[0], command.slice(1), {
     cwd,
-    stdio: ["pipe", "pipe", "inherit"],
+    stdio: ["pipe", "pipe", "pipe"],
     env: process.env,
     shell: isWindows
   });
+  const stderrCapture = createStderrCapture(child);
+  child.once("close", (code, signal) => {
+    onAgentSubprocessExit?.({ code, signal });
+  });
   return new Promise((resolve14, reject) => {
+    let initSettled = false;
+    const settleReject = (err) => {
+      if (initSettled) return;
+      initSettled = true;
+      try {
+        child.kill();
+      } catch {
+      }
+      reject(err);
+    };
+    const settleResolve = (handle) => {
+      if (initSettled) return;
+      initSettled = true;
+      resolve14(handle);
+    };
     child.on("error", (err) => {
-      child.kill();
-      reject(new Error(formatSpawnError(err, command[0])));
+      settleReject(new Error(formatSpawnError(err, command[0])));
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderrCapture.append(chunk);
+      if (initSettled) return;
+      const stderrText = stderrCapture.getText();
+      if (backendAgentType && stderrText.trim() && localAgentErrorSuggestsAuth(backendAgentType, stderrText)) {
+        settleReject(new Error(stderrText.trim()));
+      }
     });
     (async () => {
       try {
         const writable = Writable.toWeb(child.stdin);
         const readable = Readable.toWeb(child.stdout);
         const stream = ndJsonStream2(writable, readable);
+        const extNotification = createSdkStdioExtNotificationHandler({
+          backendAgentType,
+          onSessionUpdate
+        });
         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));
+          },
+          async extNotification(method, params) {
+            await extNotification(method, params);
           }
         });
         const connection = new ClientSideConnection2(client, stream);
@@ -22194,39 +22706,82 @@ 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({
+        settleResolve({
           sessionId,
           async sendPrompt(prompt, _options) {
             try {
               const response = await connection.prompt({
                 sessionId,
-                prompt: { type: "text", text: prompt }
+                prompt: [{ type: "text", text: prompt }]
               });
+              await new Promise((r2) => setImmediate(r2));
               const r = response;
-              const cancelled = (r?.stopReason ?? "").toLowerCase() === "cancelled";
+              const stopReason = (r?.stopReason ?? "").toLowerCase();
+              const cancelled = stopReason === "cancelled";
+              const refusal = stopReason === "refusal";
+              const stderrAfter = stderrCapture.getText();
+              const agentType = backendAgentType ?? null;
+              const stderrEvaluated = Boolean(stderrAfter && agentType);
+              const stderrSuggestsAuth = stderrEvaluated ? localAgentErrorSuggestsAuth(agentType, stderrAfter) : false;
+              if (cancelled) {
+                return {
+                  success: false,
+                  stopReason: r?.stopReason,
+                  output: r?.output,
+                  error: mergeErrorWithStderr("Stopped by user", stderrAfter)
+                };
+              }
+              if (refusal) {
+                return {
+                  success: false,
+                  stopReason: r?.stopReason,
+                  output: r?.output,
+                  error: mergeErrorWithStderr("The agent refused the request.", stderrAfter)
+                };
+              }
+              if (stderrSuggestsAuth) {
+                return {
+                  success: false,
+                  stopReason: r?.stopReason,
+                  output: r?.output,
+                  error: stderrAfter
+                };
+              }
               return {
-                success: !cancelled,
+                success: true,
                 stopReason: r?.stopReason,
-                output: r?.output,
-                ...cancelled ? { error: "Stopped by user" } : {}
+                output: r?.output
               };
             } catch (err) {
+              await new Promise((r) => setImmediate(r));
+              const stderrAfter = stderrCapture.getText();
+              const merged = mergeErrorWithStderr(formatJsonRpcStyleError(err), stderrAfter);
               return {
                 success: false,
-                error: err instanceof Error ? err.message : String(err)
+                error: merged
               };
             }
           },
           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() {
@@ -22236,8 +22791,14 @@ async function createAcpClient(options) {
           }
         });
       } catch (err) {
-        child.kill();
-        reject(new Error(toErrorMessage(err)));
+        if (initSettled) return;
+        try {
+          child.kill();
+        } catch {
+        }
+        const stderrText = stderrCapture.getText();
+        const base = formatJsonRpcStyleError(err);
+        settleReject(new Error(mergeErrorWithStderr(base, stderrText)));
       }
     })();
   });
@@ -22540,11 +23101,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 +23121,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 +23316,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 +23353,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 +23504,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 +23513,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 +26816,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 +28091,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 +28104,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 +28113,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 +28128,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 +28164,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 +28201,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 +28250,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 +28282,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 +28320,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 +28340,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 +28369,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 +28383,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,
@@ -27847,11 +28410,20 @@ async function sendPromptToAgent(options) {
     promptId,
     sessionId,
     runId,
+    agentType,
     agentCwd,
     sendResult,
     sendSessionUpdate,
     log: log2
   } = options;
+  function augmentAuthFields(errorText) {
+    const err = errorText ?? "";
+    const at = agentType ?? null;
+    const evaluated = Boolean(at && err.trim());
+    const suggestsAuth = evaluated && at ? localAgentErrorSuggestsAuth(at, err) : false;
+    if (!suggestsAuth || !agentType) return {};
+    return { agentAuthRequired: true, agentType };
+  }
   try {
     const result = await handle.sendPrompt(promptText, {});
     if (sessionId && runId && sendSessionUpdate && agentCwd && result.success) {
@@ -27863,12 +28435,14 @@ async function sendPromptToAgent(options) {
         log: log2
       });
     }
+    const errStr = typeof result.error === "string" ? result.error : void 0;
     sendResult({
       type: "prompt_result",
       id: promptId,
       ...sessionId ? { sessionId } : {},
       ...runId ? { runId } : {},
-      ...result
+      ...result,
+      ...augmentAuthFields(errStr)
     });
     if (!result.success) {
       log2(`[Agent] ${result.error ?? "Error"}`);
@@ -27876,20 +28450,20 @@ 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,
       ...sessionId ? { sessionId } : {},
       ...runId ? { runId } : {},
       success: false,
-      error: errMsg
+      error: errMsg,
+      ...augmentAuthFields(errMsg)
     });
   }
 }
 // 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
@@ -27902,87 +28476,99 @@ function errorMessage(err) {
   return String(err);
 }
+// src/acp/clients/claude-code-acp-client.ts
+var claude_code_acp_client_exports = {};
+__export(claude_code_acp_client_exports, {
+  BACKEND_LOCAL_AGENT_TYPE: () => BACKEND_LOCAL_AGENT_TYPE,
+  buildClaudeCodeAcpSpawnCommand: () => buildClaudeCodeAcpSpawnCommand,
+  createClaudeCodeAcpClient: () => createClaudeCodeAcpClient,
+  detectLocalAgentPresence: () => detectLocalAgentPresence
+});
+import { execFile as execFile4 } from "node:child_process";
+import { promisify as promisify4 } from "node:util";
+// src/acp/clients/detect-command-on-path.ts
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+var execFileAsync3 = promisify3(execFile3);
+async function isCommandOnPath(command, timeoutMs = 4e3) {
+  try {
+    await execFileAsync3("which", [command], { timeout: timeoutMs });
+    return true;
+  } catch {
+    return false;
+  }
+}
+// src/acp/clients/claude-code-acp-client.ts
+var execFileAsync4 = promisify4(execFile4);
+var BACKEND_LOCAL_AGENT_TYPE = "claude-code";
+async function detectLocalAgentPresence() {
+  if (await isCommandOnPath("claude")) return true;
+  try {
+    await execFileAsync4("npx", ["--yes", "@anthropic-ai/claude-code", "--version"], { timeout: 25e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+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/codex-acp-client.ts
+var codex_acp_client_exports = {};
+__export(codex_acp_client_exports, {
+  BACKEND_LOCAL_AGENT_TYPE: () => BACKEND_LOCAL_AGENT_TYPE2,
+  DEFAULT_CODEX_ACP_COMMAND: () => DEFAULT_CODEX_ACP_COMMAND,
+  buildCodexAcpSpawnCommand: () => buildCodexAcpSpawnCommand,
+  createCodexAcpClient: () => createCodexAcpClient,
+  detectLocalAgentPresence: () => detectLocalAgentPresence2,
+  isCodexAcpCommand: () => isCodexAcpCommand
+});
+var BACKEND_LOCAL_AGENT_TYPE2 = "codex-acp";
+async function detectLocalAgentPresence2() {
+  return isCommandOnPath("codex");
+}
 var DEFAULT_CODEX_ACP_COMMAND = ["npx", "--yes", "@zed-industries/codex-acp"];
 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/cursor-acp-client.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
-import { dirname } from "node:path";
+var cursor_acp_client_exports = {};
+__export(cursor_acp_client_exports, {
+  BACKEND_LOCAL_AGENT_TYPE: () => BACKEND_LOCAL_AGENT_TYPE3,
+  buildCursorAcpSpawnCommand: () => buildCursorAcpSpawnCommand,
+  createCursorAcpClient: () => createCursorAcpClient,
+  detectLocalAgentPresence: () => detectLocalAgentPresence3
+});
+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,16 +28606,31 @@ 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(),
+    backendAgentType,
+    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), {
     cwd,
-    stdio: ["pipe", "pipe", "inherit"],
+    stdio: ["pipe", "pipe", "pipe"],
     env: process.env,
     shell: isWindows
   });
+  const stderrCapture = createStderrCapture(child);
+  child.stderr?.on("data", (chunk) => stderrCapture.append(chunk));
   return new Promise((resolve14, reject) => {
     child.on("error", (err) => {
       child.kill();
@@ -28153,8 +28754,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;
@@ -28213,17 +28814,52 @@ async function createCursorAcpClient(options) {
                 sessionId,
                 prompt: [{ type: "text", text: prompt }]
               });
+              await new Promise((r) => setImmediate(r));
               const output = (result?.output ?? promptOutputBuffer) || void 0;
-              const cancelled = (result?.stopReason ?? "").toLowerCase() === "cancelled";
+              const stopReason = (result?.stopReason ?? "").toLowerCase();
+              const cancelled = stopReason === "cancelled";
+              const refusal = stopReason === "refusal";
+              const stderrAfter = stderrCapture.getText();
+              const agentType = backendAgentType ?? null;
+              const stderrEvaluated = Boolean(stderrAfter && agentType);
+              const stderrSuggestsAuth = stderrEvaluated ? localAgentErrorSuggestsAuth(agentType, stderrAfter) : false;
+              if (cancelled) {
+                return {
+                  success: false,
+                  stopReason: result?.stopReason,
+                  output: output || void 0,
+                  error: mergeErrorWithStderr("Stopped by user", stderrAfter)
+                };
+              }
+              if (refusal) {
+                return {
+                  success: false,
+                  stopReason: result?.stopReason,
+                  output: output || void 0,
+                  error: mergeErrorWithStderr("The agent refused the request.", stderrAfter)
+                };
+              }
+              if (stderrSuggestsAuth) {
+                return {
+                  success: false,
+                  stopReason: result?.stopReason,
+                  output: output || void 0,
+                  error: stderrAfter
+                };
+              }
               return {
-                success: !cancelled,
+                success: true,
                 stopReason: result?.stopReason,
-                output: output || void 0,
-                ...cancelled ? { error: "Stopped by user" } : {}
+                output: output || void 0
               };
             } catch (err) {
-              const message = err != null && typeof err === "object" && "message" in err ? String(err.message) : String(err);
-              return { success: false, error: message };
+              await new Promise((r) => setImmediate(r));
+              const stderrAfter = stderrCapture.getText();
+              const merged = mergeErrorWithStderr(formatJsonRpcStyleError(err), stderrAfter);
+              return {
+                success: false,
+                error: merged
+              };
             }
           },
           async cancel() {
@@ -28242,38 +28878,120 @@ async function createCursorAcpClient(options) {
         });
       } catch (err) {
         child.kill();
-        reject(err);
+        const merged = mergeErrorWithStderr(formatJsonRpcStyleError(err), stderrCapture.getText());
+        reject(merged ? new Error(merged) : err instanceof Error ? err : new Error(String(err)));
       }
     })();
   });
 }
+var BACKEND_LOCAL_AGENT_TYPE3 = "cursor-cli";
+async function detectLocalAgentPresence3() {
+  return isCommandOnPath("agent");
+}
+// src/acp/clients/kiro-acp-client.ts
+var kiro_acp_client_exports = {};
+__export(kiro_acp_client_exports, {
+  BACKEND_LOCAL_AGENT_TYPE: () => BACKEND_LOCAL_AGENT_TYPE4,
+  DEFAULT_KIRO_ACP_COMMAND: () => DEFAULT_KIRO_ACP_COMMAND,
+  buildKiroAcpSpawnCommand: () => buildKiroAcpSpawnCommand,
+  createKiroAcpClient: () => createKiroAcpClient,
+  detectLocalAgentPresence: () => detectLocalAgentPresence4,
+  isKiroAcpCommand: () => isKiroAcpCommand
+});
+var BACKEND_LOCAL_AGENT_TYPE4 = "kiro-acp";
+async function detectLocalAgentPresence4() {
+  return isCommandOnPath("kiro-cli");
+}
+var DEFAULT_KIRO_ACP_COMMAND = ["kiro-cli", "acp"];
+function isKiroAcpCommand(command) {
+  if (command.length < 2) return false;
+  if (command[command.length - 1] !== "acp") return false;
+  return command.slice(0, -1).some(
+    (a) => a === "kiro-cli" || /[/\\]kiro-cli(\.exe)?$/i.test(a)
+  );
+}
+function buildKiroAcpSpawnCommand(base, _sessionMode) {
+  return [...base];
+}
+async function createKiroAcpClient(options) {
+  const base = options.command?.length && isKiroAcpCommand(options.command) ? options.command : [...DEFAULT_KIRO_ACP_COMMAND];
+  const command = buildKiroAcpSpawnCommand(base, options.sessionMode);
+  return createSdkStdioAcpClient({ ...options, command });
+}
 // src/acp/resolve-agent-command.ts
 var AGENT_TYPE_DEFAULT_COMMANDS = {
-  "cursor-cli": ["agent", "acp"],
-  "codex-acp": [...DEFAULT_CODEX_ACP_COMMAND],
-  "claude-code": ["npx", "--yes", "@anthropic-ai/claude-code"]
+  [BACKEND_LOCAL_AGENT_TYPE3]: ["agent", "acp"],
+  [BACKEND_LOCAL_AGENT_TYPE2]: [...DEFAULT_CODEX_ACP_COMMAND],
+  /** ACP stdio agent; `@anthropic-ai/claude-code` is the interactive CLI and does not speak ACP on stdout. */
+  [BACKEND_LOCAL_AGENT_TYPE]: ["npx", "--yes", "@agentclientprotocol/claude-agent-acp"],
+  /** [Kiro CLI ACP](https://kiro.dev/docs/cli/acp/) — use full path to `kiro-cli` in PATH if the IDE cannot find it. */
+  [BACKEND_LOCAL_AGENT_TYPE4]: [...DEFAULT_KIRO_ACP_COMMAND]
 };
+var AGENT_TYPE_DISPLAY_NAMES = {
+  [BACKEND_LOCAL_AGENT_TYPE3]: "Cursor",
+  [BACKEND_LOCAL_AGENT_TYPE2]: "Codex",
+  [BACKEND_LOCAL_AGENT_TYPE]: "Claude Code",
+  [BACKEND_LOCAL_AGENT_TYPE4]: "Kiro"
+};
+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;
+  if (agentType === BACKEND_LOCAL_AGENT_TYPE3) return true;
   return command[0] === "agent" && command[1] === "acp";
 }
 function useCodexAcp(agentType, command) {
-  if (agentType === "codex-acp") return true;
+  if (agentType === BACKEND_LOCAL_AGENT_TYPE2) return true;
   return isCodexAcpCommand(command);
 }
+function useKiroAcp(agentType, command) {
+  if (agentType === BACKEND_LOCAL_AGENT_TYPE4) return true;
+  return isKiroAcpCommand(command);
+}
 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)
+    };
+  }
+  if (useKiroAcp(preferredAgentType, command)) {
+    return {
+      command,
+      label: preferredAgentType,
+      createClient: createKiroAcpClient,
+      spawnCommandForSession: (sessionMode) => buildKiroAcpSpawnCommand(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 +29100,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 +29646,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 +29661,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 +29674,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 +29681,16 @@ async function ensureAcpClient(options) {
       log: log2
     });
     state.acpStartPromise = resolved.createClient({
-      command: fullCmd,
+      command: resolved.command,
+      sessionMode: mode,
       cwd: targetCwd,
+      backendAgentType: preferredAgentType,
+      onAgentSubprocessExit: () => {
+        state.acpHandle = null;
+        state.acpStartPromise = null;
+        state.acpAgentKey = null;
+        state.lastAcpStartError = "Agent subprocess exited";
+      },
       ...hooks
     }).then((h) => {
       state.lastAcpStartError = null;
@@ -29003,6 +29728,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,
@@ -29032,17 +29765,24 @@ async function createAcpManager(options) {
         log: log2
       });
       if (!handle) {
+        const errMsg = state.lastAcpStartError || "No agent configured. Register local agents on this bridge in the app.";
+        const evaluated = Boolean(preferredForPrompt && errMsg.trim());
+        const suggestsAuth = evaluated ? localAgentErrorSuggestsAuth(preferredForPrompt, errMsg) : false;
+        const auth = suggestsAuth && preferredForPrompt ? { agentAuthRequired: true, agentType: preferredForPrompt } : {};
         sendResult({
           type: "prompt_result",
           id: promptId,
           ...sessionId ? { sessionId } : {},
           ...runId ? { runId } : {},
           success: false,
-          error: state.lastAcpStartError || "No agent configured. Register local agents on this bridge in the app."
+          error: errMsg,
+          ...auth
         });
         return;
       }
-      if (promptRouting.sessionId !== sessionId || promptRouting.runId !== runId) return;
+      if (promptRouting.sessionId !== sessionId || promptRouting.runId !== runId) {
+        return;
+      }
       if (runId && pendingCancelRunId === runId) {
         pendingCancelRunId = void 0;
         try {
@@ -29066,6 +29806,7 @@ async function createAcpManager(options) {
         promptId,
         sessionId,
         runId,
+        agentType: preferredForPrompt,
         agentCwd: cwd,
         sendResult,
         sendSessionUpdate,
@@ -29083,6 +29824,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 +29833,7 @@ async function createAcpManager(options) {
         return false;
       }
     }
+    log2("[Agent] Stop requested (agent still starting)");
     pendingCancelRunId = runId;
     return true;
   }
@@ -29103,7 +29846,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
@@ -29154,8 +29904,8 @@ var handleAgentConfigMessage = (msg, deps) => {
 // src/acp/from-bridge/handle-bridge-prompt.ts
 import * as path11 from "node:path";
-import { execFile as execFile3 } from "node:child_process";
-import { promisify as promisify3 } from "node:util";
+import { execFile as execFile5 } from "node:child_process";
+import { promisify as promisify5 } from "node:util";
 // src/git/bridge-queue-key.ts
 import * as path10 from "node:path";
@@ -29213,10 +29963,10 @@ async function resolveBridgeQueueBindFields(options) {
 }
 // src/acp/from-bridge/handle-bridge-prompt.ts
-var execFileAsync3 = promisify3(execFile3);
+var execFileAsync5 = promisify5(execFile5);
 async function readGitBranch(cwd) {
   try {
-    const { stdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd, maxBuffer: 64 * 1024 });
+    const { stdout } = await execFileAsync5("git", ["branch", "--show-current"], { cwd, maxBuffer: 64 * 1024 });
     const b = stdout.trim();
     return b || null;
   } catch {
@@ -29238,6 +29988,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 +30052,7 @@ function handleBridgePrompt(msg, deps) {
       promptId: msg.id,
       sessionId,
       runId,
-      mode: msg.mode,
+      mode,
       agentType,
       cwd: effectiveCwd,
       sendResult,
@@ -29370,7 +30122,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 +30143,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 +30174,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 +30205,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 +30340,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 +30351,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 +30408,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 +30448,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 +30459,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 +30563,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 +30598,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 +30606,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 +30634,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 +30645,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 +30669,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 +30685,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 +30783,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 +30795,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 +30896,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 +30909,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 +30919,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 +30936,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 +30946,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 +30984,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 +31027,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 +31052,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 +31065,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 +31337,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 +31373,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 +31411,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 +31513,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 +31527,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 +31601,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 +31628,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 +31637,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     };
   } catch (e) {
     try {
-      fs19.closeSync(logFd);
+      fs18.closeSync(logFd);
     } catch {
     }
     rmDirQuiet(tmpRoot);
@@ -30909,22 +31648,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 +31689,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 +32049,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 +32218,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 +32257,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 +32310,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 +32331,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) => {
@@ -31657,47 +32400,19 @@ function createOnBridgeIdentified(opts) {
   };
 }
-// 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;
-      }
-    }
-  }
-};
+// src/acp/detect-local-agent-types.ts
+var LOCAL_AGENT_ACP_MODULES = [
+  cursor_acp_client_exports,
+  codex_acp_client_exports,
+  kiro_acp_client_exports,
+  claude_code_acp_client_exports
+];
 async function detectLocalAgentTypes() {
   try {
     const out = [];
-    for (const [type, check2] of Object.entries(CHECKS)) {
+    for (const mod of LOCAL_AGENT_ACP_MODULES) {
       try {
-        if (await check2()) out.push(type);
+        if (await mod.detectLocalAgentPresence()) out.push(mod.BACKEND_LOCAL_AGENT_TYPE);
       } catch {
       }
     }
@@ -31787,8 +32502,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 +32542,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 +32617,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 +32676,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,