cursor-route 0.1.8 → 0.1.10

package/dist/jobs.js

@@ -2,7 +2,7 @@ import { mkdirSync, writeFileSync, readFileSync, readdirSync, existsSync, unlink
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { dirname } from "node:path";
-import { config, sessionName, defaultDsModelFromEnv, DS_MODEL_IDS, } from "./config.js";
+import { config, sessionName, defaultDsModelFromEnv, DS_MODEL_IDS, openCodeModel, } from "./config.js";
 import { getAdapter } from "./adapters/index.js";
 import { spawn } from "node:child_process";
 import { spawnSync } from "node:child_process";
@@ -59,6 +59,29 @@ export function readJob(id) {
 export function writeJob(job) {
     writeSecure(jobPaths(job.id).json, JSON.stringify(job, null, 2));
 }
+export function jobEvidence(job, sessionAlive) {
+    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) {
     try {
         process.kill(pid, 0);
@@ -73,6 +96,9 @@ function pidAlive(pid) {
             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");
     }
@@ -219,14 +245,17 @@ export function startJob(opts) {
     writeSecure(paths.prompt, opts.prompt);
     let model;
     let modelId;
+    let dsAlias;
     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;
             }
@@ -241,13 +270,29 @@ export function startJob(opts) {
             }
         }
     }
+    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.message };
+        }
+    }
     let plan;
     try {
         plan = adapter.buildLaunch({
             promptFile: paths.prompt,
             cwd,
             alwaysApprove,
-            model,
+            model: dsAlias,
             modelId,
             dryRun: Boolean(opts.dryRun),
         });

package/docs/briefs/WORKING.md

@@ -1,9 +1,9 @@
 ---
 title: cursor-route workspace — working brief (edit in place)
 repo: ~/Projects/cursor-route
-npm: cursor-route@0.1.8 (LIVE on npm latest)
+npm: cursor-route@0.1.10 (unreleased — OpenCode worker)
 created: 2026-08-12
-updated: 2026-08-14
+updated: 2026-08-21
 ---
 
 # cursor-route — living brief
@@ -21,10 +21,11 @@ Cursor Agent plans. Workers run in tmux via `cursor-route`:
 | `easy` | OpenRouter free | Wording / drafts — non-secret prompts only |
 | `mid` | claude-ds (DeepSeek behind Claude Code) | Default implement (**Flash**; `--model pro` when needed) |
 | `hard` | Grok CLI | Hard implement |
+| opt-in | OpenCode | `--worker opencode` coding agent on Zen free models (default `opencode/big-pickle`) |
 
-Always-approve on (`--ask` / `CURSOR_ROUTE_ASK=1` to opt out). Jobs live in `~/.local/share/cursor-route/jobs`, not in this clone.
+Always-approve on for coding worktrees (`--ask` / `CURSOR_ROUTE_ASK=1` to opt out) — not LIVE Discord/trading. Jobs live in `~/.local/share/cursor-route/jobs`, not in this clone.
 
-Install: `npm i -g cursor-route` → **0.1.8**. Release notes: [CHANGELOG.md](../../CHANGELOG.md).
+Install: `npm i -g cursor-route` → **0.1.9** live; **0.1.10** unreleased (OpenCode worker). Release notes: [CHANGELOG.md](../../CHANGELOG.md).
 
 ## Open (edit / check off)
 
@@ -36,6 +37,9 @@ Install: `npm i -g cursor-route` → **0.1.8**. Release notes: [CHANGELOG.md](..
 - [x] **Official DeepSeek Harness** — `deepseek` adapter slot present; `@deepseek-ai/dsh` 0.1.0-rc.6 (2026-08-13, github.com/deepseek-ai/deepseek-harness, MIT) is a developer-preview plugin kernel (web UI + `dsh --profile headless "job"`), not a Claude Code replacement; mid does not swap
 - [x] **0.1.7 debug fixes** — env default wired through `startJob`; Anthropic hatch omits DS ids; preserve `[1m]`
 - [x] **Experimental `--worker deepseek`** — 0.1.8: real dsh adapter (`dsh --profile headless` + per-job Cordis patch pins the model; never writes `~/.dsh/settings.yaml`). Always-approve → `DSH_PERMISSION_MODE=danger-full-access`, `--ask` → `workspace-write`; key via env only. Health ✓ needs `dsh` + `DEEPSEEK_API_KEY` (override `CURSOR_ROUTE_DSH_BIN`). Mid stays **claude-ds**.
+- [x] **route-orch brief steals (2026-08-14)** — AutoDesign / misevolution / Vero habits into the public skill: **Verify / claim closeout** (external eval contract; activity ≠ verification), **Eval & skill hygiene** (mid-run Verify-rewrite ban; skill misevolution HITL — no auto-promotion of worker-trajectory variants; verify-fail → reconsider plan/definition + stage attribution spawn/execute/verify); handoff shape Success criteria + Verify + NEVER; skills synced; mid stays claude-ds.
+- [x] **Health proves mid DeepSeek + evidence tree** — 0.1.9: `lane:mid` ✓ only when DeepSeek is proven (shim or DeepSeek `ANTHROPIC_BASE_URL`; Anthropic hatch is not proof); health JSON `lanes.mid`; `status --json` evidence tree (`spawn` / `execute` / `verify.claim=unverified`); skill health-before-mid + evidence-tree closeout. Mid stays **claude-ds**.
+- [x] **Opt-in `--worker opencode`** — 0.1.10: `opencode run --dir` + `--model` (default Zen free `opencode/big-pickle` / `--model free`); always-approve → `--auto`; `--ask` omits it; never rewrites `~/.config/opencode/opencode.json`. Health ✓ needs `opencode` on PATH (`CURSOR_ROUTE_OPENCODE_BIN`). Mid stays **claude-ds**; easy stays OpenRouter chat. Free Zen may log/train — non-secret prompts.
 - [ ] **Hero GIF** — still outstanding; dry-run fixture ships as the substitute for now (`docs/fixtures/hero-demo.log` — see `docs/DEMO_GIF.md`)
 - [x] **Do not** paste private `ROUTE_KIT`, SIP, prod paths, or hang-watchdog env into this public repo
 
@@ -48,6 +52,7 @@ Install: `npm i -g cursor-route` → **0.1.8**. Release notes: [CHANGELOG.md](..
 | `src/adapters/deepseek.ts` | Experimental dsh worker (`--worker deepseek`; mid stays claude-ds) |
 | `src/adapters/grok.ts` | Hard worker |
 | `src/adapters/openrouter.ts` | Easy worker |
+| `src/adapters/opencode.ts` | Opt-in OpenCode worker (`--worker opencode`; mid stays claude-ds) |
 | `skills/route-orch/SKILL.md` | Cursor skill — spawn CLI, do not implement in-session |
 | `CHANGELOG.md` | Release notes |
 | `SECURITY.md` | Secret refuse gate |
@@ -64,3 +69,6 @@ Install: `npm i -g cursor-route` → **0.1.8**. Release notes: [CHANGELOG.md](..
 | 2026-08-13 | GPTSOL fixes: scrub inherited env/paths, stable job ids, ignore `docs/briefs/handoffs/`, GIF checkbox wording. |
 | 2026-08-14 | DeepSeek Harness eval: `@deepseek-ai/dsh` 0.1.0-rc.6 is a developer-preview plugin kernel, not a mid replacement; `--worker deepseek` stays unhealthy; mid remains claude-ds (docs-only, no version bump). |
 | 2026-08-14 | Experimental `--worker deepseek` wired to official dsh (headless + per-job patch + `DSH_PERMISSION_MODE` + key-via-env); `--model` applies to claude-ds + deepseek; mid stays claude-ds → 0.1.8 LIVE. |
+| 2026-08-14 | route-orch brief steals (AutoDesign / misevolution / Vero): **Verify / claim closeout** + **Eval & skill hygiene**; handoff Success criteria + Verify + NEVER; both skill copies synced; mid stays claude-ds. Docs-only, no version bump. |
+| 2026-08-18 | Health `lane:mid` + `lanes.mid` prove DeepSeek; status evidence tree (`verify.claim` stays unverified); skill health-before-mid + closeout tree; mid stays claude-ds → 0.1.9 LIVE. |
+| 2026-08-21 | Opt-in `--worker opencode` (Zen free `opencode/big-pickle`, `--auto`, no config rewrite); mid stays claude-ds → 0.1.10. |

package/docs/demo-notes.md

@@ -6,10 +6,10 @@ Simulated capture output for README / tweet assets — replace with a real GIF o
 
 ```
 $ cursor-route --version
-0.1.8
+0.1.9
 
 $ cursor-route health
-cursor-route v0.1.8
+cursor-route v0.1.9
 health: OK
   ✓ tmux
   ✓ runtime          bun ok
@@ -18,6 +18,7 @@ health: OK
   ✓ worker:claude-ds
   ✓ worker:openrouter
   ✗ worker:deepseek  dsh not found — mid default remains claude-ds
+  ✓ lane:mid         DeepSeek proven (claude-ds (DeepSeek shim))
   ✓ jobs_dir         ~/.local/share/cursor-route/jobs
 
 $ cursor-route start --lane mid "Add a failing test then make it pass"

package/docs/fixtures/hero-demo.log

@@ -1,8 +1,8 @@
 $ 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
 
   ✓ tmux             ok
@@ -12,6 +12,7 @@ health: OK
   ✓ worker:claude-ds ok (claude-ds (DeepSeek shim); default model deepseek-v4-flash) @ ~/.local/bin/claude-ds
   ✗ worker:openrouter OPENROUTER_API_KEY not set — export your OpenRouter key (easy lane model defaults to openrouter/free) @ node '~/Projects/cursor-route/dist/openrouter-run.js'
   ✗ worker:deepseek  dsh (@deepseek-ai/dsh) not found — install: npm i -g @deepseek-ai/dsh. Mid default remains claude-ds.
+  ✓ lane:mid         DeepSeek proven (claude-ds (DeepSeek shim))
   ✓ cursor_cli       optional ok (agent on PATH) — v0 supervisor is Cursor skill, not CLI
   ✓ relaxed          CURSOR_ROUTE_RELAXED=1 — tmux optional (headless OK)
   ✓ jobs_dir         ~/.local/share/cursor-route/jobs

package/llms.txt

@@ -1,14 +1,14 @@
 # cursor-route
 
-> Cursor stays the planner. DeepSeek (mid), Grok CLI (hard), and OpenRouter free models (easy) run parallel coding workers in tmux.
+> Cursor stays the planner. DeepSeek (mid), Grok CLI (hard), and OpenRouter free models (easy) run parallel coding workers in tmux. `--worker opencode` is an opt-in coding agent on OpenCode Zen free models.
 
-MIT CLI + Cursor skill. npm: https://www.npmjs.com/package/cursor-route (latest **0.1.8**)
+MIT CLI + Cursor skill. npm: https://www.npmjs.com/package/cursor-route (latest **0.1.10**)
 GitHub: https://github.com/cemini23/cursor-route
 
 ## 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 (wording/drafts, non-secret prompts only).
+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 (wording/drafts, non-secret prompts only). `--worker opencode` is an opt-in coding agent (default `opencode/big-pickle`) — not a lane default.
 
 ### 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.
@@ -22,15 +22,19 @@ No. The mid worker is DeepSeek. Claude Code is the harness, configured with `ANT
 | `--model flash` (default) | `deepseek-v4-flash` | Cheap mid execute |
 | `--model pro` | `deepseek-v4-pro` | Harder mid / Grok usage stand-in |
 
+### How do I use OpenCode free models?
+Install OpenCode (`npm i -g opencode-ai`), run `opencode auth login`, then `cursor-route start --worker opencode "…"`. Default model is `opencode/big-pickle` (`--model free`). Mid stays `claude-ds`.
+
 ### How do I install?
 Run `npm i -g cursor-route`, install tmux if needed, then run `cursor-route health`. Copy the Cursor skill from `$(npm root -g)/cursor-route/skills/route-orch`. Source: 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 use OpenCode Zen free models.
 
 ## Install
 
 - npm: `npm i -g cursor-route`
 - Health: `cursor-route health`
 - Mid: `cursor-route start --lane mid "…"` (Flash) · `--model pro` when needed
+- OpenCode (opt-in): `cursor-route start --worker opencode "…"`
 - Skill: `/route-orch` (Cursor)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cursor-route",
-  "version": "0.1.8",
-  "description": "Cursor stays the brain. Grok CLI + DeepSeek (claude-ds) + OpenRouter easy lane are the parallel army \u2014 lane-aware /route orchestration in tmux.",
+  "version": "0.1.10",
+  "description": "Cursor stays the brain. Grok CLI + DeepSeek (claude-ds) + OpenRouter easy lane + OpenCode (opt-in free) are the parallel army \u2014 lane-aware /route orchestration in tmux.",
   "type": "module",
   "license": "MIT",
   "bin": {
@@ -41,6 +41,7 @@
     "deepseek",
     "claude-ds",
     "openrouter",
+    "opencode",
     "tmux",
     "orchestrator",
     "agents",

package/skills/route-orch/SKILL.md

@@ -2,10 +2,10 @@
 name: route-orch
 description: >-
   Delegate coding work from Cursor to parallel Grok CLI / claude-ds (DeepSeek) /
-  OpenRouter (easy lane) workers via cursor-route. Use when the user says
-  /route-orch, spawn workers, parallel agents with cursor-route, or explicitly
-  asks to outsource implementation to Grok/DeepSeek panes — not for private
-  Cemini /route.
+  OpenRouter (easy lane) / OpenCode (opt-in free) workers via cursor-route. Use
+  when the user says /route-orch, spawn workers, parallel agents with
+  cursor-route, or explicitly asks to outsource implementation to
+  Grok/DeepSeek/OpenCode panes — not for private Cemini /route.
 ---
 
 # route-orch (cursor-route)
@@ -14,11 +14,11 @@ You are the **orchestrator**. Do **not** implement bulk code in this Cursor sess
 
 ## When to activate
 
-- User says `/route-orch`, `spawn workers`, or asks for parallel Grok/DeepSeek via **cursor-route**
-- Mid/hard implementation that should run on a subscription worker (Grok CLI / claude-ds)
+- User says `/route-orch`, `spawn workers`, or asks for parallel Grok/DeepSeek/OpenCode via **cursor-route**
+- Mid/hard implementation that should run on a subscription worker (Grok CLI / claude-ds) or opt-in OpenCode free models
 - Multi-file investigation that benefits from parallel panes
 
-**Do not steal federation `/route`.** Private Cemini `/route` (route-task → SIP → verify → Grok/claude-ds chain) is a different skill. This public skill only drives the `cursor-route` CLI.
+**Do not steal federation `/route`.** Private Cemini `/route` (route-task → verify → Grok/claude-ds chain) is a different skill. This public skill only drives the `cursor-route` CLI.
 
 ## Lanes (public core)
 
@@ -59,10 +59,24 @@ cursor-route start --worker deepseek --model pro --dir "$PWD" "…"   # --model
 
 Health ✓ needs `dsh` on PATH and `DEEPSEEK_API_KEY` set. The adapter pins `--model` via a per-job `--patch` (never touches `~/.dsh/settings.yaml`); always-approve → `DSH_PERMISSION_MODE=danger-full-access`, `--ask` → `workspace-write`. The key never enters the command or patch.
 
+## Experimental: --worker opencode (free Zen)
+
+OpenCode as an opt-in **coding agent** on OpenCode Zen free models — **not a lane default** (mid stays `claude-ds`; easy stays OpenRouter chat). Use this to cut Grok / DeepSeek usage on implement work.
+
+```bash
+npm i -g opencode-ai
+opencode auth login
+cursor-route start --worker opencode --dir "$PWD" "…"
+cursor-route start --worker opencode --model free --dir "$PWD" "…"
+cursor-route start --worker opencode --model opencode/hy3-free --dir "$PWD" "…"
+```
+
+Health ✓ needs `opencode` on PATH (override `CURSOR_ROUTE_OPENCODE_BIN`). Default model is `opencode/big-pickle` (`CURSOR_ROUTE_OPENCODE_MODEL` / `--model free`). Always-approve → `opencode run --auto`; `--ask` omits `--auto`. Never rewrites `~/.config/opencode/opencode.json`. Free Zen models may log/train — keep secrets off this worker (same refuse gate as easy).
+
 ## Workflow
 
-1. Run `cursor-route health` (or `CURSOR_ROUTE_RELAXED=1` for headless). If the **target worker** is unhealthy, fix before spawning.
-2. Write a clear handoff prompt with **verify criteria** (no secrets, no LIVE Discord).
+1. Run `cursor-route health` (or `CURSOR_ROUTE_RELAXED=1` for headless). If the **target worker** is unhealthy, fix before spawning. If targeting **mid**, require `lane:mid` ✓ (or health JSON `lanes.mid.deepseek`) before spawn — `CURSOR_ROUTE_ALLOW_ANTHROPIC=1` is not DeepSeek proof.
+2. Write a clear handoff prompt with **Success criteria** + **Verify** + **NEVER** (no secrets, no LIVE Discord).
 3. Spawn:
 
 ```bash
@@ -70,24 +84,49 @@ cursor-route start --lane hard --dir "$PWD" "$(cat <<'EOF'
 ## Task
 ...
 
+## Success criteria
+- [ ] ...
+
 ## Verify
 - [ ] ...
+
+## NEVER
+- ...
 EOF
 )"
 ```
 
-Or `--worker grok` / `--worker claude-ds` / `--worker deepseek` (experimental) / `--worker openrouter` (or `--lane easy`). Use `--no-tmux` only when tmux is unavailable.
+Or `--worker grok` / `--worker claude-ds` / `--worker deepseek` (experimental) / `--worker opencode` (opt-in free) / `--worker openrouter` (or `--lane easy`). Use `--no-tmux` only when tmux is unavailable.
 
 4. Monitor: `cursor-route jobs --json` · `cursor-route capture <id>` · `cursor-route send <id> "…"` (tmux only).
-5. Summarize worker results with **verify evidence** — no status-only “done”. If verify fails, `send` a correction or spawn a follow-up — do not invent success.
+5. Summarize worker results with **verify evidence** — no status-only “done” (see Verify / claim closeout). If verify fails, reconsider the plan/definition (not only retry) — `send` a correction or spawn a follow-up; do not invent success.
+
+## Verify / claim closeout
+
+Verify criteria are an **external eval contract** (AutoDesign pattern), fixed by the parent — not a checklist the worker may rewrite:
+
+- Workers must **not rewrite Success criteria / Verify** to claim done
+- Parent closeout is an **evidence tree**: report **spawn** (job id, worker, lane, model) + **execute** (status, exit) + **verify** (`capture` excerpt / exit). A single “done” scalar is not enough.
+- Parent closes a job only on **capture / exit evidence** (`cursor-route capture <id>`, job exit status)
+- `cursor-route status --json` `.evidence.verify.claim` stays `"unverified"` until the parent reads capture
+- **activity ≠ verification** — busy panes, many tool calls, or long transcripts do not make a claim true
+
+## Eval & skill hygiene
+
+- **External eval contract (AutoDesign):** do not rewrite Verify / Success criteria mid-run to make a failing job look green — capture + exit status are the contract (see Verify / claim closeout).
+- **Skill misevolution:** do not auto-edit `route-orch` or promote skill variants from worker trajectories without operator HITL — write-time approval ≠ safe retrieval later.
+- **On verify fail:** prefer reconsidering the plan/definition (wrong approach) over grinding the same tactic; attribute failure to stage when possible (spawn vs execute vs verify).
 
 ## Always-approve
 
-Defaults on for workers. Opt out: `cursor-route start … --ask` or `CURSOR_ROUTE_ASK=1`.
+Defaults on for workers. Opt out: `cursor-route start … --ask` or `CURSOR_ROUTE_ASK=1`. Always-approve is for **coding worktrees only** — it does not authorize LIVE Discord, trading, or irreversible SaaS.
 
 ## Anti-patterns
 
 - Do not paste API keys / private keys into prompts or `send`
-- Do not claim the official DeepSeek harness (`@deepseek-ai/dsh`) is the mid default — `--worker deepseek` is experimental only; mid stays **claude-ds**
-- Do not open-source or dump private Cemini `agent-toolkit` paths into public handoffs
+- Do not claim the official DeepSeek harness (`@deepseek-ai/dsh`) is the mid default — `--worker deepseek` is an opt-in experiment (cheap to abandon), not a product fork; mid stays **claude-ds**
+- Do not claim OpenCode is the mid default — `--worker opencode` is opt-in for free Zen (or other) models; mid stays **claude-ds**
+- Do not fork a second mid harness
+- Do not open-source or dump private cemini `agent-toolkit` paths into public handoffs
 - Do not mark done without reading `capture` / exit status
+- When editing this skill itself, treat changes as **skill-evolution** — do not auto-promote harmful instructions; prefer **HITL** (no unattended promote from worker trajectories)

package/src/adapters/claude-ds.ts

@@ -124,6 +124,25 @@ function resolveClaudeDs(): { binary: string; mode: string } | null {
   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(): boolean {
+  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(): string {
+  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?: DsModelAlias, modelId?: string): { alias: DsModelAlias; id: string } {
   if (modelId) {
     const alias = requested ?? resolveDsModel(modelId).alias;

package/src/adapters/index.ts

@@ -4,12 +4,14 @@ import { grokAdapter } from "./grok.ts";
 import { claudeDsAdapter } from "./claude-ds.ts";
 import { openRouterAdapter } from "./openrouter.ts";
 import { deepseekAdapter } from "./deepseek.ts";
+import { opencodeAdapter } from "./opencode.ts";
 
 const registry: Record<WorkerKind, Adapter> = {
   grok: grokAdapter,
   "claude-ds": claudeDsAdapter,
   openrouter: openRouterAdapter,
   deepseek: deepseekAdapter,
+  opencode: opencodeAdapter,
 };
 
 export function getAdapter(worker: WorkerKind): Adapter {

package/src/adapters/opencode.test.ts

@@ -0,0 +1,238 @@
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, writeFileSync, chmodSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { opencodeAdapter } from "./opencode.ts";
+import { startJob } from "../jobs.ts";
+import {
+  openCodeModel,
+  assertOpenCodeModel,
+  OPENCODE_DEFAULT_MODEL,
+} from "../config.ts";
+
+describe("openCodeModel", () => {
+  test("defaults to OpenCode Zen Big Pickle", () => {
+    const prev = process.env.CURSOR_ROUTE_OPENCODE_MODEL;
+    delete process.env.CURSOR_ROUTE_OPENCODE_MODEL;
+    try {
+      expect(openCodeModel()).toBe("opencode/big-pickle");
+      expect(openCodeModel("")).toBe(OPENCODE_DEFAULT_MODEL);
+      expect(openCodeModel("free")).toBe("opencode/big-pickle");
+    } finally {
+      if (prev === undefined) delete process.env.CURSOR_ROUTE_OPENCODE_MODEL;
+      else process.env.CURSOR_ROUTE_OPENCODE_MODEL = prev;
+    }
+  });
+
+  test("env override wins for empty/free", () => {
+    const prev = process.env.CURSOR_ROUTE_OPENCODE_MODEL;
+    process.env.CURSOR_ROUTE_OPENCODE_MODEL = "opencode/hy3-free";
+    try {
+      expect(openCodeModel()).toBe("opencode/hy3-free");
+      expect(openCodeModel("free")).toBe("opencode/hy3-free");
+    } finally {
+      if (prev === undefined) delete process.env.CURSOR_ROUTE_OPENCODE_MODEL;
+      else process.env.CURSOR_ROUTE_OPENCODE_MODEL = prev;
+    }
+  });
+
+  test("explicit provider/model wins over env", () => {
+    const prev = process.env.CURSOR_ROUTE_OPENCODE_MODEL;
+    process.env.CURSOR_ROUTE_OPENCODE_MODEL = "opencode/hy3-free";
+    try {
+      expect(openCodeModel("opencode/mimo-v2.5-free")).toBe("opencode/mimo-v2.5-free");
+    } finally {
+      if (prev === undefined) delete process.env.CURSOR_ROUTE_OPENCODE_MODEL;
+      else process.env.CURSOR_ROUTE_OPENCODE_MODEL = prev;
+    }
+  });
+
+  test("accepts OpenRouter-style extra slash and :free", () => {
+    expect(assertOpenCodeModel("openrouter/qwen/qwen3-coder:free")).toBe(
+      "openrouter/qwen/qwen3-coder:free",
+    );
+  });
+
+  test("rejects injection / flash|pro aliases", () => {
+    expect(() => openCodeModel("flash")).toThrow(/provider\/model/);
+    expect(() => openCodeModel("x\n--evil")).toThrow(/provider\/model/);
+    expect(() => openCodeModel("opencode/big pickle")).toThrow(/provider\/model/);
+  });
+});
+
+describe("opencode adapter", () => {
+  const makeFake = (suffix: string) => {
+    const dir = join(tmpdir(), `cr-oc-${process.pid}-${suffix}`);
+    mkdirSync(dir, { recursive: true });
+    const bin = join(dir, "opencode");
+    writeFileSync(bin, "#!/bin/sh\necho fake-opencode\n");
+    chmodSync(bin, 0o755);
+    return { dir, bin };
+  };
+
+  const withEnv = (patch: Record<string, string | undefined>, fn: () => void) => {
+    const prev = new Map<string, string | undefined>();
+    for (const k of Object.keys(patch)) {
+      prev.set(k, process.env[k]);
+      const v = patch[k];
+      if (v === undefined) delete process.env[k];
+      else process.env[k] = v;
+    }
+    try {
+      fn();
+    } finally {
+      for (const [k, v] of prev) {
+        if (v === undefined) delete process.env[k];
+        else process.env[k] = v;
+      }
+    }
+  };
+
+  test("health: no binary → not ok, install hint names npm package", () => {
+    withEnv(
+      { CURSOR_ROUTE_OPENCODE_BIN: join(tmpdir(), `missing-oc-${process.pid}`) },
+      () => {
+        const h = opencodeAdapter.health();
+        expect(h.ok).toBe(false);
+        expect(h.detail).toMatch(/npm i -g opencode-ai/);
+      },
+    );
+  });
+
+  test("health: binary → ok (auth at first start)", () => {
+    const { bin } = makeFake("ok");
+    withEnv({ CURSOR_ROUTE_OPENCODE_BIN: bin }, () => {
+      const h = opencodeAdapter.health();
+      expect(h.ok).toBe(true);
+      expect(h.binary).toBe(bin);
+      expect(h.detail).toContain("opencode/big-pickle");
+    });
+    rmSync(join(tmpdir(), `cr-oc-${process.pid}-ok`), { recursive: true, force: true });
+  });
+
+  test("buildLaunch: default free model + --auto; prompt via cat", () => {
+    const { dir, bin } = makeFake("launch");
+    const promptFile = join(dir, "job.prompt");
+    writeFileSync(promptFile, "ping");
+    withEnv(
+      {
+        CURSOR_ROUTE_OPENCODE_BIN: bin,
+        CURSOR_ROUTE_OPENCODE_MODEL: undefined,
+        CURSOR_ROUTE_ASK: undefined,
+      },
+      () => {
+        const plan = opencodeAdapter.buildLaunch({
+          promptFile,
+          cwd: dir,
+          alwaysApprove: true,
+        });
+        expect(plan.command).toContain("run");
+        expect(plan.command).toContain("--auto");
+        expect(plan.command).toContain("opencode/big-pickle");
+        expect(plan.command).toContain("$(cat");
+        expect(plan.command).toContain("--dir");
+        expect(plan.alwaysApprove).toBe(true);
+        expect(plan.command).not.toContain("npx");
+      },
+    );
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("buildLaunch: alwaysApprove false (--ask) omits --auto", () => {
+    const { dir, bin } = makeFake("ask");
+    const promptFile = join(dir, "job.prompt");
+    writeFileSync(promptFile, "ping");
+    withEnv({ CURSOR_ROUTE_OPENCODE_BIN: bin }, () => {
+      const plan = opencodeAdapter.buildLaunch({
+        promptFile,
+        cwd: dir,
+        alwaysApprove: false,
+        modelId: "opencode/hy3-free",
+      });
+      expect(plan.command).toContain("opencode/hy3-free");
+      expect(plan.command).not.toContain("--auto");
+      expect(plan.alwaysApprove).toBe(false);
+    });
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("buildLaunch: CURSOR_ROUTE_ASK=1 opts out even when alwaysApprove true", () => {
+    const { dir, bin } = makeFake("ask-env");
+    const promptFile = join(dir, "job.prompt");
+    writeFileSync(promptFile, "ping");
+    withEnv({ CURSOR_ROUTE_OPENCODE_BIN: bin, CURSOR_ROUTE_ASK: "1" }, () => {
+      const plan = opencodeAdapter.buildLaunch({
+        promptFile,
+        cwd: dir,
+        alwaysApprove: true,
+      });
+      expect(plan.command).not.toContain("--auto");
+      expect(plan.alwaysApprove).toBe(false);
+    });
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("buildLaunch: missing binary falls back to plain `opencode` for dry-run", () => {
+    const { dir } = makeFake("nobin");
+    const promptFile = join(dir, "job.prompt");
+    writeFileSync(promptFile, "ping");
+    const empty = join(dir, "empty");
+    mkdirSync(empty, { recursive: true });
+    withEnv(
+      {
+        CURSOR_ROUTE_OPENCODE_BIN: undefined,
+        PATH: empty,
+        CURSOR_ROUTE_OPENCODE_MODEL: undefined,
+      },
+      () => {
+        const plan = opencodeAdapter.buildLaunch({
+          promptFile,
+          cwd: dir,
+          alwaysApprove: true,
+          dryRun: true,
+        });
+        expect(plan.command).toContain("'opencode' run");
+        expect(plan.command).toContain("--auto");
+      },
+    );
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  test("--worker opencode dry-run succeeds with fake binary", () => {
+    const dir = join(tmpdir(), `cr-oc-start-${process.pid}`);
+    mkdirSync(dir, { recursive: true });
+    const bin = join(dir, "opencode");
+    writeFileSync(bin, "#!/bin/sh\necho fake-opencode\n");
+    chmodSync(bin, 0o755);
+    const prev = {
+      bin: process.env.CURSOR_ROUTE_OPENCODE_BIN,
+      model: process.env.CURSOR_ROUTE_OPENCODE_MODEL,
+      jobs: process.env.CURSOR_ROUTE_JOBS_DIR,
+    };
+    process.env.CURSOR_ROUTE_OPENCODE_BIN = bin;
+    delete process.env.CURSOR_ROUTE_OPENCODE_MODEL;
+    process.env.CURSOR_ROUTE_JOBS_DIR = join(dir, "jobs");
+    try {
+      const result = startJob({
+        prompt: "ping",
+        worker: "opencode",
+        dryRun: true,
+      });
+      expect(result.ok).toBe(true);
+      if (!result.ok) return;
+      expect(result.job.worker).toBe("opencode");
+      expect(result.job.model).toBe("opencode/big-pickle");
+      expect(result.command).toContain("run");
+      expect(result.command).toContain("--auto");
+      expect(result.command).toContain("$(cat");
+    } finally {
+      if (prev.bin === undefined) delete process.env.CURSOR_ROUTE_OPENCODE_BIN;
+      else process.env.CURSOR_ROUTE_OPENCODE_BIN = prev.bin;
+      if (prev.model === undefined) delete process.env.CURSOR_ROUTE_OPENCODE_MODEL;
+      else process.env.CURSOR_ROUTE_OPENCODE_MODEL = prev.model;
+      if (prev.jobs === undefined) delete process.env.CURSOR_ROUTE_JOBS_DIR;
+      else process.env.CURSOR_ROUTE_JOBS_DIR = prev.jobs;
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});