cursor-route 0.1.9 → 0.1.11

package/src/adapters/opencode.test.ts

@@ -0,0 +1,297 @@
+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 live Zen pick (Ox Alpha fallback when offline)", () => {
+    const prev = {
+      model: process.env.CURSOR_ROUTE_OPENCODE_MODEL,
+      offline: process.env.CURSOR_ROUTE_ZEN_OFFLINE,
+      cache: process.env.CURSOR_ROUTE_ZEN_CACHE_PATH,
+      json: process.env.CURSOR_ROUTE_ZEN_CATALOG_JSON,
+      refresh: process.env.CURSOR_ROUTE_ZEN_REFRESH,
+    };
+    const cache = join(tmpdir(), `cr-oc-model-${process.pid}.json`);
+    delete process.env.CURSOR_ROUTE_OPENCODE_MODEL;
+    delete process.env.CURSOR_ROUTE_ZEN_CATALOG_JSON;
+    process.env.CURSOR_ROUTE_ZEN_OFFLINE = "1";
+    process.env.CURSOR_ROUTE_ZEN_CACHE_PATH = cache;
+    process.env.CURSOR_ROUTE_ZEN_REFRESH = "1";
+    try {
+      expect(openCodeModel()).toBe("opencode/x-preview-f-free");
+      expect(openCodeModel("")).toBe(OPENCODE_DEFAULT_MODEL);
+      expect(openCodeModel("free")).toBe("opencode/x-preview-f-free");
+    } finally {
+      if (prev.model === undefined) delete process.env.CURSOR_ROUTE_OPENCODE_MODEL;
+      else process.env.CURSOR_ROUTE_OPENCODE_MODEL = prev.model;
+      if (prev.offline === undefined) delete process.env.CURSOR_ROUTE_ZEN_OFFLINE;
+      else process.env.CURSOR_ROUTE_ZEN_OFFLINE = prev.offline;
+      if (prev.cache === undefined) delete process.env.CURSOR_ROUTE_ZEN_CACHE_PATH;
+      else process.env.CURSOR_ROUTE_ZEN_CACHE_PATH = prev.cache;
+      if (prev.json === undefined) delete process.env.CURSOR_ROUTE_ZEN_CATALOG_JSON;
+      else process.env.CURSOR_ROUTE_ZEN_CATALOG_JSON = prev.json;
+      if (prev.refresh === undefined) delete process.env.CURSOR_ROUTE_ZEN_REFRESH;
+      else process.env.CURSOR_ROUTE_ZEN_REFRESH = prev.refresh;
+      rmSync(cache, { force: true });
+    }
+  });
+
+  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 { dir, bin } = makeFake("ok");
+    withEnv(
+      {
+        CURSOR_ROUTE_OPENCODE_BIN: bin,
+        CURSOR_ROUTE_ZEN_CACHE_PATH: join(dir, "missing-cache.json"),
+      },
+      () => {
+        const h = opencodeAdapter.health();
+        expect(h.ok).toBe(true);
+        expect(h.binary).toBe(bin);
+        expect(h.detail).toContain("live Zen pick");
+        expect(h.detail).toContain("opencode/x-preview-f-free");
+      },
+    );
+    rmSync(dir, { 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,
+        CURSOR_ROUTE_ZEN_OFFLINE: "1",
+        CURSOR_ROUTE_ZEN_CACHE_PATH: join(dir, "zen-cache.json"),
+        CURSOR_ROUTE_ZEN_REFRESH: "1",
+        CURSOR_ROUTE_ZEN_CATALOG_JSON: 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/x-preview-f-free");
+        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",
+        CURSOR_ROUTE_ZEN_OFFLINE: "1",
+        CURSOR_ROUTE_ZEN_CACHE_PATH: join(dir, "zen-cache.json"),
+        CURSOR_ROUTE_ZEN_REFRESH: "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,
+        CURSOR_ROUTE_ZEN_OFFLINE: "1",
+        CURSOR_ROUTE_ZEN_CACHE_PATH: join(dir, "zen-cache.json"),
+        CURSOR_ROUTE_ZEN_REFRESH: "1",
+      },
+      () => {
+        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,
+      offline: process.env.CURSOR_ROUTE_ZEN_OFFLINE,
+      cache: process.env.CURSOR_ROUTE_ZEN_CACHE_PATH,
+      refresh: process.env.CURSOR_ROUTE_ZEN_REFRESH,
+      json: process.env.CURSOR_ROUTE_ZEN_CATALOG_JSON,
+    };
+    process.env.CURSOR_ROUTE_OPENCODE_BIN = bin;
+    delete process.env.CURSOR_ROUTE_OPENCODE_MODEL;
+    delete process.env.CURSOR_ROUTE_ZEN_CATALOG_JSON;
+    process.env.CURSOR_ROUTE_JOBS_DIR = join(dir, "jobs");
+    process.env.CURSOR_ROUTE_ZEN_OFFLINE = "1";
+    process.env.CURSOR_ROUTE_ZEN_CACHE_PATH = join(dir, "zen-cache.json");
+    process.env.CURSOR_ROUTE_ZEN_REFRESH = "1";
+    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/x-preview-f-free");
+      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;
+      if (prev.offline === undefined) delete process.env.CURSOR_ROUTE_ZEN_OFFLINE;
+      else process.env.CURSOR_ROUTE_ZEN_OFFLINE = prev.offline;
+      if (prev.cache === undefined) delete process.env.CURSOR_ROUTE_ZEN_CACHE_PATH;
+      else process.env.CURSOR_ROUTE_ZEN_CACHE_PATH = prev.cache;
+      if (prev.refresh === undefined) delete process.env.CURSOR_ROUTE_ZEN_REFRESH;
+      else process.env.CURSOR_ROUTE_ZEN_REFRESH = prev.refresh;
+      if (prev.json === undefined) delete process.env.CURSOR_ROUTE_ZEN_CATALOG_JSON;
+      else process.env.CURSOR_ROUTE_ZEN_CATALOG_JSON = prev.json;
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/adapters/opencode.ts

@@ -0,0 +1,85 @@
+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, cachedZenFreePick } from "../config.ts";
+
+/**
+ * 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(): 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.",
+      };
+    }
+    // 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/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.11");
     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.11", () => {
+    expect(config.version).toBe("0.1.11");
   });
 
-  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 (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
@@ -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 pin (unset or free = live Zen free pick); --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/x-preview-f-free) 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,13 @@ export function openRouterBaseUrl(): string {
   return process.env.OPENROUTER_BASE_URL || "https://openrouter.ai/api/v1";
 }
 
+export {
+  OPENCODE_DEFAULT_MODEL,
+  assertOpenCodeModel,
+  openCodeModel,
+  cachedZenFreePick,
+} from "./zen-free.ts";
+
 function maxConcurrentJobsFromEnv(): number {
   const raw = process.env.CURSOR_ROUTE_MAX_JOBS;
   if (raw) {
@@ -89,7 +97,7 @@ function maxConcurrentJobsFromEnv(): number {
  */
 export const config = {
   product: "cursor-route",
-  version: "0.1.9",
+  version: "0.1.11",
   get jobsDir(): string {
     return defaultJobsDir();
   },
@@ -97,7 +105,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(