@itsaplan/runner 0.2.1 → 0.4.0

package/README.md

@@ -3,12 +3,12 @@
 [It's a Plan](https://itsaplan.dev) is a self-hosted, open-source issue tracker. An AI
 agent in it is a project member: it has a role, permissions, and its own issues.
 
-This package runs one such agent on your own machine.
+This package runs such agents on your own machine — one, or several at once.
 
 - Polls your instance for the agent's queued runs. Runs each one with a coding agent CLI.
   Reports the result.
-- Has presets for Claude Code, Codex, opencode, Gemini CLI and GitHub Copilot CLI. Each
-  preset sets the unattended flags and the session resume.
+- Has presets for Claude Code, Codex, opencode, Antigravity CLI and GitHub Copilot CLI.
+  Each preset sets the unattended flags and the session resume.
 - Runs your own `command` instead, if you prefer. The command takes the task on stdin.
 - Answers the agent's chat. Sends the text and the tool calls while the CLI prints them.
 
@@ -61,22 +61,23 @@ or mention it in a comment. The task then starts in your terminal.
 ## Which coding agent
 
 `agent` names a CLI that the runner knows. The runner then builds the command itself: the
-flags for an unattended run, and the session resume.
+flags for an unattended run, and the session resume. Every preset keeps a chat session.
 
-| Agent      | Runs                     | Keeps a chat session |
-| ---------- | ------------------------ | -------------------- |
-| `claude`   | Claude Code              | yes                  |
-| `codex`    | Codex CLI                | yes                  |
-| `opencode` | opencode                 | yes                  |
-| `gemini`   | Gemini CLI               | no                   |
-| `copilot`  | GitHub Copilot CLI       | no                   |
+| Agent         | Runs               |
+| ------------- | ------------------ |
+| `claude`      | Claude Code        |
+| `codex`       | Codex CLI          |
+| `opencode`    | opencode           |
+| `antigravity` | Antigravity CLI    |
+| `copilot`     | GitHub Copilot CLI |
 
 Each preset needs the CLI's own MCP config.
 [Coding agent setup](https://github.com/croffasia/itsaplan/blob/main/docs/runner.md) holds
 that file, and the notes for each CLI.
 
-`--agent` on the command line has priority over the file. The runner appends the
-arguments after `--` to the ones from the preset:
+`--agent` on the command line has priority over the file, except over an `agents` entry
+that names its own. The runner appends the arguments after `--` to the ones from the
+preset:
 
 ```bash
 npx -y @itsaplan/runner --agent claude -- --model opus
@@ -99,6 +100,52 @@ Your arguments come after the preset's own. A repeated flag thus replaces its va
 `command` replaces the preset with your own shell command. The command receives the task
 on stdin. The runner keeps no session for it, because it does not know how to resume one.
 
+## Several agents on one runner
+
+One key is one agent. A runner set up the way you want it can serve several of them at
+once: it polls for each key on its own, and every agent uses the coding agent, the working
+directory and the arguments the file already gives.
+
+```json
+{
+  "url": "http://localhost:3000",
+  "agent": "claude",
+  "cwd": "/Users/me/work/my-repo",
+  "apiKeys": ["the first agent's key", "the second agent's key"]
+}
+```
+
+Nothing else changes: the runner gives each command its own `ITSAPLAN_API_KEY`, so the one
+MCP config in that folder works for all of them.
+
+Use `agents` instead of `apiKeys` where an agent needs something of its own. A field an
+entry sets replaces the shared one, and it inherits every field it leaves out, except its
+`apiKey`, which every entry sets itself. `name` is what the runner's log lines call that
+agent; without it they number the agents `#1`, `#2` in the order of the file.
+
+```json
+{
+  "url": "http://localhost:3000",
+  "agent": "claude",
+  "cwd": "/Users/me/work/my-repo",
+  "agents": [
+    { "apiKey": "the first agent's key", "name": "planner" },
+    {
+      "apiKey": "the second agent's key",
+      "cwd": "/Users/me/work/other-repo",
+      "args": ["--model", "opus"]
+    }
+  ]
+}
+```
+
+`concurrency` counts per agent and per feed, so a runner with three agents at
+`concurrency: 2` can have six queued runs in flight and six chat answers alongside them,
+each one a coding agent CLI of its own. The environment variables and the command-line
+options describe every agent at once; an entry has priority over them.
+
+An agent whose key the instance refuses stops on its own, and the others keep working.
+
 ## Settings
 
 The runner reads `./itsaplan-runner.json`. For a different file, give the path as an
@@ -109,21 +156,23 @@ npx -y @itsaplan/runner /path/to/config.json
 ```
 
 The environment variables have priority over the file. The command-line options have
-priority over both.
-
-| Field            | Environment variable        | Default            | What it does                        |
-| ---------------- | --------------------------- | ------------------ | ----------------------------------- |
-| `url`            | `ITSAPLAN_URL`              | required           | Your Itsaplan instance              |
-| `apiKey`         | `ITSAPLAN_API_KEY`          | required           | The external agent's key            |
-| `agent`          | `ITSAPLAN_AGENT`            | —                  | The coding agent to run             |
-| `args`           |                             | `[]`               | Arguments added after the preset's  |
-| `command`        | `ITSAPLAN_COMMAND`          | —                  | Your own command, instead of `agent` |
-| `cwd`            | `ITSAPLAN_CWD`              | where you start it | Working directory for the command   |
-| `env`            |                             | `{}`               | Extra variables for the command     |
-| `concurrency`    | `ITSAPLAN_CONCURRENCY`      | `1`                | Tasks at once. Queued runs and chat answers count apart |
-| `pollIntervalMs` | `ITSAPLAN_POLL_INTERVAL_MS` | `3000`             | Wait after an empty queue. Minimum 1000 |
-| `timeoutMs`      | `ITSAPLAN_TIMEOUT_MS`       | `1800000`          | Time before the runner stops a task      |
-| `outputFormat`   | `ITSAPLAN_OUTPUT_FORMAT`    | the preset's       | How the runner reads a chat answer |
+priority over both. An `agents` entry has priority over all three, for the fields it sets.
+
+| Field            | Environment variable        | Default            | What it does                                                       |
+| ---------------- | --------------------------- | ------------------ | ------------------------------------------------------------------ |
+| `url`            | `ITSAPLAN_URL`              | required           | Your Itsaplan instance                                             |
+| `apiKey`         | `ITSAPLAN_API_KEY`          | required           | The external agent's key. Replaced by `apiKeys` or `agents`        |
+| `apiKeys`        |                             | —                  | Several keys, all with these settings. Not with `agents`           |
+| `agents`         |                             | —                  | Several agents, each with its own key and settings. Not with `apiKeys` |
+| `agent`          | `ITSAPLAN_AGENT`            | —                  | The coding agent to run                                            |
+| `args`           |                             | `[]`               | Arguments added after the preset's                                 |
+| `command`        | `ITSAPLAN_COMMAND`          | —                  | Your own command, instead of `agent`                               |
+| `cwd`            | `ITSAPLAN_CWD`              | where you start it | Working directory for the command                                  |
+| `env`            |                             | `{}`               | Extra variables for the command                                    |
+| `concurrency`    | `ITSAPLAN_CONCURRENCY`      | `1`                | Tasks at once, per agent. Queued runs and chat answers count apart |
+| `pollIntervalMs` | `ITSAPLAN_POLL_INTERVAL_MS` | `3000`             | Wait after an empty queue. Minimum 1000                            |
+| `timeoutMs`      | `ITSAPLAN_TIMEOUT_MS`       | `1800000`          | Time before the runner stops a task                                |
+| `outputFormat`   | `ITSAPLAN_OUTPUT_FORMAT`    | the preset's       | How the runner reads a chat answer                                 |
 
 Set `agent` or `command`. With the environment you need no file at all:
 
@@ -139,7 +188,7 @@ npx -y @itsaplan/runner --agent claude
 The server writes the task text. The text states what occurred, what to do, and to post
 the result as a comment on the issue. Your own `command` receives the text on **stdin**. A
 preset gives it to its CLI in the way that CLI accepts it: on stdin for `claude` and
-`codex`, as an argument for `gemini`, `copilot` and `opencode`.
+`codex`, as an argument for `antigravity`, `copilot` and `opencode`.
 
 The agent reads all other data through the MCP server at `$ITSAPLAN_URL/mcp`. The agent
 sends `$ITSAPLAN_API_KEY` as a bearer token, and acts as its own user with its role.
@@ -148,12 +197,12 @@ sends `$ITSAPLAN_API_KEY` as a bearer token, and acts as its own user with its r
 
 Every run holds these variables:
 
-| Variable                 | What it holds                                                    |
-| ------------------------ | ---------------------------------------------------------------- |
-| `ITSAPLAN_URL`           | the instance that sent the task                                  |
-| `ITSAPLAN_API_KEY`       | the agent's key, for the API and the MCP server                  |
-| `ITSAPLAN_TRIGGER`       | `mention`, `delegation`, `schedule`, `manual`, or `chat`         |
-| `ITSAPLAN_SYSTEM_PROMPT` | the context of the run, for a command that takes a system prompt |
+| Variable                 | What it holds                                                     |
+| ------------------------ | ----------------------------------------------------------------- |
+| `ITSAPLAN_URL`           | the instance that sent the task                                   |
+| `ITSAPLAN_API_KEY`       | the agent's key, for the API and the MCP server                   |
+| `ITSAPLAN_TRIGGER`       | `mention`, `delegation`, `field`, `schedule`, `manual`, or `chat` |
+| `ITSAPLAN_SYSTEM_PROMPT` | the context of the run, for a command that takes a system prompt  |
 
 A queued run adds three more:
 
@@ -165,11 +214,11 @@ A queued run adds three more:
 
 A chat message adds three others in their place, and `ITSAPLAN_TRIGGER` is `chat`:
 
-| Variable               | What it holds                                                   |
-| ---------------------- | ---------------------------------------------------------------- |
-| `ITSAPLAN_THREAD_ID`   | the conversation's id                                            |
-| `ITSAPLAN_MESSAGE_ID`  | the id of the message to answer                                  |
-| `ITSAPLAN_SESSION_ID`  | the coding agent's session to resume. Empty for the first message |
+| Variable              | What it holds                                                     |
+| --------------------- | ----------------------------------------------------------------- |
+| `ITSAPLAN_THREAD_ID`  | the conversation's id                                             |
+| `ITSAPLAN_MESSAGE_ID` | the id of the message to answer                                   |
+| `ITSAPLAN_SESSION_ID` | the coding agent's session to resume. Empty for the first message |
 
 The task text of a chat message includes the conversation, unless a session holds it. See
 Sessions below.
@@ -185,7 +234,8 @@ The runner streams the answer to the chat while the command runs. It reports the
 calls with the answer. `outputFormat` tells the runner how to read the output:
 
 - `text` — all the output is the answer.
-- `claude-stream-json`, `codex-jsonl`, `opencode-json` — the event stream of that CLI.
+- `claude-stream-json`, `codex-jsonl`, `opencode-json`, `antigravity-stream-json`,
+  `copilot-json` — the event stream of that CLI.
 
 A preset sets `outputFormat` for you. Set it yourself only with your own `command`. If the
 output does not agree with the format, the runner sends the output as plain text.
@@ -197,8 +247,7 @@ Without a session the server sends the last 20 messages of the conversation as p
 
 - The chat header shows the session id. Run `claude --resume <id>` in the runner's working
   directory to open the same session in your terminal.
-- `gemini` and `copilot` keep no session: neither one reports the id of a session that
-  starts non-interactively.
+- Your own `command` keeps no session. Each chat message then includes the conversation.
 - A session stays on the machine that started it. If you delete its files or move the
   runner, the answers fail. Start a new chat then.
 

package/dist/cli.js

@@ -137,7 +137,79 @@ class AnswerStream {
       case "opencode-json":
         this.readOpencodeLine(parsed);
         break;
+      case "antigravity-stream-json":
+        this.readAntigravityLine(parsed);
+        break;
+      case "copilot-json":
+        this.readCopilotLine(parsed);
+        break;
+    }
+  }
+  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;
+    if (message.event === "result") {
+      if (!this.sawAnyText && typeof message.result?.response === "string") {
+        this.appendText(message.result.response);
+      }
+      return;
+    }
+    if (!step)
+      return;
+    if (step.step_type === "agent_response") {
+      if (step.text_delta)
+        this.appendText(step.text_delta);
+      return;
     }
+    if (step.step_type !== "tool" || step.step_index === undefined)
+      return;
+    const id = `step-${step.step_index}`;
+    const tool = step.tool_info;
+    if (!this.openToolCalls.has(id)) {
+      this.openToolCalls.add(id);
+      this.pushToolCall(id, step.tool_name ?? tool?.name ?? "tool", JSON.stringify(tool?.parameters ?? {}));
+    }
+    if (this.closedToolCalls.has(id))
+      return;
+    const result = tool?.error?.message ?? tool?.output;
+    if (typeof result !== "string")
+      return;
+    this.closedToolCalls.add(id);
+    this.pushToolResult(id, result);
   }
   readCodexLine(message) {
     if (message.type === "thread.started" && message.thread_id) {
@@ -264,7 +336,6 @@ var PRESETS = {
   claude: {
     bin: "claude",
     outputFormat: "claude-stream-json",
-    sessions: true,
     promptVia: "stdin",
     systemPromptFlag: "--append-system-prompt",
     head: (sessionId) => [
@@ -282,7 +353,6 @@ var PRESETS = {
   codex: {
     bin: "codex",
     outputFormat: "codex-jsonl",
-    sessions: true,
     promptVia: "stdin",
     head: (sessionId) => [
       ...sessionId ? ["exec", "resume", sessionId] : ["exec"],
@@ -295,7 +365,6 @@ var PRESETS = {
   opencode: {
     bin: "opencode",
     outputFormat: "opencode-json",
-    sessions: true,
     promptVia: "arg",
     head: (sessionId) => [
       "run",
@@ -305,20 +374,31 @@ var PRESETS = {
     ],
     tail: []
   },
-  gemini: {
-    bin: "gemini",
-    outputFormat: "text",
-    sessions: false,
+  antigravity: {
+    bin: "agy",
+    outputFormat: "antigravity-stream-json",
     promptVia: "arg",
-    head: () => ["--approval-mode", "yolo"],
+    head: (sessionId) => [
+      ...sessionId ? ["--conversation", sessionId] : [],
+      "--output-format",
+      "stream-json",
+      "--dangerously-skip-permissions",
+      "--print-timeout",
+      "24h"
+    ],
     tail: ["-p"]
   },
   copilot: {
     bin: "copilot",
-    outputFormat: "text",
-    sessions: false,
+    outputFormat: "copilot-json",
     promptVia: "arg",
-    head: () => ["--allow-all-tools", "--no-ask-user"],
+    head: (sessionId) => [
+      "--allow-all-tools",
+      "--no-ask-user",
+      "--output-format",
+      "json",
+      ...sessionId ? ["--session-id", sessionId] : []
+    ],
     tail: ["-p"]
   }
 };
@@ -335,7 +415,7 @@ ${prompt}`;
 }
 function presetArgv(preset, sessionId, systemPrompt, extraArgs, prompt) {
   return [
-    ...preset.head(preset.sessions ? sessionId : null),
+    ...preset.head(sessionId),
     ...preset.systemPromptFlag && systemPrompt ? [preset.systemPromptFlag, systemPrompt] : [],
     ...extraArgs,
     ...preset.tail,
@@ -344,7 +424,14 @@ function presetArgv(preset, sessionId, systemPrompt, extraArgs, prompt) {
 }
 
 // src/config.ts
-var OUTPUT_FORMATS = ["text", "claude-stream-json", "codex-jsonl", "opencode-json"];
+var OUTPUT_FORMATS = [
+  "text",
+  "claude-stream-json",
+  "codex-jsonl",
+  "opencode-json",
+  "antigravity-stream-json",
+  "copilot-json"
+];
 function presetOf(config) {
   if (config.command || !config.agent)
     return;
@@ -356,12 +443,16 @@ var DEFAULTS = {
   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 = typeof value === "string" ? value.trim() : "";
+  const name = textOf(value);
   if (!name)
     return preset?.outputFormat ?? "text";
   const format = OUTPUT_FORMATS.find((candidate) => candidate === name);
@@ -371,7 +462,7 @@ function outputFormatFrom(value, preset) {
   return format;
 }
 function agentFrom(value) {
-  const name = typeof value === "string" ? value.trim() : "";
+  const name = textOf(value);
   if (!name)
     return;
   if (!isPresetName(name)) {
@@ -388,7 +479,7 @@ function argsFrom(value) {
   return value;
 }
 function required(value, field) {
-  const text = typeof value === "string" ? value.trim() : "";
+  const text = textOf(value);
   if (!text)
     throw new Error(`${field} is required — set it in the config file or the environment`);
   return text;
@@ -408,27 +499,90 @@ async function readConfigFile(path) {
     throw new Error(`${path} is not valid JSON`);
   }
 }
-async function loadConfig(path, overrides = {}) {
-  const raw = await readConfigFile(path);
-  const env = process.env;
-  const agent = agentFrom(overrides.agent ?? env.ITSAPLAN_AGENT ?? raw.agent);
-  const command = (env.ITSAPLAN_COMMAND ?? raw.command)?.trim() || undefined;
+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);
   if (!agent && !command) {
     throw new Error(`set either agent (one of ${PRESET_NAMES.join(", ")}) or command in the config file or the environment`);
   }
   return {
-    url: required(env.ITSAPLAN_URL ?? raw.url, "url").replace(/\/+$/, ""),
-    apiKey: required(env.ITSAPLAN_API_KEY ?? raw.apiKey, "apiKey"),
+    name,
+    url: required(fields.url, "url").replace(/\/+$/, ""),
+    apiKey: required(fields.apiKey, "apiKey"),
     agent,
     command,
-    args: [...argsFrom(raw.args), ...overrides.args ?? []],
-    cwd: (env.ITSAPLAN_CWD ?? raw.cwd)?.replace(/^~/, env.HOME ?? "~"),
-    env: raw.env ?? {},
-    concurrency: intFrom(env.ITSAPLAN_CONCURRENCY ?? raw.concurrency, DEFAULTS.concurrency),
-    pollIntervalMs: Math.max(intFrom(env.ITSAPLAN_POLL_INTERVAL_MS ?? raw.pollIntervalMs, DEFAULTS.pollIntervalMs), MIN_POLL_INTERVAL_MS),
-    timeoutMs: intFrom(env.ITSAPLAN_TIMEOUT_MS ?? raw.timeoutMs, DEFAULTS.timeoutMs),
-    outputFormat: outputFormatFrom(env.ITSAPLAN_OUTPUT_FORMAT ?? raw.outputFormat, presetOf({ 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];
+  }
+  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);
+  return entries.map((entry, index) => configFrom(merge(shared, entry), nameOf(entry, index, entries.length), overrides.args ?? []));
 }
 
 // src/execute.ts
@@ -466,7 +620,7 @@ function stdinText(preset, task) {
     return "";
   return presetPrompt(preset, task.systemPrompt, task.prompt);
 }
-async function execute(config, task, onData) {
+async function execute(config, task, opts = {}) {
   const preset = presetOf(config);
   const [bin, args] = spawnArgs(config, preset, task);
   const child = spawn(bin, args, {
@@ -474,19 +628,23 @@ async function execute(config, task, onData) {
     env: childEnv(config, task),
     detached: true
   });
+  const kill = () => {
+    if (child.pid !== undefined)
+      killGroup(child.pid);
+  };
   let timedOut = false;
   const timer = setTimeout(() => {
     timedOut = true;
-    if (child.pid !== undefined)
-      killGroup(child.pid);
+    kill();
   }, config.timeoutMs);
+  opts.signal?.addEventListener("abort", kill, { once: true });
   let stdout = "";
   let stderr = "";
   child.stdout.setEncoding("utf8");
   child.stderr.setEncoding("utf8");
   child.stdout.on("data", (chunk) => {
     stdout = tail2(stdout + chunk, OUTPUT_LIMIT);
-    onData?.(chunk);
+    opts.onData?.(chunk);
   });
   child.stderr.on("data", (chunk) => {
     stderr = tail2(stderr + chunk, ERROR_LIMIT);
@@ -503,6 +661,7 @@ async function execute(config, task, onData) {
     ({ code, signal } = await exited);
   } finally {
     clearTimeout(timer);
+    opts.signal?.removeEventListener("abort", kill);
   }
   const output = stdout.trim();
   if (code === 0)
@@ -518,13 +677,14 @@ async function execute(config, task, onData) {
 
 // src/chat.ts
 var FLUSH_MS = 500;
-async function answer(config, client, message) {
+async function answer(config, client, message, stop) {
   let reported = message.sessionId !== null;
-  const stream = new AnswerStream(config.outputFormat, message.threadId, String(message.id), (events) => {
+  const stream = new AnswerStream(config.outputFormat, message.threadId, String(message.id), async (events) => {
     const started = reported ? undefined : stream.startedSession() ?? undefined;
     if (started)
       reported = true;
-    return client.chatEvents(message.id, events, started);
+    if (await client.chatEvents(message.id, events, started))
+      stop.abort();
   });
   const flushing = setInterval(() => {
     stream.flush().catch(() => {});
@@ -540,7 +700,9 @@ async function answer(config, client, message) {
       ITSAPLAN_MESSAGE_ID: String(message.id),
       ITSAPLAN_SESSION_ID: message.sessionId ?? ""
     }
-  }, (chunk) => stream.write(chunk)).finally(() => clearInterval(flushing));
+  }, { onData: (chunk) => stream.write(chunk), signal: stop.signal }).finally(() => clearInterval(flushing));
+  if (stop.signal.aborted)
+    return;
   if (outcome.status === "success") {
     await stream.finish(outcome.output);
     await client.chatResult(message.id, { status: "success" });
@@ -600,28 +762,36 @@ class Client {
     return body.message;
   }
   async chatEvents(messageId, events, sessionId) {
-    await this.post(`/agent-chats/${messageId}/events`, {
+    const res = await this.post(`/agent-chats/${messageId}/events`, {
       events,
       ...sessionId && { sessionId }
     });
+    return canceled(res);
   }
   async chatHeartbeat(messageId) {
-    await this.post(`/agent-chats/${messageId}/heartbeat`);
+    return canceled(await this.post(`/agent-chats/${messageId}/heartbeat`));
   }
   async chatResult(messageId, result) {
     await this.post(`/agent-chats/${messageId}/result`, result);
   }
 }
+async function canceled(res) {
+  const body = await res.json().catch(() => ({}));
+  return body.canceled === true;
+}
 
 // src/cli.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(`[itsaplan-runner] ${message}`);
+  console.log(`${prefixOf("")} ${message}`);
 }
-async function withHeartbeat(beat, work) {
+async function withHeartbeat(log2, beat, work) {
   const timer = setInterval(() => {
-    beat().catch((err) => log(`heartbeat failed: ${String(err)}`));
+    beat().catch((err) => log2(`heartbeat failed: ${String(err)}`));
   }, HEARTBEAT_MS);
   try {
     return await work;
@@ -642,31 +812,38 @@ function taskOf(run) {
     }
   };
 }
-async function handle(config, client, run) {
+async function handle(config, client, log2, run) {
   const label = run.issueIdentifier ?? `run ${run.id}`;
-  log(`${label}: started (${run.trigger})`);
+  log2(`${label}: started (${run.trigger})`);
   try {
-    const outcome = await withHeartbeat(() => client.heartbeat(run.id), execute(config, taskOf(run)));
+    const outcome = await withHeartbeat(log2, () => client.heartbeat(run.id), execute(config, taskOf(run)));
     await client.report(run.id, outcome);
-    log(`${label}: ${outcome.status}${outcome.error ? ` — ${outcome.error}` : ""}`);
+    log2(`${label}: ${outcome.status}${outcome.error ? ` — ${outcome.error}` : ""}`);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    log(`${label}: runner error — ${message}`);
+    log2(`${label}: runner error — ${message}`);
     await client.report(run.id, { status: "failed", error: message }).catch(() => {});
   }
 }
-async function handleChat(config, client, message) {
-  log(`chat ${message.id}: answering`);
+async function handleChat(config, client, log2, message) {
+  log2(`chat ${message.id}: answering`);
+  const stop = new AbortController;
   try {
-    await withHeartbeat(() => client.chatHeartbeat(message.id), answer(config, client, message));
-    log(`chat ${message.id}: answered`);
+    await withHeartbeat(log2, async () => {
+      if (await client.chatHeartbeat(message.id))
+        stop.abort();
+    }, answer(config, client, message, stop));
   } catch (err) {
-    const text = err instanceof Error ? err.message : String(err);
-    log(`chat ${message.id}: runner error — ${text}`);
-    await client.chatResult(message.id, { status: "failed", error: text }).catch(() => {});
+    if (!stop.signal.aborted) {
+      const text = err instanceof Error ? err.message : String(err);
+      log2(`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"}`);
 }
-async function drain(state, concurrency, take, run, onEmpty) {
+async function drain(state, log2, concurrency, take, run, onEmpty) {
   const active = new Set;
   let done = false;
   while (!state.stopping && !done) {
@@ -680,7 +857,7 @@ async function drain(state, concurrency, take, run, onEmpty) {
     } catch (err) {
       if (err instanceof RequestError && (err.status === 401 || err.status === 403))
         throw err;
-      log(`claim failed: ${String(err)}`);
+      log2(`claim failed: ${String(err)}`);
       await sleep(ERROR_BACKOFF_MS);
       continue;
     }
@@ -718,43 +895,54 @@ function parseArgv(argv) {
   }
   return parsed;
 }
-async function main() {
-  const cli = parseArgv(process.argv.slice(2));
-  const configPath = cli.configPath ?? process.env.ITSAPLAN_RUNNER_CONFIG ?? "./itsaplan-runner.json";
-  const config = await loadConfig(configPath, { agent: cli.agent, args: cli.args });
+async function serve(state, config) {
   const client = new Client(config);
-  const state = { stopping: false };
-  for (const signal of ["SIGINT", "SIGTERM"]) {
-    process.on(signal, () => {
-      if (state.stopping) {
-        log("quitting now — the commands in flight keep running, their runs are retried");
-        process.exit(1);
-      }
-      state.stopping = true;
-      log("stopping — finishing the tasks in flight, press again to quit now");
-    });
-  }
-  log(`running ${config.agent ?? "the configured command"}, polling ${config.url} every ` + `${config.pollIntervalMs}ms, up to ${config.concurrency} at once`);
+  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`);
   let chatSupported = true;
   await Promise.all([
-    drain(state, config.concurrency, () => client.claim(), (run) => handle(config, client, run), async () => {
+    drain(state, log2, config.concurrency, () => client.claim(), (run) => handle(config, client, log2, run), async () => {
       await sleep(config.pollIntervalMs);
       return true;
     }),
-    drain(state, config.concurrency, async () => {
+    drain(state, log2, config.concurrency, async () => {
       try {
         return await client.claimChat();
       } catch (err) {
         if (err instanceof RequestError && err.status === 404) {
-          log("this instance has no chat feed — only queued runs will be answered");
+          log2("this instance has no chat feed — only queued runs will be answered");
           chatSupported = false;
           return null;
         }
         throw err;
       }
-    }, (message) => handleChat(config, client, message), () => Promise.resolve(chatSupported))
+    }, (message) => handleChat(config, client, log2, message), () => Promise.resolve(chatSupported))
   ]);
 }
+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 };
+  for (const signal of ["SIGINT", "SIGTERM"]) {
+    process.on(signal, () => {
+      if (state.stopping) {
+        log("quitting now — the commands in flight keep running, their runs are retried");
+        process.exit(1);
+      }
+      state.stopping = true;
+      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;
+  })));
+  if (served.includes(false))
+    process.exit(1);
+}
 main().catch((err) => {
   console.error(`[itsaplan-runner] ${err instanceof Error ? err.message : String(err)}`);
   process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itsaplan/runner",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "Runs an Itsaplan external agent's queued tasks and answers its chat on your own machine",
   "keywords": [
     "itsaplan",
@@ -17,7 +17,7 @@
     "linear-alternative",
     "claude-code",
     "codex",
-    "gemini-cli",
+    "antigravity",
     "opencode"
   ],
   "homepage": "https://github.com/croffasia/itsaplan/tree/main/packages/runner#readme",