cursor-route 0.1.9 → 0.1.11

package/dist/zen-free.js

@@ -0,0 +1,237 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+/**
+ * Live OpenCode Zen free-model pick — same idea as agent-toolkit
+ * `select-openrouter-free-model.ps1`: probe the catalog, keep $0 text/coding
+ * models, rank, cache ~15 min. Hardcoded ids are fallback only.
+ *
+ * Catalog: GET https://opencode.ai/zen/v1/models (no key). Zen ids are
+ * `big-pickle` / `x-preview-f-free`; the CLI wants `opencode/<id>`.
+ */
+export const ZEN_MODELS_URL_DEFAULT = "https://opencode.ai/zen/v1/models";
+/** Offline / fetch-fail fallback — Ox Alpha (zero-retention, currently top-tier free). */
+export const OPENCODE_DEFAULT_MODEL = "opencode/x-preview-f-free";
+const EXCLUDE_RE = /lyria|whisper|tts|embed|embedding|image|vision-only|audio|diffusion|flux|stable-diffusion|moderation/i;
+const CODING_RE = /coder|instruct|chat|laguna|nemotron|glm|qwen|kimi|deepseek|mimo|hy3|gpt-oss|north|gemma/i;
+const OX_ALPHA_RE = /x-preview|ox-alpha|oxalpha/i;
+const CONTRIBUTOR_RE = /contributor-free/i;
+function zenModelsUrl() {
+    return (process.env.CURSOR_ROUTE_ZEN_MODELS_URL || ZEN_MODELS_URL_DEFAULT).trim();
+}
+function cacheMinutes() {
+    const n = Number(process.env.CURSOR_ROUTE_ZEN_CACHE_MINUTES);
+    return Number.isFinite(n) && n > 0 ? n : 15;
+}
+function cachePath() {
+    return process.env.CURSOR_ROUTE_ZEN_CACHE_PATH?.trim() ||
+        join(tmpdir(), "cursor-route-zen-best-free.json");
+}
+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/x-preview-f-free) or free`);
+    }
+    return id;
+}
+/** Prefix a Zen catalog id (`x-preview-f-free`) for `opencode run --model`. */
+export function asOpenCodeZenId(raw) {
+    const id = raw.trim();
+    if (!id)
+        throw new Error("empty Zen model id");
+    return id.includes("/") ? assertOpenCodeModel(id) : assertOpenCodeModel(`opencode/${id}`);
+}
+function num(v) {
+    if (typeof v === "number" && Number.isFinite(v))
+        return v;
+    if (typeof v === "string" && v.trim()) {
+        const n = Number(v);
+        if (Number.isFinite(n))
+            return n;
+    }
+    return NaN;
+}
+export function isZenFreeModel(m) {
+    const id = (m.id || "").trim();
+    if (!id)
+        return false;
+    if (EXCLUDE_RE.test(id) || EXCLUDE_RE.test(m.name || ""))
+        return false;
+    const prompt = num(m.pricing?.prompt);
+    const completion = num(m.pricing?.completion);
+    const pricedFree = prompt === 0 && completion === 0;
+    const tagged = id.endsWith("-free") ||
+        id.endsWith(":free") ||
+        /(^|\/)big-pickle$/i.test(id);
+    return tagged || pricedFree;
+}
+/** Higher boost wins. Ox Alpha first while it is in the free catalog. */
+export function zenFreeBoost(id) {
+    const s = id.toLowerCase();
+    if (OX_ALPHA_RE.test(s))
+        return 40;
+    if (CONTRIBUTOR_RE.test(s))
+        return 1;
+    if (CODING_RE.test(s))
+        return 20;
+    if (s.endsWith("-free") || s.endsWith(":free"))
+        return 10;
+    if (/(^|\/)big-pickle$/.test(s))
+        return 5;
+    return 0;
+}
+export function rankZenFreeModels(models) {
+    const out = [];
+    for (const m of models) {
+        if (!isZenFreeModel(m))
+            continue;
+        const raw = (m.id || "").trim();
+        let id;
+        try {
+            id = asOpenCodeZenId(raw);
+        }
+        catch {
+            continue;
+        }
+        const ctx = Number.isFinite(Number(m.context_length)) ? Number(m.context_length) : 0;
+        out.push({
+            id,
+            name: (m.name || raw).trim(),
+            context_length: ctx,
+            boost: zenFreeBoost(id),
+        });
+    }
+    out.sort((a, b) => {
+        if (b.boost !== a.boost)
+            return b.boost - a.boost;
+        if (b.context_length !== a.context_length)
+            return b.context_length - a.context_length;
+        return a.id.localeCompare(b.id);
+    });
+    return out;
+}
+function readCache() {
+    const p = cachePath();
+    if (!existsSync(p))
+        return null;
+    try {
+        const j = JSON.parse(readFileSync(p, "utf8"));
+        if (!j?.id)
+            return null;
+        const ageMs = Date.now() - Date.parse(j.picked_at);
+        if (!Number.isFinite(ageMs) || ageMs < 0)
+            return null;
+        if (ageMs > cacheMinutes() * 60_000)
+            return null;
+        assertOpenCodeModel(j.id);
+        return j;
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(pick) {
+    try {
+        writeFileSync(cachePath(), JSON.stringify(pick), { mode: 0o600 });
+    }
+    catch {
+        /* cache is optional */
+    }
+}
+function httpGetSync(url, timeoutMs = 4000) {
+    const sec = Math.max(1, Math.ceil(timeoutMs / 1000));
+    const curl = spawnSync("curl", ["-fsS", "--max-time", String(sec), "-H", "Accept: application/json", url], { encoding: "utf8", timeout: timeoutMs + 500, env: { ...process.env } });
+    if (curl.status === 0 && curl.stdout?.trim())
+        return curl.stdout;
+    return null;
+}
+function parseCatalog(raw) {
+    const j = JSON.parse(raw);
+    if (Array.isArray(j))
+        return j;
+    if (Array.isArray(j.data))
+        return j.data;
+    return [];
+}
+export function loadZenCatalog() {
+    const inline = process.env.CURSOR_ROUTE_ZEN_CATALOG_JSON?.trim();
+    if (inline)
+        return parseCatalog(inline);
+    if (process.env.CURSOR_ROUTE_ZEN_OFFLINE === "1")
+        return [];
+    const body = httpGetSync(zenModelsUrl());
+    if (!body)
+        return [];
+    try {
+        return parseCatalog(body);
+    }
+    catch {
+        return [];
+    }
+}
+/** Last live pick if the cache is still fresh — health-safe (no network). */
+export function cachedZenFreePick() {
+    try {
+        return readCache()?.id ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Best live Zen free model, or OPENCODE_DEFAULT_MODEL if the catalog is empty/offline.
+ * `CURSOR_ROUTE_ZEN_REFRESH=1` skips cache. Tests: `CURSOR_ROUTE_ZEN_OFFLINE=1` or
+ * `CURSOR_ROUTE_ZEN_CATALOG_JSON`.
+ */
+export function pickZenFreeModel(opts) {
+    const refresh = opts?.refresh ||
+        process.env.CURSOR_ROUTE_ZEN_REFRESH === "1";
+    if (!refresh && opts?.catalog === undefined) {
+        const cached = readCache();
+        if (cached)
+            return cached.id;
+    }
+    const models = opts?.catalog ?? loadZenCatalog();
+    const ranked = rankZenFreeModels(models);
+    const winner = ranked[0];
+    if (!winner) {
+        const fallback = {
+            id: OPENCODE_DEFAULT_MODEL,
+            name: "Ox Alpha Free (fallback)",
+            context_length: 0,
+            boost: 0,
+            picked_at: new Date().toISOString(),
+            candidates: 0,
+            source: "fallback",
+        };
+        if (opts?.catalog === undefined)
+            writeCache(fallback);
+        return fallback.id;
+    }
+    const pick = {
+        id: winner.id,
+        name: winner.name,
+        context_length: winner.context_length,
+        boost: winner.boost,
+        picked_at: new Date().toISOString(),
+        candidates: ranked.length,
+        source: "ranked-free",
+    };
+    if (opts?.catalog === undefined)
+        writeCache(pick);
+    return pick.id;
+}
+/**
+ * Resolve OpenCode `--model` / env to a concrete `provider/model` id.
+ * Empty or `free` → CURSOR_ROUTE_OPENCODE_MODEL pin, else live Zen free pick.
+ */
+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 assertOpenCodeModel(env);
+        return pickZenFreeModel();
+    }
+    return assertOpenCodeModel(v);
+}

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.11 (LIVE on npm latest)
 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; `--model free` ranks live Zen catalog (Ox Alpha first while listed) |
 
 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.11**. Release notes: [CHANGELOG.md](../../CHANGELOG.md).
 
 ## Open (edit / check off)
 
@@ -38,6 +39,8 @@ 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`; 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.
+- [x] **Live Zen free pick** — 0.1.11: `--model free` ranks `GET https://opencode.ai/zen/v1/models` (Ox Alpha first while listed; ~15 min cache; Ox Alpha fallback if fetch fails). Pin with `CURSOR_ROUTE_OPENCODE_MODEL`. Health stays offline (cache/fallback only).
 - [ ] **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 +53,8 @@ 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) |
