cursor-route 0.1.8 → 0.1.10

package/src/adapters/opencode.ts

@@ -0,0 +1,89 @@
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import type { Adapter, WorkerHealth } from "./types.ts";
+import { shellQuote } from "../util.ts";
+import { openCodeModel, OPENCODE_DEFAULT_MODEL } from "../config.ts";
+
+/**
+ * Opt-in OpenCode worker (`opencode run`) — a coding agent that can use
+ * OpenCode Zen free models (default `opencode/big-pickle`) to cut Grok /
+ * DeepSeek usage. Not a lane default: mid stays claude-ds; easy stays
+ * OpenRouter chat (no tools).
+ *
+ * We never rewrite ~/.config/opencode/opencode.json (parallel jobs would
+ * race). Always-approve maps to `opencode run --auto` (still honors explicit
+ * deny rules). Prompt is inlined via cat — never interpolated.
+ */
+
+function findOpencode(): string | null {
+  // Env override lets tests pin a fake opencode — but it must exist, so a
+  // stale override cannot pass health with a dangling path.
+  const override = process.env.CURSOR_ROUTE_OPENCODE_BIN;
+  if (override) return existsSync(override) ? override : null;
+  try {
+    return (
+      execSync("command -v opencode", {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        env: { ...process.env },
+      }).trim() || null
+    );
+  } catch {
+    return null;
+  }
+}
+
+export const opencodeAdapter: Adapter = {
+  kind: "opencode",
+  label: "OpenCode (free Zen / other models)",
+  health(): WorkerHealth {
+    const binary = findOpencode();
+    if (!binary) {
+      return {
+        worker: "opencode",
+        ok: false,
+        binary: null,
+        detail:
+          "opencode not found — install: npm i -g opencode-ai (or brew install opencode). Then: opencode auth login. Mid default remains claude-ds.",
+      };
+    }
+    let defaultModel = OPENCODE_DEFAULT_MODEL;
+    try {
+      defaultModel = openCodeModel();
+    } catch {
+      /* invalid env — health still ok; startJob will fail loud */
+    }
+    return {
+      worker: "opencode",
+      ok: true,
+      binary,
+      detail: `ok (opencode run; default model ${defaultModel}; auth at first start — opencode auth login if jobs fail; mid default remains claude-ds)`,
+    };
+  },
+  buildLaunch({ promptFile, cwd, alwaysApprove, modelId }) {
+    // Missing binary is tolerated here so `--dry-run` can still print the
+    // command; real starts are gated by the health preflight.
+    const binary = findOpencode() || "opencode";
+    const id = openCodeModel(modelId);
+
+    const ask = process.env.CURSOR_ROUTE_ASK === "1";
+    const skip = alwaysApprove && !ask;
+
+    const parts = [
+      shellQuote(binary),
+      "run",
+      "--dir",
+      shellQuote(cwd),
+      "--model",
+      shellQuote(id),
+    ];
+    if (skip) parts.push("--auto");
+    parts.push(`"$(cat ${shellQuote(promptFile)})"`);
+
+    return {
+      worker: "opencode",
+      command: `cd ${shellQuote(cwd)} && ${parts.join(" ")}`,
+      alwaysApprove: skip,
+    };
+  },
+};

package/src/adapters/types.ts

