opencode-worker 0.1.5 → 0.1.7

package/README.md

@@ -12,13 +12,30 @@ A set-but-empty `--opencode-bin`/`OPENCODE_WORKER_BIN` fails with `BIN_EMPTY` in
 
 - Child env is rebuilt from scratch: only `PATH`, `LANG`, `LC_ALL`, `TMPDIR` pass through. No API keys or credentials.
 - `HOME` and `XDG_{CONFIG,DATA,CACHE,STATE}_HOME` point into `<dir>/.opencode-worker/`.
-- Generated config: `model` = `small_model` = requested model, `enabled_providers: ["opencode"]`, `permission.external_directory: "deny"`.
+- Generated config: `model` = `small_model` = requested model, `enabled_providers: ["opencode"]`.
+- Project config is ignored: `opencode.json`, `.opencode/` agents, plugins and MCP in the task dir are not loaded (`OPENCODE_DISABLE_PROJECT_CONFIG=1`, private `OPENCODE_CONFIG_DIR`). `AGENTS.md` still applies.
+- Tools are default-deny: only `read`, `list`, `glob`, `grep`, `edit` (incl. write/patch), `bash`, `todowrite`, `todoread` are allowed; `external_directory` is denied. No web fetch, no sub-agents.
 - Models outside the `opencode` provider are rejected (`PROVIDER_NOT_ALLOWED`); there is no fallback.
-- Job timeout: default 900 s (15 min). Set it once per install with `OPENCODE_WORKER_TIMEOUT_SEC` (CLI and MCP server), or per job with `--timeout` / `worker_start.timeoutSec`. On expiry: SIGTERM, then SIGKILL after 5 s; an `alarm()` 10 s later also kills the worker if this process itself died.
+- No job time limit by default: a job runs until it finishes, `worker_cancel`, or the MCP session closes — like a subagent. Opt in to a limit with `OPENCODE_WORKER_TIMEOUT_SEC` (per install) or `--timeout` / `worker_start.timeoutSec` (per job); on expiry: SIGTERM, then SIGKILL after 5 s, plus an `alarm()` 10 s later that fires even if this process died.
+- Cancel and timeout stop the whole process tree: opencode plus every command it spawned (tool shells run in their own process groups, so the tree is walked by parent pid).
 - Fixed flags: `run --pure --auto --format json --agent <agent> --model <model> --variant <variant>`.
 
 Defaults: model `opencode/deepseek-v4.1-flash-free`, variant `low`, agent `build`.
 
+## Reasoning
+
+`--variant` / `worker_start.variant` selects reasoning effort. Valid values are the model's own variants (read from `opencode models`) plus `none`:
+
+| variant | effect |
+|---|---|
+| `none` | reasoning off (added by opencode-worker as `reasoningEffort: "none"`) |
+| `low` (default) | light reasoning |
+| `high` | more reasoning |
+| `max` | most reasoning |
+
+Unknown values (e.g. `medium`, which this model does not define) fail with `BAD_VARIANT` instead of silently using the provider default.
+On short tasks the difference is small: in our runs `low`/`high`/`max` averaged roughly 30/45/70 reasoning tokens and `none` produced 0, with the same answers.
+
 ## CLI
 
 ```sh
@@ -59,20 +76,20 @@ Recommended flow: `worker_start` → `worker_wait` (repeat while it returns `sta
     "opencode-worker": {
       "command": "npx",
       "args": ["-y", "opencode-worker", "mcp"],
-      "env": { "OPENCODE_WORKER_BIN": "/path/to/opencode", "OPENCODE_WORKER_TIMEOUT_SEC": "1800" }
+      "env": { "OPENCODE_WORKER_BIN": "/path/to/opencode" }
     }
   }
 }
 ```
 
-`OPENCODE_WORKER_TIMEOUT_SEC` is optional (default 900); it is the job limit, independent of the per-call `worker_wait` limit.
+Optional: `"OPENCODE_WORKER_TIMEOUT_SEC": "1800"` in `env` caps every job; omit it for no limit. It is independent of the per-call `worker_wait` limit.
 
 ### Client setup
 
 Claude Code (tools must be allowed in `-p` mode; put the prompt right after `-p`, because `--allowedTools` and `--mcp-config` are variadic and swallow trailing arguments):
 
 ```sh
