@ai-setting/roy-task-plugin 0.3.0 → 0.4.0

package/dist/cli.js

@@ -2,7 +2,18 @@
 import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// ../cli/src/args.ts
+// ../../../packages/cli/src/daemon/runners/types.ts
+var RUNTIMES = Object.freeze(["opencode", "claude"]);
+var DEFAULT_RUNTIME = "opencode";
+var DEFAULT_RUNTIME_BIN = Object.freeze({
+  opencode: "opencode",
+  claude: "claude"
+});
+function isRuntimeName(value) {
+  return RUNTIMES.includes(value);
+}
+
+// ../../../packages/cli/src/args.ts
 var DEFAULT_PROFILE = "default";
 var DEFAULT_AGENT = "roy";
 var DEFAULT_EVENT_KEY = "im.message.receive_v1";
@@ -42,6 +53,7 @@ function parseServe(argv) {
     replyEnabled: true,
     cardEnabled: true,
     timeoutMs: DEFAULT_TIMEOUT_MS,
+    runtime: DEFAULT_RUNTIME,
     opencodeBin: "opencode"
   };
   for (let i = 0;i < argv.length; i++) {
@@ -82,6 +94,26 @@ function parseServe(argv) {
         serve.eventKeys.push(v);
         break;
       }
+      case "--runtime": {
+        const v = take();
+        if (v instanceof Error)
+          return { command: "unknown", error: v.message };
+        if (!isRuntimeName(v)) {
+          return {
+            command: "unknown",
+            error: `--runtime must be one of ${RUNTIMES.join("|")}, got "${v}"`
+          };
+        }
+        serve.runtime = v;
+        break;
+      }
+      case "--runtime-bin": {
+        const v = take();
+        if (v instanceof Error)
+          return { command: "unknown", error: v.message };
+        serve.runtimeBin = v;
+        break;
+      }
       case "--opencode-bin": {
         const v = take();
         if (v instanceof Error)
@@ -157,8 +189,16 @@ function readValue(argv, flag) {
   }
   return;
 }
+function resolveRuntimeBin(options) {
+  if (options.runtimeBin !== undefined)
+    return options.runtimeBin;
+  if (options.runtime === "opencode" && options.opencodeBin !== "opencode") {
+    return options.opencodeBin;
+  }
+  return;
+}
 function usage() {
-  return `roy-task — bridge Feishu (Lark) messages to an OpenCode roy agent
+  return `roy-task — bridge Feishu (Lark) messages to a roy agent (opencode or claude)
 
 USAGE
   roy-task [serve] [options]      start the daemon (default command)
@@ -174,13 +214,17 @@ SERVE OPTIONS
                           consumer per (app, EventKey); a second one
                           silently splits the event stream.
   --event-key <key>       event key to consume (repeatable)       (default: ${DEFAULT_EVENT_KEY})
-  --agent <name>          opencode agent to dispatch to           (default: ${DEFAULT_AGENT})
-  --opencode-bin <path>   opencode binary                         (default: opencode)
+  --agent <name>          agent to dispatch to                    (default: ${DEFAULT_AGENT})
+  --runtime <name>        which harness runs the agent            (default: ${DEFAULT_RUNTIME})
+                          one of: ${RUNTIMES.join(" | ")}
+  --runtime-bin <path>    binary for the selected runtime         (default: per-runtime)
+  --opencode-bin <path>   DEPRECATED alias for --runtime-bin
+                          (only applies when --runtime opencode)
   --max-concurrency <n>   max simultaneous agent runs             (default: 1)
                           ⚠️ >1 only safe across DIFFERENT chats;
                           same-session concurrency cross-contaminates.
   --timeout-ms <n>        per-run timeout                          (default: ${DEFAULT_TIMEOUT_MS})
-  --dry-run               never spawn opencode, never reply
+  --dry-run               never spawn the runtime, never reply
   --once                  stop after the first event (testing / CI)
   --reply / --no-reply    send the reply back to Feishu          (default: on)
   --card / --no-card      render a roy-agent progress card        (default: on)
@@ -190,8 +234,9 @@ SERVE OPTIONS
                           never block the text reply.
 
 NOTES
-  • stdin is forced to EOF for \`opencode run\` (stdio[0]="ignore"). Without it
-    opencode's readStdin() waits for EOF on a socket and the run hangs forever.
+  • stdin is forced to EOF for the agent child (stdio[0]="ignore"). Without it
+    both \`opencode run\` and \`claude --print\` wait for EOF on a socket and the
+    run hangs forever.
   • \`lark-cli event consume\` needs the OPPOSITE: its stdin must stay open.
     That side is handled by roy-agent-core, which we import.
   • Replies are sent by the daemon (not by the agent) as a single structured
@@ -202,7 +247,7 @@ NOTES
 `;
 }
 
-// ../cli/src/daemon/concurrency.ts
+// ../../../packages/cli/src/daemon/concurrency.ts
 class ConcurrencyGate {
   maxConcurrency;
   running = 0;
@@ -259,7 +304,7 @@ class ConcurrencyGate {
   }
 }
 
-// ../cli/src/daemon/dedupe.ts
+// ../../../packages/cli/src/daemon/dedupe.ts
 var DEFAULT_TTL_MS = 60000;
 var DEFAULT_MAX_ENTRIES = 5000;
 
@@ -305,7 +350,7 @@ class Deduper {
   }
 }
 
