@buildautomaton/cli 0.1.6 → 0.1.8

package/dist/cli.js

@@ -30318,6 +30318,284 @@ async function closeBridgeConnection(state, acpManager, devServerManager, log2)
   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";
@@ -30520,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) {
@@ -30536,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"}`);
@@ -30555,7 +30844,8 @@ async function sendPromptToAgent(options) {
       ...sessionId ? { sessionId } : {},
       ...runId ? { runId } : {},
       success: false,
-      error: errMsg
+      error: errMsg,
+      ...augmentAuthFields(errMsg)
     });
   }
 }
@@ -30574,6 +30864,30 @@ 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/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";
@@ -30644,6 +30958,83 @@ function toDisplayPathRelativeToCwd(cwd, 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") {
@@ -30651,14 +31042,6 @@ function formatSpawnError(err, command) {
   }
   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");
@@ -30674,7 +31057,9 @@ async function createSdkStdioAcpClient(options) {
   const {
     command,
     cwd = getBridgeWorkspaceDirectory(),
+    backendAgentType,
     onSessionUpdate,
+    onRequest,
     onFileChange,
     killSubprocessAfterCancelMs,
     onAgentSubprocessExit
@@ -30682,30 +31067,67 @@ async function createSdkStdioAcpClient(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
+        });
+        let permissionSeq = 0;
+        const pendingPermissionResolvers = /* @__PURE__ */ new Map();
         const client = (_agent) => ({
           async requestPermission(params) {
-            const opt = params?.options?.[0];
-            if (opt && typeof opt.optionId === "string") {
-              return { outcome: { outcome: "selected", optionId: opt.optionId } };
+            const requestId = `perm-${++permissionSeq}`;
+            const paramsRecord = params != null && typeof params === "object" ? params : {};
+            try {
+              onRequest?.({
+                requestId,
+                method: "session/request_permission",
+                params: paramsRecord
+              });
+            } catch {
             }
-            return { outcome: { outcome: "cancelled" } };
+            return await new Promise((resolve16) => {
+              pendingPermissionResolvers.set(requestId, resolve16);
+            });
           },
           async readTextFile(params) {
             const abs = resolveSafePathUnderCwd(cwd, params.path);
@@ -30737,6 +31159,9 @@ async function createSdkStdioAcpClient(options) {
           },
           async sessionUpdate(params) {
             onSessionUpdate?.(bridgePayloadFromSdkSessionNotification(params));
+          },
+          async extNotification(method, params) {
+            await extNotification(method, params);
           }
         });
         const connection = new ClientSideConnection2(client, stream);
@@ -30752,7 +31177,7 @@ async function createSdkStdioAcpClient(options) {
         });
         const newSessionRes = await connection.newSession({ cwd, mcpServers: [] });
         const sessionId = newSessionRes.sessionId;
-        resolve15({
+        settleResolve({
           sessionId,
           async sendPrompt(prompt, _options) {
             try {
@@ -30760,22 +31185,59 @@ async function createSdkStdioAcpClient(options) {
                 sessionId,
                 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() {
+            for (const [id, resolve16] of [...pendingPermissionResolvers.entries()]) {
+              pendingPermissionResolvers.delete(id);
+              resolve16({ outcome: { outcome: "cancelled" } });
+            }
             try {
               await connection.cancel({ sessionId });
             } catch {
@@ -30789,36 +31251,42 @@ async function createSdkStdioAcpClient(options) {
               t.unref?.();
             }
           },
-          resolveRequest() {
+          resolveRequest(requestId, result) {
+            const resolve16 = pendingPermissionResolvers.get(requestId);
+            if (!resolve16) return;
+            pendingPermissionResolvers.delete(requestId);
+            resolve16(result);
           },
           disconnect() {
             child.kill();
           }
         });
       } 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/codex-acp-client.ts
-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 base = options.command?.length && options.command.some((a) => a.includes("codex-acp")) ? options.command : [...DEFAULT_CODEX_ACP_COMMAND];
-  const command = buildCodexAcpSpawnCommand(base, options.sessionMode);
-  return createSdkStdioAcpClient({ ...options, command });
-}
-
 // src/acp/clients/claude-code-acp-client.ts
+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();
@@ -30835,7 +31303,42 @@ async function createClaudeCodeAcpClient(options) {
   });
 }
 
+// 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 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
+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";
@@ -30886,15 +31389,23 @@ function buildCursorAcpSpawnCommand(base, sessionMode) {
 }
 async function createCursorAcpClient(options) {
   const command = buildCursorAcpSpawnCommand(options.command, options.sessionMode);
-  const { cwd = getBridgeWorkspaceDirectory(), onSessionUpdate, onRequest, onFileChange } = options;
+  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();
@@ -30961,7 +31472,13 @@ async function createCursorAcpClient(options) {
         return;
       }
       if (method === "session/request_permission" && typeof id === "number") {
-        respond(id, { outcome: { outcome: "selected", optionId: "allow-once" } });
+        const params = msg.params ?? {};
+        pendingRequests.set(id, { method, params });
+        onRequest?.({
+          requestId: String(id),
+          method,
+          params
+        });
         return;
       }
       if (typeof id === "number" && method) {
@@ -31058,8 +31575,15 @@ async function createCursorAcpClient(options) {
           return new Promise((res, rej) => {
             child.stdin.write(line, (err) => err ? rej(err) : res());
           });
+        }, cancelPendingPermissionRequests2 = function() {
+          for (const [reqId, pending2] of [...pendingRequests.entries()]) {
+            if (pending2.method === "session/request_permission") {
+              respond(reqId, { outcome: { outcome: "cancelled" } });
+              pendingRequests.delete(reqId);
+            }
+          }
         };
-        var sendSessionCancelNotification = sendSessionCancelNotification2;
+        var sendSessionCancelNotification = sendSessionCancelNotification2, cancelPendingPermissionRequests = cancelPendingPermissionRequests2;
         await send("initialize", {
           protocolVersion: 1,
           clientCapabilities: { fs: { readTextFile: true, writeTextFile: true }, terminal: false },
@@ -31078,20 +31602,56 @@ 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() {
+            cancelPendingPermissionRequests2();
             await sendSessionCancelNotification2();
           },
           resolveRequest(requestId, result) {
@@ -31107,23 +31667,62 @@ 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],
+  [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. */
-  "claude-code": ["npx", "--yes", "@agentclientprotocol/claude-agent-acp"]
+  [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 = {
-  "cursor-cli": "Cursor",
-  "codex-acp": "Codex",
-  "claude-code": "Claude Code"
+  [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";
@@ -31132,13 +31731,17 @@ function getAgentTypeDisplayName(agentType) {
   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];
@@ -31159,6 +31762,14 @@ function resolveAgentCommand(preferredAgentType) {
       spawnCommandForSession: (sessionMode) => buildCodexAcpSpawnCommand(command, sessionMode)
     };
   }
+  if (useKiroAcp(preferredAgentType, command)) {
+    return {
+      command,
+      label: preferredAgentType,
+      createClient: createKiroAcpClient,
+      spawnCommandForSession: (sessionMode) => buildKiroAcpSpawnCommand(command, sessionMode)
+    };
+  }
   return {
     command,
     label: preferredAgentType,
@@ -31333,14 +31944,16 @@ function createBridgeOnRequest(opts) {
     const sessionId = routing.sessionId;
     const sendReq = getSendRequest();
     if (!runId || !sendReq) return;
+    const kind = request.method === "cursor/create_plan" ? "plan" : request.method === "session/request_permission" ? "permission" : "question";
+    const sessionUpdate = request.method === "cursor/create_plan" ? "plan" : request.method === "session/request_permission" ? "permission" : "question";
     try {
       sendReq({
         type: "session_update",
         ...sessionId ? { sessionId } : {},
         runId,
-        kind: request.method === "cursor/create_plan" ? "plan" : "question",
+        kind,
         payload: {
-          sessionUpdate: request.method === "cursor/create_plan" ? "plan" : "question",
+          sessionUpdate,
           requestId: request.requestId,
           method: request.method,
           params: request.params
@@ -31775,6 +32388,9 @@ function createBridgeOnSessionUpdate(opts) {
       pathTracker.accumulatedPathsByToolKey.delete(toolKey);
     }
     if (runId && send) {
+      if (updateKind === "permission") {
+        return;
+      }
       try {
         send({
           type: "session_update",
@@ -31862,6 +32478,7 @@ async function ensureAcpClient(options) {
       command: resolved.command,
       sessionMode: mode,
       cwd: targetCwd,
+      backendAgentType: preferredAgentType,
       onAgentSubprocessExit: () => {
         state.acpHandle = null;
         state.acpStartPromise = null;
@@ -31942,17 +32559,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 {
@@ -31976,6 +32600,7 @@ async function createAcpManager(options) {
         promptId,
         sessionId,
         runId,
+        agentType: preferredForPrompt,
         agentCwd: cwd,
         sendResult,
         sendSessionUpdate,
@@ -32073,8 +32698,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";
@@ -32132,10 +32757,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 {
@@ -34850,48 +35475,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;
-    }
-  },
-  /** Bridge spawns `@agentclientprotocol/claude-agent-acp` via npx; detection is “Claude toolchain likely present”. */
-  "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 {
       }
     }