cursor-route 0.1.10 → 0.1.13

package/skills/route-orch/SKILL.md

@@ -24,27 +24,30 @@ You are the **orchestrator**. Do **not** implement bulk code in this Cursor sess
 
 | Lane | Worker | Use when |
 |------|--------|----------|
-| `easy` | `openrouter` (OpenRouter free models) | Wording / drafts — non-secret prompts only |
+| `easy` | `openrouter` (live OpenRouter free pick) | Wording / drafts — non-secret prompts only |
 | `mid` | `claude-ds` (DeepSeek via Claude Code harness) | Standard implement / refactor |
 | `hard` | `grok` | Premium plan in Cursor → Grok implement |
 
-Free OpenRouter models may log prompts — keep secrets off the easy lane (the CLI refuse gate still applies).
+Free OpenRouter models may log prompts — keep secrets off the easy lane (the CLI refuse gate still applies). Easy lane **live-picks** the best free text model at request time (unset / `--model free`). Pin with `CURSOR_ROUTE_OPENROUTER_MODEL` or `--model provider/model`. Fetch-fail fallback is the OpenRouter router `openrouter/free` only.
 
 ## claude-ds models
 
 One harness. Do not install a second coding loop.
 
-| Flag / role | Model | When |
-|-------------|-------|------|
-| default mid (`--model flash`) | `deepseek-v4-flash` | `--lane mid` cheap execute |
-| Grok stand-in (`--model pro`) | `deepseek-v4-pro` | Grok CLI **usage/quota** out (not a missing `grok login`) |
+| Flag | Model id | When |
+|------|----------|------|
+| `--model flash` (default) | `deepseek-v4-flash` | Cheap mid execute. Prefer this when Grok **usage** is out |
+| `--model vision` | `deepseek-v4-flash-vision-exp` | Screenshots / ui mocks / image prompts (or auto-pick) |
+| `--model pro` | `deepseek-v4-pro` | Harder mid / **hard backup** only — not the default Grok-out stand-in |
+| `--model deepseek-v4-pro[1m]` | preserved SKU | Large-context Pro |
 
 ```bash
 cursor-route start --lane mid --dir "$PWD" "…"
+cursor-route start --lane mid --model vision --dir "$PWD" "…"
 cursor-route start --lane mid --model pro --dir "$PWD" "…"
 ```
 
-If `worker:grok` is ✗ on health, that is usually **auth** (`grok login` / `XAI_API_KEY`) — not the Pro stand-in case.
+If `worker:grok` is ✗ on health, that is usually **auth** (`grok login` / `XAI_API_KEY`) — not the Pro case. When Grok **usage** is out, stay on Flash.
 
 ## Experimental: --worker deepseek (dsh)
 
@@ -71,7 +74,7 @@ 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).
+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
 
@@ -116,6 +119,8 @@ Verify criteria are an **external eval contract** (AutoDesign pattern), fixed by
 - **External eval contract (AutoDesign):** do not rewrite Verify / Success criteria mid-run to make a failing job look green — capture + exit status are the contract (see Verify / claim closeout).
 - **Skill misevolution:** do not auto-edit `route-orch` or promote skill variants from worker trajectories without operator HITL — write-time approval ≠ safe retrieval later.
 - **On verify fail:** prefer reconsidering the plan/definition (wrong approach) over grinding the same tactic; attribute failure to stage when possible (spawn vs execute vs verify).
+- **Step-wise re-route (ProgRouter):** `--lane` is the first pick. If progress stalls or verify fails, `send` a correction or spawn a follow-up on a different worker/model — do not lock the first worker for the whole job. Parent still closes on capture/exit evidence.
+- **Do not auto-spawn N panes for multi-perspective:** spawn workers for **implementation parallelism** (independent files/jobs). Multi-perspective reasoning stays in the Cursor parent. Do not fan out “one agent per viewpoint.”
 
 ## Always-approve
 

package/src/adapters/claude-ds.ts

