cursor-route 0.1.9 → 0.1.10

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,8 +14,8 @@ 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 → verify → Grok/claude-ds chain) is a different skill. This public skill only drives the `cursor-route` CLI.
@@ -59,6 +59,20 @@ 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. If targeting **mid**, require `lane:mid` ✓ (or health JSON `lanes.mid.deepseek`) before spawn — `CURSOR_ROUTE_ALLOW_ANTHROPIC=1` is not DeepSeek proof.
@@ -82,7 +96,7 @@ 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” (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.
@@ -111,6 +125,7 @@ Defaults on for workers. Opt out: `cursor-route start … --ask` or `CURSOR_ROUT
 
 - 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 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

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 });
+    }
+  });
+});

package/src/adapters/opencode.ts

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

package/src/adapters/types.ts

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

package/src/cli.test.ts

@@ -41,6 +41,9 @@ describe("resolveWorker", () => {
     expect(resolveWorker({ prompt: "x", lane: "mid", worker: "openrouter" })).toBe(
       "openrouter",
     );
+    expect(resolveWorker({ prompt: "x", lane: "mid", worker: "opencode" })).toBe(
+      "opencode",
+    );
   });
   test("default worker", () => {
     expect(resolveWorker({ prompt: "x" })).toBe(config.defaultWorker);
@@ -615,7 +618,7 @@ describe("health", () => {
   test("returns structured report", () => {
     const r = runHealth();
     expect(r.product).toBe("cursor-route");
-    expect(r.version).toBe("0.1.9");
+    expect(r.version).toBe("0.1.10");
     expect(r.checks.length).toBeGreaterThan(3);
     expect(r.checks.some((c) => c.name === "tmux")).toBe(true);
     expect(r.checks.some((c) => c.name === "cursor_cli")).toBe(true);
@@ -623,10 +626,32 @@ describe("health", () => {
     expect(mid).toBeDefined();
     expect(r.lanes.mid.worker).toBe("claude-ds");
     expect(r.lanes.mid.deepseek).toBe(mid!.ok);
+    expect(r.checks.some((c) => c.name === "worker:opencode")).toBe(true);
+    expect(r.checks.some((c) => c.name === "worker:deepseek")).toBe(true);
+  });
+
+  test("config version is 0.1.10", () => {
+    expect(config.version).toBe("0.1.10");
   });
 
-  test("config version is 0.1.9", () => {
-    expect(config.version).toBe("0.1.9");
+  test("OR-gate: ok can be true while worker:opencode is false", () => {
+    const prev = {
+      relaxed: process.env.CURSOR_ROUTE_RELAXED,
+      bin: process.env.CURSOR_ROUTE_OPENCODE_BIN,
+    };
+    process.env.CURSOR_ROUTE_RELAXED = "1";
+    process.env.CURSOR_ROUTE_OPENCODE_BIN = join(tmpdir(), `missing-oc-${process.pid}`);
+    try {
+      const r = runHealth();
+      const oc = r.checks.find((c) => c.name === "worker:opencode");
+      expect(oc?.ok).toBe(false);
+      expect(r.ok).toBe(true);
+    } finally {
+      if (prev.relaxed === undefined) delete process.env.CURSOR_ROUTE_RELAXED;
+      else process.env.CURSOR_ROUTE_RELAXED = prev.relaxed;
+      if (prev.bin === undefined) delete process.env.CURSOR_ROUTE_OPENCODE_BIN;
+      else process.env.CURSOR_ROUTE_OPENCODE_BIN = prev.bin;
+    }
   });
 
   test("OR-gate: ok can be true while worker:deepseek is false", () => {

package/src/cli.ts

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

package/src/config.ts

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

package/src/health.ts

@@ -133,7 +133,7 @@ export function printHealth(report: HealthReport, asJson: boolean): void {
   if (!report.ok) {
     console.log("");
     console.log("Fix the ✗ items, then re-run: cursor-route health");
-    console.log("Tip: start with one worker (grok OR claude-ds) before parallel demos.");
+    console.log("Tip: start with one worker (grok OR claude-ds OR opencode) before parallel demos.");
   } else if (report.checks.some((c) => c.name === "lane:mid" && !c.ok)) {
     console.log("");
     console.log(