-claude mcp add opencode-worker -e OPENCODE_WORKER_BIN=/path/to/opencode -e OPENCODE_WORKER_TIMEOUT_SEC=1800 -- npx -y opencode-worker mcp
+claude mcp add opencode-worker -e OPENCODE_WORKER_BIN=/path/to/opencode -- npx -y opencode-worker mcp
 claude -p "…" --allowedTools "mcp__opencode-worker__worker_start,mcp__opencode-worker__worker_wait,mcp__opencode-worker__worker_status,mcp__opencode-worker__worker_result"
 ```
 
@@ -82,19 +99,21 @@ Codex (`~/.codex/config.toml`); without the approval mode, `codex exec` rejects
 [mcp_servers.opencode-worker]
 command = "npx"
 args = ["-y", "opencode-worker", "mcp"]
-env = { OPENCODE_WORKER_BIN = "/path/to/opencode", OPENCODE_WORKER_TIMEOUT_SEC = "1800" }
+env = { OPENCODE_WORKER_BIN = "/path/to/opencode" }
 default_tools_approval_mode = "approve"
 ```
 
 OMP (`.omp/mcp.json` or `~/.omp/agent/mcp.json`): the JSON above with `"type": "stdio"`. Non-interactive: `omp -p --auto-approve "…"`.
 
 Job records are written to `$OPENCODE_WORKER_STATE_DIR` (default `$XDG_STATE_HOME/opencode-worker/jobs`, else `~/.local/state/opencode-worker/jobs`), so `worker_status`/`worker_result` work after a server or client restart.
-Closing stdin or SIGINT/SIGTERM/SIGHUP cancels running jobs and records them as `cancelled`. If the server is killed outright, its unfinished jobs report `lost`; raw logs remain in `<dir>/.opencode-worker/runs/`.
+Closing stdin or SIGINT/SIGTERM/SIGHUP cancels running jobs and records them as `cancelled`. If the server is killed outright (crash, SIGKILL), a restarted server reports its unfinished jobs as `orphaned` when the recorded worker pid is still that opencode binary (stop it with `worker_cancel`), else `lost`. Events and stderr are streamed to `<dir>/.opencode-worker/runs/<id>/` while the job runs, so partial logs survive either way.
 
 ## Notes
 
 - `<dir>/.opencode-worker/` holds state, snapshots and logs per run; delete it when done.
 - The before-snapshot copies the whole directory: use small, task-scoped directories.
+- Parallel jobs are allowed but share the free endpoint and your CPU: with 6 concurrent jobs a ~10 s task took up to ~30 s. Run a few at a time.
+- Two jobs writing the same `dir` at once will overwrite each other's files and snapshots; give each job its own directory.
 
 ## Releasing
 

package/bin/opencode-worker.mjs

@@ -13,7 +13,7 @@ Options (run):
   --model <id>           default ${DEFAULTS.model} (provider must be one of ${DEFAULTS.providers.join(",")})
   --variant <v>          default ${DEFAULTS.variant}
   --agent <name>         default ${DEFAULTS.agent}
-  --timeout <sec>        default $OPENCODE_WORKER_TIMEOUT_SEC, else ${DEFAULTS.timeoutSec}
+  --timeout <sec>        optional job time limit (default $OPENCODE_WORKER_TIMEOUT_SEC, else none)
   --opencode-bin <path>  default $OPENCODE_WORKER_BIN, then PATH
   -f, --prompt-file <f>  Read prompt from file
 

package/lib/mcp.mjs