@@ -26,7 +26,7 @@ export interface Adapter {
     alwaysApprove: boolean;
     /** Mid-lane DeepSeek flash|pro (claude-ds + deepseek; ignored by grok/openrouter / Anthropic escape hatch). */
     model?: DsModelAlias;
-    /** Concrete DeepSeek model id for -Model/--model (preserves pro[1m]). */
+    /** Concrete DeepSeek id (preserves pro[1m]) or OpenCode provider/model. */
     modelId?: string;
     /** True on --dry-run: adapters may drop artifacts they just wrote (e.g. dsh patch). */
     dryRun?: boolean;

package/src/cli.test.ts

@@ -10,12 +10,17 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { resolveWorker, startJob } from "./jobs.ts";
+import { resolveWorker, startJob, jobEvidence, type Job } from "./jobs.ts";
 import { config, resolveDsModel, resolveDsModelAlias } from "./config.ts";
 import { shellQuote, newJobId } from "./util.ts";
 import { runHealth } from "./health.ts";
 import { looksLikeSecretMaterial, redactSecrets } from "./secrets.ts";
-import { isDeepSeekRouted, isDeepSeekBaseUrl, claudeDsAdapter } from "./adapters/claude-ds.ts";
+import {
+  isDeepSeekRouted,
+  isDeepSeekBaseUrl,
+  claudeDsAdapter,
+  isMidDeepSeekProven,
+} from "./adapters/claude-ds.ts";
 import { deepseekAdapter, patchPathForPrompt } from "./adapters/deepseek.ts";
 import { grokAdapter } from "./adapters/grok.ts";
 
@@ -36,6 +41,9 @@ describe("resolveWorker", () => {
     expect(resolveWorker({ prompt: "x", lane: "mid", worker: "openrouter" })).toBe(
       "openrouter",
     );
+    expect(resolveWorker({ prompt: "x", lane: "mid", worker: "opencode" })).toBe(
+      "opencode",
+    );
   });
   test("default worker", () => {
     expect(resolveWorker({ prompt: "x" })).toBe(config.defaultWorker);
@@ -610,14 +618,40 @@ describe("health", () => {
   test("returns structured report", () => {
     const r = runHealth();
     expect(r.product).toBe("cursor-route");
-    expect(r.version).toBe("0.1.8");
+    expect(r.version).toBe("0.1.10");
     expect(r.checks.length).toBeGreaterThan(3);
     expect(r.checks.some((c) => c.name === "tmux")).toBe(true);
     expect(r.checks.some((c) => c.name === "cursor_cli")).toBe(true);
+    const mid = r.checks.find((c) => c.name === "lane:mid");
+    expect(mid).toBeDefined();
+    expect(r.lanes.mid.worker).toBe("claude-ds");
+    expect(r.lanes.mid.deepseek).toBe(mid!.ok);
+    expect(r.checks.some((c) => c.name === "worker:opencode")).toBe(true);
+    expect(r.checks.some((c) => c.name === "worker:deepseek")).toBe(true);
+  });
+
+  test("config version is 0.1.10", () => {
+    expect(config.version).toBe("0.1.10");
   });
 
-  test("config version is 0.1.8", () => {
-    expect(config.version).toBe("0.1.8");
+  test("OR-gate: ok can be true while worker:opencode is false", () => {
+    const prev = {
+      relaxed: process.env.CURSOR_ROUTE_RELAXED,
+      bin: process.env.CURSOR_ROUTE_OPENCODE_BIN,
+    };
+    process.env.CURSOR_ROUTE_RELAXED = "1";
+    process.env.CURSOR_ROUTE_OPENCODE_BIN = join(tmpdir(), `missing-oc-${process.pid}`);
+    try {
+      const r = runHealth();
+      const oc = r.checks.find((c) => c.name === "worker:opencode");
+      expect(oc?.ok).toBe(false);
+      expect(r.ok).toBe(true);
+    } finally {
+      if (prev.relaxed === undefined) delete process.env.CURSOR_ROUTE_RELAXED;
+      else process.env.CURSOR_ROUTE_RELAXED = prev.relaxed;
+      if (prev.bin === undefined) delete process.env.CURSOR_ROUTE_OPENCODE_BIN;
+      else process.env.CURSOR_ROUTE_OPENCODE_BIN = prev.bin;
+    }
   });
 
   test("OR-gate: ok can be true while worker:deepseek is false", () => {
@@ -657,4 +691,98 @@ describe("health", () => {
       else process.env.CURSOR_ROUTE_RELAXED = prev;
     }
   });
+
+  test("CURSOR_ROUTE_CLAUDE_DS_BIN pointing at an existing file proves mid DeepSeek", () => {
+    const prev = process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+    const fake = join(tmpdir(), `cr-mid-proof-${process.pid}`);
+    writeFileSync(fake, "#!/bin/sh\necho ok\n");
+    chmodSync(fake, 0o755);
+    process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = fake;
+    try {
+      expect(isMidDeepSeekProven()).toBe(true);
+    } finally {
+      if (prev === undefined) delete process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+      else process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = prev;
+      rmSync(fake, { force: true });
+    }
+  });
+
+  test("Anthropic hatch is not DeepSeek proof (shim on PATH still is)", () => {
+    const shimDir = join(tmpdir(), `cr-mid-hatch-${process.pid}`);
+    mkdirSync(shimDir, { recursive: true });
+    const claude = join(shimDir, "claude");
+    writeFileSync(claude, "#!/bin/sh\necho ok\n");
+    chmodSync(claude, 0o755);
+
+    const prev = {
+      bin: process.env.CURSOR_ROUTE_CLAUDE_DS_BIN,
+      allow: process.env.CURSOR_ROUTE_ALLOW_ANTHROPIC,
+      base: process.env.ANTHROPIC_BASE_URL,
+      crBase: process.env.CURSOR_ROUTE_ANTHROPIC_BASE_URL,
+      path: process.env.PATH,
+    };
+    delete process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+    delete process.env.CURSOR_ROUTE_ANTHROPIC_BASE_URL;
+    process.env.ANTHROPIC_BASE_URL = "https://api.anthropic.com";
+    process.env.CURSOR_ROUTE_ALLOW_ANTHROPIC = "1";
+    process.env.PATH = `${shimDir}:/usr/bin:/bin`;
+    try {
+      const detail = claudeDsAdapter.health().detail;
+      if (detail.includes("Anthropic")) {
+        expect(isMidDeepSeekProven()).toBe(false);
+        const r = runHealth();
+        const mid = r.checks.find((c) => c.name === "lane:mid");
+        expect(mid?.ok).toBe(false);
+        expect(r.lanes.mid.deepseek).toBe(false);
+      } else {
+        // Real claude-ds / deepseek-claude on PATH is proof (hatch never engages).
+        expect(isMidDeepSeekProven()).toBe(true);
+      }
+    } finally {
+      if (prev.bin === undefined) delete process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+      else process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = prev.bin;
+      if (prev.allow === undefined) delete process.env.CURSOR_ROUTE_ALLOW_ANTHROPIC;
+      else process.env.CURSOR_ROUTE_ALLOW_ANTHROPIC = prev.allow;
+      if (prev.base === undefined) delete process.env.ANTHROPIC_BASE_URL;
+      else process.env.ANTHROPIC_BASE_URL = prev.base;
+      if (prev.crBase === undefined) delete process.env.CURSOR_ROUTE_ANTHROPIC_BASE_URL;
+      else process.env.CURSOR_ROUTE_ANTHROPIC_BASE_URL = prev.crBase;
+      process.env.PATH = prev.path || "";
+      rmSync(shimDir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("jobEvidence", () => {
+  test("verify.claim is always unverified; spawn/execute keys exist", () => {
+    const job: Job = {
+      id: "abcd1234",
+      schema: "cursor-route.job.v1",
+      status: "running",
+      worker: "claude-ds",
+      lane: "mid",
+      model: "flash",
+      prompt: "ping",
+      cwd: "/tmp",
+      alwaysApprove: true,
+      tmuxSession: "cursor-route-abcd1234",
+      createdAt: "2026-08-18T00:00:00.000Z",
+      startedAt: "2026-08-18T00:00:01.000Z",
+      logBytes: 42,
+    };
+    const ev = jobEvidence(job, true);
+    expect(ev.verify.claim).toBe("unverified");
+    expect(ev.verify.captureHint).toBe("cursor-route capture abcd1234");
+    expect(ev.verify.logBytes).toBe(42);
+    expect(ev.spawn.jobId).toBe("abcd1234");
+    expect(ev.spawn.worker).toBe("claude-ds");
+    expect(ev.spawn.lane).toBe("mid");
+    expect(ev.spawn.model).toBe("flash");
+    expect(ev.spawn.startedAt).toBe("2026-08-18T00:00:01.000Z");
+    expect(ev.execute.status).toBe("running");
+    expect(ev.execute.exitCode).toBe(null);
+    expect(ev.execute.tmuxSession).toBe("cursor-route-abcd1234");
+    expect(ev.execute.pid).toBe(null);
+    expect(ev.execute.sessionAlive).toBe(true);
+  });
 });

package/src/cli.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 /**
- * cursor-route CLI — Cursor brain, Grok + DeepSeek + OpenRouter (easy) workers in tmux.
+ * cursor-route CLI — Cursor brain, Grok + DeepSeek + OpenRouter (easy) + OpenCode (opt-in) workers in tmux.
  */
 import { readFileSync, existsSync, realpathSync, statSync } from "node:fs";
 import { resolve, basename } from "node:path";
@@ -9,6 +9,7 @@ import {
   WORKERS,
   LANES,
   resolveDsModel,
+  openCodeModel,
   type WorkerKind,
   type Lane,
   type DsModelAlias,
@@ -22,6 +23,7 @@ import {
   cleanJobs,
   jobPaths,
   refreshStatus,
+  jobEvidence,
 } from "./jobs.ts";
 import {
   capturePane,
@@ -35,15 +37,15 @@ import { looksLikeSecretMaterial, redactSecrets } from "./secrets.ts";
 function usage(exitCode = 0): never {
   console.log(`cursor-route v${config.version}
 
-Cursor stays the brain. Grok CLI + DeepSeek (claude-ds) + OpenRouter (easy) are the parallel army.
+Cursor stays the brain. Grok CLI + DeepSeek (claude-ds) + OpenRouter (easy) + OpenCode (opt-in free) are the parallel army.
 
 Usage:
   cursor-route --version
-  cursor-route health [--json]
+  cursor-route health [--json]          # JSON includes lanes.mid (DeepSeek proof)
   cursor-route start <prompt> [options]
   cursor-route start --prompt-file <path> [options]
   cursor-route jobs [--json] [--limit N]
-  cursor-route status <jobId> [--json]
+  cursor-route status <jobId> [--json]  # JSON includes evidence spawn/execute/verify
   cursor-route capture <jobId> [lines]
   cursor-route send <jobId> <message>
   cursor-route attach <jobId>
@@ -52,9 +54,9 @@ Usage:
   cursor-route clean [--days N]
 
 Start options:
-  --worker <grok|claude-ds|openrouter|deepseek>  Worker adapter (default: grok; deepseek = experimental official dsh)
+  --worker <grok|claude-ds|openrouter|deepseek|opencode>  Worker adapter (default: grok; deepseek/opencode = opt-in)
   --lane <easy|mid|hard>                Lane → worker (easy=openrouter, mid=claude-ds, hard=grok)
-  --model <flash|pro>                   Mid DeepSeek only (default: flash / CURSOR_ROUTE_DS_MODEL). Parsed for claude-ds + deepseek
+  --model <flash|pro|free|provider/model>  claude-ds/deepseek: flash|pro. opencode: free (default opencode/big-pickle) or provider/model
   --dir <path>                          Working directory (default: cwd)
   --ask                                 Disable always-approve for this job
   --dry-run                             Print launch command; do not start
@@ -71,10 +73,12 @@ Env:
   CURSOR_ROUTE_GROK_BIN              Override the grok binary path (tests / power users)
   CURSOR_ROUTE_CLAUDE_DS_BIN         Override the claude-ds binary path (tests / power users)
   CURSOR_ROUTE_DSH_BIN               Override the dsh binary path (tests / power users)
+  CURSOR_ROUTE_OPENCODE_BIN          Override the opencode binary path (tests / power users)
   DEEPSEEK_API_KEY                   DeepSeek API key (required for --worker deepseek)
   OPENROUTER_API_KEY                 OpenRouter key (required for --worker openrouter / --lane easy)
   CURSOR_ROUTE_OPENROUTER_MODEL      OpenRouter model (default: openrouter/free)
   OPENROUTER_BASE_URL                OpenRouter API base (default: https://openrouter.ai/api/v1)
+  CURSOR_ROUTE_OPENCODE_MODEL        OpenCode model (default: opencode/big-pickle); --model overrides
 `);
   process.exit(exitCode);
 }
@@ -170,6 +174,14 @@ function asDsModelChoice(v: unknown): { alias: DsModelAlias; id: string } | unde
   return resolveDsModel(v);
 }
 
+function asOpenCodeModel(v: unknown): string | undefined {
+  if (v === undefined || v === true) return undefined;
+  if (typeof v !== "string") {
+    throw new Error(`Invalid --model; expected provider/model (e.g. opencode/big-pickle) or free`);
+  }
+  return openCodeModel(v);
+}
+
 function refuseSecrets(text: string, context: string): void {
   if (looksLikeSecretMaterial(text)) {
     console.error(
@@ -252,8 +264,8 @@ async function main() {
 
     let model: DsModelAlias | undefined;
     let modelId: string | undefined;
-    // --model is DeepSeek-only (claude-ds mid lane + experimental deepseek worker);
-    // ignore (do not validate) for other workers
+    // --model: DeepSeek flash|pro for claude-ds/deepseek; provider/model (or free) for opencode;
+    // ignore (do not validate) for grok/openrouter
     if (f.model !== undefined && (resolvedWorker === "claude-ds" || resolvedWorker === "deepseek")) {
       try {
         const choice = asDsModelChoice(f.model);
@@ -265,6 +277,13 @@ async function main() {
         console.error((e as Error).message);
         process.exit(2);
       }
+    } else if (f.model !== undefined && resolvedWorker === "opencode") {
+      try {
+        modelId = asOpenCodeModel(f.model);
+      } catch (e) {
+        console.error((e as Error).message);
+        process.exit(2);
+      }
     }
 
     let prompt = "";
@@ -358,7 +377,7 @@ async function main() {
     } else {
       for (const j of jobs) {
         const age = j.startedAt || j.createdAt;
-        const modelCol = j.model ? j.model.padEnd(6) : "".padEnd(6);
+        const modelCol = j.model ? j.model.padEnd(22) : "".padEnd(22);
         console.log(
           `${j.id}  ${j.status.padEnd(10)}  ${j.worker.padEnd(10)}  ${modelCol}  ${age}  ${j.prompt.slice(0, 48).replace(/\n/g, " ")}`,
         );
@@ -389,12 +408,14 @@ async function main() {
           }
         })())
       : sessionExists(job.tmuxSession);
-    const view = { ...job, sessionAlive: alive };
+    const evidence = jobEvidence(job, alive);
+    const view = { ...job, sessionAlive: alive, evidence };
     if (json) console.log(JSON.stringify(view, null, 2));
     else {
       console.log(
         `${job.id}  ${job.status}  worker=${job.worker}${job.model ? `  model=${job.model}` : ""}  sessionAlive=${alive}`,
       );
+      console.log("evidence: spawn/execute/verify (claim=unverified)");
       if (job.error) console.log(`error: ${job.error}`);
     }
     return;

package/src/config.ts

@@ -3,10 +3,11 @@ import { join } from "node:path";
 import { defaultJobsDir } from "./runtime.ts";
 
 /**
- * Workers with a live adapter. `deepseek` is the experimental official
- * DeepSeek Harness (dsh) — an opt-in worker, not a mid default.
+ * Workers with a live adapter. `deepseek` (official dsh) and `opencode`
+ * (free Zen / other models) are opt-in workers, not lane defaults.
+ * Mid stays on claude-ds; easy stays on openrouter (chat-only).
  */
-export type WorkerKind = "grok" | "claude-ds" | "openrouter" | "deepseek";
+export type WorkerKind = "grok" | "claude-ds" | "openrouter" | "deepseek" | "opencode";
 export type Lane = "easy" | "mid" | "hard";
 
 /** Public CLI aliases for mid-lane DeepSeek models. */
@@ -18,7 +19,7 @@ export interface DsModelChoice {
   id: string;
 }
 
-export const WORKERS: WorkerKind[] = ["grok", "claude-ds", "openrouter", "deepseek"];
+export const WORKERS: WorkerKind[] = ["grok", "claude-ds", "openrouter", "deepseek", "opencode"];
 export const LANES: Lane[] = ["easy", "mid", "hard"];
 export const DS_MODELS: DsModelAlias[] = ["flash", "pro"];
 
@@ -73,6 +74,37 @@ export function openRouterBaseUrl(): string {
   return process.env.OPENROUTER_BASE_URL || "https://openrouter.ai/api/v1";
 }
 
+/**
+ * Default OpenCode model: OpenCode Zen Big Pickle (free, limited-time).
+ * Override: CURSOR_ROUTE_OPENCODE_MODEL or `--model provider/model`.
+ * Alias `free` resolves to this default (or the env override).
+ */
+export const OPENCODE_DEFAULT_MODEL = "opencode/big-pickle";
+
+/** Whitelist OpenCode `provider/model` ids (no spaces / injection). */
+export function assertOpenCodeModel(id: string): string {
+  if (!/^[a-z0-9][a-z0-9._-]*(?:\/[a-z0-9][a-z0-9._\-:]+)+$/i.test(id)) {
+    throw new Error(
+      `Invalid OpenCode model ${id}; expected provider/model (e.g. opencode/big-pickle) or free`,
+    );
+  }
+  return id;
+}
+
+/**
+ * Resolve OpenCode `--model` / env to a concrete `provider/model` id.
+ * Empty or `free` → CURSOR_ROUTE_OPENCODE_MODEL, else OPENCODE_DEFAULT_MODEL.
+ */
+export function openCodeModel(raw?: string | null): string {
+  const v = (raw ?? "").trim();
+  if (!v || v.toLowerCase() === "free") {
+    const env = (process.env.CURSOR_ROUTE_OPENCODE_MODEL ?? "").trim();
+    if (!env || env.toLowerCase() === "free") return OPENCODE_DEFAULT_MODEL;
+    return assertOpenCodeModel(env);
+  }
+  return assertOpenCodeModel(v);
+}
+
 function maxConcurrentJobsFromEnv(): number {
   const raw = process.env.CURSOR_ROUTE_MAX_JOBS;
   if (raw) {
@@ -89,7 +121,7 @@ function maxConcurrentJobsFromEnv(): number {
  */
 export const config = {
   product: "cursor-route",
-  version: "0.1.8",
+  version: "0.1.10",
   get jobsDir(): string {
     return defaultJobsDir();
   },
@@ -97,7 +129,7 @@ export const config = {
   defaultWorker: "grok" as WorkerKind,
   /**
    * Lane → default worker (Cemini /route public core).
-   * `deepseek` is experimental only — mid stays on claude-ds.
+   * `deepseek` and `opencode` are opt-in only — mid stays on claude-ds.
    */
   laneWorkers: {
     easy: "openrouter" as WorkerKind,

package/src/health.ts

@@ -1,5 +1,6 @@
 import { execSync } from "node:child_process";
 import { allAdapters } from "./adapters/index.ts";
+import { isMidDeepSeekProven, midDeepSeekProofDetail } from "./adapters/claude-ds.ts";
 import { config } from "./config.ts";
 import { isTmuxAvailable } from "./tmux.ts";
 import { commandExists } from "./util.ts";
@@ -13,6 +14,9 @@ export interface HealthReport {
     ok: boolean;
     detail: string;
   }>;
+  lanes: {
+    mid: { worker: "claude-ds"; deepseek: boolean; detail: string };
+  };
 }
 
 export function runHealth(): HealthReport {
@@ -58,6 +62,15 @@ export function runHealth(): HealthReport {
     });
   }
 
+  // Informational: mid is proven DeepSeek (not the overall OR-gate).
+  const midOk = isMidDeepSeekProven();
+  const midDetail = midDeepSeekProofDetail();
+  checks.push({
+    name: "lane:mid",
+    ok: midOk,
+    detail: midDetail,
+  });
+
   // Optional supervisor probe (v0 skill-only; Cursor CLI agent is informational)
   const agentBin =
     (commandExists("agent") && "agent") ||
@@ -99,6 +112,9 @@ export function runHealth(): HealthReport {
     product: config.product,
     version: config.version,
     checks,
+    lanes: {
+      mid: { worker: "claude-ds", deepseek: midOk, detail: midDetail },
+    },
   };
 }
 
@@ -117,6 +133,11 @@ export function printHealth(report: HealthReport, asJson: boolean): void {
   if (!report.ok) {
     console.log("");
     console.log("Fix the ✗ items, then re-run: cursor-route health");
-    console.log("Tip: start with one worker (grok OR claude-ds) before parallel demos.");
+    console.log("Tip: start with one worker (grok OR claude-ds OR opencode) before parallel demos.");
+  } else if (report.checks.some((c) => c.name === "lane:mid" && !c.ok)) {
+    console.log("");
+    console.log(
+      "Tip: health OK without a DeepSeek mid — --lane mid will fail until lane:mid is ✓.",
+    );
   }
 }

package/src/jobs.ts

@@ -17,6 +17,7 @@ import {
   sessionName,
   defaultDsModelFromEnv,
   DS_MODEL_IDS,
+  openCodeModel,
   type Lane,
   type WorkerKind,
   type DsModelAlias,
@@ -37,8 +38,8 @@ export interface Job {
   status: JobStatus;
   worker: WorkerKind;
   lane?: Lane;
-  /** Mid-lane DeepSeek model alias (flash|pro). Set for claude-ds and deepseek. */
-  model?: DsModelAlias;
+  /** Worker model: flash|pro for claude-ds/deepseek; provider/model for opencode. */
+  model?: string;
   prompt: string;
   cwd: string;
   alwaysApprove: boolean;
@@ -105,6 +106,53 @@ export function writeJob(job: Job): void {
   writeSecure(jobPaths(job.id).json, JSON.stringify(job, null, 2));
 }
 
+/** Evidence tree for status --json. Parent must capture; claim is never auto-green. */
+export interface JobEvidence {
+  spawn: {
+    jobId: string;
+    worker: WorkerKind;
+    lane: Lane | null;
+    model: string | null;
+    startedAt: string;
+  };
+  execute: {
+    status: JobStatus;
+    exitCode: number | null;
+    tmuxSession: string;
+    pid: number | null;
+    sessionAlive: boolean;
+  };
+  verify: {
+    captureHint: string;
+    logBytes: number | null;
+    claim: "unverified";
+  };
+}
+
+export function jobEvidence(job: Job, sessionAlive: boolean): JobEvidence {
+  return {
+    spawn: {
+      jobId: job.id,
+      worker: job.worker,
+      lane: job.lane ?? null,
+      model: job.model ?? null,
+      startedAt: job.startedAt ?? job.createdAt,
+    },
+    execute: {
+      status: job.status,
+      exitCode: job.exitCode ?? null,
+      tmuxSession: job.tmuxSession,
+      pid: job.pid ?? null,
+      sessionAlive,
+    },
+    verify: {
+      captureHint: `cursor-route capture ${job.id}`,
+      logBytes: job.logBytes ?? null,
+      claim: "unverified",
+    },
+  };
+}
+
 function pidAlive(pid: number): boolean {
   try {
     process.kill(pid, 0);
@@ -118,6 +166,8 @@ function pidAlive(pid: number): boolean {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
     });
+    // spawnSync does not throw on EPERM (macOS sandbox); empty stdout is not "dead".
+    if (r.error || r.status !== 0) return true;
     const state = (r.stdout || "").trim();
     return state !== "" && !state.startsWith("Z");
   } catch {
@@ -233,7 +283,7 @@ export interface StartOptions {
   lane?: Lane;
   /** Mid-lane DeepSeek: flash (default) | pro (claude-ds + deepseek). Ignored by grok/openrouter. */
   model?: DsModelAlias;
-  /** Concrete DeepSeek id (preserves pro[1m]). Derived from --model / env when unset. */
+  /** Concrete DeepSeek id (preserves pro[1m]) or OpenCode provider/model. Derived from --model / env when unset. */
   modelId?: string;
   cwd?: string;
   alwaysApprove?: boolean;
@@ -282,15 +332,18 @@ export function startJob(opts: StartOptions): {
   const paths = jobPaths(id);
   writeSecure(paths.prompt, opts.prompt);
 
-  let model: DsModelAlias | undefined;
+  let model: string | undefined;
   let modelId: string | undefined;
+  let dsAlias: DsModelAlias | undefined;
   if (worker === "claude-ds" || worker === "deepseek") {
     if (opts.model) {
+      dsAlias = opts.model;
       model = opts.model;
       modelId = opts.modelId ?? DS_MODEL_IDS[opts.model];
     } else {
       try {
         const choice = defaultDsModelFromEnv();
+        dsAlias = choice.alias;
         model = choice.alias;
         modelId = opts.modelId ?? choice.id;
       } catch (e) {
@@ -302,6 +355,19 @@ export function startJob(opts: StartOptions): {
         return { ok: false, error: (e as Error).message };
       }
     }
+  } else if (worker === "opencode") {
+    try {
+      const ocModel = openCodeModel(opts.modelId);
+      model = ocModel;
+      modelId = ocModel;
+    } catch (e) {
+      try {
+        unlinkSync(paths.prompt);
+      } catch {
+        /* ignore */
+      }
+      return { ok: false, error: (e as Error).message };
+    }
   }
 
   let plan;
@@ -310,7 +376,7 @@ export function startJob(opts: StartOptions): {
       promptFile: paths.prompt,
       cwd,
       alwaysApprove,
-      model,
+      model: dsAlias,
       modelId,
       dryRun: Boolean(opts.dryRun),
     });