@@ -212,7 +212,7 @@ export const claudeDsAdapter: Adapter = {
       resolved.mode.startsWith("claude-ds") || resolved.mode.startsWith("deepseek-claude");
 
     // Anthropic escape hatch: do not pass DeepSeek model ids (unknown to Anthropic).
-    // --model flash|pro is DeepSeek-only; stock Claude uses its own defaults / ANTHROPIC_MODEL.
+    // --model flash|pro|vision is DeepSeek-only; stock Claude uses its own defaults / ANTHROPIC_MODEL.
     if (isAnthropicEscape) {
       const parts = [
         shellQuote(resolved.binary),

package/src/adapters/opencode.test.ts

@@ -11,16 +11,36 @@ import {
 } from "../config.ts";
 
 describe("openCodeModel", () => {
-  test("defaults to OpenCode Zen Big Pickle", () => {
-    const prev = process.env.CURSOR_ROUTE_OPENCODE_MODEL;
+  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/big-pickle");
+      expect(openCodeModel()).toBe("opencode/x-preview-f-free");
       expect(openCodeModel("")).toBe(OPENCODE_DEFAULT_MODEL);
-      expect(openCodeModel("free")).toBe("opencode/big-pickle");
+      expect(openCodeModel("free")).toBe("opencode/x-preview-f-free");
     } finally {
-      if (prev === undefined) delete process.env.CURSOR_ROUTE_OPENCODE_MODEL;
-      else process.env.CURSOR_ROUTE_OPENCODE_MODEL = prev;
+      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 });
     }
   });
 
@@ -100,14 +120,21 @@ describe("opencode adapter", () => {
   });
 
   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 });
+    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", () => {
@@ -119,6 +146,10 @@ describe("opencode adapter", () => {
         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({
@@ -128,7 +159,7 @@ describe("opencode adapter", () => {
         });
         expect(plan.command).toContain("run");
         expect(plan.command).toContain("--auto");
-        expect(plan.command).toContain("opencode/big-pickle");
+        expect(plan.command).toContain("opencode/x-preview-f-free");
         expect(plan.command).toContain("$(cat");
         expect(plan.command).toContain("--dir");
         expect(plan.alwaysApprove).toBe(true);
@@ -160,15 +191,24 @@ describe("opencode adapter", () => {
     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);
-    });
+    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 });
   });
 