+| `src/zen-free.ts` | Live Zen catalog rank for `--model free` |
 | `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 +72,6 @@ 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 LIVE. |
+| 2026-08-21 | Live Zen free pick (Ox Alpha first while listed; OpenRouter-style catalog rank) → 0.1.11 LIVE. |

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.11**)
 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 (`--model free` ranks the live Zen catalog; Ox Alpha wins while listed) — 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 "…"`. `--model free` ranks live Zen free models (Ox Alpha first while listed). 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.11",
+  "description": "Cursor stays the brain. Grok CLI + DeepSeek (claude-ds) + OpenRouter easy lane + OpenCode (opt-in free) are the parallel army \u2014 lane-aware /route orchestration in tmux.",
   "type": "module",
   "license": "MIT",
   "bin": {
@@ -41,6 +41,7 @@
     "deepseek",
     "claude-ds",
     "openrouter",
+    "opencode",
     "tmux",
     "orchestrator",
     "agents",

package/skills/route-orch/SKILL.md

@@ -2,10 +2,10 @@
 name: route-orch
 description: >-
   Delegate coding work from Cursor to parallel Grok CLI / claude-ds (DeepSeek) /
-  OpenRouter (easy lane) workers via cursor-route. Use when the user says
-  /route-orch, spawn workers, parallel agents with cursor-route, or explicitly
-  asks to outsource implementation to Grok/DeepSeek panes — not for private
-  Cemini /route.
+  OpenRouter (easy lane) / OpenCode (opt-in free) workers via cursor-route. Use
+  when the user says /route-orch, spawn workers, parallel agents with
+  cursor-route, or explicitly asks to outsource implementation to
+  Grok/DeepSeek/OpenCode panes — not for private Cemini /route.
 ---
 
 # route-orch (cursor-route)
@@ -14,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`). `--model free` / unset ranks the live OpenCode Zen catalog (Ox Alpha first while listed; pin with `CURSOR_ROUTE_OPENCODE_MODEL` or `--model provider/model`). 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). Ox Alpha (`opencode/x-preview-f-free`) is the zero-retention free option.
+
 ## 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 {