-// ../cli/src/daemon/session-map.ts
+// ../../../packages/cli/src/daemon/session-map.ts
 import { createHash } from "node:crypto";
 var DIGEST_LEN = 16;
 function deriveSessionId(input) {
@@ -316,7 +361,7 @@ function deriveSessionId(input) {
   return `ses_${digest.slice(0, DIGEST_LEN)}`;
 }
 
-// ../cli/src/daemon/prompt.ts
+// ../../../packages/cli/src/daemon/prompt.ts
 var OPENCODE_STDIO = Object.freeze([
   "ignore",
   "pipe",
@@ -369,7 +414,7 @@ function buildOpencodeArgs(input) {
   return args;
 }
 
-// ../cli/src/daemon/task-card.ts
+// ../../../packages/cli/src/daemon/task-card.ts
 var CARD_OP_TIMEOUT_MS = 15000;
 
 class CardTimeoutError extends Error {
@@ -506,7 +551,7 @@ function describeToolUse(tool) {
   };
 }
 
-// ../cli/src/daemon/dispatcher.ts
+// ../../../packages/cli/src/daemon/dispatcher.ts
 function cardReport(handle) {
   const out = {};
   if (handle.messageId)
@@ -781,7 +826,7 @@ class Dispatcher {
   }
 }
 
-// ../cli/src/daemon/es-listener.ts
+// ../../../packages/cli/src/daemon/es-listener.ts
 import { larkCliHandler } from "@ai-setting/roy-agent-core/env/event-source";
 function createEventListener(config) {
   const eventKeys = config.eventKeys?.length ? config.eventKeys : ["im.message.receive_v1"];
@@ -823,79 +868,10 @@ function createEventListener(config) {
   };
 }
 
-// ../cli/src/daemon/ndjson.ts
-class NdjsonAssembler {
-  tail = "";
-  texts = [];
-  error;
-  toolCalls = 0;
-  sessionId;
-  tools = [];
-  pushChunk(chunk) {
-    this.tail += chunk;
-    let idx = this.tail.indexOf(`
-`);
-    while (idx !== -1) {
-      const line = this.tail.slice(0, idx);
-      this.tail = this.tail.slice(idx + 1);
-      this.parseLine(line);
-      idx = this.tail.indexOf(`
-`);
-    }
-  }
-  pushLine(line) {
-    this.parseLine(line);
-  }
-  finishIncomplete() {
-    return this.tail.trim();
-  }
-  parseLine(line) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed[0] !== "{")
-      return;
-    let parsed;
-    try {
-      parsed = JSON.parse(trimmed);
-    } catch {
-      return;
-    }
-    if (parsed.sessionID)
-      this.sessionId = parsed.sessionID;
-    if (parsed.type === "text" && typeof parsed.part?.text === "string") {
-      this.texts.push(parsed.part.text);
-      return;
-    }
-    if (parsed.type === "tool_use") {
-      this.toolCalls += 1;
-      const name = parsed.part?.tool ?? parsed.tool;
-      if (typeof name === "string" && name) {
-        this.tools.push(name);
-      }
-      return;
-    }
-    if (parsed.type === "error") {
-      if (this.error === undefined) {
-        this.error = parsed.error?.message ?? parsed.error?.type ?? "unknown opencode error";
-      }
-    }
-  }
-  finish() {
-    if (this.tail.trim()) {
-      this.parseLine(this.tail);
-      this.tail = "";
-    }
-    const text = this.texts.join("").trim();
-    return {
-      text,
-      error: this.error,
-      toolCalls: this.toolCalls,
-      sessionId: this.sessionId,
-      tools: this.tools
-    };
-  }
-}
+// ../../../packages/cli/src/daemon/runners/claude.ts
+import { createHash as createHash2 } from "node:crypto";
 
-// ../cli/src/runtime/spawn.ts
+// ../../../packages/cli/src/runtime/spawn.ts
 import { spawn } from "node:child_process";
 function runCapture(cmd, opts = {}) {
   return new Promise((resolve, reject) => {
@@ -1018,7 +994,429 @@ function isMissingBinary(err) {
   return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
 }
 
-// ../cli/src/daemon/opencode-runner.ts
+// ../../../packages/cli/src/daemon/runners/claude-agents.ts
+var CLAUDE_ROY_AGENT_NAME = "roy";
+var ROY_AGENT_DESCRIPTION = "Roy — task-as-first-class-citizen agent. Uses the roy-agent task lifecycle " + "(task_tree → task_create → task_update → task_operation_create → task_complete) " + "so every piece of work is tracked in the local task store.";
+var CLAUDE_ROY_TOOLS = Object.freeze([
+  "Read",
+  "Write",
+  "Edit",
+  "Bash",
+  "Grep",
+  "Glob",
+  "TodoWrite",
+  "WebFetch",
+  "WebSearch"
+]);
+var CLAUDE_ROY_SYSTEM_PROMPT = `# Roy — task-first-class-citizen agent
+
+You are **Roy**, an agent whose defining rule is simple:
+
+> **Task is a first-class citizen. No task, no work.**
+
+You are not a chat assistant that occasionally writes notes. You are a worker
+whose output is a *visible, trackable* stream of tasks. Every non-trivial
+request (more than one tool call / more than a couple of minutes of work) MUST
+become a tracked task before you start doing it, and MUST be closed out
+explicitly when you finish.
+
+## The lifecycle (non-negotiable)
+
+### 1. Orient — \`task_tree(depth=1)\` (or \`depth=2\` for bigger trees)
+Before creating anything, look at the existing tree. Decide:
+- does this work belong to an existing root (attach via \`parent_task_id\`)?
+- or is it genuinely new?
+
+Keep **root tasks ≤ 10**. Prefer attaching to an existing thematic root over
+spawning a new root. Never hardcode ids — read them from \`task_tree\`.
+
+### 2. Create — \`task_create\`
+Create the task **before** doing the work. Pass:
+- \`title\` (imperative, specific), \`description\`, \`goals_and_expected_deliverables\`
+- \`priority\` (low / medium / high), \`type\` (normal / cycle / longterm)
+- \`project_path\`, \`context\` (JSON string: worktree_path / branch / type …)
+- \`parent_task_id\` when the tree said so
+
+The tool returns a **numeric task id** — that number is your handle for the
+rest of the conversation.
+
+### 3. Track — \`task_update\`
+Report progress as you go, not only at the end:
+- \`status\`: todo → active → (paused / cancelled) → completed
+- \`progress\`: 0–100
+- \`current_status\`: one human sentence about where you are right now
+
+If the scope changes, \`task_update\` the description/goals instead of silently
+doing something else.
+
+### 4. Record milestones — \`task_operation_create\`
+This tool has **two orthogonal dimensions** and you must keep them distinct:
+- **state / milestone dimension** — \`milestone_type\` + \`milestone_title\` +
+  \`milestone_description\`: *what* was reached (e.g. "GREEN: all tests pass").
+- **process dimension** — \`process_description\`: *how* you got there —
+  strategy + tool steps, strictly **100–150 characters**.
+  Too short = rejected (no value); too long = rejected (use the session log).
+
+Rules: do **not** use the process field to restate the milestone, and do not
+use milestones as a substitute for progress. Milestones mark *state
+transitions*: RED→GREEN, blocker found, decision made, review passed.
+
+### 5. Close — \`task_complete\`
+Before completing:
+1. \`task_get(task_id)\` and re-read goal + delivery.
+2. Verify the goal and delivery actually match what you delivered. If they do
+   not, either extend the task (\`task_update\`) or say so honestly.
+3. Call \`task_complete\` with \`deliverable_storage_path\` — a locator for the
+   work product: a file path, a git branch/worktree, a doc URL, a commit URL.
+   The path is persisted into the task context and as an operation record.
+
+\`task_complete\` cannot be used on \`cycle\` tasks (they are periodic by
+design) — use \`task_update\` to reset those.
+
+## Other tools
+
+- \`task_get(task_id, include_operations)\` — full detail; use it before
+  resuming or completing a task.
+- \`task_list(...)\` — flat listing with filters (status / priority / type).
+- \`task_search(keywords)\` — find by title / description / goals / tags.
+  **Search before creating**, to avoid duplicates.
+
+## Where tasks live
+
+All tasks and operations are persisted by the roy-task-plugin in the
+**single** project store — locally that is SQLite at
+\`~/.roy-task-plugin/tasks.db\` (or the remote service when the plugin is
+configured with \`persistence: "remote"\`). Do not create side databases, do
+not maintain your own to-do list in files, and do not track work in chat only:
+if it is not in the task store, it is not tracked.
+
+## Tool surface on Claude Code
+
+The lifecycle above is expressed through the \`roy-agent tasks\` CLI (run it with
+the \`Bash\` tool), because Claude Code does not yet expose the \`task_*\` tools
+natively. The mapping is 1:1 — same store, same ids, same semantics:
+
+| lifecycle step | Claude Code command |
+|---|---|
+| \`task_tree(depth=1)\` | \`roy-agent tasks tree\` |
+| \`task_create\` | \`roy-agent tasks create "<title>" -d "<description>" -g "<goals>" -p high --project-path "<path>"\` |
+| \`task_update\` | \`roy-agent tasks update <id> --status active --progress 50 --current-status "…"\` |
+| \`task_operation_create\` | \`roy-agent tasks operations <id>\` to read; record milestones via the CLI's update/ops surface |
+| \`task_complete\` | \`roy-agent tasks complete <id> --deliverable "<path>"\` |
+| \`task_get\` | \`roy-agent tasks get <id>\` |
+| \`task_list\` | \`roy-agent tasks list\` |
+| \`task_search\` | \`roy-agent tasks search <keywords>\` |
+
+Prefer \`--json\` (\`-j\`) when you need to parse ids. The task id printed by
+\`create\` is your handle for the rest of the turn.
+
+## Style
+
+- Be direct and concrete; the user is reading task titles and milestones.
+- Report the task id and its state whenever you finish a step.
+- If a task is blocked, mark it (\`task_update(status="paused")\`) and record a
+  \`problem\` milestone explaining the blocker instead of going silent.`;
+function buildClaudeAgentsJson(opts = {}) {
+  const def = {
+    description: opts.description ?? ROY_AGENT_DESCRIPTION,
+    prompt: opts.prompt ?? CLAUDE_ROY_SYSTEM_PROMPT,
+    tools: [...opts.tools ?? CLAUDE_ROY_TOOLS]
+  };
+  if (opts.model)
+    def.model = opts.model;
+  return JSON.stringify({ [opts.name ?? CLAUDE_ROY_AGENT_NAME]: def });
+}
+
+// ../../../packages/cli/src/daemon/runners/claude-sessions.ts
+function createClaudeSessionRegistry() {
+  const sessions = new Map;
+  return {
+    get: (key) => sessions.get(key),
+    set: (key, id) => {
+      sessions.set(key, id);
+    },
+    delete: (key) => {
+      sessions.delete(key);
+    },
+    size: () => sessions.size
+  };
+}
+
+// ../../../packages/cli/src/daemon/ndjson.ts
+class LineSplitter {
+  tail = "";
+  pushChunk(chunk) {
+    this.tail += chunk;
+    const out = [];
+    let idx = this.tail.indexOf(`
+`);
+    while (idx !== -1) {
+      out.push(this.tail.slice(0, idx));
+      this.tail = this.tail.slice(idx + 1);
+      idx = this.tail.indexOf(`
+`);
+    }
+    return out;
+  }
+  finish() {
+    if (!this.tail)
+      return [];
+    const line = this.tail;
+    this.tail = "";
+    return [line];
+  }
+}
+
+class NdjsonAssembler {
+  tail = "";
+  texts = [];
+  error;
+  toolCalls = 0;
+  sessionId;
+  tools = [];
+  pushChunk(chunk) {
+    this.tail += chunk;
+    let idx = this.tail.indexOf(`
+`);
+    while (idx !== -1) {
+      const line = this.tail.slice(0, idx);
+      this.tail = this.tail.slice(idx + 1);
+      this.parseLine(line);
+      idx = this.tail.indexOf(`
+`);
+    }
+  }
+  pushLine(line) {
+    this.parseLine(line);
+  }
+  finishIncomplete() {
+    return this.tail.trim();
+  }
+  parseLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed[0] !== "{")
+      return;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    if (parsed.sessionID)
+      this.sessionId = parsed.sessionID;
+    if (parsed.type === "text" && typeof parsed.part?.text === "string") {
+      this.texts.push(parsed.part.text);
+      return;
+    }
+    if (parsed.type === "tool_use") {
+      this.toolCalls += 1;
+      const name = parsed.part?.tool ?? parsed.tool;
+      if (typeof name === "string" && name) {
+        this.tools.push(name);
+      }
+      return;
+    }
+    if (parsed.type === "error") {
+      if (this.error === undefined) {
+        this.error = parsed.error?.message ?? parsed.error?.type ?? "unknown opencode error";
+      }
+    }
+  }
+  finish() {
+    if (this.tail.trim()) {
+      this.parseLine(this.tail);
+      this.tail = "";
+    }
+    const text = this.texts.join("").trim();
+    return {
+      text,
+      error: this.error,
+      toolCalls: this.toolCalls,
+      sessionId: this.sessionId,
+      tools: this.tools
+    };
+  }
+}
+
+// ../../../packages/cli/src/daemon/runners/claude-stream.ts
+class ClaudeStreamDecoder {
+  lines = new LineSplitter;
+  state = { assistantText: [], tools: [] };
+  pushChunk(chunk) {
+    for (const line of this.lines.pushChunk(chunk))
+      this.consume(line);
+  }
+  finish() {
+    for (const line of this.lines.finish())
+      this.consume(line);
+    return this.toResult();
+  }
+  snapshot() {
+    return { ...this.state, assistantText: [...this.state.assistantText], tools: [...this.state.tools] };
+  }
+  consume(rawLine) {
+    const line = rawLine.trim();
+    if (!line.startsWith("{"))
+      return;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (typeof event !== "object" || event === null)
+      return;
+    const ev = event;
+    const sessionId = typeof ev.session_id === "string" ? ev.session_id : undefined;
+    if (sessionId && !this.state.sessionId)
+      this.state.sessionId = sessionId;
+    if (ev.type === "assistant") {
+      this.consumeAssistant(ev);
+      return;
+    }
+    if (ev.type === "result") {
+      this.state.result = ev;
+    }
+  }
+  consumeAssistant(ev) {
+    const message = ev.message;
+    const content = message?.content;
+    if (!Array.isArray(content))
+      return;
+    for (const block of content) {
+      if (typeof block !== "object" || block === null)
+        continue;
+      const b = block;
+      if (b.type === "text" && typeof b.text === "string") {
+        this.state.assistantText.push(b.text);
+      } else if (b.type === "tool_use") {
+        if (typeof b.name === "string")
+          this.state.tools.push(b.name);
+      }
+    }
+  }
+  toResult() {
+    const { result } = this.state;
+    const toolCalls = this.state.tools.length > 0 ? this.state.tools.length : undefined;
+    const tools = this.state.tools.length > 0 ? [...this.state.tools] : undefined;
+    if (result?.is_error) {
+      const detail = typeof result.result === "string" && result.result.trim() !== "" ? result.result.trim() : result.subtype === undefined ? "claude reported is_error" : `claude reported ${result.subtype}`;
+      return { text: "", sessionId: this.state.sessionId, toolCalls, tools, error: detail.slice(0, 1000) };
+    }
+    if (typeof result?.result === "string" && result.result.trim() !== "") {
+      return { text: result.result.trim(), sessionId: this.state.sessionId, toolCalls, tools };
+    }
+    const fallback = this.state.assistantText.join("").trim();
+    return { text: fallback, sessionId: this.state.sessionId, toolCalls, tools };
+  }
+}
+
+// ../../../packages/cli/src/daemon/runners/claude.ts
+var DEFAULT_CLAUDE_TIMEOUT_MS = 10 * 60 * 1000;
+var CLAUDE_STDIO = Object.freeze([
+  "ignore",
+  "pipe",
+  "pipe"
+]);
+function buildClaudeArgs(input) {
+  const args = ["--print", "--output-format", "stream-json", "--verbose"];
+  if (input.agentsJson)
+    args.push("--agents", input.agentsJson);
+  args.push("--agent", input.agent ?? "roy");
+  args.push("--dangerously-skip-permissions");
+  if (input.sessionId)
+    args.push("--resume", claudeSessionUuid(input.sessionId));
+  args.push(input.prompt);
+  return args;
+}
+function isClaudeSessionUuid(value) {
+  if (!value)
+    return false;
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+function claudeSessionUuid(sessionKey) {
+  if (isClaudeSessionUuid(sessionKey))
+    return sessionKey;
+  const digest = createHash2("sha256").update(sessionKey).digest("hex");
+  const h = digest.slice(0, 32);
+  return [
+    h.slice(0, 8),
+    h.slice(8, 12),
+    `4${h.slice(13, 16)}`,
+    `8${h.slice(17, 20)}`,
+    h.slice(20, 32)
+  ].join("-");
+}
+function makeClaudeRunner(opts = {}) {
+  const bin = opts.bin ?? "claude";
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_CLAUDE_TIMEOUT_MS;
+  const agentsJson = opts.agentsJson ?? buildClaudeAgentsJson();
+  const sessions = opts.sessions ?? createClaudeSessionRegistry();
+  return async function runAgent(input) {
+    const known = input.sessionId ? sessions.get(input.sessionId) : undefined;
+    const args = buildClaudeArgs({
+      prompt: input.prompt,
+      agent: input.agent,
+      agentsJson,
+      sessionId: known
+    });
+    const decoder = new ClaudeStreamDecoder;
+    let stderr = "";
+    let handle;
+    try {
+      handle = spawnStreaming([bin, ...args], {
+        stdin: CLAUDE_STDIO[0],
+        env: { ...process.env, NO_COLOR: "1" },
+        timeoutMs,
+        onStdout: (chunk) => decoder.pushChunk(chunk),
+        onStderr: (chunk) => {
+          if (stderr.length < 64 * 1024)
+            stderr += chunk;
+        }
+      });
+    } catch (err) {
+      return { text: "", error: `failed to spawn ${bin}: ${errMsg(err)}` };
+    }
+    let code;
+    try {
+      code = await handle.exited;
+    } catch (err) {
+      if (isMissingBinary(err)) {
+        return { text: "", error: `failed to spawn ${bin}: ${errMsg(err)}` };
+      }
+      return { text: "", error: errMsg(err) };
+    }
+    const result = decoder.finish();
+    if (input.sessionId && result.sessionId && !result.error) {
+      sessions.set(input.sessionId, result.sessionId);
+    }
+    if (code === 124) {
+      return { ...result, error: `claude timed out after ${timeoutMs}ms` };
+    }
+    if (result.error) {
+      if (input.sessionId && /No conversation found|not a UUID|session title/i.test(result.error)) {
+        sessions.delete(input.sessionId);
+      }
+      return result;
+    }
+    if (code !== 0 && !result.text) {
+      return {
+        text: "",
+        toolCalls: result.toolCalls,
+        tools: result.tools,
+        error: `claude exited ${code}: ${(stderr || "no stderr").trim().slice(0, 1000)}`
+      };
+    }
+    return result;
+  };
+}
+function errMsg(err) {
+  if (err instanceof Error)
+    return err.message;
+  return String(err);
+}
+
+// ../../../packages/cli/src/daemon/runners/opencode.ts
 var DEFAULT_OPENCODE_TIMEOUT_MS = 10 * 60 * 1000;
 function makeOpencodeRunner(opts = {}) {
   const bin = opts.bin ?? "opencode";
@@ -1044,16 +1442,16 @@ function makeOpencodeRunner(opts = {}) {
         }
       });
     } catch (err) {
-      return { text: "", error: `failed to spawn ${bin}: ${errMsg(err)}` };
+      return { text: "", error: `failed to spawn ${bin}: ${errMsg2(err)}` };
     }
     let code;
     try {
       code = await handle.exited;
     } catch (err) {
       if (isMissingBinary(err)) {
-        return { text: "", error: `failed to spawn ${bin}: ${errMsg(err)}` };
+        return { text: "", error: `failed to spawn ${bin}: ${errMsg2(err)}` };
       }
-      return { text: "", error: errMsg(err) };
+      return { text: "", error: errMsg2(err) };
     }
     const result = assembler.finish();
     if (code === 124) {
@@ -1090,11 +1488,31 @@ function makeOpencodeRunner(opts = {}) {
     };
   };
 }