@@ -183,6 +223,9 @@ describe("opencode adapter", () => {
         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({
@@ -208,10 +251,18 @@ describe("opencode adapter", () => {
       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",
@@ -221,7 +272,7 @@ describe("opencode adapter", () => {
       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.job.model).toBe("opencode/x-preview-f-free");
       expect(result.command).toContain("run");
       expect(result.command).toContain("--auto");
       expect(result.command).toContain("$(cat");
@@ -232,6 +283,14 @@ describe("opencode adapter", () => {
       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

@@ -2,13 +2,13 @@ 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";
+import { openCodeModel, OPENCODE_DEFAULT_MODEL, cachedZenFreePick } 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).
+ * 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
@@ -47,17 +47,13 @@ export const opencodeAdapter: Adapter = {
           "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 */
-    }
+    // 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; default model ${defaultModel}; auth at first start — opencode auth login if jobs fail; mid default remains claude-ds)`,
+      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 }) {

package/src/adapters/openrouter.test.ts

@@ -11,6 +11,10 @@ afterEach(() => {
   delete process.env.OPENROUTER_API_KEY;
   delete process.env.CURSOR_ROUTE_OPENROUTER_MODEL;
   delete process.env.OPENROUTER_BASE_URL;
+  delete process.env.CURSOR_ROUTE_OR_OFFLINE;
+  delete process.env.CURSOR_ROUTE_OR_CATALOG_JSON;
+  delete process.env.CURSOR_ROUTE_OR_CACHE_PATH;
+  delete process.env.CURSOR_ROUTE_OR_REFRESH;
 });
 
 describe("openrouter adapter", () => {
@@ -20,13 +24,38 @@ describe("openrouter adapter", () => {
     expect(h.worker).toBe("openrouter");
     expect(h.ok).toBe(false);
     expect(h.detail).toContain("OPENROUTER_API_KEY");
+    expect(h.detail).not.toMatch(/defaults to openrouter\/free/);
   });
 
   test("health passes with a fake key (no network)", () => {
     setKey();
-    const h = openRouterAdapter.health();
-    expect(h.ok).toBe(true);
-    expect(h.detail).toContain("openrouter/free");
+    const prev = {
+      model: process.env.CURSOR_ROUTE_OPENROUTER_MODEL,
+      offline: process.env.CURSOR_ROUTE_OR_OFFLINE,
+      json: process.env.CURSOR_ROUTE_OR_CATALOG_JSON,
+      cache: process.env.CURSOR_ROUTE_OR_CACHE_PATH,
+    };
+    delete process.env.CURSOR_ROUTE_OPENROUTER_MODEL;
+    process.env.CURSOR_ROUTE_OR_OFFLINE = "1";
+    delete process.env.CURSOR_ROUTE_OR_CATALOG_JSON;
+    process.env.CURSOR_ROUTE_OR_CACHE_PATH = "/tmp/cursor-route-or-health-missing.json";
+    try {
+      const h = openRouterAdapter.health();
+      expect(h.ok).toBe(true);
+      expect(h.detail.toLowerCase()).toMatch(/live pick/);
+      expect(h.detail).toMatch(/fallback/);
+      expect(h.detail).not.toMatch(/now openrouter\/free/);
+      expect(h.detail).not.toMatch(/defaults to openrouter\/free/);
+    } finally {
+      if (prev.model === undefined) delete process.env.CURSOR_ROUTE_OPENROUTER_MODEL;
+      else process.env.CURSOR_ROUTE_OPENROUTER_MODEL = prev.model;
+      if (prev.offline === undefined) delete process.env.CURSOR_ROUTE_OR_OFFLINE;
+      else process.env.CURSOR_ROUTE_OR_OFFLINE = prev.offline;
+      if (prev.json === undefined) delete process.env.CURSOR_ROUTE_OR_CATALOG_JSON;
+      else process.env.CURSOR_ROUTE_OR_CATALOG_JSON = prev.json;
+      if (prev.cache === undefined) delete process.env.CURSOR_ROUTE_OR_CACHE_PATH;
+      else process.env.CURSOR_ROUTE_OR_CACHE_PATH = prev.cache;
+    }
   });
 
   test("buildLaunch passes key via env and never echoes it in the command", () => {

package/src/adapters/openrouter.ts

@@ -3,7 +3,11 @@ import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import type { Adapter, WorkerHealth } from "./types.ts";
 import { shellQuote } from "../util.ts";
-import { openRouterModel, openRouterBaseUrl } from "../config.ts";
+import {
+  cachedOrFreePick,
+  OPENROUTER_FALLBACK_MODEL,
+  openRouterBaseUrl,
+} from "../config.ts";
 
 /**
  * Resolve how to invoke the one-shot runner. Prefer the compiled dist via node
@@ -22,11 +26,11 @@ function resolveRunner(): { command: string } | null {
   return null;
 }
 
-function openRouterEnv(): Record<string, string> | undefined {
+function openRouterEnv(modelId?: string): Record<string, string> | undefined {
   const key = process.env.OPENROUTER_API_KEY;
   if (!key) return undefined;
   const env: Record<string, string> = { OPENROUTER_API_KEY: key };
-  const model = process.env.CURSOR_ROUTE_OPENROUTER_MODEL;
+  const model = modelId || process.env.CURSOR_ROUTE_OPENROUTER_MODEL;
   if (model) env.CURSOR_ROUTE_OPENROUTER_MODEL = model;
   const base = process.env.OPENROUTER_BASE_URL;
   if (base) env.OPENROUTER_BASE_URL = base;
@@ -44,7 +48,7 @@ export const openRouterAdapter: Adapter = {
         ok: false,
         binary: runner?.command ?? null,
         detail:
-          "OPENROUTER_API_KEY not set — export your OpenRouter key (easy lane model defaults to openrouter/free)",
+          "OPENROUTER_API_KEY not set — export your OpenRouter key (easy lane live-picks a free model at start; pin with CURSOR_ROUTE_OPENROUTER_MODEL)",
       };
     }
     if (!runner) {
@@ -55,19 +59,25 @@ export const openRouterAdapter: Adapter = {
         detail: "openrouter-run not found — run bun run build (or use Bun from a source clone)",
       };
     }
+    // Health stays offline: ranked cache hit, else label the router fallback
+    // (do not present openrouter/free as a fresh live pick).
+    const cached = cachedOrFreePick();
+    const detail = cached
+      ? `ok (live pick at start; cached ${cached} @ ${openRouterBaseUrl()})`
+      : `ok (live pick at start; no catalog cache, fetch-fail fallback ${OPENROUTER_FALLBACK_MODEL} @ ${openRouterBaseUrl()})`;
     return {
       worker: "openrouter",
       ok: true,
       binary: runner.command,
-      detail: `ok (model ${openRouterModel()} @ ${openRouterBaseUrl()})`,
+      detail,
     };
   },
-  buildLaunch({ promptFile }) {
+  buildLaunch({ promptFile, modelId }) {
     const runner = resolveRunner();
     if (!runner) throw new Error("openrouter runner not available — run: bun run build");
     // Missing key is tolerated here so `--dry-run` can still print the command;
     // real starts are gated by the health preflight (which requires the key).
-    const env = openRouterEnv();
+    const env = openRouterEnv(modelId);
 
     // No interactive approval concept for a pure HTTP call — nothing to auto-approve.
     return {

package/src/adapters/types.ts

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