cursor-route 0.1.8 → 0.1.10

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## Unreleased
+
+_(none)_
+
+## 0.1.10 — 2026-08-21
+
+- Opt-in `--worker opencode`: OpenCode `run` as a coding agent that defaults to Zen free model `opencode/big-pickle` (alias `--model free`). Not a lane default — mid stays `claude-ds`, easy stays OpenRouter chat.
+- Always-approve → `opencode run --auto` (still honors explicit deny rules); `--ask` / `CURSOR_ROUTE_ASK=1` omits `--auto`. Never rewrites `~/.config/opencode/opencode.json`.
+- `--model provider/model` for opencode (env `CURSOR_ROUTE_OPENCODE_MODEL`); `flash|pro` still DeepSeek-only.
+- Health: `worker:opencode` ✓ when `opencode` is on PATH (override `CURSOR_ROUTE_OPENCODE_BIN`). Auth is `opencode auth login` at first start (same pattern as grok).
+- Dry-run works without opencode installed (falls back to plain `opencode` in the printed command); real starts stay gated by health.
+- Docs / `route-orch`: OpenCode is an opt-in usage-reduction worker, not a second mid harness. Free Zen models may log/train — non-secret prompts only.
+
+## 0.1.9 — 2026-08-18
+
+- Health proves mid DeepSeek: dedicated `lane:mid` check is ✓ only when mid is a `claude-ds` / `deepseek-claude` shim or stock `claude` with DeepSeek `ANTHROPIC_BASE_URL`. `CURSOR_ROUTE_ALLOW_ANTHROPIC=1` is not proof. Overall `ok` still uses the existing OR-gate (any worker + `CURSOR_ROUTE_RELAXED=1`); grok-only installs stay OK with `lane:mid` ✗ plus a fix tip.
+- Health JSON includes `lanes.mid.{ worker, deepseek, detail }` (`worker` is always `"claude-ds"`).
+- `status --json` adds an evidence tree (`spawn` / `execute` / `verify`). `verify.claim` is always `"unverified"` — the parent must capture; status never auto-greens.
+- Headless pid liveness: if `ps` is unreadable (`EPERM` / non-zero), treat the pid as **alive** (fail-safe), not dead — avoids false-completed kills on sandboxed `ps`.
+- `route-orch` skill: health-before-mid, evidence-tree closeout, always-approve is coding-worktrees-only (not LIVE Discord/trading), do not fork the mid harness; `--worker deepseek` stays experimental / cheap-to-abandon.
+- Docs: `route-orch` **Eval & skill hygiene** (folded from Unreleased) — external eval contract (AutoDesign): never rewrite Verify / Success criteria mid-run to make a failing job look green (capture + exit status are the contract); skill misevolution: no auto-edit / promote skill variants from worker trajectories without operator HITL (write-time approval ≠ safe retrieval later); verify fail → prefer reconsidering the plan/definition over grinding the same tactic, with stage attribution when possible (spawn vs execute vs verify). Mid stays `claude-ds`.
+
 ## 0.1.8 — 2026-08-14
 
 - Experimental `--worker deepseek`: official DeepSeek Harness (`dsh`, `@deepseek-ai/dsh`) runs headless — `dsh --profile headless` with a per-job Cordis patch pinning the model. Not a mid default: `laneWorkers.mid` stays `claude-ds`.

package/CONTRIBUTING.md

@@ -12,6 +12,7 @@ CURSOR_ROUTE_RELAXED=1 ./bin/cursor-route health   # without tmux
 ./bin/cursor-route start --dry-run --lane mid --model flash "ping"
 ./bin/cursor-route start --dry-run --lane mid --model pro "ping"
 ./bin/cursor-route start --dry-run --worker deepseek --model flash "ping"   # needs dsh + DEEPSEEK_API_KEY for real starts
