poe-code 3.0.174 → 3.0.175

package/dist/index.js

@@ -4645,10 +4645,10 @@ function renderTableTerminal(options) {
 }
 function renderTableMarkdown(options) {
   const { columns, rows } = options;
-  const header = `| ${columns.map((c) => c.title).join(" | ")} |`;
-  const separator = `| ${columns.map((c) => c.alignment === "right" ? "---:" : ":---").join(" | ")} |`;
+  const header = `| ${columns.map((c2) => c2.title).join(" | ")} |`;
+  const separator = `| ${columns.map((c2) => c2.alignment === "right" ? "---:" : ":---").join(" | ")} |`;
   const dataRows = rows.map(
-    (row) => `| ${columns.map((c) => stripAnsi2(row[c.name] ?? "").replace(/\|/g, "\\|")).join(" | ")} |`
+    (row) => `| ${columns.map((c2) => stripAnsi2(row[c2.name] ?? "").replace(/\|/g, "\\|")).join(" | ")} |`
   );
   return [header, separator, ...dataRows].join("\n");
 }
@@ -8239,6 +8239,42 @@ var init_dashboard2 = __esm({
   }
 });
 
+// node_modules/fast-string-truncated-width/dist/utils.js
+var init_utils = __esm({
+  "node_modules/fast-string-truncated-width/dist/utils.js"() {
+  }
+});
+
+// node_modules/fast-string-truncated-width/dist/index.js
+var EMOJI_RE, MODIFIER_RE;
+var init_dist = __esm({
+  "node_modules/fast-string-truncated-width/dist/index.js"() {
+    init_utils();
+    EMOJI_RE = new RegExp("[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[\\u{E0061}-\\u{E007A}]{2}[\\u{E0030}-\\u{E0039}\\u{E0061}-\\u{E007A}]{1,3}\\u{E007F}|(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation})(?:\\u200D(?:\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation}|\\p{Emoji}\\uFE0F\\u20E3?))*", "yu");
+    MODIFIER_RE = new RegExp("\\p{M}+", "gu");
+  }
+});
+
+// node_modules/fast-string-width/dist/index.js
+var init_dist2 = __esm({
+  "node_modules/fast-string-width/dist/index.js"() {
+    init_dist();
+  }
+});
+
+// node_modules/fast-wrap-ansi/lib/main.js
+var ANSI_ESCAPE_BELL, ANSI_CSI, ANSI_OSC, ANSI_ESCAPE_LINK, GROUP_REGEX;
+var init_main = __esm({
+  "node_modules/fast-wrap-ansi/lib/main.js"() {
+    init_dist2();
+    ANSI_ESCAPE_BELL = "\x07";
+    ANSI_CSI = "[";
+    ANSI_OSC = "]";
+    ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+    GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+  }
+});
+
 // node_modules/sisteransi/src/index.js
 var require_src = __commonJS({
   "node_modules/sisteransi/src/index.js"(exports, module) {
@@ -8247,16 +8283,16 @@ var require_src = __commonJS({
     var CSI = `${ESC}[`;
     var beep = "\x07";
     var cursor = {
-      to(x, y) {
-        if (!y) return `${CSI}${x + 1}G`;
-        return `${CSI}${y + 1};${x + 1}H`;
+      to(x, y2) {
+        if (!y2) return `${CSI}${x + 1}G`;
+        return `${CSI}${y2 + 1};${x + 1}H`;
       },
-      move(x, y) {
+      move(x, y2) {
         let ret = "";
         if (x < 0) ret += `${CSI}${-x}D`;
         else if (x > 0) ret += `${CSI}${x}C`;
-        if (y < 0) ret += `${CSI}${-y}A`;
-        else if (y > 0) ret += `${CSI}${y}B`;
+        if (y2 < 0) ret += `${CSI}${-y2}A`;
+        else if (y2 > 0) ret += `${CSI}${y2}B`;
         return ret;
       },
       up: (count = 1) => `${CSI}${count}A`,
@@ -8296,30 +8332,24 @@ var require_src = __commonJS({
 });
 
 // node_modules/@clack/core/dist/index.mjs
-import { stdout as R, stdin as q } from "node:process";
-import * as k from "node:readline";
-import ot from "node:readline";
-import { ReadStream as J } from "node:tty";
-function Ct(t) {
-  return t === z;
-}
-var import_sisteransi, P, ct, pt, ft, j, Q, dt, U, et, At, _, bt, z;
-var init_dist = __esm({
+import { styleText as y } from "node:util";
+import { stdout as S, stdin as $ } from "node:process";
+import * as _ from "node:readline";
+import P from "node:readline";
+import { ReadStream as D } from "node:tty";
+function q(r) {
+  return r === C;
+}
+var import_sisteransi, E, G, u, Y, C;
+var init_dist3 = __esm({
   "node_modules/@clack/core/dist/index.mjs"() {
+    init_main();
     import_sisteransi = __toESM(require_src(), 1);
-    P = new RegExp("[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[\\u{E0061}-\\u{E007A}]{2}[\\u{E0030}-\\u{E0039}\\u{E0061}-\\u{E007A}]{1,3}\\u{E007F}|(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation})(?:\\u200D(?:\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation}|\\p{Emoji}\\uFE0F\\u20E3?))*", "yu");
-    ct = new RegExp("\\p{M}+", "gu");
-    pt = { limit: 1 / 0, ellipsis: "" };
-    ft = { limit: 1 / 0, ellipsis: "", ellipsisWidth: 0 };
-    j = "\x07";
-    Q = "[";
-    dt = "]";
-    U = `${dt}8;;`;
-    et = new RegExp(`(?:\\${Q}(?<code>\\d+)m|\\${U}(?<uri>.*)${j})`, "y");
-    At = ["up", "down", "left", "right", "space", "enter", "cancel"];
-    _ = { actions: new Set(At), aliases: /* @__PURE__ */ new Map([["k", "up"], ["j", "down"], ["h", "left"], ["l", "right"], ["", "cancel"], ["escape", "cancel"]]), messages: { cancel: "Canceled", error: "Something went wrong" }, withGuide: true };
-    bt = globalThis.process.platform.startsWith("win");
-    z = /* @__PURE__ */ Symbol("clack:cancel");
+    E = ["up", "down", "left", "right", "space", "enter", "cancel"];
+    G = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+    u = { actions: new Set(E), aliases: /* @__PURE__ */ new Map([["k", "up"], ["j", "down"], ["h", "left"], ["l", "right"], ["", "cancel"], ["escape", "cancel"]]), messages: { cancel: "Canceled", error: "Something went wrong" }, withGuide: true, date: { monthNames: [...G], messages: { required: "Please enter a valid date", invalidMonth: "There are only 12 months in a year", invalidDay: (r, t) => `There are only ${r} days in ${t}`, afterMin: (r) => `Date must be on or after ${r.toISOString().slice(0, 10)}`, beforeMax: (r) => `Date must be on or before ${r.toISOString().slice(0, 10)}` } } };
+    Y = globalThis.process.platform.startsWith("win");
+    C = /* @__PURE__ */ Symbol("clack:cancel");
   }
 });
 
@@ -8336,7 +8366,7 @@ function cancel(msg = "") {
 var init_cancel = __esm({
   "packages/design-system/src/prompts/primitives/cancel.ts"() {
     "use strict";
-    init_dist();
+    init_dist3();
     init_output_format();
   }
 });
@@ -8584,7 +8614,7 @@ async function confirm2(opts) {
 }
 async function confirmOrCancel(opts) {
   const result = await confirm2(opts);
-  if (Ct(result)) {
+  if (q(result)) {
     cancel("Operation cancelled.");
     throw new PromptCancelledError();
   }
@@ -8738,6 +8768,126 @@ var init_src6 = __esm({
   }
 });
 
+// packages/agent-spawn/src/acp/session-update-converter.ts
+function createToolRenderState() {
+  return {
+    startedToolCalls: /* @__PURE__ */ new Set(),
+    toolCallKinds: /* @__PURE__ */ new Map(),
+    toolCallTitles: /* @__PURE__ */ new Map()
+  };
+}
+function toRenderKind(kind) {
+  if (kind === "execute") return "exec";
+  if (kind === "write") return "edit";
+  if (kind === "read") return "read";
+  return "other";
+}
+function toToolTitle(title, locations) {
+  if (locations && locations.length > 0 && locations[0].path) {
+    return locations[0].path;
+  }
+  return title;
+}
+function toToolOutput(value) {
+  if (typeof value === "string") return value;
+  if (value === void 0 || value === null) return "";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function extractToolOutputText(update) {
+  const raw = toToolOutput(update.rawOutput);
+  if (raw) return raw;
+  if (!update.content) return "";
+  return update.content.filter((c2) => c2.type === "text" && c2.text).map((c2) => c2.text).join("");
+}
+function sessionUpdateToEvents(update, state) {
+  if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
+    return [{ event: "agent_message", text: update.content.text }];
+  }
+  if (update.sessionUpdate === "agent_thought_chunk" && update.content.type === "text") {
+    return [{ event: "reasoning", text: update.content.text }];
+  }
+  if (update.sessionUpdate === "usage_update") {
+    const cachedTokens = Math.max(0, update.size - update.used);
+    const usage = {
+      event: "usage",
+      inputTokens: update.used,
+      outputTokens: 0
+    };
+    if (cachedTokens > 0) {
+      usage.cachedTokens = cachedTokens;
+    }
+    if (update.cost && update.cost.currency === "USD") {
+      usage.costUsd = update.cost.amount;
+    }
+    return [usage];
+  }
+  if (update.sessionUpdate === "tool_call") {
+    const renderKind = toRenderKind(update.kind);
+    const title = toToolTitle(update.title, update.locations);
+    state.toolCallKinds.set(update.toolCallId, renderKind);
+    state.toolCallTitles.set(update.toolCallId, title);
+    if (state.startedToolCalls.has(update.toolCallId)) {
+      return [];
+    }
+    state.startedToolCalls.add(update.toolCallId);
+    return [{
+      event: "tool_start",
+      kind: renderKind,
+      title,
+      id: update.toolCallId
+    }];
+  }
+  if (update.sessionUpdate === "tool_call_update") {
+    const renderKind = toRenderKind(update.kind ?? void 0) || state.toolCallKinds.get(update.toolCallId) || "other";
+    state.toolCallKinds.set(update.toolCallId, renderKind);
+    const events = [];
+    const toolTitle = toToolTitle(
+      state.toolCallTitles.get(update.toolCallId) ?? update.toolCallId,
+      update.locations
+    );
+    state.toolCallTitles.set(update.toolCallId, toolTitle);
+    const status = update.status;
+    const shouldStart = !state.startedToolCalls.has(update.toolCallId) && (status === "pending" || status === "in_progress");
+    if (shouldStart) {
+      state.startedToolCalls.add(update.toolCallId);
+      events.push({
+        event: "tool_start",
+        kind: renderKind,
+        title: toolTitle,
+        id: update.toolCallId
+      });
+    }
+    if (status === "completed" || status === "failed" || status === "cancelled") {
+      if (!state.startedToolCalls.has(update.toolCallId)) {
+        state.startedToolCalls.add(update.toolCallId);
+        events.push({
+          event: "tool_start",
+          kind: renderKind,
+          title: toolTitle,
+          id: update.toolCallId
+        });
+      }
+      events.push({
+        event: "tool_complete",
+        kind: renderKind,
+        path: extractToolOutputText(update),
+        id: update.toolCallId
+      });
+    }
+    return events;
+  }
+  return [];
+}
+var init_session_update_converter = __esm({
+  "packages/agent-spawn/src/acp/session-update-converter.ts"() {
+    "use strict";
+  }
+});
+
 // packages/agent-spawn/src/acp/renderer.ts
 function writeLine2(line) {
   process.stdout.write(`${line}
@@ -8828,2147 +8978,2042 @@ var init_renderer2 = __esm({
   "packages/agent-spawn/src/acp/renderer.ts"() {
     "use strict";
     init_src6();
+    init_session_update_converter();
   }
 });
 
-// packages/agent-spawn/src/acp/replay.ts
-import path9 from "node:path";
-import { homedir as homedir2 } from "node:os";
-import { open, readdir } from "node:fs/promises";
-import { createInterface as createInterface2 } from "node:readline";
-var init_replay = __esm({
-  "packages/agent-spawn/src/acp/replay.ts"() {
+// packages/poe-acp-client/src/types.ts
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAcpErrorCode(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= -2147483648 && value <= 2147483647;
+}
+function isAcpError(value) {
+  if (value instanceof AcpError) {
+    return true;
+  }
+  if (!isObjectRecord(value)) {
+    return false;
+  }
+  if (!isAcpErrorCode(value.code) || typeof value.message !== "string") {
+    return false;
+  }
+  return value.data === void 0 || Object.prototype.hasOwnProperty.call(value, "data");
+}
+var ACP_ERROR_CODE_PARSE, ACP_ERROR_CODE_INVALID_REQUEST, ACP_ERROR_CODE_METHOD_NOT_FOUND, ACP_ERROR_CODE_INVALID_PARAMS, ACP_ERROR_CODE_INTERNAL, ACP_ERROR_CODE_RESOURCE_NOT_FOUND, AcpError;
+var init_types3 = __esm({
+  "packages/poe-acp-client/src/types.ts"() {
     "use strict";
-    init_renderer2();
+    ACP_ERROR_CODE_PARSE = -32700;
+    ACP_ERROR_CODE_INVALID_REQUEST = -32600;
+    ACP_ERROR_CODE_METHOD_NOT_FOUND = -32601;
+    ACP_ERROR_CODE_INVALID_PARAMS = -32602;
+    ACP_ERROR_CODE_INTERNAL = -32603;
+    ACP_ERROR_CODE_RESOURCE_NOT_FOUND = -32002;
+    AcpError = class extends Error {
+      code;
+      data;
+      constructor(code, message2, data) {
+        super(message2);
+        this.name = "AcpError";
+        this.code = code;
+        if (data !== void 0) {
+          this.data = data;
+        }
+      }
+    };
   }
 });
 
-// packages/agent-spawn/src/adapters/utils.ts
-function truncate2(text4, maxLength) {
-  if (text4.length <= maxLength) return text4;
-  if (maxLength <= 3) return text4.slice(0, maxLength);
-  return `${text4.slice(0, maxLength - 3)}...`;
+// packages/poe-acp-client/src/jsonrpc-message-layer.ts
+function isObjectRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isNonEmptyString(value) {
-  return typeof value === "string" && value.length > 0;
+function hasOwn2(value, property) {
+  return Object.prototype.hasOwnProperty.call(value, property);
 }
-function extractThreadId(value) {
-  if (!value || typeof value !== "object") return;
-  const obj = value;
-  const maybeThreadId = isNonEmptyString(obj.thread_id) && obj.thread_id || isNonEmptyString(obj.threadId) && obj.threadId || isNonEmptyString(obj.threadID) && obj.threadID || isNonEmptyString(obj.session_id) && obj.session_id || isNonEmptyString(obj.sessionId) && obj.sessionId || isNonEmptyString(obj.sessionID) && obj.sessionID;
-  return maybeThreadId || void 0;
+function isRequestId(value) {
+  return value === null || typeof value === "string" || typeof value === "number";
 }
-var init_utils = __esm({
-  "packages/agent-spawn/src/adapters/utils.ts"() {
-    "use strict";
+function toRequestId(value) {
+  return isRequestId(value) ? value : null;
+}
+function parseError() {
+  return new AcpError(ACP_ERROR_CODE_PARSE, "Parse error");
+}
+function invalidRequest() {
+  return new AcpError(ACP_ERROR_CODE_INVALID_REQUEST, "Invalid Request");
+}
+function methodNotFound(method) {
+  return new AcpError(
+    ACP_ERROR_CODE_METHOD_NOT_FOUND,
+    `Method not found: "${method}"`
+  );
+}
+function internalError(message2) {
+  return new AcpError(ACP_ERROR_CODE_INTERNAL, message2);
+}
+function isJsonRpcErrorObject(value) {
+  if (!isObjectRecord2(value)) {
+    return false;
   }
-});
-
-// packages/agent-spawn/src/adapters/claude.ts
-function extractTitle(name, input) {
-  const keys = TITLE_KEYS[name];
-  if (keys && input && typeof input === "object") {
-    const obj = input;
-    for (const key of keys) {
-      const value = obj[key];
-      if (typeof value === "string" && value.length > 0) {
-        return truncate2(value, 80);
-      }
-    }
+  if (!isAcpErrorCode(value.code) || typeof value.message !== "string") {
+    return false;
   }
-  return name;
+  return value.data === void 0 || hasOwn2(value, "data");
 }
-async function* adaptClaude(lines) {
-  const toolKindsById = /* @__PURE__ */ new Map();
-  let emittedSessionStart = false;
-  for await (const rawLine of lines) {
-    const line = rawLine.trim();
-    if (!line) continue;
-    const firstChar = line[0];
-    if (firstChar !== "{" && firstChar !== "[") {
-      continue;
-    }
-    let event;
-    try {
-      event = JSON.parse(line);
-    } catch (error2) {
-      const stack = error2 instanceof Error ? error2.stack : void 0;
-      yield {
-        event: "error",
-        message: `[adaptClaude] Malformed JSON line: ${truncate2(line, 200)}`,
-        stack
-      };
-      continue;
-    }
-    const eventType = event.type;
-    if (!isNonEmptyString(eventType)) continue;
-    if (!emittedSessionStart) {
-      const threadId = extractThreadId(event);
-      emittedSessionStart = true;
-      yield { event: "session_start", threadId };
-    }
-    if (eventType === "result") {
-      const usage = event.usage ?? {};
-      const inputTokens = typeof usage.input_tokens === "number" ? usage.input_tokens : typeof event.input_tokens === "number" ? event.input_tokens : typeof event.num_input_tokens === "number" ? event.num_input_tokens : 0;
-      const outputTokens = typeof usage.output_tokens === "number" ? usage.output_tokens : typeof event.output_tokens === "number" ? event.output_tokens : typeof event.num_output_tokens === "number" ? event.num_output_tokens : 0;
-      const costUsd = typeof usage.cost_usd === "number" ? usage.cost_usd : typeof event.cost_usd === "number" ? event.cost_usd : void 0;
-      yield { event: "usage", inputTokens, outputTokens, costUsd };
-      continue;
-    }
-    if (eventType !== "assistant" && eventType !== "user") continue;
-    const message2 = event.message ?? null;
-    if (!message2 || typeof message2 !== "object") continue;
-    const content = message2.content ?? null;
-    if (!Array.isArray(content)) continue;
-    for (const block of content) {
-      const item = block;
-      if (!item || typeof item !== "object") continue;
-      const blockType = item.type;
-      if (!isNonEmptyString(blockType)) continue;
-      if (eventType === "assistant") {
-        if (blockType === "text" && isNonEmptyString(item.text)) {
-          yield {
-            event: "agent_message",
-            text: item.text
-          };
-          continue;
-        }
-        if (blockType === "tool_use" && isNonEmptyString(item.id) && isNonEmptyString(item.name)) {
-          const kind = TOOL_KIND_MAP[item.name] ?? "other";
-          toolKindsById.set(item.id, kind);
-          yield {
-            event: "tool_start",
-            id: item.id,
-            kind,
-            title: extractTitle(item.name, item.input),
-            input: item.input
-          };
-        }
-        continue;
-      }
-      if (eventType === "user") {
-        if (!isNonEmptyString(item.tool_use_id)) continue;
-        if (blockType !== "tool_result") continue;
-        const kind = toolKindsById.get(item.tool_use_id);
-        toolKindsById.delete(item.tool_use_id);
-        let path54;
-        if (typeof item.content === "string") {
-          path54 = item.content;
-        } else {
-          try {
-            path54 = JSON.stringify(item.content);
-          } catch {
-            path54 = String(item.content);
-          }
-        }
-        yield {
-          event: "tool_complete",
-          id: item.tool_use_id,
-          kind,
-          path: path54
-        };
+function toResponseError(error2) {
+  return new AcpError(error2.code, error2.message, error2.data);
+}
+function toDispatchError(error2) {
+  if (error2 instanceof AcpError) {
+    return error2;
+  }
+  if (isAcpError(error2)) {
+    return new AcpError(error2.code, error2.message, error2.data);
+  }
+  if (error2 instanceof Error && error2.message.length > 0) {
+    return internalError(error2.message);
+  }
+  return internalError("Internal error");
+}
+function chunkToString(chunk) {
+  if (typeof chunk === "string") {
+    return chunk;
+  }
+  if (chunk instanceof Uint8Array) {
+    return Buffer.from(chunk).toString("utf8");
+  }
+  return String(chunk);
+}
+function normalizeLine(line) {
+  return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+async function* readLines(stream) {
+  let buffer = "";
+  for await (const chunk of stream) {
+    buffer += chunkToString(chunk);
+    while (true) {
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex === -1) {
+        break;
       }
+      const line = buffer.slice(0, newlineIndex);
+      buffer = buffer.slice(newlineIndex + 1);
+      yield normalizeLine(line);
     }
   }
+  if (buffer.length > 0) {
+    yield normalizeLine(buffer);
+  }
 }
-var TOOL_KIND_MAP, TITLE_KEYS;
-var init_claude = __esm({
-  "packages/agent-spawn/src/adapters/claude.ts"() {
-    "use strict";
-    init_utils();
-    TOOL_KIND_MAP = {
-      Read: "read",
-      Write: "edit",
-      Edit: "edit",
-      NotebookEdit: "edit",
-      Bash: "exec",
-      Glob: "search",
-      Grep: "search",
-      Task: "think"
+function createResponseMessage(id, result) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    result: result === void 0 ? null : result
+  };
+}
+function createJsonRpcErrorResponse(id, error2) {
+  const response = {
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code: error2.code,
+      message: error2.message
+    }
+  };
+  if (error2.data !== void 0) {
+    response.error.data = error2.data;
+  }
+  return response;
+}
+function serializeJsonRpcMessage(message2) {
+  return `${JSON.stringify(message2)}
+`;
+}
+function parseJsonRpcMessage(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return {
+      type: "invalid",
+      id: null,
+      error: parseError()
     };
-    TITLE_KEYS = {
-      Bash: ["command"],
-      Read: ["file_path"],
-      Write: ["file_path"],
-      Edit: ["file_path"],
-      NotebookEdit: ["notebook_path"],
-      Glob: ["pattern"],
-      Grep: ["pattern"],
-      Task: ["description", "prompt"]
+  }
+  if (!isObjectRecord2(parsed)) {
+    return {
+      type: "invalid",
+      id: null,
+      error: invalidRequest()
     };
   }
-});
-
-// packages/agent-spawn/src/adapters/codex.ts
-async function* adaptCodex(lines) {
-  const toolTitleById = /* @__PURE__ */ new Map();
-  const toolKindById = /* @__PURE__ */ new Map();
-  for await (const rawLine of lines) {
-    const line = rawLine.trim();
-    if (!line) continue;
-    let event;
-    try {
-      event = JSON.parse(line);
-    } catch (error2) {
-      const stack = error2 instanceof Error ? error2.stack : void 0;
-      yield {
-        event: "error",
-        message: `[adaptCodex] Malformed JSON line: ${truncate2(line, 200)}`,
-        stack
+  const id = toRequestId(parsed.id);
+  if (parsed.jsonrpc !== "2.0") {
+    return {
+      type: "invalid",
+      id,
+      error: invalidRequest()
+    };
+  }
+  const hasMethod = hasOwn2(parsed, "method");
+  const hasId = hasOwn2(parsed, "id");
+  if (hasMethod) {
+    if (typeof parsed.method !== "string") {
+      return {
+        type: "invalid",
+        id,
+        error: invalidRequest()
       };
-      continue;
-    }
-    const eventType = event.type;
-    if (!isNonEmptyString(eventType)) continue;
-    if (eventType === "thread.started") {
-      const maybeThreadId = extractThreadId(event);
-      yield { event: "session_start", threadId: maybeThreadId };
-      continue;
     }
-    if (eventType === "turn.started") {
-      continue;
+    if (hasId) {
+      if (!isRequestId(parsed.id)) {
+        return {
+          type: "invalid",
+          id: null,
+          error: invalidRequest()
+        };
+      }
+      const request = {
+        jsonrpc: "2.0",
+        id: parsed.id,
+        method: parsed.method
+      };
+      if (hasOwn2(parsed, "params")) {
+        request.params = parsed.params;
+      }
+      return { type: "request", message: request };
     }
-    if (eventType === "turn.completed") {
-      const usage = event.usage ?? {};
-      const inputTokens = typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
-      const outputTokens = typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
-      const cachedTokens = typeof usage.cached_input_tokens === "number" ? usage.cached_input_tokens : 0;
-      yield { event: "usage", inputTokens, outputTokens, cachedTokens };
-      continue;
-    }
-    if (eventType === "turn.failed") {
-      const message2 = extractErrorMessage(event) ?? "Turn failed";
-      yield { event: "error", message: message2 };
-      continue;
-    }
-    const item = event.item ?? null;
-    if (!item || typeof item !== "object") continue;
-    const itemType = item.type;
-    if (!isNonEmptyString(itemType)) continue;
-    if (eventType === "item.started") {
-      if (!isNonEmptyString(item.id)) continue;
-      let kind;
-      let title;
-      if (itemType === "command_execution") {
-        kind = "exec";
-        title = truncate2(isNonEmptyString(item.command) ? item.command : "", 80);
-      } else if (itemType === "file_edit") {
-        kind = "edit";
-        title = isNonEmptyString(item.path) ? item.path : "";
-      } else if (itemType === "thinking") {
-        kind = "think";
-        title = "thinking...";
-      } else if (itemType === "mcp_tool_call") {
-        const server = isNonEmptyString(item.server) ? item.server : "unknown";
-        const tool = isNonEmptyString(item.tool) ? item.tool : "unknown";
-        kind = "other";
-        title = `${server}.${tool}`;
-      }
-      if (kind && title !== void 0) {
-        toolTitleById.set(item.id, title);
-        toolKindById.set(item.id, kind);
-        yield { event: "tool_start", id: item.id, kind, title };
-      }
-      continue;
-    }
-    if (eventType === "item.completed") {
-      if (itemType === "agent_message") {
-        if (!isNonEmptyString(item.text)) continue;
-        yield { event: "agent_message", text: item.text };
-        continue;
-      }
-      if (itemType === "reasoning") {
-        const text4 = isNonEmptyString(item.text) ? item.text : isNonEmptyString(item.content) ? item.content : isNonEmptyString(item.summary) ? item.summary : void 0;
-        if (!text4) continue;
-        yield { event: "reasoning", text: text4 };
-        continue;
-      }
-      if (!isNonEmptyString(item.id)) continue;
-      if (itemType === "command_execution" || itemType === "file_edit" || itemType === "mcp_tool_call") {
-        const kindFromStart = toolKindById.get(item.id);
-        const kind = kindFromStart ?? (itemType === "command_execution" ? "exec" : itemType === "file_edit" ? "edit" : "other");
-        const titleFromEvent = isNonEmptyString(item.path) ? item.path : itemType === "mcp_tool_call" ? `${isNonEmptyString(item.server) ? item.server : "unknown"}.${isNonEmptyString(item.tool) ? item.tool : "unknown"}` : void 0;
-        const path54 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
-        toolTitleById.delete(item.id);
-        toolKindById.delete(item.id);
-        yield { event: "tool_complete", id: item.id, kind, path: path54 };
-      }
+    const notification = {
+      jsonrpc: "2.0",
+      method: parsed.method
+    };
+    if (hasOwn2(parsed, "params")) {
+      notification.params = parsed.params;
     }
+    return {
+      type: "notification",
+      message: notification
+    };
   }
-}
-function extractErrorMessage(event) {
-  if (isNonEmptyString(event.message)) return event.message;
-  const error2 = event.error;
-  if (isNonEmptyString(error2)) return error2;
-  if (typeof error2 === "object" && error2 !== null) {
-    const errorObj = error2;
-    if (isNonEmptyString(errorObj.message)) return errorObj.message;
+  if (!hasId || !isRequestId(parsed.id)) {
+    return {
+      type: "invalid",
+      id,
+      error: invalidRequest()
+    };
   }
-  if (isNonEmptyString(event.reason)) return event.reason;
-  return void 0;
-}
-var init_codex3 = __esm({
-  "packages/agent-spawn/src/adapters/codex.ts"() {
-    "use strict";
-    init_utils();
+  const hasResult = hasOwn2(parsed, "result");
+  const hasError = hasOwn2(parsed, "error");
+  if (hasResult === hasError) {
+    return {
+      type: "invalid",
+      id: parsed.id,
+      error: invalidRequest()
+    };
   }
-});
-
-// packages/agent-spawn/src/adapters/kimi.ts
-async function* adaptKimi(lines) {
-  let emittedSessionStart = false;
-  for await (const rawLine of lines) {
-    const line = rawLine.trim();
-    if (!line) continue;
-    let event;
-    try {
-      event = JSON.parse(line);
-    } catch (error2) {
-      const stack = error2 instanceof Error ? error2.stack : void 0;
-      yield {
-        event: "error",
-        message: `[adaptKimi] Malformed JSON line: ${truncate2(line, 200)}`,
-        stack
-      };
-      continue;
-    }
-    if (!event || typeof event !== "object") continue;
-    if (!emittedSessionStart) {
-      const threadId = extractThreadId(event);
-      if (threadId) {
-        emittedSessionStart = true;
-        yield { event: "session_start", threadId };
+  if (hasResult) {
+    return {
+      type: "response",
+      message: {
+        jsonrpc: "2.0",
+        id: parsed.id,
+        result: parsed.result
       }
-    }
-    const role = event.role;
-    if (!isNonEmptyString(role) || role !== "assistant") continue;
-    const content = event.content;
-    if (!isNonEmptyString(content)) continue;
-    yield { event: "agent_message", text: content };
+    };
   }
-}
-var init_kimi3 = __esm({
-  "packages/agent-spawn/src/adapters/kimi.ts"() {
-    "use strict";
-    init_utils();
+  if (!isJsonRpcErrorObject(parsed.error)) {
+    return {
+      type: "invalid",
+      id: parsed.id,
+      error: invalidRequest()
+    };
   }
-});
-
-// packages/agent-spawn/src/adapters/native.ts
-async function* adaptNative(lines) {
-  for await (const rawLine of lines) {
-    const line = rawLine.trim();
-    if (!line) continue;
-    let event;
-    try {
-      event = JSON.parse(line);
-    } catch (error2) {
-      const stack = error2 instanceof Error ? error2.stack : void 0;
-      yield {
-        event: "error",
-        message: `[adaptNative] Malformed JSON line: ${truncate2(line, 200)}`,
-        stack
-      };
-      continue;
-    }
-    const maybeEventType = event?.event;
-    if (!isNonEmptyString(maybeEventType)) {
-      yield {
-        event: "error",
-        message: `[adaptNative] Line missing string "event" field: ${truncate2(line, 200)}`
-      };
-      continue;
+  return {
+    type: "response",
+    message: {
+      jsonrpc: "2.0",
+      id: parsed.id,
+      error: parsed.error
     }
-    yield event;
-  }
+  };
 }
-var init_native = __esm({
-  "packages/agent-spawn/src/adapters/native.ts"() {
+var JsonRpcMessageLayer;
+var init_jsonrpc_message_layer = __esm({
+  "packages/poe-acp-client/src/jsonrpc-message-layer.ts"() {
     "use strict";
-    init_utils();
-  }
-});
-
-// packages/agent-spawn/src/adapters/opencode.ts
-function guessToolKind(toolName) {
-  const normalized = toolName.toLowerCase();
-  if (normalized === "bash" || normalized === "shell" || normalized === "sh") return "exec";
-  if (normalized.includes("read")) return "read";
-  if (normalized.includes("write") || normalized.includes("edit") || normalized.includes("patch")) {
-    return "edit";
-  }
-  if (normalized.includes("search") || normalized.includes("grep") || normalized.includes("glob") || normalized.includes("find")) {
-    return "search";
-  }
-  if (normalized.includes("think") || normalized.includes("task")) return "think";
-  return "other";
-}
-function safeStringify(value) {
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-async function* adaptOpenCode(lines) {
-  let emittedSessionStart = false;
-  const toolKindById = /* @__PURE__ */ new Map();
-  for await (const rawLine of lines) {
-    const line = rawLine.trim();
-    if (!line) continue;
-    let event;
-    try {
-      event = JSON.parse(line);
-    } catch (error2) {
-      const stack = error2 instanceof Error ? error2.stack : void 0;
-      yield {
-        event: "error",
-        message: `[adaptOpenCode] Malformed JSON line: ${truncate2(line, 200)}`,
-        stack
-      };
-      continue;
-    }
-    if (!event || typeof event !== "object") continue;
-    const sessionID = extractThreadId(event);
-    if (!emittedSessionStart && isNonEmptyString(sessionID)) {
-      emittedSessionStart = true;
-      yield { event: "session_start", threadId: sessionID };
-    }
-    const eventType = event.type;
-    if (!isNonEmptyString(eventType)) continue;
-    if (eventType === "text") {
-      const part = event.part ?? null;
-      if (!part || typeof part !== "object") continue;
-      if (!isNonEmptyString(part.text)) continue;
-      yield { event: "agent_message", text: part.text };
-      continue;
-    }
-    if (eventType === "tool_use") {
-      const part = event.part ?? null;
-      if (!part || typeof part !== "object") continue;
-      if (!isNonEmptyString(part.callID) || !isNonEmptyString(part.tool)) continue;
-      const state = part.state ?? null;
-      if (!state || typeof state !== "object") continue;
-      const kind = guessToolKind(part.tool);
-      const status = state.status;
-      const terminal = status === "completed" || status === "failed";
-      if (!toolKindById.has(part.callID)) {
-        toolKindById.set(part.callID, kind);
-        let title = part.tool;
-        const maybeInput = state.input;
-        if (kind === "exec" && maybeInput && typeof maybeInput === "object") {
-          const command = maybeInput.command;
-          if (isNonEmptyString(command)) {
-            title = truncate2(command, 80);
-          }
-        }
-        yield {
-          event: "tool_start",
-          id: part.callID,
-          kind,
-          title,
-          input: state.input
+    init_types3();
+    JsonRpcMessageLayer = class {
+      input;
+      output;
+      requestHandlers = /* @__PURE__ */ new Map();
+      notificationHandlers = /* @__PURE__ */ new Map();
+      pending = /* @__PURE__ */ new Map();
+      nextRequestId;
+      disposed = false;
+      constructor(options) {
+        this.input = options.input;
+        this.output = options.output;
+        this.nextRequestId = options.firstRequestId ?? 1;
+        if (!Number.isFinite(this.nextRequestId)) {
+          throw new Error("firstRequestId must be a finite number");
+        }
+        void this.consumeInput();
+      }
+      onRequest(method, handler) {
+        this.requestHandlers.set(method, handler);
+      }
+      onNotification(method, handler) {
+        this.notificationHandlers.set(method, handler);
+      }
+      pendingRequestCount() {
+        return this.pending.size;
+      }
+      sendNotification(method, params) {
+        const notification = {
+          jsonrpc: "2.0",
+          method
         };
+        if (params !== void 0) {
+          notification.params = params;
+        }
+        this.sendMessage(notification);
       }
-      if (terminal) {
-        const kindFromStart = toolKindById.get(part.callID) ?? kind;
-        toolKindById.delete(part.callID);
-        yield {
-          event: "tool_complete",
-          id: part.callID,
-          kind: kindFromStart,
-          path: safeStringify(state.output)
+      sendRequest(method, params, options = {}) {
+        if (this.disposed) {
+          throw new Error("JSON-RPC message layer is disposed");
+        }
+        const id = options.id === void 0 ? this.nextRequestId++ : options.id;
+        if (this.pending.has(id)) {
+          throw new Error(`A request with id ${JSON.stringify(id)} is already pending`);
+        }
+        const request = {
+          jsonrpc: "2.0",
+          id,
+          method
         };
+        if (params !== void 0) {
+          request.params = params;
+        }
+        return new Promise((resolve2, reject) => {
+          this.pending.set(id, {
+            method,
+            resolve: resolve2,
+            reject
+          });
+          try {
+            this.sendMessage(request);
+          } catch (error2) {
+            this.pending.delete(id);
+            reject(error2);
+          }
+        });
+      }
+      dispose(reason = new Error("JSON-RPC message layer disposed")) {
+        if (this.disposed) {
+          return;
+        }
+        this.disposed = true;
+        this.rejectAllPending(reason);
+      }
+      async consumeInput() {
+        try {
+          for await (const line of readLines(this.input)) {
+            if (this.disposed || line.length === 0) {
+              continue;
+            }
+            await this.handleIncomingLine(line);
+          }
+          if (!this.disposed) {
+            this.dispose(new Error("JSON-RPC input stream closed"));
+          }
+        } catch (error2) {
+          if (!this.disposed) {
+            this.dispose(
+              error2 instanceof Error ? error2 : new Error(`JSON-RPC input stream failed: ${String(error2)}`)
+            );
+          }
+        }
+      }
+      async handleIncomingLine(line) {
+        const parsed = parseJsonRpcMessage(line);
+        if (parsed.type === "invalid") {
+          this.sendMessage(createJsonRpcErrorResponse(parsed.id, parsed.error));
+          return;
+        }
+        if (parsed.type === "response") {
+          this.handleResponse(parsed.message);
+          return;
+        }
+        if (parsed.type === "notification") {
+          await this.handleNotification(parsed.message);
+          return;
+        }
+        await this.handleRequest(parsed.message);
+      }
+      handleResponse(message2) {
+        const pending = this.pending.get(message2.id);
+        if (!pending) {
+          return;
+        }
+        this.pending.delete(message2.id);
+        if ("error" in message2) {
+          pending.reject(toResponseError(message2.error));
+          return;
+        }
+        pending.resolve(message2.result);
+      }
+      async handleRequest(message2) {
+        const handler = this.requestHandlers.get(message2.method);
+        if (!handler) {
+          this.sendMessage(createJsonRpcErrorResponse(message2.id, methodNotFound(message2.method)));
+          return;
+        }
+        try {
+          const result = await handler(message2.params, {
+            id: message2.id,
+            method: message2.method
+          });
+          this.sendMessage(createResponseMessage(message2.id, result));
+        } catch (error2) {
+          this.sendMessage(createJsonRpcErrorResponse(message2.id, toDispatchError(error2)));
+        }
+      }
+      async handleNotification(message2) {
+        const handler = this.notificationHandlers.get(message2.method);
+        if (!handler) {
+          return;
+        }
+        try {
+          await handler(message2.params, { method: message2.method });
+        } catch {
+        }
+      }
+      sendMessage(message2) {
+        if (this.disposed) {
+          throw new Error("JSON-RPC message layer is disposed");
+        }
+        this.output.write(serializeJsonRpcMessage(message2));
+      }
+      rejectAllPending(error2) {
+        for (const pending of this.pending.values()) {
+          pending.reject(error2);
+        }
+        this.pending.clear();
       }
-      continue;
-    }
-    if (eventType === "step_finish") {
-      const part = event.part ?? null;
-      if (!part || typeof part !== "object") continue;
-      const tokens = part.tokens ?? null;
-      if (!tokens || typeof tokens !== "object") continue;
-      const inputTokens = typeof tokens.input === "number" ? tokens.input : 0;
-      const outputTokens = typeof tokens.output === "number" ? tokens.output : 0;
-      const cache = tokens.cache ?? null;
-      const cachedTokens = cache && typeof cache === "object" && typeof cache.read === "number" ? cache.read : void 0;
-      if (inputTokens === 0 && outputTokens === 0 && cachedTokens === void 0) continue;
-      yield { event: "usage", inputTokens, outputTokens, cachedTokens };
-      continue;
-    }
-  }
-}
-var init_opencode3 = __esm({
-  "packages/agent-spawn/src/adapters/opencode.ts"() {
-    "use strict";
-    init_utils();
-  }
-});
-
-// packages/agent-spawn/src/adapters/index.ts
-function getAdapter(type) {
-  const adapter = adapters[type];
-  if (!adapter) {
-    throw new Error(`Unknown adapter "${String(type)}".`);
-  }
-  return adapter;
-}
-var adapters;
-var init_adapters = __esm({
-  "packages/agent-spawn/src/adapters/index.ts"() {
-    "use strict";
-    init_claude();
-    init_codex3();
-    init_kimi3();
-    init_native();
-    init_opencode3();
-    init_codex3();
-    init_claude();
-    init_kimi3();
-    init_native();
-    init_opencode3();
-    adapters = {
-      codex: adaptCodex,
-      claude: adaptClaude,
-      kimi: adaptKimi,
-      native: adaptNative,
-      opencode: adaptOpenCode
     };
   }
 });
 
-// packages/agent-spawn/src/acp/line-reader.ts
-function chunkToString(chunk) {
-  if (typeof chunk === "string") return chunk;
-  if (chunk instanceof Uint8Array) return Buffer.from(chunk).toString("utf8");
-  return String(chunk);
-}
-async function* readLines(stream) {
-  let buffer = "";
-  for await (const chunk of stream) {
-    buffer += chunkToString(chunk);
-    while (true) {
-      const newlineIndex = buffer.indexOf("\n");
-      if (newlineIndex === -1) break;
-      yield buffer.slice(0, newlineIndex);
-      buffer = buffer.slice(newlineIndex + 1);
-    }
-  }
-  if (buffer.length > 0) {
-    yield buffer;
+// packages/poe-acp-client/src/acp-transport.ts
+import {
+  spawn as spawnChildProcess3
+} from "node:child_process";
+function assertExtensionMethod(method) {
+  if (!method.startsWith("_")) {
+    throw new Error('Extension method must start with "_"');
   }
 }
-var init_line_reader = __esm({
-  "packages/agent-spawn/src/acp/line-reader.ts"() {
+var AcpTransport;
+var init_acp_transport = __esm({
+  "packages/poe-acp-client/src/acp-transport.ts"() {
     "use strict";
-  }
-});
-
-// packages/agent-spawn/src/acp/spawn.ts
-import { spawn as spawnChildProcess3 } from "node:child_process";
-function createAbortError2() {
-  const error2 = new Error("Agent spawn aborted");
-  error2.name = "AbortError";
-  return error2;
+    init_jsonrpc_message_layer();
+    AcpTransport = class {
+      closed;
+      command;
+      child;
+      layer;
+      stderrChunks = [];
+      resolveClosed = null;
+      closeEvent = null;
+      closeReason = null;
+      constructor(options) {
+        const {
+          command,
+          args = [],
+          cwd,
+          env,
+          firstRequestId,
+          spawn: spawn9 = spawnChildProcess3
+        } = options;
+        this.command = command;
+        this.closed = new Promise((resolve2) => {
+          this.resolveClosed = resolve2;
+        });
+        this.child = spawn9(command, [...args], {
+          cwd,
+          env,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        this.child.stderr.setEncoding("utf8");
+        this.child.stderr.on("data", (chunk) => {
+          this.stderrChunks.push(String(chunk));
+        });
+        this.child.stdin.on("error", (error2) => {
+          const reason = error2 instanceof Error ? error2 : new Error(String(error2));
+          this.close(reason, this.child.exitCode ?? null, this.child.signalCode ?? null);
+        });
+        this.layer = new JsonRpcMessageLayer({
+          input: this.child.stdout,
+          output: this.child.stdin,
+          firstRequestId
+        });
+        this.child.once("error", (error2) => {
+          const reason = error2 instanceof Error ? error2 : new Error(String(error2));
+          this.close(reason, this.child.exitCode ?? null, this.child.signalCode ?? null);
+        });
+        this.child.once("close", (code, signal) => {
+          const reason = this.closeReason ?? new Error(
+            `ACP transport closed (command "${this.command}", code: ${code ?? "null"}${signal ? `, signal: ${signal}` : ""})`
+          );
+          this.close(reason, code ?? null, signal ?? null);
+        });
+      }
+      sendRequest(method, params, options = {}) {
+        return this.layer.sendRequest(method, params, options);
+      }
+      sendExtRequest(method, params, options = {}) {
+        assertExtensionMethod(method);
+        return this.layer.sendRequest(method, params, options);
+      }
+      sendNotification(method, params) {
+        this.layer.sendNotification(method, params);
+      }
+      sendExtNotification(method, params) {
+        assertExtensionMethod(method);
+        this.layer.sendNotification(method, params);
+      }
+      onRequest(method, handler) {
+        this.layer.onRequest(method, handler);
+      }
+      onExtRequest(method, handler) {
+        assertExtensionMethod(method);
+        this.layer.onRequest(method, handler);
+      }
+      onNotification(method, handler) {
+        this.layer.onNotification(method, handler);
+      }
+      onExtNotification(method, handler) {
+        assertExtensionMethod(method);
+        this.layer.onNotification(method, handler);
+      }
+      getStderrOutput() {
+        return this.stderrChunks.join("");
+      }
+      pendingRequestCount() {
+        return this.layer.pendingRequestCount();
+      }
+      dispose(reason = new Error("ACP transport disposed")) {
+        if (this.closeEvent !== null) {
+          return;
+        }
+        this.closeReason = reason;
+        this.layer.dispose(reason);
+        if (!this.child.stdin.destroyed && !this.child.stdin.writableEnded) {
+          this.child.stdin.end();
+        }
+        if (this.child.exitCode !== null || this.child.signalCode !== null) {
+          this.close(reason, this.child.exitCode, this.child.signalCode);
+          return;
+        }
+        const killed = this.child.kill();
+        if (!killed) {
+          this.close(reason, this.child.exitCode, this.child.signalCode);
+        }
+      }
+      close(reason, code, signal) {
+        if (this.closeEvent !== null) {
+          return;
+        }
+        this.layer.dispose(reason);
+        this.closeEvent = {
+          code,
+          signal,
+          reason,
+          stderr: this.getStderrOutput()
+        };
+        this.resolveClosed?.(this.closeEvent);
+        this.resolveClosed = null;
+      }
+    };
+  }
+});
+
+// packages/poe-acp-client/src/acp-client.ts
+import { isAbsolute } from "node:path";
+function toError(reason) {
+  return reason instanceof Error ? reason : new Error(String(reason));
 }
-function createActivityTimeoutError2(timeoutMs) {
-  const error2 = new Error(
-    `Agent spawn timed out after ${timeoutMs / 1e3}s of inactivity`
+function invalidParams(message2) {
+  return new AcpError(
+    ACP_ERROR_CODE_INVALID_PARAMS,
+    `Invalid params: ${message2}`
   );
-  error2.name = "ActivityTimeoutError";
-  return error2;
 }
-function isAcpEvent(value) {
-  return !!value && typeof value === "object" && "event" in value;
-}
-function getDefaultArgsPosition2(config) {
-  return config.defaultArgsPosition ?? "afterPrompt";
+function resourceNotFound(resource) {
+  return new AcpError(
+    ACP_ERROR_CODE_RESOURCE_NOT_FOUND,
+    `Resource not found: ${resource}`
+  );
 }
-function getMcpArgsPosition2(config) {
-  if (config.mcpArgsPosition) {
-    return config.mcpArgsPosition;
+function assertAbsolutePath(path54) {
+  if (!isAbsolute(path54)) {
+    throw invalidParams('"path" must be an absolute path');
   }
-  return config.mcpArgsBeforeCommand ? "beforeCommand" : "afterCommand";
 }
-function spawnStreaming(options) {
-  if (options.signal?.aborted) {
-    throw createAbortError2();
-  }
-  const { agentId, binaryName, spawnConfig } = resolveConfig(options.agentId);
-  if (spawnConfig === void 0) {
-    throw new Error(`Agent "${agentId}" has no spawn config.`);
-  }
-  if (spawnConfig.kind !== "cli") {
-    throw new Error(`Agent "${agentId}" does not support CLI spawn.`);
-  }
-  if (!binaryName) {
-    throw new Error(`Agent "${agentId}" has no binaryName.`);
-  }
-  const mcpArgs = getMcpArgs(spawnConfig, options.mcpServers);
-  const mcpEnvVars = getMcpEnv(spawnConfig, options.mcpServers);
-  const defaultArgsPosition = getDefaultArgsPosition2(spawnConfig);
-  const mcpArgsPosition = getMcpArgsPosition2(spawnConfig);
-  const args = [];
-  if (mcpArgsPosition === "beforeCommand") {
-    args.push(...mcpArgs);
-  }
-  if (defaultArgsPosition === "beforePrompt") {
-    args.push(...spawnConfig.defaultArgs);
-  }
-  if (mcpArgsPosition === "beforePrompt") {
-    args.push(...mcpArgs);
-  }
-  args.push(spawnConfig.promptFlag);
-  const useStdin = !!options.useStdin && !!spawnConfig.stdinMode;
-  if (!useStdin || !spawnConfig.stdinMode?.omitPrompt) {
-    args.push(options.prompt);
-  }
-  if (options.model && spawnConfig.modelFlag) {
-    let model = spawnConfig.modelStripProviderPrefix ? stripModelNamespace(options.model) : options.model;
-    if (spawnConfig.modelTransform) model = spawnConfig.modelTransform(model);
-    args.push(spawnConfig.modelFlag, model);
-  }
-  if (defaultArgsPosition === "afterPrompt") {
-    args.push(...spawnConfig.defaultArgs);
-  }
-  if (mcpArgsPosition === "afterCommand") {
-    args.push(...mcpArgs);
+function assertOneBasedLineNumber(line) {
+  if (line === null || line === void 0) {
+    return;
   }
-  const modeResolved = resolveModeConfig(spawnConfig.modes[options.mode ?? "yolo"]);
-  args.push(...modeResolved.args);
-  if (useStdin) {
-    args.push(...spawnConfig.stdinMode.extraArgs);
+  if (!Number.isInteger(line) || line < 1) {
+    throw invalidParams('"line" must be a 1-based integer');
   }
-  if (options.args && options.args.length > 0) {
-    args.push(...options.args);
+}
+function assertExtensionMethod2(method) {
+  if (!method.startsWith("_")) {
+    throw new Error('Extension method must start with "_"');
   }
-  const envOverrides = { ...mcpEnvVars, ...modeResolved.env };
-  const child = spawnChildProcess3(binaryName, args, {
-    cwd: options.cwd,
-    stdio: ["pipe", "pipe", "pipe"],
-    env: Object.keys(envOverrides).length > 0 ? { ...process.env, ...envOverrides } : void 0
-  });
-  let aborted = false;
-  let timedOut = false;
-  const onAbort = () => {
-    aborted = true;
-    child.kill("SIGTERM");
+}
+function isInjectedTransportOptions(options) {
+  return "transport" in options;
+}
+function createAsyncQueue() {
+  const values = [];
+  const waiters = [];
+  let closed = false;
+  let failure = null;
+  const resolveOne = (value) => {
+    const waiter = waiters.shift();
+    if (!waiter) {
+      return false;
+    }
+    waiter.resolve({ done: false, value });
+    return true;
   };
-  options.signal?.addEventListener("abort", onAbort, { once: true });
-  let activityTimer;
-  const resetActivityTimer = options.activityTimeoutMs ? () => {
-    if (activityTimer) clearTimeout(activityTimer);
-    activityTimer = setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGTERM");
-    }, options.activityTimeoutMs);
-  } : void 0;
-  resetActivityTimer?.();
-  const result = { stdout: "", stderr: "", exitCode: 1 };
-  child.stderr.setEncoding("utf8");
-  child.stderr.on("data", (chunk) => {
-    result.stderr += chunk;
-    resetActivityTimer?.();
-  });
-  if (useStdin) {
-    child.stdin.write(options.prompt);
-  }
-  child.stdin.end();
-  const adapter = getAdapter(spawnConfig.adapter);
-  const events = (async function* () {
-    for await (const output of adapter(readLines(child.stdout))) {
-      if (!isAcpEvent(output)) continue;
-      resetActivityTimer?.();
-      yield output;
-    }
-  })();
-  const done = new Promise((resolve2, reject) => {
-    child.on("error", (error2) => {
-      options.signal?.removeEventListener("abort", onAbort);
-      if (activityTimer) clearTimeout(activityTimer);
-      if (aborted) {
-        reject(createAbortError2());
+  const iterator = {
+    push(value) {
+      if (closed || failure) {
         return;
       }
-      reject(error2);
-    });
-    child.on("close", (code) => {
-      options.signal?.removeEventListener("abort", onAbort);
-      if (activityTimer) clearTimeout(activityTimer);
-      if (aborted) {
-        reject(createAbortError2());
+      if (!resolveOne(value)) {
+        values.push(value);
+      }
+    },
+    complete() {
+      if (closed || failure) {
         return;
       }
-      if (timedOut) {
-        reject(createActivityTimeoutError2(options.activityTimeoutMs));
+      closed = true;
+      while (waiters.length > 0) {
+        waiters.shift()?.resolve({ done: true, value: void 0 });
+      }
+    },
+    fail(error2) {
+      if (closed || failure) {
         return;
       }
-      result.exitCode = code ?? 1;
-      resolve2(result);
-    });
-  });
-  return { events, done };
-}
-var init_spawn2 = __esm({
-  "packages/agent-spawn/src/acp/spawn.ts"() {
-    "use strict";
-    init_adapters();
-    init_line_reader();
-    init_resolve_config();
-    init_mcp_args();
-    init_model_utils();
-    init_types2();
-  }
-});
-
-// packages/poe-acp-client/src/types.ts
-function isObjectRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isAcpErrorCode(value) {
-  return typeof value === "number" && Number.isInteger(value) && value >= -2147483648 && value <= 2147483647;
-}
-function isAcpError(value) {
-  if (value instanceof AcpError) {
-    return true;
-  }
-  if (!isObjectRecord(value)) {
-    return false;
-  }
-  if (!isAcpErrorCode(value.code) || typeof value.message !== "string") {
-    return false;
-  }
-  return value.data === void 0 || Object.prototype.hasOwnProperty.call(value, "data");
-}
-var ACP_ERROR_CODE_PARSE, ACP_ERROR_CODE_INVALID_REQUEST, ACP_ERROR_CODE_METHOD_NOT_FOUND, ACP_ERROR_CODE_INVALID_PARAMS, ACP_ERROR_CODE_INTERNAL, ACP_ERROR_CODE_RESOURCE_NOT_FOUND, AcpError;
-var init_types3 = __esm({
-  "packages/poe-acp-client/src/types.ts"() {
-    "use strict";
-    ACP_ERROR_CODE_PARSE = -32700;
-    ACP_ERROR_CODE_INVALID_REQUEST = -32600;
-    ACP_ERROR_CODE_METHOD_NOT_FOUND = -32601;
-    ACP_ERROR_CODE_INVALID_PARAMS = -32602;
-    ACP_ERROR_CODE_INTERNAL = -32603;
-    ACP_ERROR_CODE_RESOURCE_NOT_FOUND = -32002;
-    AcpError = class extends Error {
-      code;
-      data;
-      constructor(code, message2, data) {
-        super(message2);
-        this.name = "AcpError";
-        this.code = code;
-        if (data !== void 0) {
-          this.data = data;
-        }
+      failure = error2;
+      while (waiters.length > 0) {
+        waiters.shift()?.reject(error2);
       }
-    };
-  }
-});
-
-// packages/poe-acp-client/src/jsonrpc-message-layer.ts
-function isObjectRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function hasOwn2(value, property) {
-  return Object.prototype.hasOwnProperty.call(value, property);
-}
-function isRequestId(value) {
-  return value === null || typeof value === "string" || typeof value === "number";
-}
-function toRequestId(value) {
-  return isRequestId(value) ? value : null;
-}
-function parseError() {
-  return new AcpError(ACP_ERROR_CODE_PARSE, "Parse error");
-}
-function invalidRequest() {
-  return new AcpError(ACP_ERROR_CODE_INVALID_REQUEST, "Invalid Request");
-}
-function methodNotFound(method) {
-  return new AcpError(
-    ACP_ERROR_CODE_METHOD_NOT_FOUND,
-    `Method not found: "${method}"`
-  );
-}
-function internalError(message2) {
-  return new AcpError(ACP_ERROR_CODE_INTERNAL, message2);
-}
-function isJsonRpcErrorObject(value) {
-  if (!isObjectRecord2(value)) {
-    return false;
-  }
-  if (!isAcpErrorCode(value.code) || typeof value.message !== "string") {
-    return false;
-  }
-  return value.data === void 0 || hasOwn2(value, "data");
-}
-function toResponseError(error2) {
-  return new AcpError(error2.code, error2.message, error2.data);
-}
-function toDispatchError(error2) {
-  if (error2 instanceof AcpError) {
-    return error2;
-  }
-  if (isAcpError(error2)) {
-    return new AcpError(error2.code, error2.message, error2.data);
-  }
-  if (error2 instanceof Error && error2.message.length > 0) {
-    return internalError(error2.message);
-  }
-  return internalError("Internal error");
-}
-function chunkToString2(chunk) {
-  if (typeof chunk === "string") {
-    return chunk;
-  }
-  if (chunk instanceof Uint8Array) {
-    return Buffer.from(chunk).toString("utf8");
-  }
-  return String(chunk);
-}
-function normalizeLine(line) {
-  return line.endsWith("\r") ? line.slice(0, -1) : line;
-}
-async function* readLines2(stream) {
-  let buffer = "";
-  for await (const chunk of stream) {
-    buffer += chunkToString2(chunk);
-    while (true) {
-      const newlineIndex = buffer.indexOf("\n");
-      if (newlineIndex === -1) {
-        break;
+    },
+    async next() {
+      if (values.length > 0) {
+        const value = values.shift();
+        return { done: false, value };
       }
-      const line = buffer.slice(0, newlineIndex);
-      buffer = buffer.slice(newlineIndex + 1);
-      yield normalizeLine(line);
-    }
-  }
-  if (buffer.length > 0) {
-    yield normalizeLine(buffer);
-  }
-}
-function createResponseMessage(id, result) {
-  return {
-    jsonrpc: "2.0",
-    id,
-    result: result === void 0 ? null : result
-  };
-}
-function createJsonRpcErrorResponse(id, error2) {
-  const response = {
-    jsonrpc: "2.0",
-    id,
-    error: {
-      code: error2.code,
-      message: error2.message
+      if (failure) {
+        throw failure;
+      }
+      if (closed) {
+        return { done: true, value: void 0 };
+      }
+      return new Promise((resolve2, reject) => {
+        waiters.push({ resolve: resolve2, reject });
+      });
+    },
+    async return() {
+      iterator.complete();
+      return { done: true, value: void 0 };
+    },
+    async throw(error2) {
+      const normalizedError = toError(error2);
+      iterator.fail(normalizedError);
+      throw normalizedError;
+    },
+    [Symbol.asyncIterator]() {
+      return iterator;
     }
   };
-  if (error2.data !== void 0) {
-    response.error.data = error2.data;
-  }
-  return response;
-}
-function serializeJsonRpcMessage(message2) {
-  return `${JSON.stringify(message2)}
-`;
+  return iterator;
 }
-function parseJsonRpcMessage(line) {
-  let parsed;
-  try {
-    parsed = JSON.parse(line);
-  } catch {
-    return {
-      type: "invalid",
-      id: null,
-      error: parseError()
-    };
-  }
-  if (!isObjectRecord2(parsed)) {
-    return {
-      type: "invalid",
-      id: null,
-      error: invalidRequest()
-    };
-  }
-  const id = toRequestId(parsed.id);
-  if (parsed.jsonrpc !== "2.0") {
-    return {
-      type: "invalid",
-      id,
-      error: invalidRequest()
-    };
-  }
-  const hasMethod = hasOwn2(parsed, "method");
-  const hasId = hasOwn2(parsed, "id");
-  if (hasMethod) {
-    if (typeof parsed.method !== "string") {
-      return {
-        type: "invalid",
-        id,
-        error: invalidRequest()
-      };
-    }
-    if (hasId) {
-      if (!isRequestId(parsed.id)) {
-        return {
-          type: "invalid",
-          id: null,
-          error: invalidRequest()
-        };
-      }
-      const request = {
-        jsonrpc: "2.0",
-        id: parsed.id,
-        method: parsed.method
-      };
-      if (hasOwn2(parsed, "params")) {
-        request.params = parsed.params;
-      }
-      return { type: "request", message: request };
-    }
-    const notification = {
-      jsonrpc: "2.0",
-      method: parsed.method
-    };
-    if (hasOwn2(parsed, "params")) {
-      notification.params = parsed.params;
-    }
-    return {
-      type: "notification",
-      message: notification
-    };
-  }
-  if (!hasId || !isRequestId(parsed.id)) {
-    return {
-      type: "invalid",
-      id,
-      error: invalidRequest()
-    };
-  }
-  const hasResult = hasOwn2(parsed, "result");
-  const hasError = hasOwn2(parsed, "error");
-  if (hasResult === hasError) {
-    return {
-      type: "invalid",
-      id: parsed.id,
-      error: invalidRequest()
-    };
-  }
-  if (hasResult) {
-    return {
-      type: "response",
-      message: {
-        jsonrpc: "2.0",
-        id: parsed.id,
-        result: parsed.result
-      }
-    };
-  }
-  if (!isJsonRpcErrorObject(parsed.error)) {
-    return {
-      type: "invalid",
-      id: parsed.id,
-      error: invalidRequest()
-    };
-  }
-  return {
-    type: "response",
-    message: {
-      jsonrpc: "2.0",
-      id: parsed.id,
-      error: parsed.error
-    }
-  };
-}
-var JsonRpcMessageLayer;
-var init_jsonrpc_message_layer = __esm({
-  "packages/poe-acp-client/src/jsonrpc-message-layer.ts"() {
+var AcpClient;
+var init_acp_client = __esm({
+  "packages/poe-acp-client/src/acp-client.ts"() {
     "use strict";
+    init_acp_transport();
     init_types3();
-    JsonRpcMessageLayer = class {
-      input;
-      output;
-      requestHandlers = /* @__PURE__ */ new Map();
-      notificationHandlers = /* @__PURE__ */ new Map();
-      pending = /* @__PURE__ */ new Map();
-      nextRequestId;
+    AcpClient = class {
+      transport;
+      clientProtocolVersion;
+      clientCapabilities;
+      clientInfo;
+      skipAuth;
+      permissionHandler;
+      fsHandler;
+      terminalHandler;
+      activePromptUpdates = /* @__PURE__ */ new Map();
+      trackedTerminalIds = /* @__PURE__ */ new Map();
+      hasRegisteredFsReadHandler = false;
+      hasRegisteredFsWriteHandler = false;
+      hasRegisteredTerminalHandlers = false;
       disposed = false;
+      lifecycleState = "uninitialized";
+      negotiatedVersion = null;
+      availableAuthMethods = [];
+      negotiatedAgentCapabilities;
+      negotiatedAgentInfo;
       constructor(options) {
-        this.input = options.input;
-        this.output = options.output;
-        this.nextRequestId = options.firstRequestId ?? 1;
-        if (!Number.isFinite(this.nextRequestId)) {
-          throw new Error("firstRequestId must be a finite number");
-        }
-        void this.consumeInput();
+        this.transport = isInjectedTransportOptions(options) ? options.transport : new AcpTransport({
+          command: options.command,
+          args: options.args,
+          cwd: options.cwd,
+          env: options.env,
+          firstRequestId: options.firstRequestId,
+          spawn: options.spawn
+        });
+        this.clientProtocolVersion = options.protocolVersion ?? 1;
+        this.clientCapabilities = options.clientCapabilities;
+        this.clientInfo = options.clientInfo;
+        this.skipAuth = options.skipAuth ?? false;
+        this.permissionHandler = options.handlers?.permission ?? options.permissionHandler;
+        this.fsHandler = options.handlers?.fs ?? options.fsHandler;
+        this.terminalHandler = options.handlers?.terminal ?? options.terminalHandler;
+        const autoApprove = options.autoApprove === true && !this.permissionHandler;
+        this.transport.onRequest(
+          "session/request_permission",
+          async (params) => {
+            if (this.permissionHandler) {
+              const outcome = await this.permissionHandler({
+                toolCall: params.toolCall,
+                options: params.options
+              });
+              return { outcome };
+            }
+            if (autoApprove) {
+              const allow = params.options.find((o) => o.kind === "allow_always") ?? params.options.find((o) => o.kind === "allow_once");
+              if (allow) {
+                return { outcome: { outcome: "selected", optionId: allow.optionId } };
+              }
+            }
+            return { outcome: { outcome: "cancelled" } };
+          }
+        );
+        this.registerCapabilityHandlers(this.clientCapabilities);
+        this.transport.onNotification("session/update", (params) => {
+          this.handleSessionUpdateNotification(params);
+        });
       }
-      onRequest(method, handler) {
-        this.requestHandlers.set(method, handler);
+      get state() {
+        return this.lifecycleState;
       }
-      onNotification(method, handler) {
-        this.notificationHandlers.set(method, handler);
+      get negotiatedProtocolVersion() {
+        return this.negotiatedVersion;
       }
-      pendingRequestCount() {
-        return this.pending.size;
+      get authMethods() {
+        return [...this.availableAuthMethods];
       }
-      sendNotification(method, params) {
-        const notification = {
-          jsonrpc: "2.0",
-          method
-        };
-        if (params !== void 0) {
-          notification.params = params;
-        }
-        this.sendMessage(notification);
+      get agentCapabilities() {
+        return this.negotiatedAgentCapabilities;
       }
-      sendRequest(method, params, options = {}) {
-        if (this.disposed) {
-          throw new Error("JSON-RPC message layer is disposed");
-        }
-        const id = options.id === void 0 ? this.nextRequestId++ : options.id;
-        if (this.pending.has(id)) {
-          throw new Error(`A request with id ${JSON.stringify(id)} is already pending`);
+      get agentInfo() {
+        return this.negotiatedAgentInfo;
+      }
+      get closed() {
+        return this.transport.closed;
+      }
+      async initialize(clientCapabilities) {
+        if (this.lifecycleState !== "uninitialized") {
+          throw new Error("initialize() can only be called once.");
         }
-        const request = {
-          jsonrpc: "2.0",
-          id,
-          method
-        };
-        if (params !== void 0) {
-          request.params = params;
+        if (clientCapabilities !== void 0) {
+          this.clientCapabilities = clientCapabilities;
+          this.registerCapabilityHandlers(clientCapabilities);
         }
-        return new Promise((resolve2, reject) => {
-          this.pending.set(id, {
-            method,
-            resolve: resolve2,
-            reject
-          });
-          try {
-            this.sendMessage(request);
-          } catch (error2) {
-            this.pending.delete(id);
-            reject(error2);
-          }
+        const response = await this.transport.sendRequest("initialize", {
+          protocolVersion: this.clientProtocolVersion,
+          clientInfo: this.clientInfo,
+          clientCapabilities: this.clientCapabilities
         });
+        const negotiatedProtocolVersion = Math.min(
+          this.clientProtocolVersion,
+          response.protocolVersion
+        );
+        this.negotiatedVersion = negotiatedProtocolVersion;
+        this.negotiatedAgentCapabilities = response.agentCapabilities;
+        this.negotiatedAgentInfo = response.agentInfo;
+        this.availableAuthMethods = response.authMethods ? [...response.authMethods] : [];
+        const requiresAuth = this.availableAuthMethods.length > 0 && !this.skipAuth;
+        this.lifecycleState = requiresAuth ? "initialized" : "ready";
+        return {
+          protocolVersion: negotiatedProtocolVersion,
+          ...this.negotiatedAgentCapabilities !== void 0 ? { agentCapabilities: this.negotiatedAgentCapabilities } : {},
+          ...this.negotiatedAgentInfo !== void 0 ? { agentInfo: this.negotiatedAgentInfo } : {},
+          ...this.availableAuthMethods.length > 0 ? { authMethods: this.authMethods } : {}
+        };
       }
-      dispose(reason = new Error("JSON-RPC message layer disposed")) {
-        if (this.disposed) {
-          return;
+      async authenticate(methodId) {
+        if (this.lifecycleState === "uninitialized") {
+          throw new Error("Cannot authenticate before initialize().");
         }
-        this.disposed = true;
-        this.rejectAllPending(reason);
-      }
-      async consumeInput() {
-        try {
-          for await (const line of readLines2(this.input)) {
-            if (this.disposed || line.length === 0) {
-              continue;
-            }
-            await this.handleIncomingLine(line);
-          }
-          if (!this.disposed) {
-            this.dispose(new Error("JSON-RPC input stream closed"));
-          }
-        } catch (error2) {
-          if (!this.disposed) {
-            this.dispose(
-              error2 instanceof Error ? error2 : new Error(`JSON-RPC input stream failed: ${String(error2)}`)
-            );
-          }
-        }
-      }
-      async handleIncomingLine(line) {
-        const parsed = parseJsonRpcMessage(line);
-        if (parsed.type === "invalid") {
-          this.sendMessage(createJsonRpcErrorResponse(parsed.id, parsed.error));
-          return;
-        }
-        if (parsed.type === "response") {
-          this.handleResponse(parsed.message);
-          return;
-        }
-        if (parsed.type === "notification") {
-          await this.handleNotification(parsed.message);
-          return;
-        }
-        await this.handleRequest(parsed.message);
-      }
-      handleResponse(message2) {
-        const pending = this.pending.get(message2.id);
-        if (!pending) {
-          return;
-        }
-        this.pending.delete(message2.id);
-        if ("error" in message2) {
-          pending.reject(toResponseError(message2.error));
-          return;
-        }
-        pending.resolve(message2.result);
-      }
-      async handleRequest(message2) {
-        const handler = this.requestHandlers.get(message2.method);
-        if (!handler) {
-          this.sendMessage(createJsonRpcErrorResponse(message2.id, methodNotFound(message2.method)));
-          return;
-        }
-        try {
-          const result = await handler(message2.params, {
-            id: message2.id,
-            method: message2.method
-          });
-          this.sendMessage(createResponseMessage(message2.id, result));
-        } catch (error2) {
-          this.sendMessage(createJsonRpcErrorResponse(message2.id, toDispatchError(error2)));
-        }
-      }
-      async handleNotification(message2) {
-        const handler = this.notificationHandlers.get(message2.method);
-        if (!handler) {
-          return;
-        }
-        try {
-          await handler(message2.params, { method: message2.method });
-        } catch {
-        }
-      }
-      sendMessage(message2) {
-        if (this.disposed) {
-          throw new Error("JSON-RPC message layer is disposed");
+        if (this.lifecycleState === "ready") {
+          throw new Error("Authentication is not required for this agent.");
         }
-        this.output.write(serializeJsonRpcMessage(message2));
-      }
-      rejectAllPending(error2) {
-        for (const pending of this.pending.values()) {
-          pending.reject(error2);
+        if (!this.availableAuthMethods.some((authMethod) => authMethod.id === methodId)) {
+          throw new Error(`Unknown auth method "${methodId}".`);
         }
-        this.pending.clear();
+        const response = await this.transport.sendRequest("authenticate", {
+          methodId
+        });
+        this.lifecycleState = "ready";
+        return response;
       }
-    };
-  }
-});
-
-// packages/poe-acp-client/src/acp-transport.ts
-import {
-  spawn as spawnChildProcess4
-} from "node:child_process";
-function assertExtensionMethod(method) {
-  if (!method.startsWith("_")) {
-    throw new Error('Extension method must start with "_"');
-  }
-}
-var AcpTransport;
-var init_acp_transport = __esm({
-  "packages/poe-acp-client/src/acp-transport.ts"() {
-    "use strict";
-    init_jsonrpc_message_layer();
-    AcpTransport = class {
-      closed;
-      command;
-      child;
-      layer;
-      stderrChunks = [];
-      resolveClosed = null;
-      closeEvent = null;
-      closeReason = null;
-      constructor(options) {
-        const {
-          command,
-          args = [],
+      async newSession(cwd, mcpServers) {
+        this.assertReady("session/new");
+        this.assertMcpServerCapabilitySupport(mcpServers);
+        return this.transport.sendRequest("session/new", {
           cwd,
-          env,
-          firstRequestId,
-          spawn: spawn9 = spawnChildProcess4
-        } = options;
-        this.command = command;
-        this.closed = new Promise((resolve2) => {
-          this.resolveClosed = resolve2;
+          mcpServers
         });
-        this.child = spawn9(command, [...args], {
+      }
+      async loadSession(sessionId, cwd, mcpServers) {
+        this.assertReady("session/load");
+        if (this.negotiatedAgentCapabilities?.loadSession !== true) {
+          throw new Error(
+            'Cannot call "session/load" because the agent does not support session loading.'
+          );
+        }
+        this.assertMcpServerCapabilitySupport(mcpServers);
+        return this.transport.sendRequest("session/load", {
+          sessionId,
           cwd,
-          env,
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        this.child.stderr.setEncoding("utf8");
-        this.child.stderr.on("data", (chunk) => {
-          this.stderrChunks.push(String(chunk));
-        });
-        this.child.stdin.on("error", (error2) => {
-          const reason = error2 instanceof Error ? error2 : new Error(String(error2));
-          this.close(reason, this.child.exitCode ?? null, this.child.signalCode ?? null);
+          mcpServers
         });
-        this.layer = new JsonRpcMessageLayer({
-          input: this.child.stdout,
-          output: this.child.stdin,
-          firstRequestId
+      }
+      async cancelSession(sessionId) {
+        this.assertReady("session/cancel");
+        const payload = { sessionId };
+        this.transport.sendNotification("session/cancel", payload);
+      }
+      async setMode(sessionId, modeId) {
+        this.assertReady("session/set_mode");
+        return this.transport.sendRequest("session/set_mode", {
+          sessionId,
+          modeId
         });
-        this.child.once("error", (error2) => {
-          const reason = error2 instanceof Error ? error2 : new Error(String(error2));
-          this.close(reason, this.child.exitCode ?? null, this.child.signalCode ?? null);
+      }
+      async setConfigOption(sessionId, configId, value) {
+        this.assertReady("session/set_config_option");
+        const response = await this.transport.sendRequest("session/set_config_option", {
+          sessionId,
+          configId,
+          value
         });
-        this.child.once("close", (code, signal) => {
-          const reason = this.closeReason ?? new Error(
-            `ACP transport closed (command "${this.command}", code: ${code ?? "null"}${signal ? `, signal: ${signal}` : ""})`
+        return response.configOptions;
+      }
+      prompt(sessionId, content) {
+        this.assertReady("session/prompt");
+        this.assertPromptContentCapabilitySupport(content);
+        if (this.activePromptUpdates.has(sessionId)) {
+          throw new Error(
+            `Cannot call "session/prompt" while another prompt is in progress for session "${sessionId}".`
           );
-          this.close(reason, code ?? null, signal ?? null);
+        }
+        const updates = createAsyncQueue();
+        this.activePromptUpdates.set(sessionId, updates);
+        let requestPromise;
+        try {
+          requestPromise = this.transport.sendRequest("session/prompt", {
+            sessionId,
+            prompt: content
+          });
+        } catch (error2) {
+          const normalizedError = toError(error2);
+          this.activePromptUpdates.delete(sessionId);
+          updates.fail(normalizedError);
+          throw normalizedError;
+        }
+        const response = requestPromise.then((promptResponse) => {
+          this.activePromptUpdates.delete(sessionId);
+          updates.complete();
+          return promptResponse;
+        }).catch((error2) => {
+          const normalizedError = toError(error2);
+          this.activePromptUpdates.delete(sessionId);
+          updates.fail(normalizedError);
+          throw normalizedError;
         });
+        return {
+          response,
+          [Symbol.asyncIterator]() {
+            return updates;
+          }
+        };
       }
-      sendRequest(method, params, options = {}) {
-        return this.layer.sendRequest(method, params, options);
-      }
-      sendExtRequest(method, params, options = {}) {
-        assertExtensionMethod(method);
-        return this.layer.sendRequest(method, params, options);
-      }
-      sendNotification(method, params) {
-        this.layer.sendNotification(method, params);
-      }
-      sendExtNotification(method, params) {
-        assertExtensionMethod(method);
-        this.layer.sendNotification(method, params);
+      async sendExtRequest(method, params, options = {}) {
+        assertExtensionMethod2(method);
+        return this.transport.sendRequest(method, params, options);
       }
-      onRequest(method, handler) {
-        this.layer.onRequest(method, handler);
+      async sendExtNotification(method, params) {
+        assertExtensionMethod2(method);
+        this.transport.sendNotification(method, params);
       }
       onExtRequest(method, handler) {
-        assertExtensionMethod(method);
-        this.layer.onRequest(method, handler);
-      }
-      onNotification(method, handler) {
-        this.layer.onNotification(method, handler);
+        assertExtensionMethod2(method);
+        this.transport.onRequest(method, handler);
       }
       onExtNotification(method, handler) {
-        assertExtensionMethod(method);
-        this.layer.onNotification(method, handler);
-      }
-      getStderrOutput() {
-        return this.stderrChunks.join("");
+        assertExtensionMethod2(method);
+        this.transport.onNotification(method, handler);
       }
-      pendingRequestCount() {
-        return this.layer.pendingRequestCount();
+      async dispose() {
+        if (this.disposed) {
+          if (this.transport.closed) {
+            await this.transport.closed;
+          }
+          return;
+        }
+        this.disposed = true;
+        const disposeReason = new Error("ACP client disposed");
+        for (const updates of this.activePromptUpdates.values()) {
+          updates.fail(disposeReason);
+        }
+        this.activePromptUpdates.clear();
+        if (typeof this.transport.dispose === "function") {
+          this.transport.dispose(disposeReason);
+        }
+        if (this.transport.closed) {
+          await this.transport.closed;
+        }
       }
-      dispose(reason = new Error("ACP transport disposed")) {
-        if (this.closeEvent !== null) {
+      assertReady(operation) {
+        if (this.lifecycleState === "ready") {
           return;
         }
-        this.closeReason = reason;
-        this.layer.dispose(reason);
-        if (!this.child.stdin.destroyed && !this.child.stdin.writableEnded) {
-          this.child.stdin.end();
+        if (this.lifecycleState === "uninitialized") {
+          throw new Error(`Cannot call "${operation}" before initialize().`);
         }
-        if (this.child.exitCode !== null || this.child.signalCode !== null) {
-          this.close(reason, this.child.exitCode, this.child.signalCode);
+        throw new Error(`Cannot call "${operation}" before authentication completes.`);
+      }
+      registerCapabilityHandlers(capabilities) {
+        if (!this.hasRegisteredFsReadHandler && capabilities?.fs?.readTextFile === true && this.fsHandler?.readTextFile) {
+          const readTextFile = this.fsHandler.readTextFile;
+          this.transport.onRequest(
+            "fs/read_text_file",
+            async (params) => {
+              assertAbsolutePath(params.path);
+              assertOneBasedLineNumber(params.line);
+              const content = await readTextFile({
+                sessionId: params.sessionId,
+                path: params.path,
+                line: params.line,
+                limit: params.limit
+              });
+              return { content };
+            }
+          );
+          this.hasRegisteredFsReadHandler = true;
+        }
+        if (!this.hasRegisteredFsWriteHandler && capabilities?.fs?.writeTextFile === true && this.fsHandler?.writeTextFile) {
+          const writeTextFile = this.fsHandler.writeTextFile;
+          this.transport.onRequest(
+            "fs/write_text_file",
+            async (params) => {
+              assertAbsolutePath(params.path);
+              await writeTextFile({
+                sessionId: params.sessionId,
+                path: params.path,
+                content: params.content
+              });
+              return {};
+            }
+          );
+          this.hasRegisteredFsWriteHandler = true;
+        }
+        if (!this.hasRegisteredTerminalHandlers && capabilities?.terminal === true && this.terminalHandler) {
+          const terminalHandler = this.terminalHandler;
+          this.transport.onRequest(
+            "terminal/create",
+            async (params) => {
+              const terminalId = await terminalHandler.create({
+                sessionId: params.sessionId,
+                command: params.command,
+                args: params.args,
+                cwd: params.cwd,
+                env: params.env,
+                outputByteLimit: params.outputByteLimit
+              });
+              this.trackTerminal(params.sessionId, terminalId);
+              return { terminalId };
+            }
+          );
+          this.transport.onRequest(
+            "terminal/output",
+            async (params) => {
+              this.assertKnownTerminal(params.sessionId, params.terminalId);
+              return terminalHandler.output({
+                sessionId: params.sessionId,
+                terminalId: params.terminalId
+              });
+            }
+          );
+          this.transport.onRequest(
+            "terminal/wait_for_exit",
+            async (params) => {
+              this.assertKnownTerminal(params.sessionId, params.terminalId);
+              return terminalHandler.waitForExit({
+                sessionId: params.sessionId,
+                terminalId: params.terminalId
+              });
+            }
+          );
+          this.transport.onRequest(
+            "terminal/kill",
+            async (params) => {
+              this.assertKnownTerminal(params.sessionId, params.terminalId);
+              await terminalHandler.kill({
+                sessionId: params.sessionId,
+                terminalId: params.terminalId
+              });
+              return {};
+            }
+          );
+          this.transport.onRequest(
+            "terminal/release",
+            async (params) => {
+              this.assertKnownTerminal(params.sessionId, params.terminalId);
+              await terminalHandler.release({
+                sessionId: params.sessionId,
+                terminalId: params.terminalId
+              });
+              this.untrackTerminal(params.sessionId, params.terminalId);
+              return {};
+            }
+          );
+          this.hasRegisteredTerminalHandlers = true;
+        }
+      }
+      assertMcpServerCapabilitySupport(mcpServers) {
+        const mcpCapabilities = this.negotiatedAgentCapabilities?.mcpCapabilities;
+        for (const mcpServer of mcpServers) {
+          if (!("type" in mcpServer)) {
+            continue;
+          }
+          if (mcpServer.type === "http" && mcpCapabilities?.http !== true) {
+            throw new Error('Agent does not support MCP server type "http".');
+          }
+          if (mcpServer.type === "sse" && mcpCapabilities?.sse !== true) {
+            throw new Error('Agent does not support MCP server type "sse".');
+          }
+        }
+      }
+      handleSessionUpdateNotification(notification) {
+        const activePrompt = this.activePromptUpdates.get(notification.sessionId);
+        if (!activePrompt) {
           return;
         }
-        const killed = this.child.kill();
-        if (!killed) {
-          this.close(reason, this.child.exitCode, this.child.signalCode);
+        activePrompt.push({
+          jsonrpc: "2.0",
+          method: "session/update",
+          params: notification
+        });
+      }
+      trackTerminal(sessionId, terminalId) {
+        const sessionTerminals = this.trackedTerminalIds.get(sessionId);
+        if (sessionTerminals) {
+          sessionTerminals.add(terminalId);
+          return;
         }
+        this.trackedTerminalIds.set(sessionId, /* @__PURE__ */ new Set([terminalId]));
       }
-      close(reason, code, signal) {
-        if (this.closeEvent !== null) {
+      assertKnownTerminal(sessionId, terminalId) {
+        const sessionTerminals = this.trackedTerminalIds.get(sessionId);
+        if (sessionTerminals?.has(terminalId) === true) {
           return;
         }
-        this.layer.dispose(reason);
-        this.closeEvent = {
-          code,
-          signal,
-          reason,
-          stderr: this.getStderrOutput()
-        };
-        this.resolveClosed?.(this.closeEvent);
-        this.resolveClosed = null;
+        throw resourceNotFound(`terminal "${terminalId}"`);
+      }
+      untrackTerminal(sessionId, terminalId) {
+        const sessionTerminals = this.trackedTerminalIds.get(sessionId);
+        if (!sessionTerminals) {
+          return;
+        }
+        sessionTerminals.delete(terminalId);
+        if (sessionTerminals.size === 0) {
+          this.trackedTerminalIds.delete(sessionId);
+        }
+      }
+      assertPromptContentCapabilitySupport(content) {
+        const promptCapabilities = this.negotiatedAgentCapabilities?.promptCapabilities;
+        for (const block of content) {
+          if (block.type === "image" && promptCapabilities?.image !== true) {
+            throw new Error('Agent does not support prompt content type "image".');
+          }
+          if (block.type === "audio" && promptCapabilities?.audio !== true) {
+            throw new Error('Agent does not support prompt content type "audio".');
+          }
+          if (block.type === "resource" && promptCapabilities?.embeddedContext !== true) {
+            throw new Error('Agent does not support prompt content type "resource".');
+          }
+        }
       }
     };
   }
 });
 
-// packages/poe-acp-client/src/acp-client.ts
-import { isAbsolute } from "node:path";
-function toError(reason) {
-  return reason instanceof Error ? reason : new Error(String(reason));
-}
-function invalidParams(message2) {
-  return new AcpError(
-    ACP_ERROR_CODE_INVALID_PARAMS,
-    `Invalid params: ${message2}`
-  );
-}
-function resourceNotFound(resource) {
-  return new AcpError(
-    ACP_ERROR_CODE_RESOURCE_NOT_FOUND,
-    `Resource not found: ${resource}`
-  );
-}
-function assertAbsolutePath(path54) {
-  if (!isAbsolute(path54)) {
-    throw invalidParams('"path" must be an absolute path');
-  }
-}
-function assertOneBasedLineNumber(line) {
-  if (line === null || line === void 0) {
-    return;
-  }
-  if (!Number.isInteger(line) || line < 1) {
-    throw invalidParams('"line" must be a 1-based integer');
+// packages/poe-acp-client/src/jsonrpc.ts
+var init_jsonrpc = __esm({
+  "packages/poe-acp-client/src/jsonrpc.ts"() {
+    "use strict";
   }
-}
-function assertExtensionMethod2(method) {
-  if (!method.startsWith("_")) {
-    throw new Error('Extension method must start with "_"');
+});
+
+// packages/poe-acp-client/src/stream-helpers.ts
+async function extractUsageFromSessionUpdateStream(stream) {
+  const updates = [];
+  for await (const entry of stream) {
+    const update = toSessionUpdate(entry);
+    if (update.sessionUpdate === "usage_update") {
+      updates.push(update);
+    }
   }
+  return updates;
 }
-function isInjectedTransportOptions(options) {
-  return "transport" in options;
-}
-function createAsyncQueue() {
-  const values = [];
-  const waiters = [];
-  let closed = false;
-  let failure = null;
-  const resolveOne = (value) => {
-    const waiter = waiters.shift();
-    if (!waiter) {
-      return false;
-    }
-    waiter.resolve({ done: false, value });
-    return true;
-  };
-  const iterator = {
-    push(value) {
-      if (closed || failure) {
-        return;
+async function extractToolCallSummariesFromSessionUpdateStream(stream) {
+  const summaries = /* @__PURE__ */ new Map();
+  for await (const entry of stream) {
+    const update = toSessionUpdate(entry);
+    if (update.sessionUpdate === "tool_call") {
+      const summary = {
+        toolCallId: update.toolCallId,
+        title: update.title
+      };
+      if (update.kind !== void 0) {
+        summary.kind = update.kind;
       }
-      if (!resolveOne(value)) {
-        values.push(value);
+      if (update.status !== void 0) {
+        summary.status = update.status;
       }
-    },
-    complete() {
-      if (closed || failure) {
-        return;
+      if (update.rawInput !== void 0) {
+        summary.rawInput = update.rawInput;
       }
-      closed = true;
-      while (waiters.length > 0) {
-        waiters.shift()?.resolve({ done: true, value: void 0 });
+      if (update.rawOutput !== void 0) {
+        summary.rawOutput = update.rawOutput;
       }
-    },
-    fail(error2) {
-      if (closed || failure) {
-        return;
+      summaries.set(update.toolCallId, summary);
+      continue;
+    }
+    if (update.sessionUpdate === "tool_call_update") {
+      const existing = summaries.get(update.toolCallId);
+      const summary = existing ?? {
+        toolCallId: update.toolCallId,
+        title: toTitle(update.title, update.toolCallId)
+      };
+      if (update.title !== null && update.title !== void 0 && update.title.length > 0) {
+        summary.title = update.title;
       }
-      failure = error2;
-      while (waiters.length > 0) {
-        waiters.shift()?.reject(error2);
+      if (update.kind !== null && update.kind !== void 0) {
+        summary.kind = update.kind;
       }
-    },
-    async next() {
-      if (values.length > 0) {
-        const value = values.shift();
-        return { done: false, value };
+      if (update.status !== null && update.status !== void 0) {
+        summary.status = update.status;
       }
-      if (failure) {
-        throw failure;
+      if (update.rawInput !== void 0) {
+        summary.rawInput = update.rawInput;
       }
-      if (closed) {
-        return { done: true, value: void 0 };
+      if (update.rawOutput !== void 0) {
+        summary.rawOutput = update.rawOutput;
       }
-      return new Promise((resolve2, reject) => {
-        waiters.push({ resolve: resolve2, reject });
-      });
-    },
-    async return() {
-      iterator.complete();
-      return { done: true, value: void 0 };
-    },
-    async throw(error2) {
-      const normalizedError = toError(error2);
-      iterator.fail(normalizedError);
-      throw normalizedError;
-    },
-    [Symbol.asyncIterator]() {
-      return iterator;
+      summaries.set(update.toolCallId, summary);
     }
-  };
-  return iterator;
+  }
+  return Array.from(summaries.values());
 }
-var AcpClient;
-var init_acp_client = __esm({
-  "packages/poe-acp-client/src/acp-client.ts"() {
+function toSessionUpdate(entry) {
+  if (isSessionUpdateNotification(entry)) {
+    return entry.params.update;
+  }
+  return entry;
+}
+function isSessionUpdateNotification(entry) {
+  return typeof entry.jsonrpc === "string" && entry.method === "session/update";
+}
+function toTitle(value, fallback) {
+  if (typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  return fallback;
+}
+var init_stream_helpers = __esm({
+  "packages/poe-acp-client/src/stream-helpers.ts"() {
     "use strict";
-    init_acp_transport();
-    init_types3();
-    AcpClient = class {
-      transport;
-      clientProtocolVersion;
-      clientCapabilities;
-      clientInfo;
-      skipAuth;
-      permissionHandler;
-      fsHandler;
-      terminalHandler;
-      activePromptUpdates = /* @__PURE__ */ new Map();
-      trackedTerminalIds = /* @__PURE__ */ new Map();
-      hasRegisteredFsReadHandler = false;
-      hasRegisteredFsWriteHandler = false;
-      hasRegisteredTerminalHandlers = false;
-      disposed = false;
-      lifecycleState = "uninitialized";
-      negotiatedVersion = null;
-      availableAuthMethods = [];
-      negotiatedAgentCapabilities;
-      negotiatedAgentInfo;
-      constructor(options) {
-        this.transport = isInjectedTransportOptions(options) ? options.transport : new AcpTransport({
-          command: options.command,
-          args: options.args,
-          cwd: options.cwd,
-          env: options.env,
-          firstRequestId: options.firstRequestId,
-          spawn: options.spawn
-        });
-        this.clientProtocolVersion = options.protocolVersion ?? 1;
-        this.clientCapabilities = options.clientCapabilities;
-        this.clientInfo = options.clientInfo;
-        this.skipAuth = options.skipAuth ?? false;
-        this.permissionHandler = options.handlers?.permission ?? options.permissionHandler;
-        this.fsHandler = options.handlers?.fs ?? options.fsHandler;
-        this.terminalHandler = options.handlers?.terminal ?? options.terminalHandler;
-        const autoApprove = options.autoApprove === true && !this.permissionHandler;
-        this.transport.onRequest(
-          "session/request_permission",
-          async (params) => {
-            if (this.permissionHandler) {
-              const outcome = await this.permissionHandler({
-                toolCall: params.toolCall,
-                options: params.options
-              });
-              return { outcome };
-            }
-            if (autoApprove) {
-              const allow = params.options.find((o) => o.kind === "allow_always") ?? params.options.find((o) => o.kind === "allow_once");
-              if (allow) {
-                return { outcome: { outcome: "selected", optionId: allow.optionId } };
-              }
-            }
-            return { outcome: { outcome: "cancelled" } };
-          }
-        );
-        this.registerCapabilityHandlers(this.clientCapabilities);
-        this.transport.onNotification("session/update", (params) => {
-          this.handleSessionUpdateNotification(params);
-        });
-      }
-      get state() {
-        return this.lifecycleState;
-      }
-      get negotiatedProtocolVersion() {
-        return this.negotiatedVersion;
-      }
-      get authMethods() {
-        return [...this.availableAuthMethods];
-      }
-      get agentCapabilities() {
-        return this.negotiatedAgentCapabilities;
-      }
-      get agentInfo() {
-        return this.negotiatedAgentInfo;
-      }
-      get closed() {
-        return this.transport.closed;
-      }
-      async initialize(clientCapabilities) {
-        if (this.lifecycleState !== "uninitialized") {
-          throw new Error("initialize() can only be called once.");
-        }
-        if (clientCapabilities !== void 0) {
-          this.clientCapabilities = clientCapabilities;
-          this.registerCapabilityHandlers(clientCapabilities);
-        }
-        const response = await this.transport.sendRequest("initialize", {
-          protocolVersion: this.clientProtocolVersion,
-          clientInfo: this.clientInfo,
-          clientCapabilities: this.clientCapabilities
-        });
-        const negotiatedProtocolVersion = Math.min(
-          this.clientProtocolVersion,
-          response.protocolVersion
-        );
-        this.negotiatedVersion = negotiatedProtocolVersion;
-        this.negotiatedAgentCapabilities = response.agentCapabilities;
-        this.negotiatedAgentInfo = response.agentInfo;
-        this.availableAuthMethods = response.authMethods ? [...response.authMethods] : [];
-        const requiresAuth = this.availableAuthMethods.length > 0 && !this.skipAuth;
-        this.lifecycleState = requiresAuth ? "initialized" : "ready";
-        return {
-          protocolVersion: negotiatedProtocolVersion,
-          ...this.negotiatedAgentCapabilities !== void 0 ? { agentCapabilities: this.negotiatedAgentCapabilities } : {},
-          ...this.negotiatedAgentInfo !== void 0 ? { agentInfo: this.negotiatedAgentInfo } : {},
-          ...this.availableAuthMethods.length > 0 ? { authMethods: this.authMethods } : {}
-        };
+  }
+});
+
+// packages/poe-acp-client/src/run-report.ts
+import * as fsPromises from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { join } from "node:path";
+async function generateRunReportFromSessionUpdateStream(stream, options = {}) {
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const bufferedEntries = [];
+  let runIdFromStream;
+  for await (const entry of stream) {
+    bufferedEntries.push(entry);
+    if (runIdFromStream) {
+      continue;
+    }
+    if (isSessionUpdateNotification2(entry)) {
+      const sessionId = toNonEmptyString(entry.params.sessionId);
+      if (sessionId) {
+        runIdFromStream = sessionId;
       }
-      async authenticate(methodId) {
-        if (this.lifecycleState === "uninitialized") {
-          throw new Error("Cannot authenticate before initialize().");
-        }
-        if (this.lifecycleState === "ready") {
-          throw new Error("Authentication is not required for this agent.");
-        }
-        if (!this.availableAuthMethods.some((authMethod) => authMethod.id === methodId)) {
-          throw new Error(`Unknown auth method "${methodId}".`);
-        }
-        const response = await this.transport.sendRequest("authenticate", {
-          methodId
-        });
-        this.lifecycleState = "ready";
-        return response;
-      }
-      async newSession(cwd, mcpServers) {
-        this.assertReady("session/new");
-        this.assertMcpServerCapabilitySupport(mcpServers);
-        return this.transport.sendRequest("session/new", {
-          cwd,
-          mcpServers
-        });
-      }
-      async loadSession(sessionId, cwd, mcpServers) {
-        this.assertReady("session/load");
-        if (this.negotiatedAgentCapabilities?.loadSession !== true) {
-          throw new Error(
-            'Cannot call "session/load" because the agent does not support session loading.'
-          );
-        }
-        this.assertMcpServerCapabilitySupport(mcpServers);
-        return this.transport.sendRequest("session/load", {
-          sessionId,
-          cwd,
-          mcpServers
-        });
-      }
-      async cancelSession(sessionId) {
-        this.assertReady("session/cancel");
-        const payload = { sessionId };
-        this.transport.sendNotification("session/cancel", payload);
-      }
-      async setMode(sessionId, modeId) {
-        this.assertReady("session/set_mode");
-        return this.transport.sendRequest("session/set_mode", {
-          sessionId,
-          modeId
-        });
-      }
-      async setConfigOption(sessionId, configId, value) {
-        this.assertReady("session/set_config_option");
-        const response = await this.transport.sendRequest("session/set_config_option", {
-          sessionId,
-          configId,
-          value
-        });
-        return response.configOptions;
-      }
-      prompt(sessionId, content) {
-        this.assertReady("session/prompt");
-        this.assertPromptContentCapabilitySupport(content);
-        if (this.activePromptUpdates.has(sessionId)) {
-          throw new Error(
-            `Cannot call "session/prompt" while another prompt is in progress for session "${sessionId}".`
-          );
-        }
-        const updates = createAsyncQueue();
-        this.activePromptUpdates.set(sessionId, updates);
-        let requestPromise;
-        try {
-          requestPromise = this.transport.sendRequest("session/prompt", {
-            sessionId,
-            prompt: content
-          });
-        } catch (error2) {
-          const normalizedError = toError(error2);
-          this.activePromptUpdates.delete(sessionId);
-          updates.fail(normalizedError);
-          throw normalizedError;
-        }
-        const response = requestPromise.then((promptResponse) => {
-          this.activePromptUpdates.delete(sessionId);
-          updates.complete();
-          return promptResponse;
-        }).catch((error2) => {
-          const normalizedError = toError(error2);
-          this.activePromptUpdates.delete(sessionId);
-          updates.fail(normalizedError);
-          throw normalizedError;
-        });
-        return {
-          response,
-          [Symbol.asyncIterator]() {
-            return updates;
-          }
-        };
-      }
-      async sendExtRequest(method, params, options = {}) {
-        assertExtensionMethod2(method);
-        return this.transport.sendRequest(method, params, options);
-      }
-      async sendExtNotification(method, params) {
-        assertExtensionMethod2(method);
-        this.transport.sendNotification(method, params);
-      }
-      onExtRequest(method, handler) {
-        assertExtensionMethod2(method);
-        this.transport.onRequest(method, handler);
-      }
-      onExtNotification(method, handler) {
-        assertExtensionMethod2(method);
-        this.transport.onNotification(method, handler);
-      }
-      async dispose() {
-        if (this.disposed) {
-          if (this.transport.closed) {
-            await this.transport.closed;
-          }
-          return;
-        }
-        this.disposed = true;
-        const disposeReason = new Error("ACP client disposed");
-        for (const updates of this.activePromptUpdates.values()) {
-          updates.fail(disposeReason);
-        }
-        this.activePromptUpdates.clear();
-        if (typeof this.transport.dispose === "function") {
-          this.transport.dispose(disposeReason);
-        }
-        if (this.transport.closed) {
-          await this.transport.closed;
-        }
+    }
+  }
+  const runId = toNonEmptyString(options.runId) ?? runIdFromStream;
+  if (!runId) {
+    throw new Error("Run id is required via options.runId or session/update stream items");
+  }
+  const startTime = normalizeTime(options.startTime, now);
+  const endTime = normalizeTime(options.endTime, now);
+  const toolCalls = await extractToolCallSummariesFromSessionUpdateStream(bufferedEntries);
+  const usageUpdates = await extractUsageFromSessionUpdateStream(bufferedEntries);
+  const usage = summarizeUsage(usageUpdates);
+  const errors = collectErrors(toolCalls, options.errors);
+  const exitStatus = options.exitStatus ?? (errors.length > 0 ? "failed" : "success");
+  return {
+    runId,
+    startTime,
+    endTime,
+    exitStatus,
+    toolCalls,
+    usage,
+    errors
+  };
+}
+function isSessionUpdateNotification2(entry) {
+  return typeof entry.jsonrpc === "string" && entry.method === "session/update";
+}
+function normalizeTime(value, now) {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value === "string" && value.length > 0) {
+    const parsed = new Date(value);
+    if (!Number.isNaN(parsed.getTime())) {
+      return parsed.toISOString();
+    }
+  }
+  return now().toISOString();
+}
+function summarizeUsage(updates) {
+  let used = 0;
+  let size = 0;
+  let cost;
+  for (const update of updates) {
+    used += update.used;
+    size += update.size;
+    if (update.cost !== void 0) {
+      cost = update.cost;
+    }
+  }
+  const usage = {
+    used,
+    size,
+    updates: updates.length
+  };
+  if (cost !== void 0) {
+    usage.cost = cost;
+  }
+  return usage;
+}
+function collectErrors(toolCalls, additionalErrors) {
+  const errors = [];
+  for (const toolCall of toolCalls) {
+    if (toolCall.status !== "failed") {
+      continue;
+    }
+    errors.push({
+      toolCallId: toolCall.toolCallId,
+      message: toErrorMessage(toolCall)
+    });
+  }
+  if (additionalErrors) {
+    for (const message2 of additionalErrors) {
+      const text4 = toNonEmptyString(message2);
+      if (text4) {
+        errors.push({ message: text4 });
       }
-      assertReady(operation) {
-        if (this.lifecycleState === "ready") {
-          return;
-        }
-        if (this.lifecycleState === "uninitialized") {
-          throw new Error(`Cannot call "${operation}" before initialize().`);
-        }
-        throw new Error(`Cannot call "${operation}" before authentication completes.`);
+    }
+  }
+  return errors;
+}
+function toErrorMessage(toolCall) {
+  if (typeof toolCall.rawOutput === "string" && toolCall.rawOutput.length > 0) {
+    return toolCall.rawOutput;
+  }
+  if (toolCall.rawOutput instanceof Error && toolCall.rawOutput.message.length > 0) {
+    return toolCall.rawOutput.message;
+  }
+  if (toolCall.rawOutput !== void 0 && toolCall.rawOutput !== null) {
+    const encoded = trySerialize(toolCall.rawOutput);
+    if (encoded) {
+      return encoded;
+    }
+  }
+  return `${toolCall.title} failed`;
+}
+function trySerialize(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    if (typeof serialized === "string" && serialized.length > 0) {
+      return serialized;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function toNonEmptyString(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return void 0;
+  }
+  return value;
+}
+var init_run_report = __esm({
+  "packages/poe-acp-client/src/run-report.ts"() {
+    "use strict";
+    init_stream_helpers();
+  }
+});
+
+// packages/poe-acp-client/src/index.ts
+var init_src7 = __esm({
+  "packages/poe-acp-client/src/index.ts"() {
+    "use strict";
+    init_acp_client();
+    init_acp_transport();
+    init_types3();
+    init_jsonrpc_message_layer();
+    init_jsonrpc();
+    init_run_report();
+    init_stream_helpers();
+  }
+});
+
+// packages/agent-spawn/src/acp/replay.ts
+import path9 from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { open, readdir } from "node:fs/promises";
+import { createInterface as createInterface2 } from "node:readline";
+var init_replay = __esm({
+  "packages/agent-spawn/src/acp/replay.ts"() {
+    "use strict";
+    init_src7();
+    init_renderer2();
+  }
+});
+
+// packages/agent-spawn/src/adapters/utils.ts
+function truncate2(text4, maxLength) {
+  if (text4.length <= maxLength) return text4;
+  if (maxLength <= 3) return text4.slice(0, maxLength);
+  return `${text4.slice(0, maxLength - 3)}...`;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function extractThreadId(value) {
+  if (!value || typeof value !== "object") return;
+  const obj = value;
+  const maybeThreadId = isNonEmptyString(obj.thread_id) && obj.thread_id || isNonEmptyString(obj.threadId) && obj.threadId || isNonEmptyString(obj.threadID) && obj.threadID || isNonEmptyString(obj.session_id) && obj.session_id || isNonEmptyString(obj.sessionId) && obj.sessionId || isNonEmptyString(obj.sessionID) && obj.sessionID;
+  return maybeThreadId || void 0;
+}
+var init_utils2 = __esm({
+  "packages/agent-spawn/src/adapters/utils.ts"() {
+    "use strict";
+  }
+});
+
+// packages/agent-spawn/src/adapters/claude.ts
+function extractTitle(name, input) {
+  const keys = TITLE_KEYS[name];
+  if (keys && input && typeof input === "object") {
+    const obj = input;
+    for (const key of keys) {
+      const value = obj[key];
+      if (typeof value === "string" && value.length > 0) {
+        return truncate2(value, 80);
       }
-      registerCapabilityHandlers(capabilities) {
-        if (!this.hasRegisteredFsReadHandler && capabilities?.fs?.readTextFile === true && this.fsHandler?.readTextFile) {
-          const readTextFile = this.fsHandler.readTextFile;
-          this.transport.onRequest(
-            "fs/read_text_file",
-            async (params) => {
-              assertAbsolutePath(params.path);
-              assertOneBasedLineNumber(params.line);
-              const content = await readTextFile({
-                sessionId: params.sessionId,
-                path: params.path,
-                line: params.line,
-                limit: params.limit
-              });
-              return { content };
-            }
-          );
-          this.hasRegisteredFsReadHandler = true;
-        }
-        if (!this.hasRegisteredFsWriteHandler && capabilities?.fs?.writeTextFile === true && this.fsHandler?.writeTextFile) {
-          const writeTextFile = this.fsHandler.writeTextFile;
-          this.transport.onRequest(
-            "fs/write_text_file",
-            async (params) => {
-              assertAbsolutePath(params.path);
-              await writeTextFile({
-                sessionId: params.sessionId,
-                path: params.path,
-                content: params.content
-              });
-              return {};
-            }
-          );
-          this.hasRegisteredFsWriteHandler = true;
+    }
+  }
+  return name;
+}
+async function* adaptClaude(lines) {
+  const toolKindsById = /* @__PURE__ */ new Map();
+  let emittedSessionStart = false;
+  for await (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    const firstChar = line[0];
+    if (firstChar !== "{" && firstChar !== "[") {
+      continue;
+    }
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch (error2) {
+      const stack = error2 instanceof Error ? error2.stack : void 0;
+      yield {
+        event: "error",
+        message: `[adaptClaude] Malformed JSON line: ${truncate2(line, 200)}`,
+        stack
+      };
+      continue;
+    }
+    const eventType = event.type;
+    if (!isNonEmptyString(eventType)) continue;
+    if (!emittedSessionStart) {
+      const threadId = extractThreadId(event);
+      emittedSessionStart = true;
+      yield { event: "session_start", threadId };
+    }
+    if (eventType === "result") {
+      const usage = event.usage ?? {};
+      const inputTokens = typeof usage.input_tokens === "number" ? usage.input_tokens : typeof event.input_tokens === "number" ? event.input_tokens : typeof event.num_input_tokens === "number" ? event.num_input_tokens : 0;
+      const outputTokens = typeof usage.output_tokens === "number" ? usage.output_tokens : typeof event.output_tokens === "number" ? event.output_tokens : typeof event.num_output_tokens === "number" ? event.num_output_tokens : 0;
+      const costUsd = typeof usage.cost_usd === "number" ? usage.cost_usd : typeof event.cost_usd === "number" ? event.cost_usd : void 0;
+      yield { event: "usage", inputTokens, outputTokens, costUsd };
+      continue;
+    }
+    if (eventType !== "assistant" && eventType !== "user") continue;
+    const message2 = event.message ?? null;
+    if (!message2 || typeof message2 !== "object") continue;
+    const content = message2.content ?? null;
+    if (!Array.isArray(content)) continue;
+    for (const block of content) {
+      const item = block;
+      if (!item || typeof item !== "object") continue;
+      const blockType = item.type;
+      if (!isNonEmptyString(blockType)) continue;
+      if (eventType === "assistant") {
+        if (blockType === "text" && isNonEmptyString(item.text)) {
+          yield {
+            event: "agent_message",
+            text: item.text
+          };
+          continue;
         }
-        if (!this.hasRegisteredTerminalHandlers && capabilities?.terminal === true && this.terminalHandler) {
-          const terminalHandler = this.terminalHandler;
-          this.transport.onRequest(
-            "terminal/create",
-            async (params) => {
-              const terminalId = await terminalHandler.create({
-                sessionId: params.sessionId,
-                command: params.command,
-                args: params.args,
-                cwd: params.cwd,
-                env: params.env,
-                outputByteLimit: params.outputByteLimit
-              });
-              this.trackTerminal(params.sessionId, terminalId);
-              return { terminalId };
-            }
-          );
-          this.transport.onRequest(
-            "terminal/output",
-            async (params) => {
-              this.assertKnownTerminal(params.sessionId, params.terminalId);
-              return terminalHandler.output({
-                sessionId: params.sessionId,
-                terminalId: params.terminalId
-              });
-            }
-          );
-          this.transport.onRequest(
-            "terminal/wait_for_exit",
-            async (params) => {
-              this.assertKnownTerminal(params.sessionId, params.terminalId);
-              return terminalHandler.waitForExit({
-                sessionId: params.sessionId,
-                terminalId: params.terminalId
-              });
-            }
-          );
-          this.transport.onRequest(
-            "terminal/kill",
-            async (params) => {
-              this.assertKnownTerminal(params.sessionId, params.terminalId);
-              await terminalHandler.kill({
-                sessionId: params.sessionId,
-                terminalId: params.terminalId
-              });
-              return {};
-            }
-          );
-          this.transport.onRequest(
-            "terminal/release",
-            async (params) => {
-              this.assertKnownTerminal(params.sessionId, params.terminalId);
-              await terminalHandler.release({
-                sessionId: params.sessionId,
-                terminalId: params.terminalId
-              });
-              this.untrackTerminal(params.sessionId, params.terminalId);
-              return {};
-            }
-          );
-          this.hasRegisteredTerminalHandlers = true;
+        if (blockType === "tool_use" && isNonEmptyString(item.id) && isNonEmptyString(item.name)) {
+          const kind = TOOL_KIND_MAP[item.name] ?? "other";
+          toolKindsById.set(item.id, kind);
+          yield {
+            event: "tool_start",
+            id: item.id,
+            kind,
+            title: extractTitle(item.name, item.input),
+            input: item.input
+          };
         }
+        continue;
       }
-      assertMcpServerCapabilitySupport(mcpServers) {
-        const mcpCapabilities = this.negotiatedAgentCapabilities?.mcpCapabilities;
-        for (const mcpServer of mcpServers) {
-          if (!("type" in mcpServer)) {
-            continue;
-          }
-          if (mcpServer.type === "http" && mcpCapabilities?.http !== true) {
-            throw new Error('Agent does not support MCP server type "http".');
-          }
-          if (mcpServer.type === "sse" && mcpCapabilities?.sse !== true) {
-            throw new Error('Agent does not support MCP server type "sse".');
+      if (eventType === "user") {
+        if (!isNonEmptyString(item.tool_use_id)) continue;
+        if (blockType !== "tool_result") continue;
+        const kind = toolKindsById.get(item.tool_use_id);
+        toolKindsById.delete(item.tool_use_id);
+        let path54;
+        if (typeof item.content === "string") {
+          path54 = item.content;
+        } else {
+          try {
+            path54 = JSON.stringify(item.content);
+          } catch {
+            path54 = String(item.content);
           }
         }
+        yield {
+          event: "tool_complete",
+          id: item.tool_use_id,
+          kind,
+          path: path54
+        };
       }
-      handleSessionUpdateNotification(notification) {
-        const activePrompt = this.activePromptUpdates.get(notification.sessionId);
-        if (!activePrompt) {
-          return;
-        }
-        activePrompt.push({
-          jsonrpc: "2.0",
-          method: "session/update",
-          params: notification
-        });
+    }
+  }
+}
+var TOOL_KIND_MAP, TITLE_KEYS;
+var init_claude = __esm({
+  "packages/agent-spawn/src/adapters/claude.ts"() {
+    "use strict";
+    init_utils2();
+    TOOL_KIND_MAP = {
+      Read: "read",
+      Write: "edit",
+      Edit: "edit",
+      NotebookEdit: "edit",
+      Bash: "exec",
+      Glob: "search",
+      Grep: "search",
+      Task: "think"
+    };
+    TITLE_KEYS = {
+      Bash: ["command"],
+      Read: ["file_path"],
+      Write: ["file_path"],
+      Edit: ["file_path"],
+      NotebookEdit: ["notebook_path"],
+      Glob: ["pattern"],
+      Grep: ["pattern"],
+      Task: ["description", "prompt"]
+    };
+  }
+});
+
+// packages/agent-spawn/src/adapters/codex.ts
+async function* adaptCodex(lines) {
+  const toolTitleById = /* @__PURE__ */ new Map();
+  const toolKindById = /* @__PURE__ */ new Map();
+  for await (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch (error2) {
+      const stack = error2 instanceof Error ? error2.stack : void 0;
+      yield {
+        event: "error",
+        message: `[adaptCodex] Malformed JSON line: ${truncate2(line, 200)}`,
+        stack
+      };
+      continue;
+    }
+    const eventType = event.type;
+    if (!isNonEmptyString(eventType)) continue;
+    if (eventType === "thread.started") {
+      const maybeThreadId = extractThreadId(event);
+      yield { event: "session_start", threadId: maybeThreadId };
+      continue;
+    }
+    if (eventType === "turn.started") {
+      continue;
+    }
+    if (eventType === "turn.completed") {
+      const usage = event.usage ?? {};
+      const inputTokens = typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
+      const outputTokens = typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
+      const cachedTokens = typeof usage.cached_input_tokens === "number" ? usage.cached_input_tokens : 0;
+      yield { event: "usage", inputTokens, outputTokens, cachedTokens };
+      continue;
+    }
+    if (eventType === "turn.failed") {
+      const message2 = extractErrorMessage(event) ?? "Turn failed";
+      yield { event: "error", message: message2 };
+      continue;
+    }
+    const item = event.item ?? null;
+    if (!item || typeof item !== "object") continue;
+    const itemType = item.type;
+    if (!isNonEmptyString(itemType)) continue;
+    if (eventType === "item.started") {
+      if (!isNonEmptyString(item.id)) continue;
+      let kind;
+      let title;
+      if (itemType === "command_execution") {
+        kind = "exec";
+        title = truncate2(isNonEmptyString(item.command) ? item.command : "", 80);
+      } else if (itemType === "file_edit") {
+        kind = "edit";
+        title = isNonEmptyString(item.path) ? item.path : "";
+      } else if (itemType === "thinking") {
+        kind = "think";
+        title = "thinking...";
+      } else if (itemType === "mcp_tool_call") {
+        const server = isNonEmptyString(item.server) ? item.server : "unknown";
+        const tool = isNonEmptyString(item.tool) ? item.tool : "unknown";
+        kind = "other";
+        title = `${server}.${tool}`;
       }
-      trackTerminal(sessionId, terminalId) {
-        const sessionTerminals = this.trackedTerminalIds.get(sessionId);
-        if (sessionTerminals) {
-          sessionTerminals.add(terminalId);
-          return;
-        }
-        this.trackedTerminalIds.set(sessionId, /* @__PURE__ */ new Set([terminalId]));
+      if (kind && title !== void 0) {
+        toolTitleById.set(item.id, title);
+        toolKindById.set(item.id, kind);
+        yield { event: "tool_start", id: item.id, kind, title };
       }
-      assertKnownTerminal(sessionId, terminalId) {
-        const sessionTerminals = this.trackedTerminalIds.get(sessionId);
-        if (sessionTerminals?.has(terminalId) === true) {
-          return;
-        }
-        throw resourceNotFound(`terminal "${terminalId}"`);
+      continue;
+    }
+    if (eventType === "item.completed") {
+      if (itemType === "agent_message") {
+        if (!isNonEmptyString(item.text)) continue;
+        yield { event: "agent_message", text: item.text };
+        continue;
       }
-      untrackTerminal(sessionId, terminalId) {
-        const sessionTerminals = this.trackedTerminalIds.get(sessionId);
-        if (!sessionTerminals) {
-          return;
-        }
-        sessionTerminals.delete(terminalId);
-        if (sessionTerminals.size === 0) {
-          this.trackedTerminalIds.delete(sessionId);
-        }
+      if (itemType === "reasoning") {
+        const text4 = isNonEmptyString(item.text) ? item.text : isNonEmptyString(item.content) ? item.content : isNonEmptyString(item.summary) ? item.summary : void 0;
+        if (!text4) continue;
+        yield { event: "reasoning", text: text4 };
+        continue;
       }
-      assertPromptContentCapabilitySupport(content) {
-        const promptCapabilities = this.negotiatedAgentCapabilities?.promptCapabilities;
-        for (const block of content) {
-          if (block.type === "image" && promptCapabilities?.image !== true) {
-            throw new Error('Agent does not support prompt content type "image".');
-          }
-          if (block.type === "audio" && promptCapabilities?.audio !== true) {
-            throw new Error('Agent does not support prompt content type "audio".');
-          }
-          if (block.type === "resource" && promptCapabilities?.embeddedContext !== true) {
-            throw new Error('Agent does not support prompt content type "resource".');
-          }
-        }
+      if (!isNonEmptyString(item.id)) continue;
+      if (itemType === "command_execution" || itemType === "file_edit" || itemType === "mcp_tool_call") {
+        const kindFromStart = toolKindById.get(item.id);
+        const kind = kindFromStart ?? (itemType === "command_execution" ? "exec" : itemType === "file_edit" ? "edit" : "other");
+        const titleFromEvent = isNonEmptyString(item.path) ? item.path : itemType === "mcp_tool_call" ? `${isNonEmptyString(item.server) ? item.server : "unknown"}.${isNonEmptyString(item.tool) ? item.tool : "unknown"}` : void 0;
+        const path54 = titleFromEvent ?? toolTitleById.get(item.id) ?? "";
+        toolTitleById.delete(item.id);
+        toolKindById.delete(item.id);
+        yield { event: "tool_complete", id: item.id, kind, path: path54 };
       }
-    };
+    }
+  }
+}
+function extractErrorMessage(event) {
+  if (isNonEmptyString(event.message)) return event.message;
+  const error2 = event.error;
+  if (isNonEmptyString(error2)) return error2;
+  if (typeof error2 === "object" && error2 !== null) {
+    const errorObj = error2;
+    if (isNonEmptyString(errorObj.message)) return errorObj.message;
+  }
+  if (isNonEmptyString(event.reason)) return event.reason;
+  return void 0;
+}
+var init_codex3 = __esm({
+  "packages/agent-spawn/src/adapters/codex.ts"() {
+    "use strict";
+    init_utils2();
   }
 });
 
-// packages/poe-acp-client/src/jsonrpc.ts
-var init_jsonrpc = __esm({
-  "packages/poe-acp-client/src/jsonrpc.ts"() {
+// packages/agent-spawn/src/adapters/kimi.ts
+async function* adaptKimi(lines) {
+  let emittedSessionStart = false;
+  for await (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch (error2) {
+      const stack = error2 instanceof Error ? error2.stack : void 0;
+      yield {
+        event: "error",
+        message: `[adaptKimi] Malformed JSON line: ${truncate2(line, 200)}`,
+        stack
+      };
+      continue;
+    }
+    if (!event || typeof event !== "object") continue;
+    if (!emittedSessionStart) {
+      const threadId = extractThreadId(event);
+      if (threadId) {
+        emittedSessionStart = true;
+        yield { event: "session_start", threadId };
+      }
+    }
+    const role = event.role;
+    if (!isNonEmptyString(role) || role !== "assistant") continue;
+    const content = event.content;
+    if (!isNonEmptyString(content)) continue;
+    yield { event: "agent_message", text: content };
+  }
+}
+var init_kimi3 = __esm({
+  "packages/agent-spawn/src/adapters/kimi.ts"() {
     "use strict";
+    init_utils2();
   }
 });
 
-// packages/poe-acp-client/src/stream-helpers.ts
-async function extractUsageFromSessionUpdateStream(stream) {
-  const updates = [];
-  for await (const entry of stream) {
-    const update = toSessionUpdate(entry);
-    if (update.sessionUpdate === "usage_update") {
-      updates.push(update);
+// packages/agent-spawn/src/adapters/native.ts
+async function* adaptNative(lines) {
+  for await (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch (error2) {
+      const stack = error2 instanceof Error ? error2.stack : void 0;
+      yield {
+        event: "error",
+        message: `[adaptNative] Malformed JSON line: ${truncate2(line, 200)}`,
+        stack
+      };
+      continue;
+    }
+    const maybeEventType = event?.event;
+    if (!isNonEmptyString(maybeEventType)) {
+      yield {
+        event: "error",
+        message: `[adaptNative] Line missing string "event" field: ${truncate2(line, 200)}`
+      };
+      continue;
     }
+    yield event;
   }
-  return updates;
 }
-async function extractToolCallSummariesFromSessionUpdateStream(stream) {
-  const summaries = /* @__PURE__ */ new Map();
-  for await (const entry of stream) {
-    const update = toSessionUpdate(entry);
-    if (update.sessionUpdate === "tool_call") {
-      const summary = {
-        toolCallId: update.toolCallId,
-        title: update.title
+var init_native = __esm({
+  "packages/agent-spawn/src/adapters/native.ts"() {
+    "use strict";
+    init_utils2();
+  }
+});
+
+// packages/agent-spawn/src/adapters/opencode.ts
+function guessToolKind(toolName) {
+  const normalized = toolName.toLowerCase();
+  if (normalized === "bash" || normalized === "shell" || normalized === "sh") return "exec";
+  if (normalized.includes("read")) return "read";
+  if (normalized.includes("write") || normalized.includes("edit") || normalized.includes("patch")) {
+    return "edit";
+  }
+  if (normalized.includes("search") || normalized.includes("grep") || normalized.includes("glob") || normalized.includes("find")) {
+    return "search";
+  }
+  if (normalized.includes("think") || normalized.includes("task")) return "think";
+  return "other";
+}
+function safeStringify(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+async function* adaptOpenCode(lines) {
+  let emittedSessionStart = false;
+  const toolKindById = /* @__PURE__ */ new Map();
+  for await (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch (error2) {
+      const stack = error2 instanceof Error ? error2.stack : void 0;
+      yield {
+        event: "error",
+        message: `[adaptOpenCode] Malformed JSON line: ${truncate2(line, 200)}`,
+        stack
       };
-      if (update.kind !== void 0) {
-        summary.kind = update.kind;
-      }
-      if (update.status !== void 0) {
-        summary.status = update.status;
-      }
-      if (update.rawInput !== void 0) {
-        summary.rawInput = update.rawInput;
+      continue;
+    }
+    if (!event || typeof event !== "object") continue;
+    const sessionID = extractThreadId(event);
+    if (!emittedSessionStart && isNonEmptyString(sessionID)) {
+      emittedSessionStart = true;
+      yield { event: "session_start", threadId: sessionID };
+    }
+    const eventType = event.type;
+    if (!isNonEmptyString(eventType)) continue;
+    if (eventType === "text") {
+      const part = event.part ?? null;
+      if (!part || typeof part !== "object") continue;
+      if (!isNonEmptyString(part.text)) continue;
+      yield { event: "agent_message", text: part.text };
+      continue;
+    }
+    if (eventType === "tool_use") {
+      const part = event.part ?? null;
+      if (!part || typeof part !== "object") continue;
+      if (!isNonEmptyString(part.callID) || !isNonEmptyString(part.tool)) continue;
+      const state = part.state ?? null;
+      if (!state || typeof state !== "object") continue;
+      const kind = guessToolKind(part.tool);
+      const status = state.status;
+      const terminal = status === "completed" || status === "failed";
+      if (!toolKindById.has(part.callID)) {
+        toolKindById.set(part.callID, kind);
+        let title = part.tool;
+        const maybeInput = state.input;
+        if (kind === "exec" && maybeInput && typeof maybeInput === "object") {
+          const command = maybeInput.command;
+          if (isNonEmptyString(command)) {
+            title = truncate2(command, 80);
+          }
+        }
+        yield {
+          event: "tool_start",
+          id: part.callID,
+          kind,
+          title,
+          input: state.input
+        };
       }
-      if (update.rawOutput !== void 0) {
-        summary.rawOutput = update.rawOutput;
+      if (terminal) {
+        const kindFromStart = toolKindById.get(part.callID) ?? kind;
+        toolKindById.delete(part.callID);
+        yield {
+          event: "tool_complete",
+          id: part.callID,
+          kind: kindFromStart,
+          path: safeStringify(state.output)
+        };
       }
-      summaries.set(update.toolCallId, summary);
       continue;
     }
-    if (update.sessionUpdate === "tool_call_update") {
-      const existing = summaries.get(update.toolCallId);
-      const summary = existing ?? {
-        toolCallId: update.toolCallId,
-        title: toTitle(update.title, update.toolCallId)
-      };
-      if (update.title !== null && update.title !== void 0 && update.title.length > 0) {
-        summary.title = update.title;
-      }
-      if (update.kind !== null && update.kind !== void 0) {
-        summary.kind = update.kind;
-      }
-      if (update.status !== null && update.status !== void 0) {
-        summary.status = update.status;
-      }
-      if (update.rawInput !== void 0) {
-        summary.rawInput = update.rawInput;
-      }
-      if (update.rawOutput !== void 0) {
-        summary.rawOutput = update.rawOutput;
-      }
-      summaries.set(update.toolCallId, summary);
+    if (eventType === "step_finish") {
+      const part = event.part ?? null;
+      if (!part || typeof part !== "object") continue;
+      const tokens = part.tokens ?? null;
+      if (!tokens || typeof tokens !== "object") continue;
+      const inputTokens = typeof tokens.input === "number" ? tokens.input : 0;
+      const outputTokens = typeof tokens.output === "number" ? tokens.output : 0;
+      const cache = tokens.cache ?? null;
+      const cachedTokens = cache && typeof cache === "object" && typeof cache.read === "number" ? cache.read : void 0;
+      if (inputTokens === 0 && outputTokens === 0 && cachedTokens === void 0) continue;
+      yield { event: "usage", inputTokens, outputTokens, cachedTokens };
+      continue;
     }
   }
-  return Array.from(summaries.values());
 }
-function toSessionUpdate(entry) {
-  if (isSessionUpdateNotification(entry)) {
-    return entry.params.update;
+var init_opencode3 = __esm({
+  "packages/agent-spawn/src/adapters/opencode.ts"() {
+    "use strict";
+    init_utils2();
   }
-  return entry;
-}
-function isSessionUpdateNotification(entry) {
-  return typeof entry.jsonrpc === "string" && entry.method === "session/update";
-}
-function toTitle(value, fallback) {
-  if (typeof value === "string" && value.length > 0) {
-    return value;
+});
+
+// packages/agent-spawn/src/adapters/index.ts
+function getAdapter(type) {
+  const adapter = adapters[type];
+  if (!adapter) {
+    throw new Error(`Unknown adapter "${String(type)}".`);
   }
-  return fallback;
+  return adapter;
 }
-var init_stream_helpers = __esm({
-  "packages/poe-acp-client/src/stream-helpers.ts"() {
+var adapters;
+var init_adapters = __esm({
+  "packages/agent-spawn/src/adapters/index.ts"() {
     "use strict";
+    init_claude();
+    init_codex3();
+    init_kimi3();
+    init_native();
+    init_opencode3();
+    init_codex3();
+    init_claude();
+    init_kimi3();
+    init_native();
+    init_opencode3();
+    adapters = {
+      codex: adaptCodex,
+      claude: adaptClaude,
+      kimi: adaptKimi,
+      native: adaptNative,
+      opencode: adaptOpenCode
+    };
   }
 });
 
-// packages/poe-acp-client/src/run-report.ts
-import * as fsPromises from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
-import { join } from "node:path";
-async function generateRunReportFromSessionUpdateStream(stream, options = {}) {
-  const now = options.now ?? (() => /* @__PURE__ */ new Date());
-  const bufferedEntries = [];
-  let runIdFromStream;
-  for await (const entry of stream) {
-    bufferedEntries.push(entry);
-    if (runIdFromStream) {
-      continue;
-    }
-    if (isSessionUpdateNotification2(entry)) {
-      const sessionId = toNonEmptyString(entry.params.sessionId);
-      if (sessionId) {
-        runIdFromStream = sessionId;
-      }
+// packages/agent-spawn/src/acp/line-reader.ts
+function chunkToString2(chunk) {
+  if (typeof chunk === "string") return chunk;
+  if (chunk instanceof Uint8Array) return Buffer.from(chunk).toString("utf8");
+  return String(chunk);
+}
+async function* readLines2(stream) {
+  let buffer = "";
+  for await (const chunk of stream) {
+    buffer += chunkToString2(chunk);
+    while (true) {
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex === -1) break;
+      yield buffer.slice(0, newlineIndex);
+      buffer = buffer.slice(newlineIndex + 1);
     }
   }
-  const runId = toNonEmptyString(options.runId) ?? runIdFromStream;
-  if (!runId) {
-    throw new Error("Run id is required via options.runId or session/update stream items");
+  if (buffer.length > 0) {
+    yield buffer;
   }
-  const startTime = normalizeTime(options.startTime, now);
-  const endTime = normalizeTime(options.endTime, now);
-  const toolCalls = await extractToolCallSummariesFromSessionUpdateStream(bufferedEntries);
-  const usageUpdates = await extractUsageFromSessionUpdateStream(bufferedEntries);
-  const usage = summarizeUsage(usageUpdates);
-  const errors = collectErrors(toolCalls, options.errors);
-  const exitStatus = options.exitStatus ?? (errors.length > 0 ? "failed" : "success");
-  return {
-    runId,
-    startTime,
-    endTime,
-    exitStatus,
-    toolCalls,
-    usage,
-    errors
-  };
-}
-function isSessionUpdateNotification2(entry) {
-  return typeof entry.jsonrpc === "string" && entry.method === "session/update";
 }
-function normalizeTime(value, now) {
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  if (typeof value === "string" && value.length > 0) {
-    const parsed = new Date(value);
-    if (!Number.isNaN(parsed.getTime())) {
-      return parsed.toISOString();
-    }
+var init_line_reader = __esm({
+  "packages/agent-spawn/src/acp/line-reader.ts"() {
+    "use strict";
   }
-  return now().toISOString();
+});
+
+// packages/agent-spawn/src/acp/spawn.ts
+import { spawn as spawnChildProcess4 } from "node:child_process";
+function createAbortError2() {
+  const error2 = new Error("Agent spawn aborted");
+  error2.name = "AbortError";
+  return error2;
 }
-function summarizeUsage(updates) {
-  let used = 0;
-  let size = 0;
-  let cost;
-  for (const update of updates) {
-    used += update.used;
-    size += update.size;
-    if (update.cost !== void 0) {
-      cost = update.cost;
-    }
-  }
-  const usage = {
-    used,
-    size,
-    updates: updates.length
-  };
-  if (cost !== void 0) {
-    usage.cost = cost;
-  }
-  return usage;
+function createActivityTimeoutError2(timeoutMs) {
+  const error2 = new Error(
+    `Agent spawn timed out after ${timeoutMs / 1e3}s of inactivity`
+  );
+  error2.name = "ActivityTimeoutError";
+  return error2;
 }
-function collectErrors(toolCalls, additionalErrors) {
-  const errors = [];
-  for (const toolCall of toolCalls) {
-    if (toolCall.status !== "failed") {
-      continue;
-    }
-    errors.push({
-      toolCallId: toolCall.toolCallId,
-      message: toErrorMessage(toolCall)
-    });
-  }
-  if (additionalErrors) {
-    for (const message2 of additionalErrors) {
-      const text4 = toNonEmptyString(message2);
-      if (text4) {
-        errors.push({ message: text4 });
-      }
-    }
-  }
-  return errors;
+function isAcpEvent(value) {
+  return !!value && typeof value === "object" && "event" in value;
 }
-function toErrorMessage(toolCall) {
-  if (typeof toolCall.rawOutput === "string" && toolCall.rawOutput.length > 0) {
-    return toolCall.rawOutput;
+function getDefaultArgsPosition2(config) {
+  return config.defaultArgsPosition ?? "afterPrompt";
+}
+function getMcpArgsPosition2(config) {
+  if (config.mcpArgsPosition) {
+    return config.mcpArgsPosition;
   }
-  if (toolCall.rawOutput instanceof Error && toolCall.rawOutput.message.length > 0) {
-    return toolCall.rawOutput.message;
+  return config.mcpArgsBeforeCommand ? "beforeCommand" : "afterCommand";
+}
+function spawnStreaming(options) {
+  if (options.signal?.aborted) {
+    throw createAbortError2();
   }
-  if (toolCall.rawOutput !== void 0 && toolCall.rawOutput !== null) {
-    const encoded = trySerialize(toolCall.rawOutput);
-    if (encoded) {
-      return encoded;
-    }
+  const { agentId, binaryName, spawnConfig } = resolveConfig(options.agentId);
+  if (spawnConfig === void 0) {
+    throw new Error(`Agent "${agentId}" has no spawn config.`);
   }
-  return `${toolCall.title} failed`;
-}
-function trySerialize(value) {
-  try {
-    const serialized = JSON.stringify(value);
-    if (typeof serialized === "string" && serialized.length > 0) {
-      return serialized;
-    }
-  } catch {
-    return void 0;
+  if (spawnConfig.kind !== "cli") {
+    throw new Error(`Agent "${agentId}" does not support CLI spawn.`);
   }
-  return void 0;
-}
-function toNonEmptyString(value) {
-  if (typeof value !== "string" || value.length === 0) {
-    return void 0;
+  if (!binaryName) {
+    throw new Error(`Agent "${agentId}" has no binaryName.`);
   }
-  return value;
-}
-var init_run_report = __esm({
-  "packages/poe-acp-client/src/run-report.ts"() {
-    "use strict";
-    init_stream_helpers();
+  const mcpArgs = getMcpArgs(spawnConfig, options.mcpServers);
+  const mcpEnvVars = getMcpEnv(spawnConfig, options.mcpServers);
+  const defaultArgsPosition = getDefaultArgsPosition2(spawnConfig);
+  const mcpArgsPosition = getMcpArgsPosition2(spawnConfig);
+  const args = [];
+  if (mcpArgsPosition === "beforeCommand") {
+    args.push(...mcpArgs);
   }
-});
-
-// packages/poe-acp-client/src/index.ts
-var init_src7 = __esm({
-  "packages/poe-acp-client/src/index.ts"() {
-    "use strict";
-    init_acp_client();
-    init_acp_transport();
-    init_types3();
-    init_jsonrpc_message_layer();
-    init_jsonrpc();
-    init_run_report();
-    init_stream_helpers();
+  if (defaultArgsPosition === "beforePrompt") {
+    args.push(...spawnConfig.defaultArgs);
   }
-});
-
-// packages/agent-spawn/src/acp/spawn-acp.ts
-function toRenderKind(kind) {
-  if (kind === "execute") return "exec";
-  if (kind === "write") return "edit";
-  if (kind === "read") return "read";
-  return "other";
-}
-function toToolTitle(title, locations) {
-  if (locations && locations.length > 0 && locations[0].path) {
-    return locations[0].path;
+  if (mcpArgsPosition === "beforePrompt") {
+    args.push(...mcpArgs);
   }
-  return title;
-}
-function toToolOutput(value) {
-  if (typeof value === "string") return value;
-  if (value === void 0 || value === null) return "";
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
+  args.push(spawnConfig.promptFlag);
+  const useStdin = !!options.useStdin && !!spawnConfig.stdinMode;
+  if (!useStdin || !spawnConfig.stdinMode?.omitPrompt) {
+    args.push(options.prompt);
   }
-}
-function extractToolOutputText(update) {
-  const raw = toToolOutput(update.rawOutput);
-  if (raw) return raw;
-  if (!update.content) return "";
-  return update.content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join("");
-}
-function toEventsFromSessionUpdate(notification, state) {
-  const update = notification.params.update;
-  if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
-    return [{ event: "agent_message", text: update.content.text }];
+  if (options.model && spawnConfig.modelFlag) {
+    let model = spawnConfig.modelStripProviderPrefix ? stripModelNamespace(options.model) : options.model;
+    if (spawnConfig.modelTransform) model = spawnConfig.modelTransform(model);
+    args.push(spawnConfig.modelFlag, model);
   }
-  if (update.sessionUpdate === "agent_thought_chunk" && update.content.type === "text") {
-    return [{ event: "reasoning", text: update.content.text }];
+  if (defaultArgsPosition === "afterPrompt") {
+    args.push(...spawnConfig.defaultArgs);
   }
-  if (update.sessionUpdate === "usage_update") {
-    const cachedTokens = Math.max(0, update.size - update.used);
-    const usage = {
-      event: "usage",
-      inputTokens: update.used,
-      outputTokens: 0
-    };
-    if (cachedTokens > 0) {
-      usage.cachedTokens = cachedTokens;
-    }
-    if (update.cost && update.cost.currency === "USD") {
-      usage.costUsd = update.cost.amount;
-    }
-    return [usage];
+  if (mcpArgsPosition === "afterCommand") {
+    args.push(...mcpArgs);
   }
-  if (update.sessionUpdate === "tool_call") {
-    const renderKind = toRenderKind(update.kind);
-    const title = toToolTitle(update.title, update.locations);
-    state.toolCallKinds.set(update.toolCallId, renderKind);
-    state.toolCallTitles.set(update.toolCallId, title);
-    if (state.startedToolCalls.has(update.toolCallId)) {
-      return [];
-    }
-    state.startedToolCalls.add(update.toolCallId);
-    return [{
-      event: "tool_start",
-      kind: renderKind,
-      title,
-      id: update.toolCallId
-    }];
+  const modeResolved = resolveModeConfig(spawnConfig.modes[options.mode ?? "yolo"]);
+  args.push(...modeResolved.args);
+  if (useStdin) {
+    args.push(...spawnConfig.stdinMode.extraArgs);
   }
-  if (update.sessionUpdate === "tool_call_update") {
-    const renderKind = toRenderKind(update.kind ?? void 0) || state.toolCallKinds.get(update.toolCallId) || "other";
-    state.toolCallKinds.set(update.toolCallId, renderKind);
-    const events = [];
-    const toolTitle = toToolTitle(
-      state.toolCallTitles.get(update.toolCallId) ?? update.toolCallId,
-      update.locations
-    );
-    state.toolCallTitles.set(update.toolCallId, toolTitle);
-    const status = update.status;
-    const shouldStart = !state.startedToolCalls.has(update.toolCallId) && (status === "pending" || status === "in_progress");
-    if (shouldStart) {
-      state.startedToolCalls.add(update.toolCallId);
-      events.push({
-        event: "tool_start",
-        kind: renderKind,
-        title: toolTitle,
-        id: update.toolCallId
-      });
+  if (options.args && options.args.length > 0) {
+    args.push(...options.args);
+  }
+  const envOverrides = { ...mcpEnvVars, ...modeResolved.env };
+  const child = spawnChildProcess4(binaryName, args, {
+    cwd: options.cwd,
+    stdio: ["pipe", "pipe", "pipe"],
+    env: Object.keys(envOverrides).length > 0 ? { ...process.env, ...envOverrides } : void 0
+  });
+  let aborted = false;
+  let timedOut = false;
+  const onAbort = () => {
+    aborted = true;
+    child.kill("SIGTERM");
+  };
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  let activityTimer;
+  const resetActivityTimer = options.activityTimeoutMs ? () => {
+    if (activityTimer) clearTimeout(activityTimer);
+    activityTimer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+    }, options.activityTimeoutMs);
+  } : void 0;
+  resetActivityTimer?.();
+  const result = { stdout: "", stderr: "", exitCode: 1 };
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (chunk) => {
+    result.stderr += chunk;
+    resetActivityTimer?.();
+  });
+  if (useStdin) {
+    child.stdin.write(options.prompt);
+  }
+  child.stdin.end();
+  const adapter = getAdapter(spawnConfig.adapter);
+  const events = (async function* () {
+    for await (const output of adapter(readLines2(child.stdout))) {
+      if (!isAcpEvent(output)) continue;
+      resetActivityTimer?.();
+      yield output;
     }
-    if (status === "completed" || status === "failed" || status === "cancelled") {
-      if (!state.startedToolCalls.has(update.toolCallId)) {
-        state.startedToolCalls.add(update.toolCallId);
-        events.push({
-          event: "tool_start",
-          kind: renderKind,
-          title: toolTitle,
-          id: update.toolCallId
-        });
+  })();
+  const done = new Promise((resolve2, reject) => {
+    child.on("error", (error2) => {
+      options.signal?.removeEventListener("abort", onAbort);
+      if (activityTimer) clearTimeout(activityTimer);
+      if (aborted) {
+        reject(createAbortError2());
+        return;
       }
-      events.push({
-        event: "tool_complete",
-        kind: renderKind,
-        path: extractToolOutputText(update),
-        id: update.toolCallId
-      });
-    }
-    return events;
-  }
-  return [];
+      reject(error2);
+    });
+    child.on("close", (code) => {
+      options.signal?.removeEventListener("abort", onAbort);
+      if (activityTimer) clearTimeout(activityTimer);
+      if (aborted) {
+        reject(createAbortError2());
+        return;
+      }
+      if (timedOut) {
+        reject(createActivityTimeoutError2(options.activityTimeoutMs));
+        return;
+      }
+      result.exitCode = code ?? 1;
+      resolve2(result);
+    });
+  });
+  return { events, done };
 }
+var init_spawn2 = __esm({
+  "packages/agent-spawn/src/acp/spawn.ts"() {
+    "use strict";
+    init_adapters();
+    init_line_reader();
+    init_resolve_config();
+    init_mcp_args();
+    init_model_utils();
+    init_types2();
+  }
+});
+
+// packages/agent-spawn/src/acp/spawn-acp.ts
 function toAcpMcpServers(servers) {
   if (!servers) return [];
   return Object.entries(servers).map(([name, server]) => ({
     name,
     command: server.command,
     args: server.args ?? [],
-    env: server.env ? Object.entries(server.env).map(([k2, v]) => ({ name: k2, value: v })) : []
+    env: server.env ? Object.entries(server.env).map(([k, v]) => ({ name: k, value: v })) : []
   }));
 }
 function createAbortError3() {
@@ -11009,11 +11054,7 @@ function spawnAcp(options) {
     void client.dispose();
   };
   options.signal?.addEventListener("abort", onAbort, { once: true });
-  const toolState = {
-    startedToolCalls: /* @__PURE__ */ new Set(),
-    toolCallKinds: /* @__PURE__ */ new Map(),
-    toolCallTitles: /* @__PURE__ */ new Map()
-  };
+  const toolState = createToolRenderState();
   let sessionId = "";
   let assistantText = "";
   let lastToolOutput = "";
@@ -11069,7 +11110,11 @@ function spawnAcp(options) {
         if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
           assistantText += update.content.text;
         }
-        for (const event of toEventsFromSessionUpdate(notification, toolState)) {
+        const events2 = sessionUpdateToEvents(update, toolState);
+        if (events2.length > 0) {
+          events2[0]._meta = { ...events2[0]._meta ?? {}, raw: update };
+        }
+        for (const event of events2) {
           if (event.event === "tool_complete") {
             const output = event.path;
             if (output) {
@@ -11128,6 +11173,7 @@ var init_spawn_acp = __esm({
     init_src2();
     init_src7();
     init_configs();
+    init_session_update_converter();
   }
 });
 
@@ -11378,7 +11424,9 @@ var init_spawn_log = __esm({
           if (!this.fileHandle) {
             return;
           }
-          await this.fileHandle.appendFile(`${JSON.stringify(event)}
+          const meta = event._meta;
+          const toLog = meta?.raw ?? event;
+          await this.fileHandle.appendFile(`${JSON.stringify(toLog)}
 `, "utf8");
         } catch {
           this.isDisabled = true;
@@ -14014,7 +14062,7 @@ function createAbortError4() {
   error2.name = "AbortError";
   return error2;
 }
-var init_utils2 = __esm({
+var init_utils3 = __esm({
   "packages/pipeline/src/utils.ts"() {
     "use strict";
   }
@@ -14240,7 +14288,7 @@ var init_loader = __esm({
   "packages/pipeline/src/config/loader.ts"() {
     "use strict";
     init_src3();
-    init_utils2();
+    init_utils3();
   }
 });
 
@@ -14386,7 +14434,7 @@ function parsePlan(yamlContent, options = {}) {
 var init_parser2 = __esm({
   "packages/pipeline/src/plan/parser.ts"() {
     "use strict";
-    init_utils2();
+    init_utils3();
   }
 });
 
@@ -14588,7 +14636,7 @@ var init_discovery = __esm({
     "use strict";
     init_loader();
     init_parser2();
-    init_utils2();
+    init_utils3();
   }
 });
 
@@ -15647,7 +15695,7 @@ var init_pipeline = __esm({
     init_parser2();
     init_writer();
     init_runner();
-    init_utils2();
+    init_utils3();
   }
 });
 
@@ -17880,6 +17928,7 @@ var init_ralph = __esm({
         this.kind = kind;
         this.name = "RalphWorkflowStopError";
       }
+      kind;
     };
   }
 });
@@ -18073,6 +18122,8 @@ var init_journal = __esm({
         this.journalPath = journalPath;
         this.fs = fs3;
       }
+      journalPath;
+      fs;
       async init() {
         await this.fs.mkdir(dirname2(this.journalPath), { recursive: true });
         try {
@@ -19272,11 +19323,11 @@ function assertValidEnumValues(values) {
     throw new Error("Enum schema values must be unique");
   }
 }
-var S;
+var S2;
 var init_src17 = __esm({
   "packages/cmdkit-schema/src/index.ts"() {
     "use strict";
-    S = {
+    S2 = {
       String(options = {}) {
         return {
           kind: "string",
@@ -20373,7 +20424,7 @@ async function selectAutomationName(message2, automations) {
     message: message2,
     options: automations.map((a) => ({ label: a.label ?? formatLabel(a.name), value: a.name }))
   });
-  if (Ct(selected)) {
+  if (q(selected)) {
     cancel("Operation cancelled.");
     throw new UserError("Operation cancelled.");
   }
@@ -20417,12 +20468,12 @@ var init_commands = __esm({
       name: "run",
       description: "Run a GitHub automation.",
       positional: ["name"],
-      params: S.Object({
-        name: S.Optional(S.String({ description: "Automation name to run" })),
-        agent: S.Optional(S.String({ description: "Agent to run the automation with" })),
-        model: S.Optional(S.String({ description: "Model override for the agent" })),
-        mode: S.Optional(S.Enum(["yolo", "edit", "read"], { description: "Permission mode (yolo | edit | read)" })),
-        cwd: S.Optional(S.String({ description: "Working directory for the automation" }))
+      params: S2.Object({
+        name: S2.Optional(S2.String({ description: "Automation name to run" })),
+        agent: S2.Optional(S2.String({ description: "Agent to run the automation with" })),
+        model: S2.Optional(S2.String({ description: "Model override for the agent" })),
+        mode: S2.Optional(S2.Enum(["yolo", "edit", "read"], { description: "Permission mode (yolo | edit | read)" })),
+        cwd: S2.Optional(S2.String({ description: "Working directory for the automation" }))
       }),
       secrets: {
         poeApiKey: { env: "POE_API_KEY" },
@@ -20503,7 +20554,7 @@ var init_commands = __esm({
     listCommand = defineCommand({
       name: "list",
       description: "List available automations.",
-      params: S.Object({}),
+      params: S2.Object({}),
       scope: ["cli", "sdk"],
       handler: async () => discoverAutomations(await resolveBuiltInPromptsDir(), ...projectPromptDirs(resolveCwd())),
       render: {
@@ -20531,9 +20582,9 @@ var init_commands = __esm({
       name: "install",
       description: "Install one or all automation workflows into the current repo.",
       positional: ["name"],
-      params: S.Object({
-        name: S.Optional(
-          S.Enum(installableAutomations, {
+      params: S2.Object({
+        name: S2.Optional(
+          S2.Enum(installableAutomations, {
             description: "Pick a GitHub workflow to install",
             loadOptions: async () => {
               const automations = await discoverAutomations(await resolveBuiltInPromptsDir());
@@ -20541,7 +20592,7 @@ var init_commands = __esm({
             }
           })
         ),
-        eject: S.Optional(S.Boolean())
+        eject: S2.Optional(S2.Boolean())
       }),
       scope: ["cli"],
       handler: async ({ params }) => {
@@ -20590,8 +20641,8 @@ var init_commands = __esm({
       name: "uninstall",
       description: "Remove an installed automation workflow from the current repo.",
       positional: ["name"],
-      params: S.Object({
-        name: S.Enum(installableAutomations, {
+      params: S2.Object({
+        name: S2.Enum(installableAutomations, {
           description: "Pick a GitHub workflow to uninstall",
           loadOptions: async () => {
             const automations = await discoverAutomations(await resolveBuiltInPromptsDir());
@@ -20625,8 +20676,8 @@ var init_commands = __esm({
       name: "require-user-allow",
       description: "Fail when COMMENT_AUTHOR_ASSOCIATION is not allowed by the automation frontmatter.",
       positional: ["name"],
-      params: S.Object({
-        name: S.String()
+      params: S2.Object({
+        name: S2.String()
       }),
       scope: ["cli"],
       handler: async ({ params, env }) => {
@@ -20639,8 +20690,8 @@ var init_commands = __esm({
       name: "require-comment-prefix",
       description: "Fail when COMMENT_BODY does not start with the automation prefix frontmatter.",
       positional: ["name"],
-      params: S.Object({
-        name: S.String()
+      params: S2.Object({
+        name: S2.String()
       }),
       scope: ["cli"],
       handler: async ({ params, env }) => {
@@ -20653,8 +20704,8 @@ var init_commands = __esm({
       name: "prepare",
       description: "Install and configure the agent required by a workflow automation.",
       positional: ["name"],
-      params: S.Object({
-        name: S.String()
+      params: S2.Object({
+        name: S2.String()
       }),
       scope: ["cli"],
       handler: async ({ params, env }) => {
@@ -20675,8 +20726,8 @@ var init_commands = __esm({
       name: "prompt-preview",
       description: "Preview the resolved prompt for an automation.",
       positional: ["name"],
-      params: S.Object({
-        name: S.String()
+      params: S2.Object({
+        name: S2.String()
       }),
       scope: ["cli", "sdk"],
       handler: async ({ params, env }) => {
@@ -20698,7 +20749,7 @@ var init_commands = __esm({
     variablesCommand = defineCommand({
       name: "variables",
       description: "List shared prompt variables and where each value comes from.",
-      params: S.Object({}),
+      params: S2.Object({}),
       scope: ["cli", "sdk"],
       handler: async () => {
         const cwd = resolveCwd();
@@ -25057,7 +25108,7 @@ function createEventQueue() {
     }
   };
 }
-function createToolRenderState() {
+function createToolRenderState2() {
   return {
     startedToolCalls: /* @__PURE__ */ new Set(),
     toolCallKinds: /* @__PURE__ */ new Map(),
@@ -25209,7 +25260,7 @@ function toPromptText2(prompt) {
   }
   return lines.join("\n");
 }
-function toEventsFromSessionUpdate2(notification, state) {
+function toEventsFromSessionUpdate(notification, state) {
   const update = notification.params.update;
   if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
     return [{ event: "agent_message", text: update.content.text }];
@@ -25407,7 +25458,7 @@ function createInMemoryAcpTransport2(options) {
 }
 async function runPoeAgentAcpLifecycle(options) {
   const sessionUpdates = [];
-  const toolState = createToolRenderState();
+  const toolState = createToolRenderState2();
   let sessionId = "";
   let assistantText = "";
   const transport = createInMemoryAcpTransport2({
@@ -25432,7 +25483,7 @@ async function runPoeAgentAcpLifecycle(options) {
       if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
         assistantText += update.content.text;
       }
-      for (const event of toEventsFromSessionUpdate2(notification, toolState)) {
+      for (const event of toEventsFromSessionUpdate(notification, toolState)) {
         emitEvent(options.onEvent, event);
       }
     }
@@ -26267,7 +26318,7 @@ async function promptForField(field) {
       options,
       initialValue: field.hasDefault ? field.defaultValue : void 0
     });
-    if (Ct(selected)) {
+    if (q(selected)) {
       cancel("Operation cancelled.");
       throw new UserError("Operation cancelled.");
     }
@@ -26278,7 +26329,7 @@ async function promptForField(field) {
       message: field.displayPath,
       initialValue: field.hasDefault ? Boolean(field.defaultValue) : void 0
     });
-    if (Ct(selected)) {
+    if (q(selected)) {
       cancel("Operation cancelled.");
       throw new UserError("Operation cancelled.");
     }
@@ -26288,7 +26339,7 @@ async function promptForField(field) {
     message: field.displayPath,
     initialValue: field.hasDefault && field.defaultValue !== void 0 ? formatResolvedValue(field.defaultValue) : void 0
   });
-  if (Ct(entered)) {
+  if (q(entered)) {
     cancel("Operation cancelled.");
     throw new UserError("Operation cancelled.");
   }
@@ -26851,7 +26902,7 @@ async function executeCommand(state, services, requirementOptions) {
         message: "Proceed?",
         initialValue: true
       });
-      if (Ct(proceed)) {
+      if (q(proceed)) {
         cancel("Operation cancelled.");
         throw new UserError("Operation cancelled.");
       }
@@ -27060,7 +27111,7 @@ function createCliContainer(dependencies) {
     checkAuth: async (apiKey) => await checkAuth({ apiKey }) !== null,
     confirm: async (message2) => {
       const result = await confirm2({ message: message2 });
-      if (Ct(result)) {
+      if (q(result)) {
         cancel("Operation cancelled.");
         throw new OperationCancelledError();
       }
@@ -27814,7 +27865,7 @@ async function confirmUnconfiguredService(container, service, label, flags) {
   const shouldProceed = await confirm2({
     message: `${label} is not configured via poe. Do you want to proceed?`
   });
-  if (Ct(shouldProceed)) {
+  if (q(shouldProceed)) {
     throw new OperationCancelledError();
   }
   return shouldProceed === true;
@@ -28554,7 +28605,7 @@ function registerUtilsCommand(program, container) {
   const utils = program.command("utils").description("Utility commands for inspecting and managing poe-code.").addHelpCommand(false);
   registerConfigCommand(utils, container);
 }
-var init_utils3 = __esm({
+var init_utils4 = __esm({
   "src/cli/commands/utils.ts"() {
     "use strict";
     init_config4();
@@ -29082,6 +29133,7 @@ var init_types5 = __esm({
         this.code = code;
         this.name = "ToolError";
       }
+      code;
     };
   }
 });
@@ -29257,6 +29309,8 @@ var init_image = __esm({
         this.base64Data = base64Data;
         this.mimeType = mimeType;
       }
+      base64Data;
+      mimeType;
       static async fromUrl(url) {
         const response = await fetch(url);
         if (!response.ok) {
@@ -29331,6 +29385,8 @@ var init_audio = __esm({
         this.base64Data = base64Data;
         this.mimeType = mimeType;
       }
+      base64Data;
+      mimeType;
       static async fromUrl(url) {
         const response = await fetch(url);
         if (!response.ok) {
@@ -29401,6 +29457,10 @@ var init_file = __esm({
         this.isText = isText;
         this.name = name;
       }
+      data;
+      mimeType;
+      isText;
+      name;
       static async fromUrl(url) {
         const response = await fetch(url);
         if (!response.ok) {
@@ -30678,7 +30738,7 @@ ${formatMcpToolsDocs()}`).action(async (options) => {
           message: "Select agent to configure:",
           options: supportedAgents.map((a) => ({ value: a, label: a }))
         });
-        if (Ct(selected)) {
+        if (q(selected)) {
           cancel("Operation cancelled");
           return;
         }
@@ -31032,7 +31092,7 @@ function registerSkillCommand(program, container) {
           message: "Select agent to configure:",
           options: supportedAgents2.map((a) => ({ value: a, label: a }))
         });
-        if (Ct(selected)) {
+        if (q(selected)) {
           cancel("Operation cancelled");
           return;
         }
@@ -31065,7 +31125,7 @@ function registerSkillCommand(program, container) {
           { value: "local", label: "Local" }
         ]
       });
-      if (Ct(selected)) {
+      if (q(selected)) {
         cancel("Operation cancelled");
         return;
       }
@@ -31111,7 +31171,7 @@ function registerSkillCommand(program, container) {
         message: "Select agent to unconfigure:",
         options: supportedAgents2.map((a) => ({ value: a, label: a }))
       });
-      if (Ct(selected)) {
+      if (q(selected)) {
         cancel("Operation cancelled");
         return;
       }
@@ -31141,7 +31201,7 @@ function registerSkillCommand(program, container) {
           { value: "local", label: "Local" }
         ]
       });
-      if (Ct(selected)) {
+      if (q(selected)) {
         cancel("Operation cancelled");
         return;
       }
@@ -31504,7 +31564,7 @@ function registerUsageCommand(program, container) {
         startingAfter = result.data[result.data.length - 1].query_id;
         if (maxPages === void 0) {
           const shouldContinue = await confirm2({ message: "Load more?" });
-          if (Ct(shouldContinue)) {
+          if (q(shouldContinue)) {
             throw new OperationCancelledError();
           }
           if (!shouldContinue) {
@@ -32028,7 +32088,7 @@ function registerPipelineCommand(program, container) {
             label: value
           }))
         });
-        if (Ct(selected)) {
+        if (q(selected)) {
           cancel("Pipeline run cancelled.");
           return;
         }
@@ -32049,7 +32109,7 @@ function registerPipelineCommand(program, container) {
         fs: container.fs,
         selectPlans: async (input) => {
           const selected = await multiselect2(input);
-          if (Ct(selected)) {
+          if (q(selected)) {
             cancel("Pipeline run cancelled.");
             return null;
           }
@@ -32057,7 +32117,7 @@ function registerPipelineCommand(program, container) {
         },
         promptForPath: async (input) => {
           const value = await text3(input);
-          if (Ct(value)) {
+          if (q(value)) {
             cancel("Pipeline run cancelled.");
             return null;
           }
@@ -32267,7 +32327,7 @@ function registerPipelineCommand(program, container) {
               label: value
             }))
           });
-          if (Ct(selected)) {
+          if (q(selected)) {
             cancel("Pipeline install cancelled.");
             return;
           }
@@ -32293,7 +32353,7 @@ function registerPipelineCommand(program, container) {
             { value: "global", label: "Global" }
           ]
         });
-        if (Ct(selected)) {
+        if (q(selected)) {
           cancel("Pipeline install cancelled.");
           return;
         }
@@ -32841,7 +32901,7 @@ async function runPlanBrowser(options) {
         value: plan.absolutePath
       }))
     });
-    if (Ct(selectedPath)) {
+    if (q(selectedPath)) {
       return;
     }
     const selectedPlan = plans.find((plan) => plan.absolutePath === selectedPath);
@@ -32860,7 +32920,7 @@ async function runPlanBrowser(options) {
         { label: "Delete", value: "delete" }
       ]
     });
-    if (Ct(action) || action === "back") {
+    if (q(action) || action === "back") {
       continue;
     }
     if (action === "edit") {
@@ -32997,7 +33057,7 @@ async function resolveSelectedPlan(options) {
       value: plan.absolutePath
     }))
   });
-  if (Ct(selected)) {
+  if (q(selected)) {
     throw new ValidationError("Plan selection cancelled.");
   }
   const matched = options.plans.find((plan) => plan.absolutePath === selected);
@@ -33312,7 +33372,7 @@ async function resolveDocPath(options) {
       value: doc.path
     }))
   });
-  if (Ct(selected)) {
+  if (q(selected)) {
     cancel("Ralph run cancelled.");
     return null;
   }
@@ -33356,7 +33416,7 @@ async function promptForAgent(program) {
       value: config.agentId
     }))
   });
-  if (Ct(selected)) {
+  if (q(selected)) {
     cancel("Ralph run cancelled.");
     return null;
   }
@@ -33393,7 +33453,7 @@ async function resolveRunIterations(options) {
   const entered = await text3({
     message: "How many Ralph iterations should run?"
   });
-  if (Ct(entered)) {
+  if (q(entered)) {
     cancel("Ralph run cancelled.");
     return null;
   }
@@ -33423,7 +33483,7 @@ async function resolveInitIterations(options) {
   const entered = await text3({
     message: "How many Ralph iterations should run?"
   });
-  if (Ct(entered)) {
+  if (q(entered)) {
     cancel("Ralph init cancelled.");
     return null;
   }
@@ -33773,7 +33833,7 @@ async function resolveDocPath2(options) {
       value: doc.path
     }))
   });
-  if (Ct(selected)) {
+  if (q(selected)) {
     cancel(options.cancelMessage);
     return null;
   }
@@ -33803,7 +33863,7 @@ async function promptForAgent2(program) {
       value: config.agentId
     }))
   });
-  if (Ct(selected)) {
+  if (q(selected)) {
     cancel("Experiment run cancelled.");
     return null;
   }
@@ -33893,7 +33953,7 @@ function registerExperimentCommand(program, container) {
           resources.logger.info(`  Reset to ${targetHash.slice(0, 7)}`);
         },
         onExperimentComplete(index, entry) {
-          const scores = entry.scores ? Object.entries(entry.scores).map(([k2, v]) => `${k2}=${v}`).join(", ") : "-";
+          const scores = entry.scores ? Object.entries(entry.scores).map(([k, v]) => `${k}=${v}`).join(", ") : "-";
           resources.logger.info(
             `Experiment ${index} ${entry.status} in ${formatDuration3(entry.durationMs)} \xB7 scores: ${scores}`
           );
@@ -33953,7 +34013,7 @@ function registerExperimentCommand(program, container) {
       const rows = entries.map((entry, index) => ({
         index: String(index + 1),
         status: entry.status,
-        scores: entry.scores ? Object.entries(entry.scores).map(([k2, v]) => `${k2}=${v}`).join(", ") : "-",
+        scores: entry.scores ? Object.entries(entry.scores).map(([k, v]) => `${k}=${v}`).join(", ") : "-",
         duration: formatDuration3(entry.durationMs),
         timestamp: entry.timestamp,
         commit: entry.commit,
@@ -34092,7 +34152,7 @@ function registerExperimentCommand(program, container) {
               label: value
             }))
           });
-          if (Ct(selected)) {
+          if (q(selected)) {
             cancel("Experiment install cancelled.");
             return;
           }
@@ -34118,7 +34178,7 @@ function registerExperimentCommand(program, container) {
             { value: "global", label: "Global" }
           ]
         });
-        if (Ct(selected)) {
+        if (q(selected)) {
           cancel("Experiment install cancelled.");
           return;
         }
@@ -34374,7 +34434,7 @@ async function resolveProcessId(value) {
   const entered = await text3({
     message: "Process ID"
   });
-  if (Ct(entered)) {
+  if (q(entered)) {
     cancel("Launch start cancelled.");
     return null;
   }
@@ -34391,7 +34451,7 @@ async function resolveCommandParts(commandArgs) {
   const entered = await text3({
     message: "Command to run"
   });
-  if (Ct(entered)) {
+  if (q(entered)) {
     cancel("Launch start cancelled.");
     return null;
   }
@@ -34415,7 +34475,7 @@ async function resolveRuntime(options) {
       { label: "docker", value: "docker" }
     ]
   });
-  if (Ct(selected)) {
+  if (q(selected)) {
     cancel("Launch start cancelled.");
     return null;
   }
@@ -34428,7 +34488,7 @@ async function resolveDockerImage(value) {
   const entered = await text3({
     message: "Docker image"
   });
-  if (Ct(entered)) {
+  if (q(entered)) {
     cancel("Launch start cancelled.");
     return null;
   }
@@ -34453,7 +34513,7 @@ async function resolveRestart(restart, assumeYes) {
       { label: "always", value: "always" }
     ]
   });
-  if (Ct(selected)) {
+  if (q(selected)) {
     cancel("Launch start cancelled.");
     return null;
   }
@@ -34631,7 +34691,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "poe-code",
-      version: "3.0.174",
+      version: "3.0.175",
       description: "CLI tool to configure Poe API for developer workflows.",
       type: "module",
       main: "./dist/index.js",
@@ -35125,7 +35185,7 @@ var init_program = __esm({
     init_login();
     init_logout();
     init_auth();
-    init_utils3();
+    init_utils4();
     init_install();
     init_unconfigure();
     init_test();
@@ -35200,7 +35260,7 @@ function createPromptRunner(adapter = {
   text: text3,
   password: password2,
   select: select2,
-  isCancel: Ct,
+  isCancel: q,
   cancel
 }) {
   const runPrompt = async (descriptor) => {