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

package/dist/cli.js

@@ -3,16 +3,432 @@ 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/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/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);
+    }
+  }
+  consumeItem(raw) {
+    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))
+        return;
+      this.state.tools.push(typeof id === "string" ? id : `cmd-${this.state.tools.length}`);
+    }
+  }
+  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;
+    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,
+        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";
@@ -107,18 +523,38 @@ function parseServe(argv) {
         serve.runtime = v;
         break;
       }
-      case "--runtime-bin": {
+      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)
+          return { command: "unknown", error: v.message };
+        serve.opencodeBin = v;
+        break;
+      }
+      case "--codex-model": {
         const v = take();
         if (v instanceof Error)
           return { command: "unknown", error: v.message };
-        serve.runtimeBin = v;
+        serve.codexModel = v;
         break;
       }
-      case "--opencode-bin": {
+      case "--codex-sandbox": {
         const v = take();
         if (v instanceof Error)
           return { command: "unknown", error: v.message };
-        serve.opencodeBin = v;
+        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": {
@@ -198,7 +634,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)
@@ -220,6 +656,9 @@ SERVE OPTIONS
   --runtime-bin <path>    binary for the selected runtime         (default: per-runtime)
   --opencode-bin <path>   DEPRECATED alias for --runtime-bin
                           (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.
@@ -871,129 +1310,6 @@ function createEventListener(config) {
 // ../../../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 });
-    });
-  });
-}
-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/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.";
@@ -1142,115 +1458,7 @@ 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() !== "") {
-    return result.result.trim();
-  }
-  if (Array.isArray(result.errors)) {
-    const parts = result.errors.map((e) => typeof e === "string" ? e.trim() : "").filter((e) => e !== "");
-    if (parts.length > 0)
-      return parts.join("; ");
-  }
-  return result.subtype === undefined ? "claude reported is_error" : `claude reported ${result.subtype}`;
-}
-
 class ClaudeStreamDecoder {
   lines = new LineSplitter;
   state = { assistantText: [], tools: [] };
@@ -1312,7 +1520,7 @@ class ClaudeStreamDecoder {
     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 = errorDetail(result);
+      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() !== "") {
@@ -1387,50 +1595,42 @@ function makeClaudeRunner(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 = decoder.finish();
-    const stderrText = stderr.trim();
-    const combined = result.error ? stderrText && !result.error.includes(stderrText) ? `${result.error} | ${stderrText}` : result.error : undefined;
-    const effective = combined ? { ...result, error: combined.slice(0, 1000) } : result;
-    if (input.sessionId && effective.sessionId) {
-      sessions.set(input.sessionId, effective.sessionId);
+    if (input.sessionId && result.sessionId && !result.error) {
+      sessions.set(input.sessionId, result.sessionId);
     }
     if (code === 124) {
-      return { ...effective, error: `claude timed out after ${timeoutMs}ms` };
+      return { ...result, error: `claude timed out after ${timeoutMs}ms` };
     }
-    if (effective.error) {
-      if (input.sessionId && STALE_SESSION_RE.test(effective.error)) {
+    if (result.error) {
+      if (input.sessionId && /No conversation found|not a UUID|session title/i.test(result.error)) {
         sessions.delete(input.sessionId);
       }
-      return effective;
+      return result;
     }
-    if (code !== 0 && !effective.text) {
-      const error = `claude exited ${code}: ${(stderr || "no stderr").trim().slice(0, 1000)}`;
-      if (input.sessionId && STALE_SESSION_RE.test(error)) {
-        sessions.delete(input.sessionId);
-      }
+    if (code !== 0 && !result.text) {
       return {
         text: "",
-        toolCalls: effective.toolCalls,
-        tools: effective.tools,
-        error
+        toolCalls: result.toolCalls,
+        tools: result.tools,
+        error: `claude exited ${code}: ${(stderr || "no stderr").trim().slice(0, 1000)}`
       };
     }
-    return effective;
+    return result;
   };
 }
-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 +1662,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) {
@@ -1508,7 +1708,7 @@ function makeOpencodeRunner(opts = {}) {
     };
   };
 }
-function errMsg2(err) {
+function errMsg3(err) {
   if (err instanceof Error)
     return err.message;
   return String(err);
@@ -1521,6 +1721,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 +1835,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 +1866,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 +1888,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 +1898,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;
@@ -1709,6 +1917,10 @@ function formatBanner(options, commands, maxConcurrency) {
     `  agent            : ${options.agent}`,
     `  runtime          : ${options.runtime}`,
     `  runtime bin      : ${resolveRuntimeBin(options) ?? "(default)"}`,
+    ...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}`,
@@ -1750,7 +1962,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 +2087,7 @@ function formatStatus(report) {
 }
 
 // ../../../packages/cli/src/main.ts
-var VERSION = "0.4.2";
+var VERSION = "0.5.0";
 async function main(argv) {
   const parsed = parseArgs(argv);
   switch (parsed.command) {