@buildautomaton/cli 0.1.5 → 0.1.7

package/dist/cli.js

@@ -974,7 +974,7 @@ var require_command = __commonJS({
     var EventEmitter2 = __require("node:events").EventEmitter;
     var childProcess = __require("node:child_process");
     var path25 = __require("node:path");
-    var fs22 = __require("node:fs");
+    var fs21 = __require("node:fs");
     var process2 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1907,10 +1907,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
           const localBin = path25.resolve(baseDir, baseName);
-          if (fs22.existsSync(localBin)) return localBin;
+          if (fs21.existsSync(localBin)) return localBin;
           if (sourceExt.includes(path25.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs22.existsSync(`${localBin}${ext}`)
+            (ext) => fs21.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1922,7 +1922,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs22.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs21.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
@@ -7426,12 +7426,12 @@ var require_src2 = __commonJS({
     function check2(path25, isFile, isDirectory) {
       log2(`checking %s`, path25);
       try {
-        const stat = fs_1.statSync(path25);
-        if (stat.isFile() && isFile) {
+        const stat2 = fs_1.statSync(path25);
+        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;
         }
@@ -25047,7 +25047,7 @@ var init_acp = __esm({
 });
 
 // src/cli.ts
-import * as fs21 from "node:fs";
+import * as fs20 from "node:fs";
 import * as path24 from "node:path";
 
 // ../../node_modules/.pnpm/commander@12.1.0/node_modules/commander/esm.mjs
@@ -25179,13 +25179,31 @@ var wrapper_default = import_websocket.default;
 
 // src/bridge/connection/create-ws-bridge.ts
 import https from "node:https";
+
+// 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;
@@ -25408,7 +25426,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;
@@ -25445,7 +25463,7 @@ function clearFirehoseReconnectQuietOnOpen(ctx, log2) {
   clearReconnectQuietOnSuccessfulConnection(
     ctx.firehoseQuiet,
     log2,
-    `${PROXY_AND_LOG_SERVICE_LABEL} Reconnected.`
+    "Preview tunnel restored (local HTTP proxy and dev logs)."
   );
 }
 
@@ -30256,34 +30274,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((resolve15) => setImmediate(resolve15));
-  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) {
@@ -30296,12 +30311,295 @@ 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.");
+}
+
+// ../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/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";
 
 // src/git/pre-turn-snapshot.ts
@@ -30416,11 +30714,11 @@ function snapshotFilePath(agentCwd, runId) {
 // 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;
   }
@@ -30430,7 +30728,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(
@@ -30474,7 +30772,7 @@ 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 newText = await readWorkspaceFileAsUtf8(absFile);
         sendSessionUpdate({
           type: "session_file_change",
           sessionId,
@@ -30500,11 +30798,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) {
@@ -30516,12 +30823,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"}`);
@@ -30529,20 +30838,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
@@ -30555,49 +30864,293 @@ function errorMessage(err) {
   return String(err);
 }
 
-// src/acp/clients/acp-client.ts
+// 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/sdk-stdio-acp-client.ts
 import { spawn as spawn2 } from "node:child_process";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname } 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/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/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 = spawn2(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((resolve15, 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;
+      resolve15(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 = readFileSync2(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 = readFileSync2(abs, "utf8");
+            } catch (e) {
+              if (e.code !== "ENOENT") throw e;
+            }
+            mkdirSync2(dirname(abs), { recursive: true });
+            writeFileSync2(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);
@@ -30605,39 +31158,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;
-        resolve15({
+        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() {
@@ -30647,94 +31243,88 @@ 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)));
       }
     })();
   });
 }
 
+// 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 spawn3 } 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",
@@ -30772,16 +31362,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 = spawn3(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((resolve15, reject) => {
     child.on("error", (err) => {
       child.kill();
@@ -30905,8 +31510,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;
@@ -30965,17 +31570,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() {
@@ -30994,38 +31634,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";
@@ -31134,7 +31856,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 };
@@ -31680,7 +32402,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();
@@ -31694,7 +32417,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}`;
@@ -31707,8 +32430,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,
@@ -31716,8 +32437,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;
@@ -31755,6 +32484,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,
@@ -31784,17 +32521,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 {
@@ -31818,6 +32562,7 @@ async function createAcpManager(options) {
         promptId,
         sessionId,
         runId,
+        agentType: preferredForPrompt,
         agentCwd: cwd,
         sendResult,
         sendSessionUpdate,
@@ -31835,6 +32580,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;
@@ -31843,6 +32589,7 @@ async function createAcpManager(options) {
         return false;
       }
     }
+    log2("[Agent] Stop requested (agent still starting)");
     pendingCancelRunId = runId;
     return true;
   }
@@ -31855,7 +32602,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
@@ -31906,8 +32660,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";
@@ -31965,10 +32719,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 {
@@ -31990,6 +32744,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);
@@ -32052,7 +32808,7 @@ function handleBridgePrompt(msg, deps) {
       promptId: msg.id,
       sessionId,
       runId,
-      mode: msg.mode,
+      mode,
       agentType,
       cwd: effectiveCwd,
       sendResult,
@@ -32296,7 +33052,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
@@ -32317,14 +33073,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;
@@ -32348,25 +33104,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");
@@ -32379,7 +33135,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;
@@ -32514,10 +33270,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;
@@ -32525,17 +33281,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";
@@ -32582,23 +33338,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);
     }
   }
@@ -32622,8 +33378,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);
   }
@@ -32633,7 +33389,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;
@@ -32737,7 +33493,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 {
@@ -32772,7 +33528,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) {
@@ -32780,22 +33536,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);
@@ -32808,10 +33564,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;
     }
@@ -32819,11 +33575,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 });
     }
@@ -32843,7 +33599,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 = [];
@@ -32859,11 +33615,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({
@@ -32957,7 +33713,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 : "";
@@ -32969,7 +33725,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,
@@ -33070,25 +33826,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
@@ -33096,7 +33839,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
@@ -33106,7 +33849,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";
@@ -33123,8 +33866,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: [] };
@@ -33133,8 +33876,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 {
   }
 }
@@ -33171,13 +33914,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}).`);
@@ -33214,18 +33957,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());
@@ -33239,7 +33982,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 });
   }
 }
 
@@ -33252,7 +33995,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 {
       }
     }
@@ -33524,7 +34267,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) {
@@ -33560,7 +34303,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));
@@ -33598,7 +34341,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) {
@@ -33700,13 +34443,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 {
   }
 }
@@ -33714,7 +34457,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;
 }
