@itsaplan/runner 0.5.3 → 0.7.0

package/dist/cli.js

@@ -3,225 +3,753 @@
 // src/cli.ts
 import { setTimeout as sleep } from "node:timers/promises";
 
-// src/agui.ts
-var FLUSH_CHARS = 1500;
-var DELTA_LIMIT = 12000;
-var TOOL_TEXT_LIMIT = 32000;
+// src/client.ts
+var REQUEST_TIMEOUT_MS = 30000;
+var CHAT_CLAIM_TIMEOUT_MS = 35000;
 
-class AnswerStream {
-  format;
-  threadId;
-  runId;
-  send;
-  messageId;
-  queued = [];
-  text = "";
-  started = false;
-  line = "";
-  sessionId = null;
-  openTextPart = "";
-  openToolCalls = new Set;
-  closedToolCalls = new Set;
-  sawPartialText = false;
-  sawAnyText = false;
-  sending = Promise.resolve();
-  usage;
-  constructor(format, threadId, runId, send) {
-    this.format = format;
-    this.threadId = threadId;
-    this.runId = runId;
-    this.send = send;
-    this.usage = new UsageReader(format);
-    this.messageId = `msg-${runId}`;
-    this.queued.push({ type: "RUN_STARTED", threadId, runId });
-  }
-  write(chunk) {
-    if (this.format === "text") {
-      this.appendText(chunk);
-      return;
-    }
-    this.line += chunk;
-    const lines = this.line.split(`
-`);
-    this.line = lines.pop() ?? "";
-    for (const line of lines)
-      this.readLine(line);
-  }
-  startedSession() {
-    return this.sessionId;
-  }
-  contextUsage() {
-    return this.usage.value();
+class RequestError extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.status = status;
   }
-  async flush() {
-    const sending = this.sending.catch(() => {}).then(() => this.sendQueued());
-    this.sending = sending.catch(() => {});
-    return sending;
+}
+
+class Client {
+  config;
+  constructor(config) {
+    this.config = config;
   }
-  async sendQueued() {
-    this.drainText();
-    if (this.queued.length === 0)
-      return;
-    const batch = this.queued;
-    this.queued = [];
-    try {
-      await this.send(batch);
-    } catch (err) {
-      this.queued.unshift(...batch);
-      throw err;
+  async post(path, body, timeoutMs = REQUEST_TIMEOUT_MS) {
+    const res = await fetch(`${this.config.url}${path}`, {
+      method: "POST",
+      headers: {
+        "x-api-key": this.config.apiKey,
+        ...body === undefined ? {} : { "content-type": "application/json" }
+      },
+      body: body === undefined ? undefined : JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!res.ok) {
+      throw new RequestError(res.status, `POST ${path} failed with ${res.status}: ${(await res.text()).slice(0, 200)}`);
     }
+    return res;
   }
-  async finish(fallback) {
-    this.closeText(fallback);
-    this.queued.push({ type: "RUN_FINISHED", threadId: this.threadId, runId: this.runId });
-    await this.flush();
+  async claim() {
+    const res = await this.post("/agent-runs/claim");
+    const body = await res.json();
+    return body.run;
   }
-  async fail(message, fallback = "") {
-    this.closeText(fallback);
-    this.queued.push({ type: "RUN_ERROR", message });
-    await this.flush();
+  async heartbeat(runId, attempt) {
+    await this.post(`/agent-runs/${runId}/heartbeat`, attempt == null ? undefined : { attempt });
   }
-  closeText(fallback) {
-    if (this.line) {
-      this.readLine(this.line);
-      this.line = "";
-    }
-    if (!this.sawAnyText && fallback)
-      this.appendText(fallback);
-    this.drainText();
-    if (this.started)
-      this.queued.push({ type: "TEXT_MESSAGE_END", messageId: this.messageId });
-    this.started = false;
+  async report(runId, result) {
+    await this.post(`/agent-runs/${runId}/result`, result);
   }
-  appendText(text) {
-    if (!text)
-      return;
-    this.sawAnyText = true;
-    this.text += text;
-    if (this.text.length >= FLUSH_CHARS)
-      this.drainText();
+  async runEvents(run, offset, events, sessionId) {
+    await this.post(`/agent-runs/${run.id}/events`, {
+      attempt: run.attempts,
+      offset,
+      events,
+      ...sessionId && { sessionId }
+    });
   }
-  drainText() {
-    if (this.text.length === 0)
-      return;
-    if (!this.started) {
-      this.started = true;
-      this.queued.push({
-        type: "TEXT_MESSAGE_START",
-        messageId: this.messageId,
-        role: "assistant"
-      });
-    }
-    while (this.text.length > 0) {
-      const delta = this.text.slice(0, DELTA_LIMIT);
-      this.text = this.text.slice(DELTA_LIMIT);
-      this.queued.push({ type: "TEXT_MESSAGE_CONTENT", messageId: this.messageId, delta });
-    }
+  async claimChat() {
+    const res = await this.post("/agent-chats/claim", undefined, CHAT_CLAIM_TIMEOUT_MS);
+    const body = await res.json();
+    return body.message;
   }
-  readLine(line) {
-    const trimmed = line.trim();
-    if (!trimmed)
-      return;
-    let parsed;
-    try {
-      parsed = JSON.parse(trimmed);
-    } catch {
-      this.appendText(`${trimmed}
-`);
-      return;
-    }
-    if (!parsed || typeof parsed !== "object")
-      return;
-    this.usage.readLine(parsed);
-    switch (this.format) {
-      case "claude-stream-json":
-        this.readClaudeLine(parsed);
-        break;
-      case "codex-jsonl":
-        this.readCodexLine(parsed);
-        break;
-      case "opencode-json":
-        this.readOpencodeLine(parsed);
-        break;
-      case "antigravity-stream-json":
-        this.readAntigravityLine(parsed);
-        break;
-      case "copilot-json":
-        this.readCopilotLine(parsed);
-        break;
-      case "pi-json":
-        this.readPiLine(parsed);
-        break;
-    }
+  async chatEvents(messageId, events, sessionId) {
+    const res = await this.post(`/agent-chats/${messageId}/events`, {
+      events,
+      ...sessionId && { sessionId }
+    });
+    return canceled(res);
   }
-  readPiLine(message) {
-    if (message.type === "session" && message.id)
-      this.sessionId ??= message.id;
-    switch (message.type) {
-      case "message_update": {
-        const event = message.assistantMessageEvent;
-        if (event?.type === "text_delta" && event.delta) {
-          this.sawPartialText = true;
-          this.appendText(event.delta);
-        }
-        return;
-      }
-      case "tool_execution_start":
-        if (message.toolCallId && !this.openToolCalls.has(message.toolCallId)) {
-          this.openToolCalls.add(message.toolCallId);
-          this.pushToolCall(message.toolCallId, message.toolName ?? "tool", JSON.stringify(message.args ?? {}));
-        }
-        return;
-      case "tool_execution_end": {
-        if (!message.toolCallId || this.closedToolCalls.has(message.toolCallId))
-          return;
-        this.closedToolCalls.add(message.toolCallId);
-        this.pushToolResult(message.toolCallId, piResultText(message.result));
-        return;
-      }
-      case "message_end":
-        if (message.message?.role === "assistant" && !this.sawAnyText && message.message.content) {
-          const body = textOfResult(message.message.content);
-          if (body)
-            this.appendText(body);
-        }
-        return;
-    }
+  async chatHeartbeat(messageId) {
+    return canceled(await this.post(`/agent-chats/${messageId}/heartbeat`));
   }
-  readCopilotLine(message) {
-    const data = message.data;
-    switch (message.type) {
-      case "result":
-        if (message.sessionId)
-          this.sessionId ??= message.sessionId;
-        return;
-      case "assistant.message_delta":
-        if (data?.deltaContent) {
-          this.sawPartialText = true;
-          this.appendText(data.deltaContent);
-        }
-        return;
-      case "assistant.message":
-        if (data?.content && !this.sawPartialText)
-          this.appendText(data.content);
-        return;
-      case "tool.execution_start":
-        if (data?.toolCallId) {
-          this.pushToolCall(data.toolCallId, data.toolName ?? "tool", JSON.stringify(data.arguments ?? {}));
-        }
-        return;
-      case "tool.execution_complete": {
-        if (!data?.toolCallId)
-          return;
-        const result = data.success ? data.result?.content : data.error?.message;
-        if (typeof result === "string")
-          this.pushToolResult(data.toolCallId, result);
-        return;
-      }
-    }
+  async chatResult(messageId, result) {
+    await this.post(`/agent-chats/${messageId}/result`, result);
   }
-  readAntigravityLine(message) {
-    const step = message.step_update;
+}
+async function canceled(res) {
+  const body = await res.json().catch(() => ({}));
+  return body.canceled === true;
+}
+
+// src/config.ts
+import { readFile } from "node:fs/promises";
+
+// src/presets.ts
+var PRESETS = {
+  claude: {
+    bin: "claude",
+    outputFormat: "claude-stream-json",
+    promptVia: "stdin",
+    systemPromptFlag: "--append-system-prompt",
+    head: (sessionId) => [
+      "-p",
+      ...sessionId ? ["--resume", sessionId] : [],
+      "--output-format",
+      "stream-json",
+      "--include-partial-messages",
+      "--verbose",
+      "--permission-mode",
+      "auto"
+    ],
+    tail: []
+  },
+  codex: {
+    bin: "codex",
+    outputFormat: "codex-jsonl",
+    promptVia: "stdin",
+    head: (sessionId) => [
+      ...sessionId ? ["exec", "resume", sessionId] : ["exec"],
+      "--json",
+      "-c",
+      'sandbox_mode="workspace-write"'
+    ],
+    tail: ["-"]
+  },
+  opencode: {
+    bin: "opencode",
+    outputFormat: "opencode-json",
+    promptVia: "arg",
+    head: (sessionId) => [
+      "run",
+      "--format",
+      "json",
+      ...sessionId ? ["--session", sessionId] : []
+    ],
+    tail: ["--"]
+  },
+  antigravity: {
+    bin: "agy",
+    outputFormat: "antigravity-stream-json",
+    promptVia: "arg",
+    head: (sessionId) => [
+      ...sessionId ? ["--conversation", sessionId] : [],
+      "--output-format",
+      "stream-json",
+      "--dangerously-skip-permissions",
+      "--print-timeout",
+      "24h"
+    ],
+    tail: ["-p"]
+  },
+  copilot: {
+    bin: "copilot",
+    outputFormat: "copilot-json",
+    promptVia: "arg",
+    head: (sessionId) => [
+      "--allow-all-tools",
+      "--no-ask-user",
+      "--output-format",
+      "json",
+      ...sessionId ? ["--session-id", sessionId] : []
+    ],
+    tail: ["-p"]
+  },
+  pi: {
+    bin: "pi",
+    outputFormat: "pi-json",
+    promptVia: "stdin",
+    systemPromptFlag: "--append-system-prompt",
+    head: (sessionId) => [
+      "-p",
+      "--mode",
+      "json",
+      ...sessionId ? ["--session-id", sessionId] : []
+    ],
+    tail: []
+  },
+  omp: {
+    bin: "omp",
+    outputFormat: "pi-json",
+    promptVia: "arg",
+    systemPromptFlag: "--append-system-prompt",
+    head: (sessionId) => [
+      "-p",
+      "--mode",
+      "json",
+      "--auto-approve",
+      ...sessionId ? ["--resume", sessionId] : []
+    ],
+    tail: ["--"]
+  }
+};
+var PRESET_NAMES = Object.keys(PRESETS);
+function isPresetName(value) {
+  return value in PRESETS;
+}
+function presetPrompt(preset, systemPrompt, prompt) {
+  if (preset.systemPromptFlag || !systemPrompt)
+    return prompt;
+  return `${systemPrompt}
+
+${prompt}`;
+}
+function presetArgv(preset, sessionId, systemPrompt, extraArgs, prompt) {
+  return [
+    ...preset.head(sessionId),
+    ...preset.systemPromptFlag && systemPrompt ? [preset.systemPromptFlag, systemPrompt] : [],
+    ...extraArgs,
+    ...preset.tail,
+    ...preset.promptVia === "arg" ? [presetPrompt(preset, systemPrompt, prompt)] : []
+  ];
+}
+
+// src/config.ts
+var OUTPUT_FORMATS = [
+  "text",
+  "claude-stream-json",
+  "codex-jsonl",
+  "opencode-json",
+  "antigravity-stream-json",
+  "copilot-json",
+  "pi-json"
+];
+function presetOf(config) {
+  if (config.command || !config.agent)
+    return;
+  return PRESETS[config.agent];
+}
+var DEFAULTS = {
+  concurrency: 1,
+  pollIntervalMs: 3000,
+  timeoutMs: 30 * 60 * 1000
+};
+var MIN_POLL_INTERVAL_MS = 1000;
+function textOf(value) {
+  const text = typeof value === "string" ? value.trim() : "";
+  return text || undefined;
+}
+function intFrom(value, fallback) {
+  const parsed = typeof value === "string" ? Number.parseInt(value, 10) : value;
+  return typeof parsed === "number" && Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function outputFormatFrom(value, preset) {
+  const name = textOf(value);
+  if (!name)
+    return preset?.outputFormat ?? "text";
+  const format = OUTPUT_FORMATS.find((candidate) => candidate === name);
+  if (!format) {
+    throw new Error(`outputFormat must be one of ${OUTPUT_FORMATS.join(", ")}`);
+  }
+  return format;
+}
+function agentFrom(value) {
+  const name = textOf(value);
+  if (!name)
+    return;
+  if (!isPresetName(name)) {
+    throw new Error(`agent must be one of ${PRESET_NAMES.join(", ")}`);
+  }
+  return name;
+}
+function portFrom(value) {
+  if (value === undefined || value === "")
+    return;
+  const port = intFrom(value, 0);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error("listen must be a port number from 1 to 65535");
+  }
+  return port;
+}
+function argsFrom(value) {
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error("args must be an array of strings");
+  }
+  return value;
+}
+function required(value, field) {
+  const text = textOf(value);
+  if (!text)
+    throw new Error(`${field} is required — set it in the config file or the environment`);
+  return text;
+}
+async function readConfigFile(path) {
+  let text;
+  try {
+    text = await readFile(path, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return {};
+    throw err;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`${path} is not valid JSON`);
+  }
+}
+function agentFieldsFrom(file) {
+  if (file.apiKeys !== undefined && file.agents !== undefined) {
+    throw new Error("set either apiKeys or agents, not both");
+  }
+  if (file.apiKeys !== undefined) {
+    const keys = file.apiKeys;
+    if (!Array.isArray(keys) || keys.some((key) => typeof key !== "string")) {
+      throw new Error("apiKeys must be an array of strings");
+    }
+    return keys.map((apiKey) => ({ apiKey }));
+  }
+  if (file.agents === undefined)
+    return [{}];
+  const agents = file.agents;
+  if (!Array.isArray(agents) || agents.some((entry) => typeof entry !== "object" || entry === null || Array.isArray(entry) || !textOf(entry.apiKey))) {
+    throw new Error("agents must be an array of objects, each with its own apiKey");
+  }
+  return agents;
+}
+function merge(shared, own) {
+  const merged = { ...shared, ...own };
+  const mode = textOf(own.agent) ?? textOf(own.command);
+  const changesMode = mode !== undefined && mode !== (textOf(shared.agent) ?? textOf(shared.command));
+  if (textOf(own.agent))
+    delete merged.command;
+  else if (textOf(own.command))
+    delete merged.agent;
+  if (changesMode && !textOf(own.outputFormat))
+    delete merged.outputFormat;
+  return merged;
+}
+function nameOf(entry, index, total) {
+  if (total === 1)
+    return "";
+  return textOf(entry.name) ?? `#${index + 1}`;
+}
+function configFrom(fields, name, extraArgs) {
+  const agent = agentFrom(fields.agent);
+  const command = textOf(fields.command);
+  const listen = portFrom(fields.listen);
+  const signingSecret = textOf(fields.signingSecret);
+  if (listen !== undefined && !signingSecret) {
+    throw new Error("signingSecret is required with listen — copy it from the agent settings");
+  }
+  if (!agent && !command) {
+    throw new Error(`set either agent (one of ${PRESET_NAMES.join(", ")}) or command in the config file or the environment`);
+  }
+  return {
+    name,
+    url: required(fields.url, "url").replace(/\/+$/, ""),
+    apiKey: required(fields.apiKey, "apiKey"),
+    agent,
+    command,
+    args: [...argsFrom(fields.args), ...extraArgs],
+    cwd: textOf(fields.cwd)?.replace(/^~/, process.env.HOME ?? "~"),
+    env: fields.env ?? {},
+    concurrency: intFrom(fields.concurrency, DEFAULTS.concurrency),
+    pollIntervalMs: Math.max(intFrom(fields.pollIntervalMs, DEFAULTS.pollIntervalMs), MIN_POLL_INTERVAL_MS),
+    timeoutMs: intFrom(fields.timeoutMs, DEFAULTS.timeoutMs),
+    outputFormat: outputFormatFrom(fields.outputFormat, presetOf({ agent, command })),
+    listen,
+    signingSecret
+  };
+}
+function assertSecretsApart(configs) {
+  const seen = new Set;
+  for (const config of configs) {
+    if (config.listen === undefined)
+      continue;
+    const key = `${config.listen} ${config.signingSecret}`;
+    if (seen.has(key)) {
+      throw new Error("each agent on a listen port needs its own signingSecret — list them in agents");
+    }
+    seen.add(key);
+  }
+}
+function sharedFields(file, overrides) {
+  const env = process.env;
+  const outside = {
+    url: env.ITSAPLAN_URL,
+    apiKey: env.ITSAPLAN_API_KEY,
+    agent: overrides.agent ?? env.ITSAPLAN_AGENT,
+    command: env.ITSAPLAN_COMMAND,
+    cwd: env.ITSAPLAN_CWD,
+    concurrency: env.ITSAPLAN_CONCURRENCY,
+    pollIntervalMs: env.ITSAPLAN_POLL_INTERVAL_MS,
+    timeoutMs: env.ITSAPLAN_TIMEOUT_MS,
+    outputFormat: env.ITSAPLAN_OUTPUT_FORMAT,
+    listen: env.ITSAPLAN_LISTEN,
+    signingSecret: env.ITSAPLAN_SIGNING_SECRET
+  };
+  for (const [field, value] of Object.entries(outside)) {
+    if (!textOf(value))
+      delete outside[field];
+  }
+  return merge(file, outside);
+}
+async function loadConfig(path, overrides = {}) {
+  const file = await readConfigFile(path);
+  const entries = agentFieldsFrom(file);
+  if (entries.length === 0) {
+    throw new Error("no agents configured — apiKeys and agents cannot be empty");
+  }
+  const shared = sharedFields(file, overrides);
+  const configs = entries.map((entry, index) => configFrom(merge(shared, entry), nameOf(entry, index, entries.length), overrides.args ?? []));
+  assertSecretsApart(configs);
+  return configs;
+}
+
+// src/listen.ts
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { createServer } from "node:http";
+var SIGNATURE_TOLERANCE_S = 300;
+var MAX_BODY_BYTES = 5 * 1024 * 1024;
+function verifySignature(secret, header, body, nowSeconds = Date.now() / 1000) {
+  const fields = new Map(header.split(",").map((part) => {
+    const at = part.indexOf("=");
+    return [part.slice(0, at).trim(), part.slice(at + 1).trim()];
+  }));
+  const t = fields.get("t");
+  const v1 = fields.get("v1");
+  if (!t || !v1 || !Number.isFinite(Number(t)))
+    return false;
+  if (Math.abs(nowSeconds - Number(t)) > SIGNATURE_TOLERANCE_S)
+    return false;
+  const expected = createHmac("sha256", secret).update(`${t}.${body}`).digest("hex");
+  const given = Buffer.from(v1);
+  const wanted = Buffer.from(expected);
+  return given.length === wanted.length && timingSafeEqual(given, wanted);
+}
+function feed(limit, work, inFlight) {
+  let active = 0;
+  const waiting = [];
+  const held = new Set;
+  const acquire = () => {
+    if (active < limit) {
+      active++;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => waiting.push(resolve));
+  };
+  const release = () => {
+    const next = waiting.shift();
+    if (next)
+      next();
+    else
+      active--;
+  };
+  return (item) => {
+    if (held.has(item.id))
+      return;
+    held.add(item.id);
+    const task = acquire().then(() => work(item)).finally(() => {
+      held.delete(item.id);
+      release();
+    });
+    inFlight.add(task);
+    task.finally(() => inFlight.delete(task)).catch(() => {});
+  };
+}
+
+class TooLargeError extends Error {
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_BODY_BYTES) {
+        reject(new TooLargeError);
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
+function startListener(port, agents, log) {
+  const inFlight = new Set;
+  const served = agents.map((agent) => ({
+    secret: agent.secret,
+    run: feed(agent.concurrency, agent.run, inFlight),
+    chat: feed(agent.concurrency, agent.chat, inFlight)
+  }));
+  const server = createServer((req, res) => {
+    if (req.method !== "POST") {
+      res.writeHead(405, { allow: "POST" }).end();
+      return;
+    }
+    readBody(req).then((body) => {
+      const header = req.headers["x-itsaplan-signature"];
+      const agent = typeof header === "string" ? served.find((candidate) => verifySignature(candidate.secret, header, body)) : undefined;
+      if (!agent) {
+        log("refused a request that no configured agent signed");
+        res.writeHead(401).end("bad signature");
+        return;
+      }
+      let payload;
+      try {
+        payload = JSON.parse(body);
+      } catch {
+        res.writeHead(400).end("body is not JSON");
+        return;
+      }
+      if (payload.event === "agent.run" && payload.run)
+        agent.run(payload.run);
+      else if (payload.event === "agent.chat" && payload.message)
+        agent.chat(payload.message);
+      else if (payload.event !== "ping") {
+        res.writeHead(400).end(`unknown event ${String(payload.event)}`);
+        return;
+      }
+      res.writeHead(200).end("ok");
+    }, (err) => {
+      res.writeHead(err instanceof TooLargeError ? 413 : 400).end();
+    });
+  });
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, () => {
+      server.off("error", reject);
+      const address = server.address();
+      resolve({
+        port: typeof address === "object" && address ? address.port : port,
+        close: async () => {
+          await new Promise((done) => {
+            server.close(() => done());
+            server.closeIdleConnections();
+          });
+          await Promise.allSettled([...inFlight]);
+        }
+      });
+    });
+  });
+}
+
+// src/agui.ts
+var FLUSH_CHARS = 1500;
+var DELTA_LIMIT = 12000;
+var TOOL_TEXT_LIMIT = 32000;
+
+class AnswerStream {
+  format;
+  threadId;
+  runId;
+  send;
+  messageId;
+  queued = [];
+  text = "";
+  started = false;
+  line = "";
+  sessionId = null;
+  openTextPart = "";
+  openToolCalls = new Set;
+  closedToolCalls = new Set;
+  sawPartialText = false;
+  sawAnyText = false;
+  segment = "";
+  lastSegment = "";
+  sending = Promise.resolve();
+  usage;
+  constructor(format, threadId, runId, send) {
+    this.format = format;
+    this.threadId = threadId;
+    this.runId = runId;
+    this.send = send;
+    this.usage = new UsageReader(format);
+    this.messageId = `msg-${runId}`;
+    this.queued.push({ type: "RUN_STARTED", threadId, runId });
+  }
+  write(chunk) {
+    if (this.format === "text") {
+      this.appendText(chunk);
+      return;
+    }
+    this.line += chunk;
+    const lines = this.line.split(`
+`);
+    this.line = lines.pop() ?? "";
+    for (const line of lines)
+      this.readLine(line);
+  }
+  startedSession() {
+    return this.sessionId;
+  }
+  answer() {
+    return (this.segment.trim() ? this.segment : this.lastSegment).trim();
+  }
+  contextUsage() {
+    return this.usage.value();
+  }
+  async flush() {
+    const sending = this.sending.catch(() => {}).then(() => this.sendQueued());
+    this.sending = sending.catch(() => {});
+    return sending;
+  }
+  async sendQueued() {
+    this.drainText();
+    if (this.queued.length === 0)
+      return;
+    const batch = this.queued;
+    this.queued = [];
+    try {
+      await this.send(batch);
+    } catch (err) {
+      this.queued.unshift(...batch);
+      throw err;
+    }
+  }
+  async finish(fallback) {
+    this.closeText(fallback);
+    this.queued.push({ type: "RUN_FINISHED", threadId: this.threadId, runId: this.runId });
+    await this.flush();
+  }
+  async fail(message, fallback = "") {
+    this.closeText(fallback);
+    this.queued.push({ type: "RUN_ERROR", message });
+    await this.flush();
+  }
+  closeText(fallback) {
+    if (this.line) {
+      this.readLine(this.line);
+      this.line = "";
+    }
+    if (!this.sawAnyText && fallback)
+      this.appendText(fallback);
+    this.drainText();
+    if (this.started)
+      this.queued.push({ type: "TEXT_MESSAGE_END", messageId: this.messageId });
+    this.started = false;
+  }
+  appendText(text) {
+    if (!text)
+      return;
+    this.sawAnyText = true;
+    this.text += text;
+    this.segment += text;
+    if (this.text.length >= FLUSH_CHARS)
+      this.drainText();
+  }
+  drainText() {
+    if (this.text.length === 0)
+      return;
+    if (!this.started) {
+      this.started = true;
+      this.queued.push({
+        type: "TEXT_MESSAGE_START",
+        messageId: this.messageId,
+        role: "assistant"
+      });
+    }
+    while (this.text.length > 0) {
+      const delta = this.text.slice(0, DELTA_LIMIT);
+      this.text = this.text.slice(DELTA_LIMIT);
+      this.queued.push({ type: "TEXT_MESSAGE_CONTENT", messageId: this.messageId, delta });
+    }
+  }
+  readLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      return;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      this.appendText(`${trimmed}
+`);
+      return;
+    }
+    if (!parsed || typeof parsed !== "object")
+      return;
+    this.usage.readLine(parsed);
+    switch (this.format) {
+      case "claude-stream-json":
+        this.readClaudeLine(parsed);
+        break;
+      case "codex-jsonl":
+        this.readCodexLine(parsed);
+        break;
+      case "opencode-json":
+        this.readOpencodeLine(parsed);
+        break;
+      case "antigravity-stream-json":
+        this.readAntigravityLine(parsed);
+        break;
+      case "copilot-json":
+        this.readCopilotLine(parsed);
+        break;
+      case "pi-json":
+        this.readPiLine(parsed);
+        break;
+    }
+  }
+  readPiLine(message) {
+    if (message.type === "session" && message.id)
+      this.sessionId ??= message.id;
+    switch (message.type) {
+      case "message_update": {
+        const event = message.assistantMessageEvent;
+        if (event?.type === "text_delta" && event.delta) {
+          this.sawPartialText = true;
+          this.appendText(event.delta);
+        }
+        return;
+      }
+      case "tool_execution_start":
+        if (message.toolCallId && !this.openToolCalls.has(message.toolCallId)) {
+          this.openToolCalls.add(message.toolCallId);
+          this.pushToolCall(message.toolCallId, message.toolName ?? "tool", JSON.stringify(message.args ?? {}));
+        }
+        return;
+      case "tool_execution_end": {
+        if (!message.toolCallId || this.closedToolCalls.has(message.toolCallId))
+          return;
+        this.closedToolCalls.add(message.toolCallId);
+        this.pushToolResult(message.toolCallId, piResultText(message.result));
+        return;
+      }
+      case "message_end":
+        if (message.message?.role === "assistant" && !this.sawAnyText && message.message.content) {
+          const body = textOfResult(message.message.content);
+          if (body)
+            this.appendText(body);
+        }
+        return;
+    }
+  }
+  readCopilotLine(message) {
+    const data = message.data;
+    switch (message.type) {
+      case "result":
+        if (message.sessionId)
+          this.sessionId ??= message.sessionId;
+        return;
+      case "assistant.message_delta":
+        if (data?.deltaContent) {
+          this.sawPartialText = true;
+          this.appendText(data.deltaContent);
+        }
+        return;
+      case "assistant.message":
+        if (data?.content && !this.sawPartialText)
+          this.appendText(data.content);
+        return;
+      case "tool.execution_start":
+        if (data?.toolCallId) {
+          this.pushToolCall(data.toolCallId, data.toolName ?? "tool", JSON.stringify(data.arguments ?? {}));
+        }
+        return;
+      case "tool.execution_complete": {
+        if (!data?.toolCallId)
+          return;
+        const result = data.success ? data.result?.content : data.error?.message;
+        if (typeof result === "string")
+          this.pushToolResult(data.toolCallId, result);
+        return;
+      }
+    }
+  }
+  readAntigravityLine(message) {
+    const step = message.step_update;
     const conversationId = message.conversation_id ?? step?.conversation_id ?? message.result?.conversation_id;
     if (conversationId)
       this.sessionId ??= conversationId;
@@ -260,15 +788,36 @@ class AnswerStream {
       return;
     }
     const item = message.item;
-    if (message.type !== "item.completed" || !item)
+    if (!item)
       return;
-    if (item.type === "agent_message" && item.text) {
+    if (message.type === "item.completed" && item.type === "agent_message" && item.text) {
       this.appendText(item.text);
       return;
     }
-    if (item.type === "command_execution" && item.id) {
-      this.pushToolCall(item.id, "shell", item.command ?? "");
-      this.pushToolResult(item.id, item.aggregated_output ?? "");
+    if (!item.id || !["command_execution", "mcp_tool_call", "file_change", "web_search"].includes(item.type ?? ""))
+      return;
+    if (!["item.started", "item.completed"].includes(message.type ?? ""))
+      return;
+    if (!this.openToolCalls.has(item.id)) {
+      this.openToolCalls.add(item.id);
+      const name = item.type === "command_execution" ? "shell" : item.tool ?? item.type ?? "tool";
+      const args = item.command ?? JSON.stringify(item.arguments ?? item.changes ?? { query: item.query });
+      this.pushToolCall(item.id, name, args);
+    }
+    if (message.type === "item.completed" && !this.closedToolCalls.has(item.id)) {
+      this.closedToolCalls.add(item.id);
+      let result = item.aggregated_output;
+      if (result == null || item.status === "failed" || item.exit_code != null && item.exit_code !== 0) {
+        result = JSON.stringify({
+          status: item.status,
+          exitCode: item.exit_code,
+          output: item.aggregated_output,
+          result: item.result,
+          error: item.error,
+          changes: item.changes
+        });
+      }
+      this.pushToolResult(item.id, result);
     }
   }
   readOpencodeLine(message) {
@@ -345,444 +894,164 @@ class AnswerStream {
     }
   }
   pushToolCall(toolCallId, toolCallName, args) {
-    this.drainText();
-    this.queued.push({ type: "TOOL_CALL_START", toolCallId, toolCallName, parentMessageId: this.messageId }, { type: "TOOL_CALL_ARGS", toolCallId, delta: tail(args, TOOL_TEXT_LIMIT) }, { type: "TOOL_CALL_END", toolCallId });
-  }
-  pushToolResult(toolCallId, content) {
-    this.drainText();
-    this.queued.push({
-      type: "TOOL_CALL_RESULT",
-      messageId: this.messageId,
-      toolCallId,
-      content: tail(content, TOOL_TEXT_LIMIT)
-    });
-  }
-}
-
-class UsageReader {
-  format;
-  last = null;
-  buffered = "";
-  constructor(format) {
-    this.format = format;
-  }
-  write(chunk) {
-    if (this.format === "text")
-      return;
-    this.buffered += chunk;
-    const lines = this.buffered.split(`
-`);
-    this.buffered = lines.pop() ?? "";
-    for (const line of lines)
-      this.readText(line);
-  }
-  end() {
-    if (!this.buffered)
-      return;
-    this.readText(this.buffered);
-    this.buffered = "";
-  }
-  value() {
-    if (this.format === "copilot-json")
-      return null;
-    return this.last ?? undefined;
-  }
-  readText(line) {
-    const trimmed = line.trim();
-    if (!trimmed)
-      return;
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (parsed && typeof parsed === "object")
-        this.readLine(parsed);
-    } catch {}
-  }
-  readLine(parsed) {
-    switch (this.format) {
-      case "claude-stream-json":
-        this.readClaude(parsed);
-        return;
-      case "codex-jsonl":
-        this.readCodex(parsed);
-        return;
-      case "opencode-json":
-        this.readOpencode(parsed);
-        return;
-      case "antigravity-stream-json":
-        this.readAntigravity(parsed);
-        return;
-      case "pi-json":
-        this.readPi(parsed);
-        return;
-    }
-  }
-  readClaude(message) {
-    const event = message.type === "stream_event" ? message.event : undefined;
-    if (!event)
-      return;
-    const usage = event.type === "message_start" ? event.message?.usage : event.usage;
-    if (!usage)
-      return;
-    const read = (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
-    const written = usage.output_tokens ?? 0;
-    if (event.type === "message_start") {
-      this.last = { inputTokens: read, outputTokens: written };
-      return;
-    }
-    if (event.type !== "message_delta")
-      return;
-    this.last = { inputTokens: read || (this.last?.inputTokens ?? 0), outputTokens: written };
-  }
-  readCodex(message) {
-    if (message.type !== "turn.completed" || !message.usage)
-      return;
-    this.last = {
-      inputTokens: message.usage.input_tokens ?? 0,
-      outputTokens: message.usage.output_tokens ?? 0
-    };
-  }
-  readOpencode(message) {
-    const tokens = message.part?.type === "step-finish" ? message.part.tokens : undefined;
-    if (!tokens)
-      return;
-    this.last = {
-      inputTokens: (tokens.input ?? 0) + (tokens.cache?.read ?? 0) + (tokens.cache?.write ?? 0),
-      outputTokens: (tokens.output ?? 0) + (tokens.reasoning ?? 0)
-    };
-  }
-  readAntigravity(message) {
-    const step = message.step_update;
-    if (!step)
-      return;
-    const usage = step.usage ?? message.usage;
-    if (!usage)
-      return;
-    this.last = {
-      inputTokens: (usage.input_tokens ?? 0) + (usage.cache_read_tokens ?? 0),
-      outputTokens: (usage.output_tokens ?? 0) + (usage.thinking_tokens ?? 0)
-    };
-  }
-  readPi(message) {
-    const usage = message.usage;
-    if (!usage)
-      return;
-    this.last = {
-      inputTokens: (usage.input ?? usage.input_tokens ?? 0) + (usage.cacheRead ?? 0),
-      outputTokens: usage.output ?? usage.output_tokens ?? 0
-    };
-  }
-}
-function tail(text, limit) {
-  if (text.length <= limit)
-    return text;
-  const mark = "…";
-  return mark + text.slice(-(limit - mark.length));
-}
-function textOfResult(content) {
-  if (typeof content === "string")
-    return content;
-  if (Array.isArray(content)) {
-    return content.map((part) => typeof part === "object" && part && ("text" in part) ? String(part.text) : "").join("");
+    this.drainText();
+    this.closeSegment();
+    this.queued.push({ type: "TOOL_CALL_START", toolCallId, toolCallName, parentMessageId: this.messageId }, { type: "TOOL_CALL_ARGS", toolCallId, delta: tail(args, TOOL_TEXT_LIMIT) }, { type: "TOOL_CALL_END", toolCallId });
   }
-  return "";
-}
-function piResultText(result) {
-  if (result && typeof result === "object" && !Array.isArray(result) && "content" in result) {
-    return textOfResult(result.content);
+  closeSegment() {
+    if (this.segment.trim())
+      this.lastSegment = this.segment;
+    this.segment = "";
   }
-  const text = textOfResult(result);
-  return text || (result == null ? "" : JSON.stringify(result));
-}
-
-// src/execute.ts
-import { spawn } from "node:child_process";
-
-// src/config.ts
-import { readFile } from "node:fs/promises";
-
-// src/presets.ts
-var PRESETS = {
-  claude: {
-    bin: "claude",
-    outputFormat: "claude-stream-json",
-    promptVia: "stdin",
-    systemPromptFlag: "--append-system-prompt",
-    head: (sessionId) => [
-      "-p",
-      ...sessionId ? ["--resume", sessionId] : [],
-      "--output-format",
-      "stream-json",
-      "--include-partial-messages",
-      "--verbose",
-      "--permission-mode",
-      "auto"
-    ],
-    tail: []
-  },
-  codex: {
-    bin: "codex",
-    outputFormat: "codex-jsonl",
-    promptVia: "stdin",
-    head: (sessionId) => [
-      ...sessionId ? ["exec", "resume", sessionId] : ["exec"],
-      "--json",
-      "-c",
-      'sandbox_mode="workspace-write"'
-    ],
-    tail: ["-"]
-  },
-  opencode: {
-    bin: "opencode",
-    outputFormat: "opencode-json",
-    promptVia: "arg",
-    head: (sessionId) => [
-      "run",
-      "--format",
-      "json",
-      ...sessionId ? ["--session", sessionId] : []
-    ],
-    tail: []
-  },
-  antigravity: {
-    bin: "agy",
-    outputFormat: "antigravity-stream-json",
-    promptVia: "arg",
-    head: (sessionId) => [
-      ...sessionId ? ["--conversation", sessionId] : [],
-      "--output-format",
-      "stream-json",
-      "--dangerously-skip-permissions",
-      "--print-timeout",
-      "24h"
-    ],
-    tail: ["-p"]
-  },
-  copilot: {
-    bin: "copilot",
-    outputFormat: "copilot-json",
-    promptVia: "arg",
-    head: (sessionId) => [
-      "--allow-all-tools",
-      "--no-ask-user",
-      "--output-format",
-      "json",
-      ...sessionId ? ["--session-id", sessionId] : []
-    ],
-    tail: ["-p"]
-  },
-  pi: {
-    bin: "pi",
-    outputFormat: "pi-json",
-    promptVia: "arg",
-    systemPromptFlag: "--append-system-prompt",
-    head: (sessionId) => [
-      "-p",
-      "--mode",
-      "json",
-      ...sessionId ? ["--session-id", sessionId] : []
-    ],
-    tail: []
-  },
-  omp: {
-    bin: "omp",
-    outputFormat: "pi-json",
-    promptVia: "arg",
-    systemPromptFlag: "--append-system-prompt",
-    head: (sessionId) => [
-      "-p",
-      "--mode",
-      "json",
-      "--auto-approve",
-      ...sessionId ? ["--resume", sessionId] : []
-    ],
-    tail: []
+  pushToolResult(toolCallId, content) {
+    this.drainText();
+    this.closeSegment();
+    this.queued.push({
+      type: "TOOL_CALL_RESULT",
+      messageId: this.messageId,
+      toolCallId,
+      content: tail(content, TOOL_TEXT_LIMIT)
+    });
   }
-};
-var PRESET_NAMES = Object.keys(PRESETS);
-function isPresetName(value) {
-  return value in PRESETS;
-}
-function presetPrompt(preset, systemPrompt, prompt) {
-  if (preset.systemPromptFlag || !systemPrompt)
-    return prompt;
-  return `${systemPrompt}
-
-${prompt}`;
-}
-function presetArgv(preset, sessionId, systemPrompt, extraArgs, prompt) {
-  return [
-    ...preset.head(sessionId),
-    ...preset.systemPromptFlag && systemPrompt ? [preset.systemPromptFlag, systemPrompt] : [],
-    ...extraArgs,
-    ...preset.tail,
-    ...preset.promptVia === "arg" ? [presetPrompt(preset, systemPrompt, prompt)] : []
-  ];
 }
 
-// src/config.ts
-var OUTPUT_FORMATS = [
-  "text",
-  "claude-stream-json",
-  "codex-jsonl",
-  "opencode-json",
-  "antigravity-stream-json",
-  "copilot-json",
-  "pi-json"
-];
-function presetOf(config) {
-  if (config.command || !config.agent)
-    return;
-  return PRESETS[config.agent];
-}
-var DEFAULTS = {
-  concurrency: 1,
-  pollIntervalMs: 3000,
-  timeoutMs: 30 * 60 * 1000
-};
-var MIN_POLL_INTERVAL_MS = 1000;
-function textOf(value) {
-  const text = typeof value === "string" ? value.trim() : "";
-  return text || undefined;
-}
-function intFrom(value, fallback) {
-  const parsed = typeof value === "string" ? Number.parseInt(value, 10) : value;
-  return typeof parsed === "number" && Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
-}
-function outputFormatFrom(value, preset) {
-  const name = textOf(value);
-  if (!name)
-    return preset?.outputFormat ?? "text";
-  const format = OUTPUT_FORMATS.find((candidate) => candidate === name);
-  if (!format) {
-    throw new Error(`outputFormat must be one of ${OUTPUT_FORMATS.join(", ")}`);
+class UsageReader {
+  format;
+  last = null;
+  buffered = "";
+  constructor(format) {
+    this.format = format;
   }
-  return format;
-}
-function agentFrom(value) {
-  const name = textOf(value);
-  if (!name)
-    return;
-  if (!isPresetName(name)) {
-    throw new Error(`agent must be one of ${PRESET_NAMES.join(", ")}`);
+  write(chunk) {
+    if (this.format === "text")
+      return;
+    this.buffered += chunk;
+    const lines = this.buffered.split(`
+`);
+    this.buffered = lines.pop() ?? "";
+    for (const line of lines)
+      this.readText(line);
   }
-  return name;
-}
-function argsFrom(value) {
-  if (value === undefined)
-    return [];
-  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
-    throw new Error("args must be an array of strings");
+  end() {
+    if (!this.buffered)
+      return;
+    this.readText(this.buffered);
+    this.buffered = "";
   }
-  return value;
-}
-function required(value, field) {
-  const text = textOf(value);
-  if (!text)
-    throw new Error(`${field} is required — set it in the config file or the environment`);
-  return text;
-}
-async function readConfigFile(path) {
-  let text;
-  try {
-    text = await readFile(path, "utf8");
-  } catch (err) {
-    if (err.code === "ENOENT")
-      return {};
-    throw err;
+  value() {
+    if (this.format === "copilot-json")
+      return null;
+    return this.last ?? undefined;
+  }
+  readText(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      return;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object")
+        this.readLine(parsed);
+    } catch {}
+  }
+  readLine(parsed) {
+    switch (this.format) {
+      case "claude-stream-json":
+        this.readClaude(parsed);
+        return;
+      case "codex-jsonl":
+        this.readCodex(parsed);
+        return;
+      case "opencode-json":
+        this.readOpencode(parsed);
+        return;
+      case "antigravity-stream-json":
+        this.readAntigravity(parsed);
+        return;
+      case "pi-json":
+        this.readPi(parsed);
+        return;
+    }
   }
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw new Error(`${path} is not valid JSON`);
+  readClaude(message) {
+    const event = message.type === "stream_event" ? message.event : undefined;
+    if (!event)
+      return;
+    const usage = event.type === "message_start" ? event.message?.usage : event.usage;
+    if (!usage)
+      return;
+    const read = (usage.input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+    const written = usage.output_tokens ?? 0;
+    if (event.type === "message_start") {
+      this.last = { inputTokens: read, outputTokens: written };
+      return;
+    }
+    if (event.type !== "message_delta")
+      return;
+    this.last = { inputTokens: read || (this.last?.inputTokens ?? 0), outputTokens: written };
   }
-}
-function agentFieldsFrom(file) {
-  if (file.apiKeys !== undefined && file.agents !== undefined) {
-    throw new Error("set either apiKeys or agents, not both");
+  readCodex(message) {
+    if (message.type !== "turn.completed" || !message.usage)
+      return;
+    this.last = {
+      inputTokens: message.usage.input_tokens ?? 0,
+      outputTokens: message.usage.output_tokens ?? 0
+    };
   }
-  if (file.apiKeys !== undefined) {
-    const keys = file.apiKeys;
-    if (!Array.isArray(keys) || keys.some((key) => typeof key !== "string")) {
-      throw new Error("apiKeys must be an array of strings");
-    }
-    return keys.map((apiKey) => ({ apiKey }));
+  readOpencode(message) {
+    const tokens = message.part?.type === "step-finish" ? message.part.tokens : undefined;
+    if (!tokens)
+      return;
+    this.last = {
+      inputTokens: (tokens.input ?? 0) + (tokens.cache?.read ?? 0) + (tokens.cache?.write ?? 0),
+      outputTokens: (tokens.output ?? 0) + (tokens.reasoning ?? 0)
+    };
   }
-  if (file.agents === undefined)
-    return [{}];
-  const agents = file.agents;
-  if (!Array.isArray(agents) || agents.some((entry) => typeof entry !== "object" || entry === null || Array.isArray(entry) || !textOf(entry.apiKey))) {
-    throw new Error("agents must be an array of objects, each with its own apiKey");
+  readAntigravity(message) {
+    const step = message.step_update;
+    if (!step)
+      return;
+    const usage = step.usage ?? message.usage;
+    if (!usage)
+      return;
+    this.last = {
+      inputTokens: (usage.input_tokens ?? 0) + (usage.cache_read_tokens ?? 0),
+      outputTokens: (usage.output_tokens ?? 0) + (usage.thinking_tokens ?? 0)
+    };
   }
-  return agents;
-}
-function merge(shared, own) {
-  const merged = { ...shared, ...own };
-  const mode = textOf(own.agent) ?? textOf(own.command);
-  const changesMode = mode !== undefined && mode !== (textOf(shared.agent) ?? textOf(shared.command));
-  if (textOf(own.agent))
-    delete merged.command;
-  else if (textOf(own.command))
-    delete merged.agent;
-  if (changesMode && !textOf(own.outputFormat))
-    delete merged.outputFormat;
-  return merged;
-}
-function nameOf(entry, index, total) {
-  if (total === 1)
-    return "";
-  return textOf(entry.name) ?? `#${index + 1}`;
-}
-function configFrom(fields, name, extraArgs) {
-  const agent = agentFrom(fields.agent);
-  const command = textOf(fields.command);
-  if (!agent && !command) {
-    throw new Error(`set either agent (one of ${PRESET_NAMES.join(", ")}) or command in the config file or the environment`);
+  readPi(message) {
+    const usage = message.usage;
+    if (!usage)
+      return;
+    this.last = {
+      inputTokens: (usage.input ?? usage.input_tokens ?? 0) + (usage.cacheRead ?? 0),
+      outputTokens: usage.output ?? usage.output_tokens ?? 0
+    };
   }
-  return {
-    name,
-    url: required(fields.url, "url").replace(/\/+$/, ""),
-    apiKey: required(fields.apiKey, "apiKey"),
-    agent,
-    command,
-    args: [...argsFrom(fields.args), ...extraArgs],
-    cwd: textOf(fields.cwd)?.replace(/^~/, process.env.HOME ?? "~"),
-    env: fields.env ?? {},
-    concurrency: intFrom(fields.concurrency, DEFAULTS.concurrency),
-    pollIntervalMs: Math.max(intFrom(fields.pollIntervalMs, DEFAULTS.pollIntervalMs), MIN_POLL_INTERVAL_MS),
-    timeoutMs: intFrom(fields.timeoutMs, DEFAULTS.timeoutMs),
-    outputFormat: outputFormatFrom(fields.outputFormat, presetOf({ agent, command }))
-  };
 }
-function sharedFields(file, overrides) {
-  const env = process.env;
-  const outside = {
-    url: env.ITSAPLAN_URL,
-    apiKey: env.ITSAPLAN_API_KEY,
-    agent: overrides.agent ?? env.ITSAPLAN_AGENT,
-    command: env.ITSAPLAN_COMMAND,
-    cwd: env.ITSAPLAN_CWD,
-    concurrency: env.ITSAPLAN_CONCURRENCY,
-    pollIntervalMs: env.ITSAPLAN_POLL_INTERVAL_MS,
-    timeoutMs: env.ITSAPLAN_TIMEOUT_MS,
-    outputFormat: env.ITSAPLAN_OUTPUT_FORMAT
-  };
-  for (const [field, value] of Object.entries(outside)) {
-    if (!textOf(value))
-      delete outside[field];
+function tail(text, limit) {
+  if (text.length <= limit)
+    return text;
+  const mark = "…";
+  return mark + text.slice(-(limit - mark.length));
+}
+function textOfResult(content) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => typeof part === "object" && part && ("text" in part) ? String(part.text) : "").join("");
   }
-  return merge(file, outside);
+  return "";
 }
-async function loadConfig(path, overrides = {}) {
-  const file = await readConfigFile(path);
-  const entries = agentFieldsFrom(file);
-  if (entries.length === 0) {
-    throw new Error("no agents configured — apiKeys and agents cannot be empty");
+function piResultText(result) {
+  if (result && typeof result === "object" && !Array.isArray(result) && "content" in result) {
+    return textOfResult(result.content);
   }
-  const shared = sharedFields(file, overrides);
-  return entries.map((entry, index) => configFrom(merge(shared, entry), nameOf(entry, index, entries.length), overrides.args ?? []));
+  const text = textOfResult(result);
+  return text || (result == null ? "" : JSON.stringify(result));
 }
 
 // src/execute.ts
+import { spawn } from "node:child_process";
 var OUTPUT_LIMIT = 8000;
 var ERROR_LIMIT = 400;
 function tail2(text, limit) {
@@ -911,85 +1180,83 @@ async function answer(config, client, message, stop) {
   await client.chatResult(message.id, { status: "failed", error, usage: stream.contextUsage() });
 }
 
-// src/client.ts
-var REQUEST_TIMEOUT_MS = 30000;
-var CHAT_CLAIM_TIMEOUT_MS = 35000;
-
-class RequestError extends Error {
-  status;
-  constructor(status, message) {
-    super(message);
-    this.status = status;
-  }
-}
-
-class Client {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  async post(path, body, timeoutMs = REQUEST_TIMEOUT_MS) {
-    const res = await fetch(`${this.config.url}${path}`, {
-      method: "POST",
-      headers: {
-        "x-api-key": this.config.apiKey,
-        ...body === undefined ? {} : { "content-type": "application/json" }
-      },
-      body: body === undefined ? undefined : JSON.stringify(body),
-      signal: AbortSignal.timeout(timeoutMs)
+// src/run.ts
+async function runTask(config, client, run) {
+  let offset = 0;
+  const stream = new AnswerStream(config.outputFormat, `run-${run.id}`, String(run.id), async (events) => {
+    if (!run.traceEvents)
+      return;
+    const session = config.outputFormat === "codex-jsonl" ? stream.startedSession() : null;
+    const sessionId = session && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(session) ? session : undefined;
+    for (let start = 0;start < events.length; start += 200) {
+      const batch = events.slice(start, start + 200);
+      await client.runEvents(run, offset + start, batch, sessionId);
+    }
+    offset += events.length;
+  });
+  const usage = new UsageReader(config.outputFormat);
+  const timer = setInterval(() => {
+    stream.flush().catch(() => {});
+  }, 500);
+  try {
+    const outcome = await execute(config, {
+      prompt: run.prompt,
+      systemPrompt: run.systemPrompt,
+      env: {
+        ITSAPLAN_RUN_ID: String(run.id),
+        ITSAPLAN_TRIGGER: run.trigger,
+        ITSAPLAN_SYSTEM_PROMPT: run.systemPrompt,
+        ITSAPLAN_ISSUE: run.issueIdentifier ?? "",
+        ITSAPLAN_ISSUE_ID: run.issueId == null ? "" : String(run.issueId)
+      }
+    }, {
+      onData: (chunk) => {
+        usage.write(chunk);
+        stream.write(chunk);
+      }
     });
-    if (!res.ok) {
-      throw new RequestError(res.status, `POST ${path} failed with ${res.status}: ${(await res.text()).slice(0, 200)}`);
+    clearInterval(timer);
+    usage.end();
+    try {
+      if (outcome.status === "success")
+        await stream.finish(outcome.output);
+      else
+        await stream.fail(outcome.error ?? "The command failed", outcome.output);
+    } catch (error) {
+      if (!isTransientEventError(error))
+        throw error;
+      try {
+        await stream.flush();
+      } catch (retryError) {
+        if (!isTransientEventError(retryError))
+          throw retryError;
+        console.error(`Run ${run.id}: trace upload failed; reporting the command result: ${String(retryError)}`);
+      }
     }
-    return res;
-  }
-  async claim() {
-    const res = await this.post("/agent-runs/claim");
-    const body = await res.json();
-    return body.run;
-  }
-  async heartbeat(runId) {
-    await this.post(`/agent-runs/${runId}/heartbeat`);
-  }
-  async report(runId, result) {
-    await this.post(`/agent-runs/${runId}/result`, result);
-  }
-  async claimChat() {
-    const res = await this.post("/agent-chats/claim", undefined, CHAT_CLAIM_TIMEOUT_MS);
-    const body = await res.json();
-    return body.message;
-  }
-  async chatEvents(messageId, events, sessionId) {
-    const res = await this.post(`/agent-chats/${messageId}/events`, {
-      events,
-      ...sessionId && { sessionId }
+    const output = config.outputFormat === "text" ? outcome.output : stream.answer();
+    await client.report(run.id, {
+      ...outcome,
+      output,
+      ...run.traceEvents && { attempt: run.attempts },
+      usage: usage.value()
     });
-    return canceled(res);
-  }
-  async chatHeartbeat(messageId) {
-    return canceled(await this.post(`/agent-chats/${messageId}/heartbeat`));
-  }
-  async chatResult(messageId, result) {
-    await this.post(`/agent-chats/${messageId}/result`, result);
+    return outcome;
+  } finally {
+    clearInterval(timer);
   }
 }
-async function canceled(res) {
-  const body = await res.json().catch(() => ({}));
-  return body.canceled === true;
+function isTransientEventError(error) {
+  if (error instanceof RequestError) {
+    return error.status === 408 || error.status === 429 || error.status >= 500;
+  }
+  return error instanceof TypeError || error instanceof Error && ["AbortError", "TimeoutError"].includes(error.name);
 }
 
-// src/cli.ts
+// src/tasks.ts
 var HEARTBEAT_MS = 60000;
-var ERROR_BACKOFF_MS = 5000;
-function prefixOf(name) {
-  return name ? `[itsaplan-runner ${name}]` : "[itsaplan-runner]";
-}
-function log(message) {
-  console.log(`${prefixOf("")} ${message}`);
-}
-async function withHeartbeat(log2, beat, work) {
+async function withHeartbeat(log, beat, work) {
   const timer = setInterval(() => {
-    beat().catch((err) => log2(`heartbeat failed: ${String(err)}`));
+    beat().catch((err) => log(`heartbeat failed: ${String(err)}`));
   }, HEARTBEAT_MS);
   try {
     return await work;
@@ -997,53 +1264,52 @@ async function withHeartbeat(log2, beat, work) {
     clearInterval(timer);
   }
 }
-function taskOf(run) {
-  return {
-    prompt: run.prompt,
-    systemPrompt: run.systemPrompt,
-    env: {
-      ITSAPLAN_RUN_ID: String(run.id),
-      ITSAPLAN_TRIGGER: run.trigger,
-      ITSAPLAN_SYSTEM_PROMPT: run.systemPrompt,
-      ITSAPLAN_ISSUE: run.issueIdentifier ?? "",
-      ITSAPLAN_ISSUE_ID: run.issueId == null ? "" : String(run.issueId)
-    }
-  };
-}
-async function handle(config, client, log2, run) {
+async function handleRun(config, client, log, run) {
   const label = run.issueIdentifier ?? `run ${run.id}`;
-  log2(`${label}: started (${run.trigger})`);
+  log(`${label}: started (${run.trigger})`);
   try {
-    const usage = new UsageReader(config.outputFormat);
-    const outcome = await withHeartbeat(log2, () => client.heartbeat(run.id), execute(config, taskOf(run), { onData: (chunk) => usage.write(chunk) }));
-    usage.end();
-    await client.report(run.id, { ...outcome, usage: usage.value() });
-    log2(`${label}: ${outcome.status}${outcome.error ? ` — ${outcome.error}` : ""}`);
+    const outcome = await withHeartbeat(log, () => client.heartbeat(run.id, run.traceEvents ? run.attempts : undefined), runTask(config, client, run));
+    log(`${label}: ${outcome.status}${outcome.error ? ` — ${outcome.error}` : ""}`);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log2(`${label}: runner error — ${message}`);
-    await client.report(run.id, { status: "failed", error: message }).catch(() => {});
+    log(`${label}: runner error — ${message}`);
+    await client.report(run.id, {
+      status: "failed",
+      error: message,
+      ...run.traceEvents && { attempt: run.attempts }
+    }).catch(() => {});
   }
 }
-async function handleChat(config, client, log2, message) {
-  log2(`chat ${message.id}: answering`);
+async function handleChat(config, client, log, message) {
+  log(`chat ${message.id}: answering`);
   const stop = new AbortController;
   try {
-    await withHeartbeat(log2, async () => {
+    await withHeartbeat(log, async () => {
       if (await client.chatHeartbeat(message.id))
         stop.abort();
     }, answer(config, client, message, stop));
   } catch (err) {
     if (!stop.signal.aborted) {
       const text = err instanceof Error ? err.message : String(err);
-      log2(`chat ${message.id}: runner error — ${text}`);
+      log(`chat ${message.id}: runner error — ${text}`);
       await client.chatResult(message.id, { status: "failed", error: text }).catch(() => {});
       return;
     }
   }
-  log2(`chat ${message.id}: ${stop.signal.aborted ? "stopped" : "answered"}`);
+  log(`chat ${message.id}: ${stop.signal.aborted ? "stopped" : "answered"}`);
+}
+
+// src/cli.ts
+var ERROR_BACKOFF_MS = 5000;
+function prefixOf(name) {
+  return name ? `[itsaplan-runner ${name}]` : "[itsaplan-runner]";
+}
+function logFor(name) {
+  const prefix = prefixOf(name);
+  return (message) => console.log(`${prefix} ${message}`);
 }
-async function drain(state, log2, concurrency, take, run, onEmpty) {
+var log = logFor("");
+async function drain(state, log, concurrency, take, run, onEmpty) {
   const active = new Set;
   let done = false;
   while (!state.stopping && !done) {
@@ -1057,7 +1323,7 @@ async function drain(state, log2, concurrency, take, run, onEmpty) {
     } catch (err) {
       if (err instanceof RequestError && (err.status === 401 || err.status === 403))
         throw err;
-      log2(`claim failed: ${String(err)}`);
+      log(`claim failed: ${String(err)}`);
       await sleep(ERROR_BACKOFF_MS);
       continue;
     }
@@ -1095,36 +1361,68 @@ function parseArgv(argv) {
   }
   return parsed;
 }
-async function serve(state, config) {
+async function poll(state, config) {
   const client = new Client(config);
-  const prefix = prefixOf(config.name);
-  const log2 = (message) => console.log(`${prefix} ${message}`);
-  log2(`running ${config.agent ?? "the configured command"}, polling ${config.url} every ` + `${config.pollIntervalMs}ms, up to ${config.concurrency} at once`);
+  const log = logFor(config.name);
+  log(`running ${config.agent ?? "the configured command"}, polling ${config.url} every ` + `${config.pollIntervalMs}ms, up to ${config.concurrency} at once`);
   let chatSupported = true;
   await Promise.all([
-    drain(state, log2, config.concurrency, () => client.claim(), (run) => handle(config, client, log2, run), async () => {
+    drain(state, log, config.concurrency, () => client.claim(), (run) => handleRun(config, client, log, run), async () => {
       await sleep(config.pollIntervalMs);
       return true;
     }),
-    drain(state, log2, config.concurrency, async () => {
+    drain(state, log, config.concurrency, async () => {
       try {
         return await client.claimChat();
       } catch (err) {
         if (err instanceof RequestError && err.status === 404) {
-          log2("this instance has no chat feed — only queued runs will be answered");
+          log("this instance has no chat feed — only queued runs will be answered");
           chatSupported = false;
           return null;
         }
         throw err;
       }
-    }, (message) => handleChat(config, client, log2, message), () => Promise.resolve(chatSupported))
+    }, (message) => handleChat(config, client, log, message), () => Promise.resolve(chatSupported))
   ]);
 }
+async function listenOn(state, port, configs) {
+  const listener = await startListener(port, configs.map((config) => {
+    const client = new Client(config);
+    const log = logFor(config.name);
+    log(`running ${config.agent ?? "the configured command"} for the tasks ${config.url} ` + `sends to port ${port}, up to ${config.concurrency} at once`);
+    return {
+      secret: config.signingSecret,
+      concurrency: config.concurrency,
+      run: (run) => handleRun(config, client, log, run),
+      chat: (message) => handleChat(config, client, log, message)
+    };
+  }), log);
+  log(`listening on port ${listener.port}`);
+  await state.stopped;
+  await listener.close();
+}
+function byPort(configs) {
+  const ports = new Map;
+  for (const config of configs) {
+    if (config.listen === undefined)
+      continue;
+    ports.set(config.listen, [...ports.get(config.listen) ?? [], config]);
+  }
+  return ports;
+}
+function settle(name, work) {
+  return work.then(() => true, (err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`${prefixOf(name)} stopped — ${message}`);
+    return false;
+  });
+}
 async function main() {
   const cli = parseArgv(process.argv.slice(2));
   const configPath = cli.configPath ?? process.env.ITSAPLAN_RUNNER_CONFIG ?? "./itsaplan-runner.json";
   const configs = await loadConfig(configPath, { agent: cli.agent, args: cli.args });
-  const state = { stopping: false };
+  let stop;
+  const state = { stopping: false, stopped: new Promise((resolve) => stop = resolve) };
   for (const signal of ["SIGINT", "SIGTERM"]) {
     process.on(signal, () => {
       if (state.stopping) {
@@ -1132,14 +1430,14 @@ async function main() {
         process.exit(1);
       }
       state.stopping = true;
+      stop();
       log("stopping — finishing the tasks in flight, press again to quit now");
     });
   }
-  const served = await Promise.all(configs.map((config) => serve(state, config).then(() => true, (err) => {
-    const message = err instanceof Error ? err.message : String(err);
-    console.error(`${prefixOf(config.name)} stopped — ${message}`);
-    return false;
-  })));
+  const served = await Promise.all([
+    ...configs.filter((config) => config.listen === undefined).map((config) => settle(config.name, poll(state, config))),
+    ...[...byPort(configs)].map(([port, listening]) => settle(listening.length === 1 ? listening[0].name : "", listenOn(state, port, listening)))
+  ]);
   if (served.includes(false))
     process.exit(1);
 }