@ai-setting/roy-task-plugin 0.4.2 → 0.6.0

package/dist/cli.js

@@ -3,28 +3,666 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../../../packages/cli/src/daemon/runners/types.ts
-var RUNTIMES = Object.freeze(["opencode", "claude"]);
+var RUNTIMES = Object.freeze(["opencode", "claude", "codex"]);
 var DEFAULT_RUNTIME = "opencode";
 var DEFAULT_RUNTIME_BIN = Object.freeze({
   opencode: "opencode",
-  claude: "claude"
+  claude: "claude",
+  codex: "codex"
 });
 function isRuntimeName(value) {
   return RUNTIMES.includes(value);
 }
 
+// ../../../packages/cli/src/runtime/spawn.ts
+import { spawn } from "node:child_process";
+function runCapture(cmd, opts = {}) {
+  return new Promise((resolve, reject) => {
+    let child;
+    try {
+      child = spawn(cmd[0], cmd.slice(1), {
+        stdio: [assertEofStdin(opts.stdin), "pipe", "pipe"],
+        env: opts.env ? normalizeEnv(opts.env) : process.env,
+        cwd: opts.cwd,
+        windowsHide: true
+      });
+    } catch (err) {
+      reject(err);
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    const timer = opts.timeoutMs && opts.timeoutMs > 0 ? setTimeout(() => {
+      timedOut = true;
+      try {
+        child.kill("SIGTERM");
+      } catch {}
+      setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {}
+      }, 2000).unref?.();
+    }, opts.timeoutMs) : undefined;
+    timer?.unref?.();
+    child.on("error", (err) => {
+      if (timer)
+        clearTimeout(timer);
+      reject(err);
+    });
+    child.on("close", (code, signal) => {
+      if (timer)
+        clearTimeout(timer);
+      if (timedOut) {
+        resolve({ code: 124, stdout, stderr });
+        return;
+      }
+      resolve({ code: code ?? (signal ? 1 : 0), stdout, stderr });
+    });
+  });
+}
+function spawnStreaming(cmd, opts = {}) {
+  const child = spawn(cmd[0], cmd.slice(1), {
+    stdio: [assertEofStdin(opts.stdin), "pipe", "pipe"],
+    env: opts.env ? normalizeEnv(opts.env) : process.env,
+    cwd: opts.cwd,
+    windowsHide: true
+  });
+  let timedOut = false;
+  const timer = opts.timeoutMs && opts.timeoutMs > 0 ? setTimeout(() => {
+    timedOut = true;
+    try {
+      child.kill("SIGTERM");
+    } catch {}
+  }, opts.timeoutMs) : undefined;
+  timer?.unref?.();
+  if (opts.onStdout || opts.onStderr) {
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => opts.onStdout?.(chunk));
+    child.stderr?.on("data", (chunk) => opts.onStderr?.(chunk));
+  } else {
+    child.stdout?.resume();
+    child.stderr?.resume();
+  }
+  const exited = new Promise((resolve, reject) => {
+    child.on("error", (err) => {
+      if (timer)
+        clearTimeout(timer);
+      reject(err);
+    });
+    child.on("close", (code, signal) => {
+      if (timer)
+        clearTimeout(timer);
+      if (timedOut) {
+        resolve(124);
+        return;
+      }
+      resolve(code ?? (signal ? 1 : 0));
+    });
+  });
+  return {
+    exited,
+    pid: child.pid,
+    kill(signal = "SIGTERM") {
+      try {
+        child.kill(signal);
+      } catch {}
+    }
+  };
+}
+function assertEofStdin(value) {
+  if (value !== undefined && value !== "ignore") {
+    throw new Error(`refusing to spawn with stdin=${String(value)}: fd 0 must be an EOF source ` + '(use "ignore"); an inherited socket hangs `opencode run` (see #4376)');
+  }
+  return "ignore";
+}
+function normalizeEnv(env) {
+  const out = {};
+  for (const [k, v] of Object.entries(env)) {
+    if (typeof v === "string")
+      out[k] = v;
+  }
+  return out;
+}
+function isMissingBinary(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+
+// ../../../packages/cli/src/daemon/task-created.ts
+var CREATED_LINE = /Task created(?:\s+successfully)?\s*:\s*#(\d+)/;
+function extractCreatedTask(text, titleHint) {
+  if (!text)
+    return;
+  return fromJson(text) ?? fromEmbeddedTaskObject(text) ?? fromTaskObjectBlob(text) ?? fromSuccessLine(text, titleHint);
+}
+function uniqueTaskId(text) {
+  let id;
+  for (const m of text.matchAll(/"taskId"\s*:\s*(\d+)/g)) {
+    const n = Number(m[1]);
+    if (!Number.isInteger(n) || n <= 0)
+      return;
+    if (id === undefined)
+      id = n;
+    else if (id !== n)
+      return;
+  }
+  return id;
+}
+function fromJson(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{"))
+    return;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    return;
+  const obj = parsed;
+  const id = obj["id"];
+  const title = obj["title"];
+  if (typeof id !== "number" || !Number.isInteger(id) || id <= 0)
+    return;
+  if (typeof title !== "string" || title.trim() === "")
+    return;
+  return { id, title: title.trim() };
+}
+function fromTaskObjectBlob(text) {
+  if (!BLOB_GATE.every((marker) => text.includes(marker)))
+    return;
+  const id = uniqueTaskId(text);
+  if (id === undefined)
+    return;
+  const title = titleFromCreatedActionTitle(text);
+  if (title === undefined)
+    return;
+  return { id, title };
+}
+function titleFromCreatedActionTitle(text) {
+  const m = /"actionTitle"\s*:\s*"Task created:\s*([^"]*)"/.exec(text);
+  const title = m?.[1]?.trim();
+  if (!title || title.length > 200)
+    return;
+  return title;
+}
+var BLOB_GATE = ['"taskId"', '"actionTitle"', "Task created:"];
+function fromEmbeddedTaskObject(text) {
+  let found;
+  for (const obj of topLevelObjects(text)) {
+    const task = taskFromObject(obj);
+    if (!task)
+      continue;
+    if (found === undefined)
+      found = task;
+    else if (found.id !== task.id)
+      return;
+  }
+  return found;
+}
+function taskFromObject(obj) {
+  const id = obj["id"];
+  const title = obj["title"];
+  if (typeof id !== "number" || !Number.isInteger(id) || id <= 0)
+    return;
+  if (typeof title !== "string" || title.trim() === "")
+    return;
+  return { id, title: title.trim() };
+}
+function topLevelObjects(text) {
+  const out = [];
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  let start = -1;
+  for (let i = 0;i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped)
+        escaped = false;
+      else if (ch === "\\")
+        escaped = true;
+      else if (ch === '"')
+        inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{") {
+      if (depth === 0 && !insideArray(text, i))
+        start = i;
+      depth++;
+      continue;
+    }
+    if (ch === "]" && depth === 0)
+      continue;
+    if (ch !== "}")
+      continue;
+    depth--;
+    if (depth !== 0 || start < 0)
+      continue;
+    const slice = text.slice(start, i + 1);
+    start = -1;
+    try {
+      const parsed = JSON.parse(slice);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        out.push(parsed);
+      }
+    } catch {}
+  }
+  return out;
+}
+function insideArray(text, at) {
+  let brackets = 0;
+  let braces = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0;i < at; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped)
+        escaped = false;
+      else if (ch === "\\")
+        escaped = true;
+      else if (ch === '"')
+        inString = false;
+      continue;
+    }
+    if (ch === '"')
+      inString = true;
+    else if (ch === "{")
+      braces++;
+    else if (ch === "}")
+      braces--;
+    else if (ch === "[")
+      brackets++;
+    else if (ch === "]")
+      brackets--;
+  }
+  return brackets > 0 && braces <= 0;
+}
+function fromSuccessLine(text, titleHint) {
+  const m = CREATED_LINE.exec(text);
+  if (!m)
+    return;
+  const id = Number(m[1]);
+  if (!Number.isInteger(id) || id <= 0)
+    return;
+  const title = titleFromCliSummary(text) || titleHint?.trim();
+  return title ? { id, title } : { id };
+}
+function titleFromCliSummary(text) {
+  const at = CREATED_LINE.exec(text);
+  if (!at)
+    return;
+  const rest = text.slice(at.index + at[0].length);
+  const m = /^\s*Title:\s*(.+)$/m.exec(rest);
+  const title = m?.[1]?.trim();
+  if (!title || title.length > 200)
+    return;
+  return title;
+}
+function isTaskCreateTool(name) {
+  return /(^|__)task_create$/.test(name);
+}
+
+// ../../../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 = [];
+  createdTask;
+  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);
+      }
+      if (this.createdTask === undefined && typeof name === "string") {
+        const part = parsed.part;
+        const output = part?.state?.output;
+        const title = part?.state?.input?.["title"];
+        if (isTaskCreateTool(name) && typeof output === "string") {
+          this.createdTask = extractCreatedTask(output, typeof title === "string" ? title : undefined);
+        }
+      }
+      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,
+      createdTask: this.createdTask
+    };
+  }
+}
+
+// ../../../packages/cli/src/daemon/runners/codex-stream.ts
+var CODEX_ITEM_TYPES = Object.freeze({
+  AGENT_MESSAGE: "agent_message",
+  COMMAND_EXECUTION: "command_execution",
+  ERROR: "error"
+});
+
+class CodexStreamDecoder {
+  lines = new LineSplitter;
+  state = { tools: [], errors: [], turnCompleted: false };
+  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, tools: [...this.state.tools], errors: [...this.state.errors] };
+  }
+  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;
+    if (ev.type === "thread.started") {
+      const id = ev.thread_id;
+      if (typeof id === "string" && id)
+        this.state.sessionId = id;
+      return;
+    }
+    if (ev.type === "turn.completed") {
+      this.state.turnCompleted = true;
+      return;
+    }
+    if (ev.type === "item.started" || ev.type === "item.completed") {
+      this.consumeItem(ev.item, ev.type === "item.completed");
+    }
+  }
+  consumeItem(raw, completed) {
+    if (typeof raw !== "object" || raw === null)
+      return;
+    const item = raw;
+    if (item.type === CODEX_ITEM_TYPES.AGENT_MESSAGE) {
+      if (typeof item.text === "string" && item.text.length > 0) {
+        this.state.text = item.text;
+      }
+      return;
+    }
+    if (item.type === CODEX_ITEM_TYPES.ERROR) {
+      if (typeof item.message === "string" && item.message.length > 0) {
+        this.state.errors.push(item.message);
+      }
+      return;
+    }
+    if (item.type === CODEX_ITEM_TYPES.COMMAND_EXECUTION) {
+      const id = item.id;
+      if (typeof id === "string" && id && this.state.tools.includes(id)) {} else {
+        this.state.tools.push(typeof id === "string" ? id : `cmd-${this.state.tools.length}`);
+      }
+      if (completed && this.state.createdTask === undefined) {
+        this.state.createdTask = extractCreatedTask(item.aggregated_output);
+      }
+    }
+  }
+  toResult() {
+    const result = {
+      text: this.state.text ?? ""
+    };
+    if (this.state.sessionId)
+      result.sessionId = this.state.sessionId;
+    if (this.state.tools.length > 0)
+      result.toolCalls = this.state.tools.length;
+    if (this.state.createdTask)
+      result.createdTask = this.state.createdTask;
+    return result;
+  }
+}
+
+// ../../../packages/cli/src/daemon/runners/codex-sessions.ts
+function createCodexSessionRegistry() {
+  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/runners/codex.ts
+var DEFAULT_CODEX_TIMEOUT_MS = 10 * 60 * 1000;
+var CODEX_STDIO = Object.freeze([
+  "ignore",
+  "pipe",
+  "pipe"
+]);
+var CODEX_SANDBOX_MODES = Object.freeze([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+function isCodexSandboxMode(value) {
+  return CODEX_SANDBOX_MODES.includes(value);
+}
+function buildCodexArgs(input) {
+  const args = ["exec", "--json"];
+  if (input.model)
+    args.push("--model", input.model);
+  args.push("--skip-git-repo-check");
+  args.push("-s", input.sandbox ?? "read-only");
+  args.push(input.prompt);
+  return args;
+}
+function buildCodexResumeArgs(sessionId, input) {
+  const args = ["exec", "resume", "--json"];
+  if (input.model)
+    args.push("--model", input.model);
+  args.push("--skip-git-repo-check");
+  if (input.sandbox === "danger-full-access") {
+    args.push("--dangerously-bypass-approvals-and-sandbox");
+  }
+  args.push(sessionId);
+  args.push(input.prompt);
+  return args;
+}
+function makeCodexRunner(opts = {}) {
+  const bin = opts.bin ?? "codex";
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_CODEX_TIMEOUT_MS;
+  const model = opts.model;
+  const sandbox = opts.sandbox ?? "read-only";
+  const sessions = opts.sessions ?? createCodexSessionRegistry();
+  return async function runAgent(input) {
+    const known = input.sessionId ? sessions.get(input.sessionId) : undefined;
+    const args = known ? buildCodexResumeArgs(known, { prompt: input.prompt, model, sandbox }) : buildCodexArgs({ prompt: input.prompt, model, sandbox });
+    const decoder = new CodexStreamDecoder;
+    let stderr = "";
+    let handle;
+    try {
+      handle = spawnStreaming([bin, ...args], {
+        stdin: CODEX_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: `codex timed out after ${timeoutMs}ms` };
+    }
+    if (result.error)
+      return result;
+    if (code !== 0 && !result.text) {
+      return {
+        text: "",
+        toolCalls: result.toolCalls,
+        tools: result.tools,
+        createdTask: result.createdTask,
+        error: `codex 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/args.ts
 var DEFAULT_PROFILE = "default";
 var DEFAULT_AGENT = "roy";
 var DEFAULT_EVENT_KEY = "im.message.receive_v1";
 var DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
+function findSubcommand(argv) {
+  for (let i = 0;i < argv.length; i++) {
+    const raw = argv[i];
+    if (raw.startsWith("-")) {
+      if (!raw.includes("=") && VALUE_FLAGS.has(raw))
+        i++;
+      continue;
+    }
+    return raw;
+  }
+  return;
+}
+var VALUE_FLAGS = new Set([
+  "--profile",
+  "--agent",
+  "--event-key",
+  "--runtime",
+  "--command",
+  "--runtime-bin",
+  "--opencode-bin",
+  "--codex-model",
+  "--codex-sandbox",
+  "--max-concurrency",
+  "--timeout-ms"
+]);
 var SUBCOMMANDS = new Set(["serve", "status", "help", "version"]);
 function parseArgs(argv) {
   if (argv.includes("--help") || argv.includes("-h"))
     return { command: "help" };
   if (argv.includes("--version") || argv.includes("-v"))
     return { command: "version" };
-  const head = argv.find((a) => !a.startsWith("-"));
+  const head = findSubcommand(argv);
   const command = head ?? "serve";
   if (!SUBCOMMANDS.has(command)) {
     return { command: "unknown", error: `unknown command "${command}"` };
@@ -107,6 +745,13 @@ function parseServe(argv) {
         serve.runtime = v;
         break;
       }
+      case "--command": {
+        const v = take();
+        if (v instanceof Error)
+          return { command: "unknown", error: v.message };
+        serve.command = v;
+        break;
+      }
       case "--runtime-bin": {
         const v = take();
         if (v instanceof Error)
@@ -121,6 +766,26 @@ function parseServe(argv) {
         serve.opencodeBin = v;
         break;
       }
+      case "--codex-model": {
+        const v = take();
+        if (v instanceof Error)
+          return { command: "unknown", error: v.message };
+        serve.codexModel = v;
+        break;
+      }
+      case "--codex-sandbox": {
+        const v = take();
+        if (v instanceof Error)
+          return { command: "unknown", error: v.message };
+        if (!isCodexSandboxMode(v)) {
+          return {
+            command: "unknown",
+            error: `--codex-sandbox must be one of ${CODEX_SANDBOX_MODES.join("|")}, got "${v}"`
+          };
+        }
+        serve.codexSandbox = v;
+        break;
+      }
       case "--max-concurrency": {
         const v = take();
         if (v instanceof Error)
@@ -190,6 +855,8 @@ function readValue(argv, flag) {
   return;
 }
 function resolveRuntimeBin(options) {
+  if (options.command !== undefined)
+    return options.command;
   if (options.runtimeBin !== undefined)
     return options.runtimeBin;
   if (options.runtime === "opencode" && options.opencodeBin !== "opencode") {
@@ -198,7 +865,7 @@ function resolveRuntimeBin(options) {
   return;
 }
 function usage() {
-  return `roy-task — bridge Feishu (Lark) messages to a roy agent (opencode or claude)
+  return `roy-task — bridge Feishu (Lark) messages to a roy agent (opencode, claude or codex)
 
 USAGE
   roy-task [serve] [options]      start the daemon (default command)
@@ -217,9 +884,15 @@ SERVE OPTIONS
   --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
+  --command <name|path>   executable to spawn, whatever the dialect
+                          is (default: the runtime's own binary).
+                          e.g. --runtime claude --command claude-minimax
+  --runtime-bin <path>    DEPRECATED alias for --command
+  --opencode-bin <path>   DEPRECATED alias for --command
                           (only applies when --runtime opencode)
+  --codex-model <name>    model for codex exec --model            (default: codex config)
+  --codex-sandbox <mode>  codex exec -s policy                   (default: read-only)
+                          one of: ${CODEX_SANDBOX_MODES.join(" | ")}
   --max-concurrency <n>   max simultaneous agent runs             (default: 1)
                           ⚠️ >1 only safe across DIFFERENT chats;
                           same-session concurrency cross-contaminates.
@@ -234,6 +907,12 @@ SERVE OPTIONS
                           never block the text reply.
 
 NOTES
+  • --runtime vs --command: --runtime picks the *dialect* (which flags and
+    which stream decoder), --command picks the *executable* that speaks it.
+    So \`--runtime claude --command claude-minimax\` keeps every claude flag
+    (--print / --output-format stream-json / --agents / --resume <uuid>) and
+    merely spawns the wrapper instead of the bare binary. Use this whenever
+    the default binary is not the one that actually works on your machine.
   • 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.
@@ -387,6 +1066,24 @@ function buildDispatchPrompt(input) {
     "3. 需要落任务就用 `task_*` 工具（task_create / task_update / …），",
     "   这是你的主要职责；不要只在回答里“描述”你打算做什么。",
     "",
+    "## 什么时候该建任务（Task #4433）",
+    "",
+    "任务由**你**决定建不建，守护进程不会替你建。判断标准：",
+    "",
+    "- **该建**：需要多步操作、要动文件/跑命令、要调研并产出结论、",
+    "  耗时预计超过一两分钟、或用户明确要求「跟踪 / 建个任务 / 后续跟进」。",
+    "  → 用 `task_create` 建任务，**然后**再开始干活（先立任务，再动手）。",
+    "- **不必建**：寒暄、谢谢、纯问答（「今天几号」「这个参数叫啥」）、",
+    "  一两句话就能答完且不需要任何工具的问题。",
+    "  → 直接回答，不要为了「显得勤快」而建一个空任务。",
+    "- **建完要更新**：动手过程中用 `task_update` 推进度 / 改 current_status，",
+    "  干完用 `task_complete` 收尾。建了任务却从不更新，比不建更糟——",
+    "  看板上会留下一个卡住的任务。",
+    "",
+    "⚠️ **卡片与任务一一对应**：只有你建了任务，用户才会收到一张进展卡片；",
+    "没建任务就只有文字回复。所以**不要**为了「想要一张卡片」而去建任务，",
+    "也不要建了任务又不用它——卡片上显示的就是你建的那个任务的真 id 和标题。",
+    "",
     "## 环境事实（必须使用下面这些值，不要自己猜）",
     "",
     `- lark-cli profile：\`${profile}\`（飞书 openId 是 per-app 隔离的，换 profile 会失败）`,
@@ -510,21 +1207,14 @@ function createNoopCardPort() {
     async finish() {}
   };
 }
-function buildCardIdentity(input) {
-  const maxTitle = input.maxTitleChars ?? 60;
-  const normalized = input.text.replace(/\r\n/g, `
-`).trim();
-  const lines = normalized.split(`
-`).map((l) => l.trim()).filter(Boolean);
-  const first = lines[0] ?? "(非文本消息)";
-  const rest = lines.slice(1).join(`
-`);
-  const title = first.length > maxTitle ? `${first.slice(0, maxTitle - 1)}…` : first;
+function buildCardMeta(input) {
   return {
-    id: `om:${input.messageId.slice(-12)}`,
-    title,
-    description: rest || first,
-    goals: "完成用户请求并把结果回复到触发消息所在会话"
+    id: input.task.id,
+    title: input.task.title ?? `Task #${input.task.id}`,
+    description: input.description ?? `由 roy-task 派发，触发消息 ${input.messageId}`,
+    type: "normal",
+    priority: "high",
+    currentStatus: "由 agent 处理中"
   };
 }
 var TOOL_LABELS = {
@@ -558,8 +1248,13 @@ function cardReport(handle) {
     out.cardMessageId = handle.messageId;
   if (handle.error)
     out.cardError = handle.error;
+  if (handle.meta && typeof handle.meta.id === "number")
+    out.taskId = handle.meta.id;
   return out;
 }
+function createdTaskReport(createdTask) {
+  return createdTask ? { taskId: createdTask.id } : {};
+}
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
@@ -654,13 +1349,18 @@ class Dispatcher {
       return { status: "dry-run", plan };
     }
     const run = async () => {
-      const cardPromise = this.openCard({ chatId, messageId, profile, raw });
       const result = await this.deps.runAgent({
         prompt: plan.prompt,
         agent: plan.agent,
         sessionId: plan.sessionId
       });
-      const card = await cardPromise;
+      const card = await this.openCard({
+        chatId,
+        messageId,
+        profile,
+        createdTask: result.createdTask,
+        requestText: extractUserText(raw)
+      });
       if (card.messageId) {
         await this.patchCard(card, {
           chatId,
@@ -676,7 +1376,13 @@ class Dispatcher {
           status: "failed",
           finalStep: `agent 报错：${result.error}`
         });
-        return { status: "agent-error", plan, error: result.error, ...cardReport(card) };
+        return {
+          status: "agent-error",
+          plan,
+          error: result.error,
+          ...createdTaskReport(result.createdTask),
+          ...cardReport(card)
+        };
       }
       if (!result.text.trim()) {
         await this.closeCard(card, {
@@ -689,6 +1395,7 @@ class Dispatcher {
           status: "no-output",
           plan,
           toolCalls: result.toolCalls ?? 0,
+          ...createdTaskReport(result.createdTask),
           ...cardReport(card)
         };
       }
@@ -699,7 +1406,13 @@ class Dispatcher {
           status: "completed",
           finalStep: "--no-reply：agent 已完成，未发送回复"
         });
-        return { status: "no-reply", plan, text: result.text, ...cardReport(card) };
+        return {
+          status: "no-reply",
+          plan,
+          text: result.text,
+          ...createdTaskReport(result.createdTask),
+          ...cardReport(card)
+        };
       }
       const sent = await this.deps.reply({
         messageId,
@@ -743,23 +1456,18 @@ class Dispatcher {
     const handle = { messageId: "" };
     if (!this.deps.card)
       return handle;
+    if (!input.createdTask)
+      return handle;
+    const meta = buildCardMeta({
+      task: input.createdTask,
+      messageId: input.messageId,
+      ...input.requestText ? { description: input.requestText } : {}
+    });
     try {
-      const identity = buildCardIdentity({
-        messageId: input.messageId,
-        text: extractUserText(input.raw)
-      });
       const started = await this.deps.card.start({
         chatId: input.chatId,
         profile: input.profile,
-        meta: {
-          id: identity.id,
-          title: identity.title,
-          description: identity.description,
-          goals: identity.goals,
-          type: "normal",
-          priority: "high",
-          currentStatus: "已收到消息，正在处理"
-        },
+        meta,
         milestones: [
           {
             title: "收到消息",
@@ -770,6 +1478,7 @@ class Dispatcher {
       });
       handle.messageId = started.messageId;
       handle.pinned = started.pinned;
+      handle.meta = meta;
     } catch (err) {
       handle.error = errorMessage(err);
     }
@@ -787,6 +1496,7 @@ class Dispatcher {
         chatId: input.chatId,
         profile: input.profile,
         status: input.status,
+        ...handle.meta ? { meta: handle.meta } : {},
         processSteps: tools.map(describeToolUse)
       });
     } catch (err) {
@@ -803,7 +1513,8 @@ class Dispatcher {
         profile: input.profile,
         status: input.status,
         finalStep: input.finalStep,
-        progress: input.status === "completed" ? 100 : undefined
+        progress: input.status === "completed" ? 100 : undefined,
+        ...handle.meta ? { meta: handle.meta } : {}
       });
     } catch (err) {
       handle.error ??= errorMessage(err);
@@ -811,188 +1522,66 @@ class Dispatcher {
   }
   buildPlan(input) {
     const derive = this.opts.sessionIdFor ?? deriveSessionId;
-    return {
-      agent: this.opts.agent ?? "roy",
-      sessionId: derive({ profile: input.profile, chatId: input.chatId }),
-      prompt: buildDispatchPrompt({
-        rawEvent: input.raw,
-        profile: input.profile,
-        recommendedAction: input.recommendedAction
-      }),
-      chatId: input.chatId,
-      messageId: input.messageId,
-      profile: input.profile
-    };
-  }
-}
-
-// ../../../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"];
-  const sourceId = config.sourceId ?? "roy-task-es";
-  const instance = larkCliHandler.createInstance({
-    id: sourceId,
-    name: "roy-task event source",
-    type: "lark-cli",
-    enabled: true,
-    profile: config.profile,
-    eventKeys
-  });
-  let callback;
-  instance.onEvent((event) => {
-    const typed = event;
-    if (!callback)
-      return;
-    Promise.resolve(callback(typed)).catch((err) => {
-      console.error("[roy-task] event handler threw:", err instanceof Error ? err.message : err);
-    });
-  });
-  return {
-    onEvent(cb) {
-      callback = cb;
-    },
-    async start() {
-      await instance.start();
-    },
-    async stop() {
-      await instance.stop();
-    },
-    status() {
-      return instance.getStatus();
-    },
-    plannedCommands() {
-      const profileFlag = config.profile ? `--profile ${config.profile} ` : "";
-      return eventKeys.map((k) => `lark-cli ${profileFlag}event consume ${k} --as bot`);
-    }
-  };
-}
-
-// ../../../packages/cli/src/daemon/runners/claude.ts
-import { createHash as createHash2 } from "node:crypto";
-
-// ../../../packages/cli/src/runtime/spawn.ts
-import { spawn } from "node:child_process";
-function runCapture(cmd, opts = {}) {
-  return new Promise((resolve, reject) => {
-    let child;
-    try {
-      child = spawn(cmd[0], cmd.slice(1), {
-        stdio: [assertEofStdin(opts.stdin), "pipe", "pipe"],
-        env: opts.env ? normalizeEnv(opts.env) : process.env,
-        cwd: opts.cwd,
-        windowsHide: true
-      });
-    } catch (err) {
-      reject(err);
-      return;
-    }
-    let stdout = "";
-    let stderr = "";
-    let timedOut = false;
-    child.stdout?.setEncoding("utf8");
-    child.stderr?.setEncoding("utf8");
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk;
-    });
-    child.stderr?.on("data", (chunk) => {
-      stderr += chunk;
-    });
-    const timer = opts.timeoutMs && opts.timeoutMs > 0 ? setTimeout(() => {
-      timedOut = true;
-      try {
-        child.kill("SIGTERM");
-      } catch {}
-      setTimeout(() => {
-        try {
-          child.kill("SIGKILL");
-        } catch {}
-      }, 2000).unref?.();
-    }, opts.timeoutMs) : undefined;
-    timer?.unref?.();
-    child.on("error", (err) => {
-      if (timer)
-        clearTimeout(timer);
-      reject(err);
-    });
-    child.on("close", (code, signal) => {
-      if (timer)
-        clearTimeout(timer);
-      if (timedOut) {
-        resolve({ code: 124, stdout, stderr });
-        return;
-      }
-      resolve({ code: code ?? (signal ? 1 : 0), stdout, stderr });
-    });
-  });
+    return {
+      agent: this.opts.agent ?? "roy",
+      sessionId: derive({ profile: input.profile, chatId: input.chatId }),
+      prompt: buildDispatchPrompt({
+        rawEvent: input.raw,
+        profile: input.profile,
+        recommendedAction: input.recommendedAction
+      }),
+      chatId: input.chatId,
+      messageId: input.messageId,
+      profile: input.profile
+    };
+  }
 }
-function spawnStreaming(cmd, opts = {}) {
-  const child = spawn(cmd[0], cmd.slice(1), {
-    stdio: [assertEofStdin(opts.stdin), "pipe", "pipe"],
-    env: opts.env ? normalizeEnv(opts.env) : process.env,
-    cwd: opts.cwd,
-    windowsHide: true
+
+// ../../../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"];
+  const sourceId = config.sourceId ?? "roy-task-es";
+  const instance = larkCliHandler.createInstance({
+    id: sourceId,
+    name: "roy-task event source",
+    type: "lark-cli",
+    enabled: true,
+    profile: config.profile,
+    eventKeys
   });
-  let timedOut = false;
-  const timer = opts.timeoutMs && opts.timeoutMs > 0 ? setTimeout(() => {
-    timedOut = true;
-    try {
-      child.kill("SIGTERM");
-    } catch {}
-  }, opts.timeoutMs) : undefined;
-  timer?.unref?.();
-  if (opts.onStdout || opts.onStderr) {
-    child.stdout?.setEncoding("utf8");
-    child.stderr?.setEncoding("utf8");
-    child.stdout?.on("data", (chunk) => opts.onStdout?.(chunk));
-    child.stderr?.on("data", (chunk) => opts.onStderr?.(chunk));
-  } else {
-    child.stdout?.resume();
-    child.stderr?.resume();
-  }
-  const exited = new Promise((resolve, reject) => {
-    child.on("error", (err) => {
-      if (timer)
-        clearTimeout(timer);
-      reject(err);
-    });
-    child.on("close", (code, signal) => {
-      if (timer)
-        clearTimeout(timer);
-      if (timedOut) {
-        resolve(124);
-        return;
-      }
-      resolve(code ?? (signal ? 1 : 0));
+  let callback;
+  instance.onEvent((event) => {
+    const typed = event;
+    if (!callback)
+      return;
+    Promise.resolve(callback(typed)).catch((err) => {
+      console.error("[roy-task] event handler threw:", err instanceof Error ? err.message : err);
     });
   });
   return {
-    exited,
-    pid: child.pid,
-    kill(signal = "SIGTERM") {
-      try {
-        child.kill(signal);
-      } catch {}
+    onEvent(cb) {
+      callback = cb;
+    },
+    async start() {
+      await instance.start();
+    },
+    async stop() {
+      await instance.stop();
+    },
+    status() {
+      return instance.getStatus();
+    },
+    plannedCommands() {
+      const profileFlag = config.profile ? `--profile ${config.profile} ` : "";
+      return eventKeys.map((k) => `lark-cli ${profileFlag}event consume ${k} --as bot`);
     }
   };
 }
-function assertEofStdin(value) {
-  if (value !== undefined && value !== "ignore") {
-    throw new Error(`refusing to spawn with stdin=${String(value)}: fd 0 must be an EOF source ` + '(use "ignore"); an inherited socket hangs `opencode run` (see #4376)');
-  }
-  return "ignore";
-}
-function normalizeEnv(env) {
-  const out = {};
-  for (const [k, v] of Object.entries(env)) {
-    if (typeof v === "string")
-      out[k] = v;
-  }
-  return out;
-}
-function isMissingBinary(err) {
-  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
-}
+
+// ../../../packages/cli/src/daemon/runners/claude.ts
+import { createHash as createHash2 } from "node:crypto";
+import { appendFileSync } from "node:fs";
 
 // ../../../packages/cli/src/daemon/runners/claude-agents.ts
 var CLAUDE_ROY_AGENT_NAME = "roy";
@@ -1142,102 +1731,6 @@ function createClaudeSessionRegistry() {
   };
 }
 
-// ../../../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
 function errorDetail(result) {
   if (typeof result.result === "string" && result.result.trim() !== "") {
@@ -1250,10 +1743,34 @@ function errorDetail(result) {
   }
   return result.subtype === undefined ? "claude reported is_error" : `claude reported ${result.subtype}`;
 }
+function flattenToolResult(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  const parts = [];
+  for (const block of content) {
+    if (typeof block === "string") {
+      parts.push(block);
+      continue;
+    }
+    if (typeof block === "object" && block !== null) {
+      const t = block.text;
+      if (typeof t === "string")
+        parts.push(t);
+    }
+  }
+  return parts.join(`
+`);
+}
 
 class ClaudeStreamDecoder {
   lines = new LineSplitter;
-  state = { assistantText: [], tools: [] };
+  state = {
+    assistantText: [],
+    tools: [],
+    pendingCreates: new Map
+  };
   pushChunk(chunk) {
     for (const line of this.lines.pushChunk(chunk))
       this.consume(line);
@@ -1286,10 +1803,38 @@ class ClaudeStreamDecoder {
       this.consumeAssistant(ev);
       return;
     }
+    if (ev.type === "user") {
+      this.consumeUser(ev);
+      return;
+    }
     if (ev.type === "result") {
       this.state.result = ev;
     }
   }
+  consumeUser(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 !== "tool_result")
+        continue;
+      const id = typeof b.tool_use_id === "string" ? b.tool_use_id : undefined;
+      const pending = id ? this.state.pendingCreates.get(id) : undefined;
+      const text = flattenToolResult(b.content);
+      if (this.state.createdTask !== undefined)
+        continue;
+      if (pending) {
+        this.state.pendingCreates.delete(id);
+        this.state.createdTask = extractCreatedTask(text, pending.titleHint);
+        continue;
+      }
+      this.state.createdTask = extractCreatedTask(text);
+    }
+  }
   consumeAssistant(ev) {
     const message = ev.message;
     const content = message?.content;
@@ -1302,8 +1847,17 @@ class ClaudeStreamDecoder {
       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")
+        if (typeof b.name === "string") {
           this.state.tools.push(b.name);
+          if (isTaskCreateTool(b.name) && typeof b.id === "string") {
+            const input = b.input;
+            const title = input?.["title"];
+            this.state.pendingCreates.set(b.id, {
+              tool: b.name,
+              titleHint: typeof title === "string" ? title : undefined
+            });
+          }
+        }
       }
     }
   }
@@ -1311,15 +1865,23 @@ class ClaudeStreamDecoder {
     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;
+    const createdTask = this.state.createdTask;
     if (result?.is_error) {
       const detail = errorDetail(result);
-      return { text: "", sessionId: this.state.sessionId, toolCalls, tools, error: detail.slice(0, 1000) };
+      return {
+        text: "",
+        sessionId: this.state.sessionId,
+        toolCalls,
+        tools,
+        createdTask,
+        error: detail.slice(0, 1000)
+      };
     }
     if (typeof result?.result === "string" && result.result.trim() !== "") {
-      return { text: result.result.trim(), sessionId: this.state.sessionId, toolCalls, tools };
+      return { text: result.result.trim(), sessionId: this.state.sessionId, toolCalls, tools, createdTask };
     }
     const fallback = this.state.assistantText.join("").trim();
-    return { text: fallback, sessionId: this.state.sessionId, toolCalls, tools };
+    return { text: fallback, sessionId: this.state.sessionId, toolCalls, tools, createdTask };
   }
 }
 
@@ -1380,23 +1942,30 @@ function makeClaudeRunner(opts = {}) {
         stdin: CLAUDE_STDIO[0],
         env: { ...process.env, NO_COLOR: "1" },
         timeoutMs,
-        onStdout: (chunk) => decoder.pushChunk(chunk),
+        onStdout: (chunk) => {
+          decoder.pushChunk(chunk);
+          if (process.env["ROY_TASK_DUMP_STREAM"]) {
+            try {
+              appendFileSync(process.env["ROY_TASK_DUMP_STREAM"], chunk);
+            } catch {}
+          }
+        },
         onStderr: (chunk) => {
           if (stderr.length < 64 * 1024)
             stderr += chunk;
         }
       });
     } 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 = decoder.finish();
     const stderrText = stderr.trim();
@@ -1430,7 +1999,7 @@ function makeClaudeRunner(opts = {}) {
   };
 }
 var STALE_SESSION_RE = /No conversation found|not a UUID|session title/i;
-function errMsg(err) {
+function errMsg2(err) {
   if (err instanceof Error)
     return err.message;
   return String(err);
@@ -1462,16 +2031,16 @@ function makeOpencodeRunner(opts = {}) {
         }
       });
     } catch (err) {
-      return { text: "", error: `failed to spawn ${bin}: ${errMsg2(err)}` };
+      return { text: "", error: `failed to spawn ${bin}: ${errMsg3(err)}` };
     }
     let code;
     try {
       code = await handle.exited;
     } catch (err) {
       if (isMissingBinary(err)) {
-        return { text: "", error: `failed to spawn ${bin}: ${errMsg2(err)}` };
+        return { text: "", error: `failed to spawn ${bin}: ${errMsg3(err)}` };
       }
-      return { text: "", error: errMsg2(err) };
+      return { text: "", error: errMsg3(err) };
     }
     const result = assembler.finish();
     if (code === 124) {
@@ -1480,7 +2049,8 @@ function makeOpencodeRunner(opts = {}) {
         error: `opencode timed out after ${timeoutMs}ms`,
         sessionId: result.sessionId,
         toolCalls: result.toolCalls,
-        tools: result.tools
+        tools: result.tools,
+        createdTask: result.createdTask
       };
     }
     if (result.error) {
@@ -1489,7 +2059,8 @@ function makeOpencodeRunner(opts = {}) {
         error: result.error,
         sessionId: result.sessionId,
         toolCalls: result.toolCalls,
-        tools: result.tools
+        tools: result.tools,
+        createdTask: result.createdTask
       };
     }
     if (code !== 0 && !result.text) {
@@ -1497,18 +2068,20 @@ function makeOpencodeRunner(opts = {}) {
         text: "",
         error: `opencode exited ${code}: ${(stderr || "no stderr").trim().slice(0, 1000)}`,
         toolCalls: result.toolCalls,
-        tools: result.tools
+        tools: result.tools,
+        createdTask: result.createdTask
       };
     }
     return {
       text: result.text,
       sessionId: result.sessionId,
       toolCalls: result.toolCalls,
-      tools: result.tools
+      tools: result.tools,
+      createdTask: result.createdTask
     };
   };
 }
-function errMsg2(err) {
+function errMsg3(err) {
   if (err instanceof Error)
     return err.message;
   return String(err);
@@ -1521,6 +2094,12 @@ var FACTORIES = {
     bin: input.bin,
     timeoutMs: input.timeoutMs,
     agentsJson: input.claudeAgentsJson
+  }),
+  codex: (input) => makeCodexRunner({
+    bin: input.bin,
+    timeoutMs: input.timeoutMs,
+    model: input.codexModel,
+    sandbox: isCodexSandboxMode(input.codexSandbox ?? "") ? input.codexSandbox : undefined
   })
 };
 function makeRunner(input = {}) {
@@ -1629,7 +2208,9 @@ async function startServe(options, deps) {
     runAgent: deps.runAgent ?? makeRunner({
       runtime: options.runtime,
       bin: resolveRuntimeBin(options),
-      timeoutMs: options.timeoutMs
+      timeoutMs: options.timeoutMs,
+      codexModel: options.codexModel,
+      codexSandbox: options.codexSandbox
     }),
     reply: deps.reply ?? defaultReplyRunner,
     gate,
@@ -1658,7 +2239,7 @@ async function startServe(options, deps) {
       try {
         await listener.stop();
       } catch (err) {
-        log(`[roy-task] listener.stop() failed: ${errMsg3(err)}`);
+        log(`[roy-task] listener.stop() failed: ${errMsg4(err)}`);
       }
       log("[roy-task] stopped");
       resolveDone();
@@ -1680,7 +2261,7 @@ async function startServe(options, deps) {
         await stop();
       }
     } catch (err) {
-      log(`[roy-task] ${label} dispatch threw: ${errMsg3(err)}`);
+      log(`[roy-task] ${label} dispatch threw: ${errMsg4(err)}`);
       if (options.once)
         await stop();
     }
@@ -1690,7 +2271,7 @@ async function startServe(options, deps) {
   try {
     await listener.start();
   } catch (err) {
-    log(`[roy-task] failed to start event listener: ${errMsg3(err)}`);
+    log(`[roy-task] failed to start event listener: ${errMsg4(err)}`);
     clearInterval(sweeper);
     resolveDone();
     throw err;
@@ -1708,7 +2289,11 @@ function formatBanner(options, commands, maxConcurrency) {
     `  profile          : ${options.profile}`,
     `  agent            : ${options.agent}`,
     `  runtime          : ${options.runtime}`,
-    `  runtime bin      : ${resolveRuntimeBin(options) ?? "(default)"}`,
+    "  command          : " + (resolveRuntimeBin(options) ?? "(default: " + options.runtime + ")"),
+    ...options.runtime === "codex" ? [
+      `  codex model      : ${options.codexModel ?? "(codex config)"}`,
+      `  codex sandbox    : ${options.codexSandbox ?? "read-only"}`
+    ] : [],
     `  max concurrency  : ${maxConcurrency}`,
     `  reply enabled    : ${options.replyEnabled}`,
     `  progress cards   : ${options.cardEnabled && !options.dryRun}`,
@@ -1727,13 +2312,15 @@ function cardSuffix(result) {
     return "";
   if (result.cardError)
     return `  card=FAILED(${result.cardError})`;
-  return `  card=${result.cardMessageId ?? "(none)"}`;
+  if (result.cardMessageId)
+    return `  card=${result.cardMessageId}`;
+  return "  card=none(no task created)";
 }
 function formatResult(label, result) {
   const card = cardSuffix(result);
   switch (result.status) {
     case "dispatched":
-      return `[roy-task] ${label} dispatched  chat=${result.plan.chatId} session=${result.plan.sessionId} ` + `reply=${result.replyMessageId ?? "(no id)"} chars=${result.text.length}${card}`;
+      return `[roy-task] ${label} dispatched  chat=${result.plan.chatId} session=${result.plan.sessionId} ` + `reply=${result.replyMessageId ?? "(no id)"} chars=${result.text.length}` + ` task=${result.taskId ?? "(none)"}${card}`;
     case "dry-run":
       return `[roy-task] ${label} DRY-RUN  would run agent=${result.plan.agent} ` + `session=${result.plan.sessionId} chat=${result.plan.chatId} prompt=${result.plan.prompt.length}chars`;
     case "duplicate":
@@ -1750,7 +2337,7 @@ function formatResult(label, result) {
       return `[roy-task] ${label} skipped: ${result.reason}`;
   }
 }
-function errMsg3(err) {
+function errMsg4(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
@@ -1875,7 +2462,7 @@ function formatStatus(report) {
 }
 
 // ../../../packages/cli/src/main.ts
-var VERSION = "0.4.2";
+var VERSION = "0.6.0";
 async function main(argv) {
   const parsed = parseArgs(argv);
   switch (parsed.command) {