@@ -33788,15 +34531,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;
@@ -33815,7 +34558,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,
@@ -33824,7 +34567,7 @@ function trySpawnMergedLogFile(command, env, cwd, signal) {
     };
   } catch (e) {
     try {
-      fs19.closeSync(logFd);
+      fs18.closeSync(logFd);
     } catch {
     }
     rmDirQuiet(tmpRoot);
@@ -33835,22 +34578,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)}
@@ -33876,13 +34619,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
@@ -34236,7 +34979,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) {
@@ -34510,9 +35255,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;
@@ -34548,16 +35294,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();
@@ -34603,6 +35347,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) {
@@ -34621,8 +35368,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) => {
@@ -34690,47 +35437,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 {
       }
     }
@@ -34820,8 +35539,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) {
@@ -34860,6 +35579,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();
@@ -34932,15 +35654,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;
@@ -34989,16 +35713,18 @@ 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);
 }
@@ -35029,7 +35755,7 @@ async function main() {
     if (opts.cwd && typeof opts.cwd === "string" && opts.cwd.trim()) {
       const resolvedCwd = path24.resolve(process.cwd(), opts.cwd.trim());
       try {
-        const st = fs21.statSync(resolvedCwd);
+        const st = fs20.statSync(resolvedCwd);
         if (!st.isDirectory()) {
           console.error(`--cwd is not a directory: ${resolvedCwd}`);
           process.exit(1);