cursor-route 0.1.9 → 0.1.11

package/CHANGELOG.md

@@ -4,6 +4,21 @@
 
 _(none)_
 
+## 0.1.11 — 2026-08-21
+
+- `--worker opencode --model free` now **ranks the live OpenCode Zen catalog** (`GET https://opencode.ai/zen/v1/models`, cached ~15 min) instead of hardcoding `opencode/big-pickle`. Ox Alpha (`opencode/x-preview-f-free`) wins while it is listed and free; coding `-free` models next; `big-pickle` last among non-contributor free. Fetch-fail fallback is Ox Alpha.
+- Pin with `--model provider/model` or `CURSOR_ROUTE_OPENCODE_MODEL`. Tests/CI: `CURSOR_ROUTE_ZEN_OFFLINE=1` or `CURSOR_ROUTE_ZEN_CATALOG_JSON` (health never fetches — cache or fallback only).
+- Mid stays `claude-ds`; easy stays OpenRouter chat. OpenCode is still opt-in, not a lane default.
+
+## 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 live Zen free pick (Ox Alpha while listed) |
 | 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,39 @@ 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
+live OpenCode Zen free models (`--model free` fetches the catalog and ranks,
+same idea as the OpenRouter free picker). Ox Alpha (`opencode/x-preview-f-free`)
+wins while it is listed and free. 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 pin (skips the live catalog pick):
+export CURSOR_ROUTE_OPENCODE_MODEL=opencode/hy3-free
+
+cursor-route health                              # worker:opencode should be ✓
+cursor-route start --worker opencode "…"         # live Zen free pick
+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`. `--model free` caches the ranked catalog
+for ~15 minutes (`CURSOR_ROUTE_ZEN_CACHE_MINUTES`).
+
+**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 +271,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 +283,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 live OpenCode Zen free models (`--model free` ranks the catalog).
 
 ## Related
 
@@ -280,6 +316,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 +330,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 --model free` picks from the live Zen catalog (Ox Alpha / `x-preview-f-free` currently ranks first and is zero-retention). Treat other free Zen models like the easy lane for secrets. Pin `CURSOR_ROUTE_OPENCODE_MODEL` when you need a specific id.
+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,78 @@
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { shellQuote } from "../util.js";
+import { openCodeModel, OPENCODE_DEFAULT_MODEL, cachedZenFreePick } from "../config.js";
+/**
+ * Opt-in OpenCode worker (`opencode run`) — a coding agent on live OpenCode
+ * Zen free models (`--model free` ranks the catalog; Ox Alpha wins while
+ * listed). 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.",
+            };
+        }
+        // Health stays offline: show a fresh cache hit, else the Ox Alpha fallback.
+        const pick = cachedZenFreePick() || OPENCODE_DEFAULT_MODEL;
+        return {
+            worker: "opencode",
+            ok: true,
+            binary,
+            detail: `ok (opencode run; --model free = live Zen pick, now ${pick}; 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 (live Zen catalog pick) 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 pin (unset or free = live Zen free pick); --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/x-preview-f-free) 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,7 @@ export function openRouterModel() {
 export function openRouterBaseUrl() {
     return process.env.OPENROUTER_BASE_URL || "https://openrouter.ai/api/v1";
 }
+export { OPENCODE_DEFAULT_MODEL, assertOpenCodeModel, openCodeModel, cachedZenFreePick, } from "./zen-free.js";
 function maxConcurrentJobsFromEnv() {
     const raw = process.env.CURSOR_ROUTE_MAX_JOBS;
     if (raw) {
@@ -65,7 +66,7 @@ function maxConcurrentJobsFromEnv() {
  */
 export const config = {
     product: "cursor-route",
-    version: "0.1.9",
+    version: "0.1.11",
     get jobsDir() {
         return defaultJobsDir();
     },
@@ -73,7 +74,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),
         });