-function errMsg(err) {
-  return err instanceof Error ? err.message : String(err);
+function errMsg2(err) {
+  if (err instanceof Error)
+    return err.message;
+  return String(err);
 }
 
-// ../cli/src/daemon/reply.ts
+// ../../../packages/cli/src/daemon/runners/registry.ts
+var FACTORIES = {
+  opencode: (input) => makeOpencodeRunner({ bin: input.bin, timeoutMs: input.timeoutMs }),
+  claude: (input) => makeClaudeRunner({
+    bin: input.bin,
+    timeoutMs: input.timeoutMs,
+    agentsJson: input.claudeAgentsJson
+  })
+};
+function makeRunner(input = {}) {
+  const name = input.runtime ?? DEFAULT_RUNTIME;
+  if (!isRuntimeName(name)) {
+    throw new Error(`unknown runtime "${name}"`);
+  }
+  const factory = FACTORIES[name];
+  return factory({ ...input, bin: input.bin ?? DEFAULT_RUNTIME_BIN[name] });
+}
+
+// ../../../packages/cli/src/daemon/reply.ts
 var MAX_POST_BYTES = 28 * 1024;
 
 class EmptyReplyError extends Error {
@@ -1178,7 +1596,7 @@ async function defaultReplyRunner(input) {
   }
 }
 
-// ../cli/src/cmd/serve.ts
+// ../../../packages/cli/src/cmd/serve.ts
 function serve(options, deps = {}) {
   return startServe(options, deps);
 }
@@ -1188,7 +1606,11 @@ async function startServe(options, deps) {
   const deduper = new Deduper;
   const card = deps.card ?? (options.cardEnabled && !options.dryRun ? createRoyAgentCardPort() : createNoopCardPort());
   const dispatcher = new Dispatcher({
-    runAgent: deps.runAgent ?? makeOpencodeRunner({ bin: options.opencodeBin, timeoutMs: options.timeoutMs }),
+    runAgent: deps.runAgent ?? makeRunner({
+      runtime: options.runtime,
+      bin: resolveRuntimeBin(options),
+      timeoutMs: options.timeoutMs
+    }),
     reply: deps.reply ?? defaultReplyRunner,
     gate,
     deduper,
@@ -1216,7 +1638,7 @@ async function startServe(options, deps) {
       try {
         await listener.stop();
       } catch (err) {
-        log(`[roy-task] listener.stop() failed: ${errMsg2(err)}`);
+        log(`[roy-task] listener.stop() failed: ${errMsg3(err)}`);
       }
       log("[roy-task] stopped");
       resolveDone();
@@ -1238,7 +1660,7 @@ async function startServe(options, deps) {
         await stop();
       }
     } catch (err) {
-      log(`[roy-task] ${label} dispatch threw: ${errMsg2(err)}`);
+      log(`[roy-task] ${label} dispatch threw: ${errMsg3(err)}`);
       if (options.once)
         await stop();
     }
@@ -1248,7 +1670,7 @@ async function startServe(options, deps) {
   try {
     await listener.start();
   } catch (err) {
-    log(`[roy-task] failed to start event listener: ${errMsg2(err)}`);
+    log(`[roy-task] failed to start event listener: ${errMsg3(err)}`);
     clearInterval(sweeper);
     resolveDone();
     throw err;
@@ -1265,7 +1687,8 @@ function formatBanner(options, commands, maxConcurrency) {
     "[roy-task] starting",
     `  profile          : ${options.profile}`,
     `  agent            : ${options.agent}`,
-    `  opencode bin     : ${options.opencodeBin}`,
+    `  runtime          : ${options.runtime}`,
+    `  runtime bin      : ${resolveRuntimeBin(options) ?? "(default)"}`,
     `  max concurrency  : ${maxConcurrency}`,
     `  reply enabled    : ${options.replyEnabled}`,
     `  progress cards   : ${options.cardEnabled && !options.dryRun}`,
@@ -1307,11 +1730,11 @@ function formatResult(label, result) {
       return `[roy-task] ${label} skipped: ${result.reason}`;
   }
 }
-function errMsg2(err) {
+function errMsg3(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
-// ../cli/src/runtime/sleep.ts
+// ../../../packages/cli/src/runtime/sleep.ts
 function sleep(ms) {
   return new Promise((resolve) => {
     const timer = setTimeout(resolve, ms);
@@ -1319,7 +1742,7 @@ function sleep(ms) {
   });
 }
 
-// ../cli/src/cmd/status.ts
+// ../../../packages/cli/src/cmd/status.ts
 async function runCapture2(cmd) {
   try {
     return await runCapture(cmd);
@@ -1431,8 +1854,8 @@ function formatStatus(report) {
 `);
 }
 
-// ../cli/src/main.ts
-var VERSION = "0.2.0";
+// ../../../packages/cli/src/main.ts
+var VERSION = "0.4.0";
 async function main(argv) {
   const parsed = parseArgs(argv);
   switch (parsed.command) {