cursor-route 0.1.9 → 0.1.10

package/CHANGELOG.md

@@ -4,6 +4,15 @@
 
 _(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.

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):
@@ -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
 
@@ -280,6 +313,7 @@ If you’d like to tip, use the **donation-only** addresses below (not trading o
 | **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).
 
@@ -293,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

@@ -10,6 +10,7 @@ Voluntary tips fund wikis, OSS tooling, and public research. **Donation-only add
 | **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/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,10 +1,10 @@
 #!/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, jobEvidence, } from "./jobs.js";
 import { capturePane, sendKeys, attachHint, listManagedSessions, sessionExists, } from "./tmux.js";
@@ -12,7 +12,7 @@ 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
@@ -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, " ")}`);
             }
         }

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.9",
+    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

@@ -107,7 +107,7 @@ 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("");

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";
@@ -245,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;
             }
@@ -267,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.9 (not published — this WorkDir only)
+npm: cursor-route@0.1.10 (unreleased — OpenCode worker)
 created: 2026-08-12
-updated: 2026-08-18
+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 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.9** once published. 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)
 
@@ -38,6 +39,7 @@ Install: `npm i -g cursor-route` → **0.1.9** once published. Release notes: [C
 - [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
 
@@ -50,6 +52,7 @@ Install: `npm i -g cursor-route` → **0.1.9** once published. Release notes: [C
 | `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 |
@@ -67,4 +70,5 @@ Install: `npm i -g cursor-route` → **0.1.9** once published. Release notes: [C
 | 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 (not published). |
+| 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/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.9**)
+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.9",
-  "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",