+./bin/cursor-route start --dry-run --worker opencode --model free "ping"    # needs opencode for real starts
 ```
 
 Keep `skills/route-orch/SKILL.md` and `.cursor/skills/route-orch/SKILL.md` identical when editing the skill.
@@ -23,6 +24,7 @@ Keep `skills/route-orch/SKILL.md` and `.cursor/skills/route-orch/SKILL.md` ident
 - Prefer adapters over rewriting the job core
 - Always-approve defaults stay documented + opt-out (`--ask` / `CURSOR_ROUTE_ASK=1`)
 - Mid default is Flash; document Pro only as harder mid / Grok **usage** stand-in (not missing `grok login`)
+- OpenCode is opt-in (`--worker opencode`); do not make it a lane default — mid stays claude-ds
 
 ## Release checklist
 

package/README.md

@@ -1,6 +1,6 @@
 # cursor-route
 
-**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.**
 
 Lane-aware `/route` orchestration in tmux — not another multi-provider fleet, not a Codex clone.
 
@@ -17,7 +17,7 @@ cursor-route capture <jobId>
 |---------|-------|---------|------|
 | [codex-orchestrator](https://github.com/kingbootoshi/codex-orchestrator) | Claude Code | Codex | Viral tmux panes |
 | [CAO](https://github.com/awslabs/cli-agent-orchestrator) | Supervisor CLI | Many (incl. Cursor CLI) | Enterprise MCP + Web UI |
-| **cursor-route** | **Cursor Agent** | **Grok CLI + claude-ds + OpenRouter (easy)** | Cost-aware lanes you already pay for |
+| **cursor-route** | **Cursor Agent** | **Grok CLI + claude-ds + OpenRouter (easy) + OpenCode (opt-in)** | Cost-aware lanes you already pay for |
 
 If you already live in Cursor, X Premium (Grok CLI), and DeepSeek — stop paying a third coding agent just to parallelize.
 
@@ -29,6 +29,7 @@ If you already live in Cursor, X Premium (Grok CLI), and DeepSeek — stop payin
 | Grok CLI | X Premium | `--lane hard` implement |
 | DeepSeek via claude-ds | DeepSeek API / plan | `--lane mid` implement (**Flash** default; `--model pro` when needed) |
 | OpenRouter free models | OpenRouter API (free tier) | `--lane easy` wording/drafts — non-secret prompts only (see Security) |
+| OpenCode (opt-in) | OpenCode Zen free models | `--worker opencode` implement on free Zen (default `opencode/big-pickle`) |
 | Codex / extra Claude | Optional | Not required for v0 |
 
 Exact dollars vary — the point is **reuse subscriptions you already have**.
@@ -43,6 +44,7 @@ Exact dollars vary — the point is **reuse subscriptions you already have**.
 | [Bun](https://bun.sh) *(or Node 20+)* | Runs the CLI |
 | [Grok CLI](https://x.ai/cli) and/or Claude Code + DeepSeek (`claude-ds`) | Workers |
 | OpenRouter API key (`OPENROUTER_API_KEY`) | Easy lane (`--lane easy` / `--worker openrouter`) |
+| [OpenCode](https://opencode.ai) (`opencode` on PATH) | Opt-in `--worker opencode` (free Zen models) |
 | `script(1)` | Job logs (macOS/Linux) |
 
 ```bash
@@ -57,6 +59,7 @@ npm i -g cursor-route
 grok login                 # if using Grok
 # configure claude-ds — see DeepSeek setup below
 export OPENROUTER_API_KEY=...   # if using the easy lane (see OpenRouter setup below)
+# optional: npm i -g opencode-ai && opencode auth login   # --worker opencode
 
 cursor-route health
 # without tmux / workers (CI / headless infra smoke):