@@ -4,8 +4,9 @@ import readline from "node:readline";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { runWorker, DEFAULTS } from "./worker.mjs";
+import { runWorker, killTree, DEFAULTS } from "./worker.mjs";
 
 const PROTOCOL = "2025-06-18";
 const jobs = new Map(); // live jobs of this server: id -> { record, controller, done }
@@ -26,17 +27,34 @@ function alive(pid) {
   try { process.kill(pid, 0); return true; } catch (e) { return e.code === "EPERM"; }
 }
 
+// The recorded pid is ours only if it is still that opencode binary (guards against pid reuse).
+function isOurWorker(record) {
+  if (!record.workerPid || !record.workerBin || !alive(record.workerPid)) return false;
+  const ps = spawnSync("ps", ["-o", "command=", "-p", String(record.workerPid)], { encoding: "utf8" });
+  return ps.status === 0 && ps.stdout.includes(record.workerBin);
+}
+
 function load(jobId) {
   if (!UUID.test(jobId ?? "")) return null;
   const live = jobs.get(jobId);
   if (live) return live.record;
   let record;
   try { record = JSON.parse(fs.readFileSync(path.join(JOBS_DIR, `${jobId}.json`), "utf8")); } catch { return null; }
-  // Owned by a server that died mid-run: the outcome is unknown.
-  if (record.status === "running" && !alive(record.serverPid)) record.status = "lost";
+  // Owner server died mid-run: the worker either still runs unattended (orphaned) or is gone (lost).
+  if (record.status === "running" && !alive(record.serverPid)) record.status = isOurWorker(record) ? "orphaned" : "lost";
   return record;
 }
 