@@ -91,10 +94,10 @@ Working notes for this repo (edit in place): [docs/briefs/WORKING.md](./docs/bri
 
 | Command | Description |
 |---------|-------------|
-| `health` | Gate #1 — tmux, runtime, workers |
+| `health` | Gate #1 — tmux, runtime, workers; proves `lane:mid` is DeepSeek (`lanes.mid` in `--json`) |
 | `start <prompt>` | Spawn worker job (`--worker` / `--lane` / `--model` / `--dir` / `--ask` / `--dry-run` / `--no-tmux`) |
 | `jobs [--json]` | List jobs |
-| `status <id>` | Job + sessionAlive |
+| `status <id>` | Job + sessionAlive; `--json` includes evidence tree (`spawn` / `execute` / `verify`) |
 | `capture <id> [n]` | Last n pane/log lines |
 | `send <id> <msg>` | Mid-task redirect (tmux send-keys) |
 | `attach <id>` | Print `tmux attach` hint |
@@ -113,10 +116,10 @@ docs/fixtures/generate-hero-demo.sh      # regenerate docs/fixtures/hero-demo.lo
 
 ```text
 $ cursor-route --version
-0.1.8
+0.1.9
 
 $ CURSOR_ROUTE_RELAXED=1 cursor-route health
-cursor-route v0.1.8
+cursor-route v0.1.9
 health: OK
 
 $ cursor-route start --lane mid --model flash --dry-run "Add a unit test for shellQuote"
@@ -140,7 +143,7 @@ A real hero GIF is still pending — recording steps live in [docs/DEMO_GIF.md](
 | `mid` | `claude-ds` | Default implement on DeepSeek (**Flash** by default) |
 | `hard` | `grok` | Hard implement on Grok CLI |
 
-Always-approve is **on** by default. Opt out: `--ask` or `CURSOR_ROUTE_ASK=1`.
+Always-approve is **on** by default for **coding worktrees only**. It does not authorize LIVE Discord, trading, or irreversible SaaS. Opt out: `--ask` or `CURSOR_ROUTE_ASK=1`.
 
 ### Mid models (Flash vs Pro)
 
@@ -163,7 +166,7 @@ export CURSOR_ROUTE_DS_MODEL=pro   # also honors ANTHROPIC_MODEL; --model overri
 
 ## DeepSeek setup (the cheap mid-lane — this is the point)
 
-`cursor-route` mid lane runs **DeepSeek**, not Anthropic. Claude Code is only the terminal harness; bills go to DeepSeek when `ANTHROPIC_BASE_URL` points at them.
+`cursor-route` mid lane runs **DeepSeek**, not Anthropic. Claude Code is only the terminal harness; bills go to DeepSeek when `ANTHROPIC_BASE_URL` points at them. `cursor-route health` shows `lane:mid` ✓ only when DeepSeek is proven (`claude-ds` / `deepseek-claude` shim, or stock `claude` with DeepSeek `ANTHROPIC_BASE_URL`) — `CURSOR_ROUTE_ALLOW_ANTHROPIC=1` is not proof.
 
 **Recommended (official DeepSeek → Claude Code):**
 
@@ -176,7 +179,7 @@ export ANTHROPIC_AUTH_TOKEN=YOUR_DEEPSEEK_API_KEY   # from platform.deepseek.com
 export ANTHROPIC_DEFAULT_HAIKU_MODEL=deepseek-v4-flash
 export CLAUDE_CODE_SUBAGENT_MODEL=deepseek-v4-flash
 
-cursor-route health          # worker:claude-ds should be ✓
+cursor-route health          # worker:claude-ds should be ✓; `lane:mid` is ✓ only when DeepSeek is proven
 cursor-route start --lane mid "…"                 # Flash (default)
 cursor-route start --lane mid --model pro "…"     # Pro when you need it
 ```
@@ -221,6 +224,36 @@ cursor-route start --lane easy "Rewrite this FAQ answer in 3 sentences"
 **wording/drafts without credentials**. The same refuse gate as every lane blocks
 key-shaped material in `start` / `send`, and the runner re-checks the prompt file.
 
+## OpenCode setup (opt-in free coding worker)
+
+`--worker opencode` runs [OpenCode](https://opencode.ai) as a **coding agent** on
+OpenCode Zen free models (default `opencode/big-pickle`). This is **not** a lane
+default — mid stays `claude-ds`; easy stays OpenRouter chat (no tools). Use it
+to burn fewer Grok / DeepSeek tokens on implement work.
+
+```bash
+npm i -g opencode-ai          # or: brew install opencode
+opencode auth login           # connect OpenCode Zen (or another provider)
+# optional:
+export CURSOR_ROUTE_OPENCODE_MODEL=opencode/big-pickle   # default; alias --model free
+
+cursor-route health                              # worker:opencode should be ✓
+cursor-route start --worker opencode "…"         # Big Pickle (free)
+cursor-route start --worker opencode --model free "…"
+cursor-route start --worker opencode --model opencode/hy3-free "…"
+```
+
+The adapter launches `opencode run --dir <cwd> --model <id>` with the prompt via
+`cat` (never interpolated). Always-approve maps to `--auto` (explicit `"deny"`
+rules still apply); `--ask` omits `--auto`. It never rewrites
+`~/.config/opencode/opencode.json`, so parallel jobs don't race. Override the
+binary with `CURSOR_ROUTE_OPENCODE_BIN`.
+
+**Non-secret prompts:** several Zen free models may log or train on prompts during
+their free period (see [OpenCode Zen](https://opencode.ai/docs/zen/) privacy notes).
+The same refuse gate as every lane still applies. `opencode/x-preview-f-free`
+(Ox Alpha) is the zero-retention free option if you need it.
+
 ## Jobs directory
 
 Jobs default to `~/.local/share/cursor-route/jobs` (override with `CURSOR_ROUTE_JOBS_DIR`).
@@ -235,7 +268,7 @@ This is **not** inside a git clone of this repo.
 ## FAQ
 
 **What is cursor-route?**  
-cursor-route is a public MIT CLI and Cursor skill that runs parallel coding workers in tmux while Cursor remains the planner. DeepSeek handles the mid lane, Grok CLI handles the hard lane, and OpenRouter free models handle the easy lane for wording/drafts.
+cursor-route is a public MIT CLI and Cursor skill that runs parallel coding workers in tmux while Cursor remains the planner. DeepSeek handles the mid lane, Grok CLI handles the hard lane, OpenRouter free models handle the easy lane for wording/drafts, and `--worker opencode` is an opt-in coding agent on OpenCode Zen free models.
 
 **How is this different from Codex orchestrator?**  
 It uses the familiar strategist and worker-pane shape, but it is not a Codex clone. cursor-route uses Cursor as the planner and DeepSeek plus Grok CLI as workers. Codex is not required.
@@ -247,7 +280,7 @@ No. The mid worker is DeepSeek. Claude Code is the harness, configured with `ANT
 Run `npm i -g cursor-route`, install tmux if needed, then run `cursor-route health`. The package is available at https://www.npmjs.com/package/cursor-route, and the source is at https://github.com/cemini23/cursor-route.
 
 **Is it free?**  
-The cursor-route code is open source under MIT. It does not make the worker services free. Your costs depend on Cursor, DeepSeek API usage, and the Grok access or balance available to you. The easy lane can be free on OpenRouter's free-model route (`openrouter/free`).
+The cursor-route code is open source under MIT. It does not make the worker services free. Your costs depend on Cursor, DeepSeek API usage, and the Grok access or balance available to you. The easy lane can be free on OpenRouter's free-model route (`openrouter/free`). `--worker opencode` can run OpenCode Zen free models (default `opencode/big-pickle`).
 
 ## Related
 
@@ -276,9 +309,11 @@ If you’d like to tip, use the **donation-only** addresses below (not trading o
 
 | Chain family | Address |
 |--------------|---------|
+| **X Money** (fiat, US) | Request [@Cemini23](https://x.com/Cemini23) in the X app — scan the Request QR |
 | **EVM** (Ethereum, Polygon, Base, Arbitrum, …) | `0x444C5C2eC439E0382aa5a17F70313c536BcC5D58` |
 | **Solana / SVM** | `J4zNn4hK9jTrKBFY8sbAGJHLoZvXvQf4B9pQSbSrocZE` |
 | **Polymarket** (referral) | [polymarket.com/?r=Cemini23](https://polymarket.com/?r=Cemini23) |
+| **Hyperliquid** (referral) | [app.hyperliquid.xyz/join/CEMINI23](https://app.hyperliquid.xyz/join/CEMINI23) |
 
 Full wallet note: [SUPPORT.md](SUPPORT.md) · canon also in [CCC SUPPORT.md](https://github.com/cemini23/cemini-claude-code-CCC/blob/main/SUPPORT.md).
 
@@ -292,6 +327,7 @@ MIT © Cemini — see [LICENSE](LICENSE).
 
 - Homebrew tap
 - Stabilize the DeepSeek harness adapter (experimental `--worker deepseek` since 0.1.8)
+- Stabilize the OpenCode adapter (`--worker opencode` since 0.1.10)
 - Codebase map injection (`--map`)
 - Cursor CLI `agent` as alternate supervisor
 - Web UI / CAO-style MCP supervisor

package/SECURITY.md

@@ -15,14 +15,15 @@ Do **not** open a public issue for credential leaks or RCE-class bugs.
 
 1. **No secrets in prompts or job files.** Do not paste API keys, SSH private keys, Discord tokens, or `.env` contents into `cursor-route start` / `send` prompts.
 2. **Free OpenRouter easy-lane models may log prompts.** `--lane easy` / `--worker openrouter` is for **non-secret** wording/drafts only. The refuse gate (`start` / `send`, plus the runner's re-check) applies to every lane — never send key-shaped material to the easy lane.
-3. **Always-approve is powerful.** Default headless workers skip interactive permission prompts (`--always-approve` / `--dangerously-skip-permissions`). Opt out with `--ask` / `CURSOR_ROUTE_ASK=1` when you need HITL.
-4. **Install from known channels only.** Prefer `npm i -g cursor-route` or a git clone of this repo. Do not pipe unknown `curl | bash` installers as the primary path.
-5. **Workers inherit your auth.** Grok CLI and Claude Code / claude-ds use *your* local login. Treat worker panes like you would treat your own shell.
-6. **No LIVE Discord / trading egress demos** from this tool. Orchestration is local.
+3. **OpenCode Zen free models may log or train during their free period.** `--worker opencode` defaults to `opencode/big-pickle`. Treat it like the easy lane for secrets. Prefer `opencode/x-preview-f-free` (Ox Alpha) when you need the zero-retention free option.
+4. **Always-approve is powerful.** Default headless workers skip interactive permission prompts (`--always-approve` / `--dangerously-skip-permissions` / OpenCode `--auto`). Opt out with `--ask` / `CURSOR_ROUTE_ASK=1` when you need HITL.
+5. **Install from known channels only.** Prefer `npm i -g cursor-route` or a git clone of this repo. Do not pipe unknown `curl | bash` installers as the primary path.
+6. **Workers inherit your auth.** Grok CLI, Claude Code / claude-ds, and OpenCode use *your* local login. Treat worker panes like you would treat your own shell.
+7. **No LIVE Discord / trading egress demos** from this tool. Orchestration is local.
 
 ## Supply chain
 
-- Declared runtime npm dependencies: **none**. System needs: Node ≥20 or Bun, `tmux`, worker CLIs (Grok / claude-ds), and an OpenRouter API key for the easy lane.
+- Declared runtime npm dependencies: **none**. System needs: Node ≥20 or Bun, `tmux`, worker CLIs (Grok / claude-ds / optional OpenCode), and an OpenRouter API key for the easy lane.
 - The npm package ships a compiled `dist/` (plain JS, no loader). The bin shim and the completion hook run the compiled JS via `node`; there is **no network fetch of `tsx` on the happy path**.
 - Running from a git clone without a build uses Bun to execute `src/` directly (Bun runs TypeScript natively) — also offline-friendly.
 - Review `package.json` before upgrading.

package/SUPPORT.md

@@ -6,9 +6,11 @@ Voluntary tips fund wikis, OSS tooling, and public research. **Donation-only add
 
 | Chain family | Address |
 |--------------|---------|
+| **X Money** (fiat, US) | Request [@Cemini23](https://x.com/Cemini23) in the X app — scan the Request QR |
 | **EVM** (Ethereum, Polygon, Base, Arbitrum, …) | `0x444C5C2eC439E0382aa5a17F70313c536BcC5D58` |
 | **Solana / SVM** | `J4zNn4hK9jTrKBFY8sbAGJHLoZvXvQf4B9pQSbSrocZE` |
 | **Polymarket** (referral) | [polymarket.com/?r=Cemini23](https://polymarket.com/?r=Cemini23) |
+| **Hyperliquid** (referral) | [app.hyperliquid.xyz/join/CEMINI23](https://app.hyperliquid.xyz/join/CEMINI23) |
 
 If you’d rather follow along or try something we ship:
 

package/dist/adapters/claude-ds.js

@@ -108,6 +108,24 @@ function resolveClaudeDs() {
     }
     return null;
 }
+/**
+ * Mid lane is proven DeepSeek only via shim (`claude-ds` / `deepseek-claude`)
+ * or stock `claude` routed to DeepSeek. The Anthropic escape hatch is not proof.
+ */
+export function isMidDeepSeekProven() {
+    const resolved = resolveClaudeDs();
+    if (!resolved)
+        return false;
+    return !resolved.mode.startsWith("claude → Anthropic");
+}
+/** Human detail for health `lane:mid` (mode when proven; install hint otherwise). */
+export function midDeepSeekProofDetail() {
+    const resolved = resolveClaudeDs();
+    if (!resolved || resolved.mode.startsWith("claude → Anthropic")) {
+        return "mid not proven DeepSeek — install claude-ds / set ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic. CURSOR_ROUTE_ALLOW_ANTHROPIC=1 is not proof.";
+    }
+    return `DeepSeek proven (${resolved.mode})`;
+}
 function pickModel(requested, modelId) {
     if (modelId) {
         const alias = requested ?? resolveDsModel(modelId).alias;

package/dist/adapters/index.js

@@ -2,11 +2,13 @@ import { grokAdapter } from "./grok.js";
 import { claudeDsAdapter } from "./claude-ds.js";
 import { openRouterAdapter } from "./openrouter.js";
 import { deepseekAdapter } from "./deepseek.js";
+import { opencodeAdapter } from "./opencode.js";
 const registry = {
     grok: grokAdapter,
     "claude-ds": claudeDsAdapter,
     openrouter: openRouterAdapter,
     deepseek: deepseekAdapter,
+    opencode: opencodeAdapter,
 };
 export function getAdapter(worker) {
     const a = registry[worker];

package/dist/adapters/opencode.js

@@ -0,0 +1,83 @@
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { shellQuote } from "../util.js";
+import { openCodeModel, OPENCODE_DEFAULT_MODEL } from "../config.js";
+/**
+ * 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() {
+    // 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 = {
+    kind: "opencode",
+    label: "OpenCode (free Zen / other models)",
+    health() {
+        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/dist/cli.js

@@ -1,26 +1,26 @@
 #!/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";
-import { config, WORKERS, LANES, resolveDsModel, } from "./config.js";
+import { config, WORKERS, LANES, resolveDsModel, openCodeModel, } from "./config.js";
 import { runHealth, printHealth } from "./health.js";
-import { startJob, listJobs, readJob, killJob, cleanJobs, jobPaths, refreshStatus, } from "./jobs.js";
+import { startJob, listJobs, readJob, killJob, cleanJobs, jobPaths, refreshStatus, jobEvidence, } from "./jobs.js";
 import { capturePane, sendKeys, attachHint, listManagedSessions, sessionExists, } from "./tmux.js";
 import { looksLikeSecretMaterial, redactSecrets } from "./secrets.js";
 function usage(exitCode = 0) {
     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>
@@ -29,9 +29,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
@@ -48,10 +48,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);
 }
@@ -150,6 +152,14 @@ function asDsModelChoice(v) {
         throw new Error(`Invalid --model; expected flash|pro`);
     return resolveDsModel(v);
 }
+function asOpenCodeModel(v) {
+    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, context) {
     if (looksLikeSecretMaterial(text)) {
         console.error(`Refusing ${context}: looks like secret key material. Remove tokens/keys and retry.`);
@@ -223,8 +233,8 @@ async function main() {
         const resolvedWorker = worker ?? (lane ? config.laneWorkers[lane] : config.defaultWorker);
         let model;
         let modelId;
-        // --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);
@@ -238,6 +248,15 @@ async function main() {
                 process.exit(2);
             }
         }
+        else if (f.model !== undefined && resolvedWorker === "opencode") {
+            try {
+                modelId = asOpenCodeModel(f.model);
+            }
+            catch (e) {
+                console.error(e.message);
+                process.exit(2);
+            }
+        }
         let prompt = "";
         if (promptFile) {
             const p = resolve(promptFile);
@@ -327,7 +346,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, " ")}`);
             }
         }
@@ -356,11 +375,13 @@ 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}`);
         }

package/dist/config.js

@@ -1,7 +1,7 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { defaultJobsDir } from "./runtime.js";
-export const WORKERS = ["grok", "claude-ds", "openrouter", "deepseek"];
+export const WORKERS = ["grok", "claude-ds", "openrouter", "deepseek", "opencode"];
 export const LANES = ["easy", "mid", "hard"];
 export const DS_MODELS = ["flash", "pro"];
 export const DS_MODEL_IDS = {
@@ -49,6 +49,33 @@ export function openRouterModel() {
 export function openRouterBaseUrl() {
     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) {
+    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) {
+    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() {
     const raw = process.env.CURSOR_ROUTE_MAX_JOBS;
     if (raw) {
@@ -65,7 +92,7 @@ function maxConcurrentJobsFromEnv() {
  */
 export const config = {
     product: "cursor-route",
-    version: "0.1.8",
+    version: "0.1.10",
     get jobsDir() {
         return defaultJobsDir();
     },
@@ -73,7 +100,7 @@ export const config = {
     defaultWorker: "grok",
     /**
      * 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",

package/dist/health.js

@@ -1,5 +1,6 @@
 import { execSync } from "node:child_process";
 import { allAdapters } from "./adapters/index.js";
+import { isMidDeepSeekProven, midDeepSeekProofDetail } from "./adapters/claude-ds.js";
 import { config } from "./config.js";
 import { isTmuxAvailable } from "./tmux.js";
 import { commandExists } from "./util.js";
@@ -42,6 +43,14 @@ export function runHealth() {
             detail: h.binary ? `${h.detail} @ ${h.binary}` : h.detail,
         });
     }
+    // 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") ||
         (commandExists("cursor-agent") && "cursor-agent") ||
@@ -78,6 +87,9 @@ export function runHealth() {
         product: config.product,
         version: config.version,
         checks,
+        lanes: {
+            mid: { worker: "claude-ds", deepseek: midOk, detail: midDetail },
+        },
     };
 }
 export function printHealth(report, asJson) {
@@ -95,6 +107,10 @@ export function printHealth(report, asJson) {
     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 ✓.");
     }
 }