+async function killOrphan(record) {
+  await killTree(record.workerPid);
+  Object.assign(record, {
+    status: "cancelled",
+    finishedAt: new Date().toISOString(),
+    error: { type: "orphan_killed", detail: `worker pid ${record.workerPid} outlived its server and was stopped; partial logs in ${record.runDir}` },
+  });
+  save(record);
+}
+
 const runSchema = {
   type: "object",
   properties: {
@@ -45,7 +63,7 @@ const runSchema = {
     model: { type: "string", description: `default ${DEFAULTS.model}` },
     variant: { type: "string", description: `default ${DEFAULTS.variant}` },
     agent: { type: "string", description: `default ${DEFAULTS.agent}` },
-    timeoutSec: { type: "number", description: `Job time limit in seconds; omit to use the server default ($OPENCODE_WORKER_TIMEOUT_SEC, else ${DEFAULTS.timeoutSec})` },
+    timeoutSec: { type: "number", description: "Optional job time limit in seconds. Default: $OPENCODE_WORKER_TIMEOUT_SEC if set, else no limit (runs until done or worker_cancel)." },
   },
   required: ["dir", "prompt"],
 };
@@ -64,14 +82,15 @@ const waitSchema = {
 const TOOLS = [
   { name: "worker_start", description: "Start an isolated OpenCode worker job (free model by default). Returns jobId immediately. Then call worker_wait.", inputSchema: runSchema },
   { name: "worker_wait", description: "Block until the job finishes or timeoutSec elapses. Finished: returns the full result (same as worker_result). Still running: returns {status: \"running\"}; call worker_wait again. Prefer this over polling worker_status.", inputSchema: waitSchema },
-  { name: "worker_status", description: "Get job status without waiting: running | done | failed | cancelled | lost (server died mid-run). Works across server restarts.", inputSchema: idSchema },
+  { name: "worker_status", description: "Get job status without waiting: running | done | failed | cancelled | orphaned (its server died but the worker still runs; stop it with worker_cancel) | lost (server and worker both gone). Works across server restarts.", inputSchema: idSchema },
   { name: "worker_result", description: "Get the JSON result (diff, tool outputs, cost, tokens, actual model) of a finished job. Works across server restarts.", inputSchema: idSchema },
-  { name: "worker_cancel", description: "Cancel a running job owned by this server (SIGTERM, then SIGKILL).", inputSchema: idSchema },
+  { name: "worker_cancel", description: "Stop a running job (SIGTERM, then SIGKILL, to the worker's whole process group). Also stops orphaned jobs left by a crashed server.", inputSchema: idSchema },
 ];
 
 function resultOf(job) {
   if (job.status === "running") return textResult({ jobId: job.jobId, status: "running" }, true);
-  if (job.status === "lost") return textResult({ ok: false, errors: [{ type: "lost", detail: "server exited before the job finished; inspect <dir>/.opencode-worker/runs" }] }, true);
+  if (job.status === "lost") return textResult({ jobId: job.jobId, status: "lost", ok: false, errors: [{ type: "lost", detail: `server and worker exited before the job finished; partial logs in ${job.runDir ?? "<dir>/.opencode-worker/runs"}` }] }, true);
+  if (job.status === "orphaned") return textResult({ jobId: job.jobId, status: "orphaned", ok: false, workerPid: job.workerPid, errors: [{ type: "orphaned", detail: `server died; worker pid ${job.workerPid} still runs but its result can no longer be collected. Call worker_cancel to stop it. Partial logs in ${job.runDir}` }] }, true);
   return textResult({ jobId: job.jobId, status: job.status, ...(job.result ?? { ok: false, errors: [job.error] }) }, !job.result?.ok);
 }
 
@@ -103,7 +122,8 @@ async function callTool(name, args, opts) {
     };
     const controller = new AbortController();
     save(record);
-    const done = runWorker({ ...args, opencodeBin: opts.opencodeBin, signal: controller.signal }).then(
+    const onSpawn = ({ pid, bin, runDir }) => { Object.assign(record, { workerPid: pid, workerBin: bin, runDir }); save(record); };
+    const done = runWorker({ ...args, opencodeBin: opts.opencodeBin, signal: controller.signal, onSpawn }).then(
       (r) => { record.result = r; record.status = r.errors.some((e) => e.type === "cancelled") ? "cancelled" : r.ok ? "done" : "failed"; },
       (e) => { record.error = { type: e.code ?? "SETUP_ERROR", detail: e.message }; record.status = "failed"; },
     ).then(() => {
@@ -117,13 +137,20 @@ async function callTool(name, args, opts) {
   if (name === "worker_wait") return waitFor(args?.jobId, args?.timeoutSec);
   const job = load(args?.jobId);
   if (!job) return textResult({ error: "unknown jobId" }, true);
-  const { jobId, status, startedAt, finishedAt, dir } = job;
-  if (name === "worker_status") return textResult({ jobId, status, startedAt, finishedAt, dir });
+  const { jobId, status, startedAt, finishedAt, dir, workerPid } = job;
+  if (name === "worker_status") return textResult({ jobId, status, startedAt, finishedAt, dir, workerPid });
   if (name === "worker_result") return resultOf(job);
   if (name === "worker_cancel") {
     const live = jobs.get(jobId);
-    live?.controller.abort();
-    return textResult({ jobId, cancelRequested: Boolean(live), status });
+    if (live) {
+      live.controller.abort();
+      return textResult({ jobId, cancelRequested: true, status });
+    }
+    if (status === "orphaned") {
+      await killOrphan(job);
+      return textResult({ jobId, cancelRequested: true, status: job.status, killedPid: workerPid });
+    }
+    return textResult({ jobId, cancelRequested: false, status });
   }
   return null;
 }

package/lib/worker.mjs

@@ -7,7 +7,7 @@ export const DEFAULTS = {
   model: "opencode/deepseek-v4.1-flash-free",
   variant: "low",
   agent: "build",
-  timeoutSec: 900,
+  timeoutSec: null, // no job time limit by default; stop via cancel or session close
   providers: ["opencode"],
 };
 const STATE_DIR = ".opencode-worker";
@@ -54,14 +54,38 @@ function isolatedEnv(stateRoot, configPath) {
     XDG_CACHE_HOME: path.join(stateRoot, "xdg/cache"),
     XDG_STATE_HOME: path.join(stateRoot, "xdg/state"),
     OPENCODE_CONFIG: configPath,
+    // Without these, an opencode.json / .opencode/ in the task dir is merged in
+    // (agents, providers, MCP, plugins) and can override our free-only config.
+    OPENCODE_CONFIG_DIR: path.join(stateRoot, "xdg/config/opencode"),
+    OPENCODE_DISABLE_PROJECT_CONFIG: "1",
     TERM: "dumb",
   };
   for (const k of ["LANG", "LC_ALL", "TMPDIR"]) if (process.env[k]) env[k] = process.env[k];
-  for (const k of ["HOME", "XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_CACHE_HOME", "XDG_STATE_HOME"])
+  for (const k of ["HOME", "XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_CACHE_HOME", "XDG_STATE_HOME", "OPENCODE_CONFIG_DIR"])
     fs.mkdirSync(env[k], { recursive: true });
   return env;
 }
 
+// Default-deny: tools added later by OpenCode, plugins or MCP never become available implicitly.
+export const ALLOWED_TOOLS = ["read", "list", "glob", "grep", "edit", "bash", "todowrite", "todoread"];
+const NO_REASONING_VARIANT = "none";
+const variantCache = new Map();
+
+/** Variants OpenCode defines for the model, plus our "none" (reasoning off). */
+function modelVariants(bin, env, model) {
+  if (variantCache.has(model)) return variantCache.get(model);
+  const [provider] = model.split("/");
+  const r = spawnSync(bin, ["models", provider, "--verbose"], { encoding: "utf8", env, timeout: 30000, maxBuffer: 16 * 1024 * 1024 });
+  const at = r.stdout?.indexOf(`${model}\n{`) ?? -1;
+  if (r.status !== 0 || at < 0) throw new WorkerError("MODEL_NOT_FOUND", `model ${model} is not listed by 'opencode models ${provider}'`);
+  // The JSON object for this model ends at the first line that is exactly "}".
+  const body = r.stdout.slice(at + model.length + 1);
+  const meta = JSON.parse(body.slice(0, body.indexOf("\n}") + 2));
+  const variants = [...Object.keys(meta.variants ?? {}), NO_REASONING_VARIANT];
+  variantCache.set(model, variants);
+  return variants;
+}
+
 function snapshot(dir, dest) {
   fs.mkdirSync(dest, { recursive: true });
   for (const name of fs.readdirSync(dir)) {
@@ -132,7 +156,7 @@ function actualModels(stateRoot, sessionID) {
   });
 }
 
-/** Job timeout default: OPENCODE_WORKER_TIMEOUT_SEC if set, else DEFAULTS.timeoutSec. */
+/** Job time limit: OPENCODE_WORKER_TIMEOUT_SEC if set, else none (run until done or cancelled). */
 export function defaultTimeoutSec() {
   const raw = process.env.OPENCODE_WORKER_TIMEOUT_SEC;
   if (raw === undefined) return DEFAULTS.timeoutSec;
@@ -142,9 +166,42 @@ export function defaultTimeoutSec() {
   return n;
 }
 
+/** pid plus all descendants. opencode runs tool commands in their own process groups, so a group kill misses them. */
+export function treePids(root) {
+  const ps = spawnSync("ps", ["-axo", "pid=,ppid="], { encoding: "utf8" });
+  const children = new Map();
+  for (const line of ps.stdout.split("\n")) {
+    const [pid, ppid] = line.trim().split(/\s+/).map(Number);
+    if (pid) children.set(ppid, [...(children.get(ppid) ?? []), pid]);
+  }
+  const out = [root];
+  for (let i = 0; i < out.length; i++) out.push(...(children.get(out[i]) ?? []));
+  return out;
+}
+
+/**
+ * Stop a worker and every command it spawned: SIGTERM, then SIGKILL after graceMs.
+ * The tree is captured before signalling because children reparent to init once opencode exits.
+ */
+export function killTree(root, graceMs = 5000) {
+  const pids = new Set(treePids(root));
+  const signalAll = (sig) => {
+    for (const pid of pids) {
+      try { process.kill(-pid, sig); } catch {} // tool shells lead their own groups
+      try { process.kill(pid, sig); } catch {}
+    }
+  };
+  signalAll("SIGTERM");
+  return new Promise((resolve) => setTimeout(() => {
+    for (const pid of treePids(root)) pids.add(pid);
+    signalAll("SIGKILL");
+    resolve([...pids]);
+  }, graceMs).unref());
+}
+
 /**
  * Run one OpenCode worker task.
- * @param {{dir:string,prompt:string,model?:string,variant?:string,agent?:string,timeoutSec?:number,opencodeBin?:string,signal?:AbortSignal}} o
+ * @param {{dir:string,prompt:string,model?:string,variant?:string,agent?:string,timeoutSec?:number|null,opencodeBin?:string,signal?:AbortSignal,onSpawn?:(info:{pid:number,bin:string,runDir:string})=>void}} o
  */
 export async function runWorker(o) {
   if (!o.dir || !o.prompt) throw new WorkerError("BAD_ARGS", "dir and prompt are required");
@@ -154,7 +211,8 @@ export async function runWorker(o) {
   const variant = o.variant ?? DEFAULTS.variant;
   const agent = o.agent ?? DEFAULTS.agent;
   const timeoutSec = o.timeoutSec ?? defaultTimeoutSec();
-  if (!(Number.isFinite(timeoutSec) && timeoutSec > 0)) throw new WorkerError("BAD_ARGS", `timeoutSec must be a positive number, got ${o.timeoutSec}`);
+  if (timeoutSec !== null && !(Number.isFinite(timeoutSec) && timeoutSec > 0))
+    throw new WorkerError("BAD_ARGS", `timeoutSec must be a positive number, got ${o.timeoutSec}`);
   const provider = model.split("/")[0];
   if (!DEFAULTS.providers.includes(provider))
     throw new WorkerError("PROVIDER_NOT_ALLOWED", `provider '${provider}' not in ${JSON.stringify(DEFAULTS.providers)}`);
@@ -167,41 +225,50 @@ export async function runWorker(o) {
   const runDir = path.join(stateRoot, "runs", runId);
   fs.mkdirSync(runDir, { recursive: true });
   const configPath = path.join(stateRoot, "opencode.json");
-  fs.writeFileSync(configPath, JSON.stringify({
+  const modelId = model.split("/").slice(1).join("/");
+  const permission = Object.fromEntries([["*", "deny"], ...ALLOWED_TOOLS.map((t) => [t, "allow"]), ["external_directory", "deny"]]);
+  const config = {
     $schema: "https://opencode.ai/config.json",
     model,
     small_model: model,
     enabled_providers: DEFAULTS.providers,
-    permission: { external_directory: "deny" },
-  }, null, 2));
+    permission,
+  };
+  if (variant === NO_REASONING_VARIANT)
+    config.provider = { [provider]: { models: { [modelId]: { variants: { [NO_REASONING_VARIANT]: { reasoningEffort: "none" } } } } } };
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
   const env = isolatedEnv(stateRoot, configPath);
+  const variants = modelVariants(bin, env, model);
+  if (!variants.includes(variant))
+    throw new WorkerError("BAD_VARIANT", `variant '${variant}' is not defined for ${model}; available: ${variants.join(", ")}`);
   const before = path.join(runDir, "before");
   snapshot(dir, before);
 
   const args = ["run", "--pure", "--auto", "--format", "json", "--agent", agent, "--model", model, "--variant", variant, o.prompt];
   const started = Date.now();
+  const eventsPath = path.join(runDir, "events.jsonl");
+  const stderrPath = path.join(runDir, "stderr.txt");
   const { exit, signal, timedOut, cancelled, stdout, stderr } = await new Promise((resolve) => {
-    // Hard deadline that survives our own death: alarm() is inherited across exec,
-    // so the worker gets SIGALRM even if this process is SIGKILLed.
-    const hard = HARD_DEADLINE_WRAPPER
-      ? spawn(HARD_DEADLINE_WRAPPER, ["-e", "alarm shift; exec { $ARGV[0] } @ARGV or die $!", String(Math.ceil(timeoutSec) + 10), bin, ...args], { cwd: dir, env, stdio: ["ignore", "pipe", "pipe"] })
-      : null;
-    const child = hard ?? spawn(bin, args, { cwd: dir, env, stdio: ["ignore", "pipe", "pipe"] });
+    // Not detached: terminal Ctrl+C on the CLI still reaches opencode.
+    const spawnOpts = { cwd: dir, env, stdio: ["ignore", "pipe", "pipe"] };
+    // Optional hard deadline that survives our own death: alarm() is inherited across exec.
+    const child = timeoutSec !== null && HARD_DEADLINE_WRAPPER
+      ? spawn(HARD_DEADLINE_WRAPPER, ["-e", "alarm shift; exec { $ARGV[0] } @ARGV or die $!", String(Math.ceil(timeoutSec) + 10), bin, ...args], spawnOpts)
+      : spawn(bin, args, spawnOpts);
     let stdout = "", stderr = "", timedOut = false, cancelled = false;
-    child.stdout.on("data", (d) => (stdout += d));
-    child.stderr.on("data", (d) => (stderr += d));
-    const kill = () => {
-      child.kill("SIGTERM");
-      setTimeout(() => child.exitCode === null && child.kill("SIGKILL"), 5000).unref();
-    };
-    const timer = setTimeout(() => { timedOut = true; kill(); }, timeoutSec * 1000);
+    // Streamed to disk so a run stays inspectable even if this process dies mid-run.
+    child.stdout.on("data", (d) => { stdout += d; fs.appendFileSync(eventsPath, d); });
+    child.stderr.on("data", (d) => { stderr += d; fs.appendFileSync(stderrPath, d); });
+    if (child.pid) o.onSpawn?.({ pid: child.pid, bin, runDir });
+    const kill = () => killTree(child.pid);
+    const timer = timeoutSec === null ? null : setTimeout(() => { timedOut = true; kill(); }, timeoutSec * 1000);
     o.signal?.addEventListener("abort", () => { cancelled = true; kill(); }, { once: true });
     child.on("error", (e) => { stderr += String(e); });
     child.on("close", (exit, signal) => { clearTimeout(timer); resolve({ exit, signal, timedOut, cancelled, stdout, stderr }); });
   });
   const durationSec = (Date.now() - started) / 1000;
-  fs.writeFileSync(path.join(runDir, "events.jsonl"), stdout);
-  fs.writeFileSync(path.join(runDir, "stderr.txt"), stderr);
+  fs.writeFileSync(eventsPath, stdout);
+  fs.writeFileSync(stderrPath, stderr);
 
   const ev = parseEvents(stdout);
   const { diff, error: diffError } = unifiedDiff(before, dir);
@@ -211,7 +278,6 @@ export async function runWorker(o) {
   if (cancelled) errors.push({ type: "cancelled" });
   if (exit !== 0 && !timedOut && !cancelled) errors.push({ type: "nonzero_exit", detail: stderr.trim().slice(-2000) || `exit ${exit} signal ${signal}` });
   if (diffError) errors.push({ type: "diff_failed", detail: diffError });
-  const modelId = model.split("/").slice(1).join("/");
   if (actual && actual.some((a) => a.provider !== provider || a.model !== modelId))
     errors.push({ type: "model_mismatch", detail: actual });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-worker",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Run the official OpenCode CLI as an isolated, time-boxed worker. CLI + MCP stdio server.",
   "repository": {
     "type": "git",