cursor-route 0.1.4 → 0.1.6

package/dist/openrouter-run.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env bun
+/**
+ * One-shot OpenRouter easy-lane runner — reads a prompt file and POSTs it to
+ * OpenRouter's chat/completions, printing the assistant reply to stdout.
+ * No runtime npm deps (Node 20+ global fetch). Invoked by the openrouter
+ * adapter (dist via node, else src via bun). Never echoes OPENROUTER_API_KEY.
+ */
+import { readFileSync } from "node:fs";
+import { openRouterModel, openRouterBaseUrl } from "./config.js";
+import { looksLikeSecretMaterial } from "./secrets.js";
+const SYSTEM_PROMPT = "You are a drafting/rewrite helper for cursor-route. Never invent credentials, API keys, or secrets; if asked for secret material, refuse. Provide educational, general-purpose help.";
+function fail(msg, code) {
+    console.error(`cursor-route/openrouter-run: ${msg}`);
+    process.exit(code);
+}
+function parseArgs(argv) {
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "-h" || a === "--help") {
+            console.log("usage: cursor-route/openrouter-run --prompt-file <path>\n" +
+                "env: OPENROUTER_API_KEY (required), CURSOR_ROUTE_OPENROUTER_MODEL, OPENROUTER_BASE_URL");
+            process.exit(0);
+        }
+        if (a === "--prompt-file") {
+            const v = argv[i + 1];
+            if (!v || v.startsWith("--"))
+                fail("--prompt-file requires a value", 2);
+            flags.promptFile = v;
+            i++;
+        }
+        else if (a.startsWith("--prompt-file=")) {
+            flags.promptFile = a.slice("--prompt-file=".length);
+        }
+        else {
+            fail(`unknown argument: ${a}`, 2);
+        }
+    }
+    return flags;
+}
+async function main() {
+    const { promptFile } = parseArgs(process.argv.slice(2));
+    if (!promptFile)
+        fail("--prompt-file <path> is required", 2);
+    let prompt;
+    try {
+        prompt = readFileSync(promptFile, "utf8");
+    }
+    catch (e) {
+        fail(`cannot read prompt file: ${e.message}`, 2);
+    }
+    if (!prompt.trim())
+        fail("prompt file is empty", 2);
+    if (looksLikeSecretMaterial(prompt)) {
+        fail("refusing prompt: looks like secret key material — easy lane is for non-secret drafts", 3);
+    }
+    const apiKey = process.env.OPENROUTER_API_KEY;
+    if (!apiKey)
+        fail("OPENROUTER_API_KEY is not set", 2);
+    const base = openRouterBaseUrl().replace(/\/+$/, "");
+    const url = `${base}/chat/completions`;
+    let res;
+    try {
+        res = await fetch(url, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+                // OpenRouter etiquette: identify the app so the provider can see usage source.
+                "HTTP-Referer": "https://github.com/cemini23/cursor-route",
+                "X-Title": "cursor-route",
+            },
+            body: JSON.stringify({
+                model: openRouterModel(),
+                messages: [
+                    { role: "system", content: SYSTEM_PROMPT },
+                    { role: "user", content: prompt },
+                ],
+            }),
+        });
+    }
+    catch (e) {
+        fail(`network error calling ${url}: ${e.message}`, 1);
+    }
+    if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        fail(`OpenRouter API ${res.status}: ${body.slice(0, 500)}`, 1);
+    }
+    const json = (await res.json());
+    const content = json.choices?.[0]?.message?.content ?? "";
+    if (!content)
+        fail("OpenRouter returned no assistant content", 1);
+    process.stdout.write(content.endsWith("\n") ? content : content + "\n");
+}
+main().catch((e) => fail(e instanceof Error ? e.message : String(e), 1));

package/docs/briefs/WORKING.md

@@ -0,0 +1,55 @@
+---
+title: cursor-route workspace — working brief (edit in place)
+repo: ~/Projects/cursor-route
+npm: cursor-route@0.1.6
+created: 2026-08-12
+updated: 2026-08-12
+---
+
+# cursor-route — living brief
+
+**Edit this file.** It is the working notes for this public repo (CLI + `route-orch` skill + adapters). Not the private Cemini `/route` skill (`agent-toolkit` / federation).
+
+When a chunk is accepted: apply it to `src/`, `README.md`, and/or `skills/route-orch/SKILL.md` (keep `.cursor/skills/route-orch/SKILL.md` in sync). Then tick **Open** and add an **Edit log** line.
+
+## What this repo is
+
+Cursor Agent plans. Workers run in tmux via `cursor-route`:
+
+| Lane | Worker | Intent |
+|------|--------|--------|
+| `easy` | OpenRouter free | Wording / drafts — non-secret prompts only |
+| `mid` | claude-ds (DeepSeek behind Claude Code) | Default implement (**Flash**) |
+| `hard` | Grok CLI | Hard implement |
+
+Always-approve on (`--ask` / `CURSOR_ROUTE_ASK=1` to opt out). Jobs live in `~/.local/share/cursor-route/jobs`, not in this clone.
+
+## Open (edit / check off)
+
+- [x] **Flash vs Pro on the CLI** — public default **Flash**; `--model pro` → `deepseek-v4-pro`
+  - [x] pass `claude-ds -Model deepseek-v4-flash|deepseek-v4-pro` from the adapter
+  - [x] add `--model flash|pro` on `start`
+  - [x] document Grok **auth** ≠ usage-out (`grok login`) vs quota → Pro stand-in
+- [x] **Skill `route-orch`** — Flash/Pro table in `skills/` + `.cursor/skills/`
+- [x] **Official DeepSeek Harness** — `deepseek` adapter slot present; mid stays on claude-ds
+- [ ] **Hero GIF** — still outstanding (`docs/DEMO_GIF.md`)
+- [x] **Do not** paste private `ROUTE_KIT`, SIP, prod paths, or hang-watchdog env into this public repo
+
+## Repo map
+
+| Path | Role |
+|------|------|
+| `src/cli.ts` | `health` / `start` / `jobs` / `capture` / `send` / `kill` |
+| `src/adapters/claude-ds.ts` | Mid worker; DeepSeek URL required; `--model` → `-Model` |
+| `src/adapters/deepseek.ts` | Reserved unreleased harness slot |
+| `src/adapters/grok.ts` | Hard worker |
+| `src/adapters/openrouter.ts` | Easy worker |
+| `skills/route-orch/SKILL.md` | Cursor skill — spawn CLI, do not implement in-session |
+| `SECURITY.md` | Secret refuse gate |
+
+## Edit log
+
+| Date | Change |
+|------|--------|
+| 2026-08-12 | Brief created in this repo. Flash/Pro CLI + skill still open. |
+| 2026-08-12 | Shipped Flash default + `--model pro`, deepseek slot, skill table → 0.1.6. |

package/docs/demo-notes.md

@@ -4,29 +4,32 @@ Simulated capture output for README / tweet assets — replace with a real GIF o
 
 ```
 $ cursor-route --version
-0.1.4
+0.1.6
 
 $ cursor-route health
-cursor-route v0.1.4
+cursor-route v0.1.6
 health: OK
   ✓ tmux
   ✓ runtime          bun ok
   ✓ script(1)
   ✓ worker:grok
   ✓ worker:claude-ds
+  ✓ worker:openrouter
+  ✗ worker:deepseek  unreleased — mid lane uses claude-ds
   ✓ jobs_dir         ~/.local/share/cursor-route/jobs
 
 $ cursor-route start --lane mid "Add a failing test then make it pass"
-started a1b2c3d4 (claude-ds)
+started a1b2c3d4 (claude-ds/flash)
 session: cursor-route-a1b2c3d4
 attach:  tmux attach -t cursor-route-a1b2c3d4
 
 $ cursor-route jobs --json
-[{ "id": "a1b2c3d4", "status": "running", "worker": "claude-ds", ... }]
+[{ "id": "a1b2c3d4", "status": "running", "worker": "claude-ds", "model": "flash", ... }]
 ```
 
 Verified locally (2026-08-10): headless `claude-ds` smoke returned `CURSOR_ROUTE_SMOKE_OK`.
 Grok smoke hit 402 (Build usage balance exhausted) — auth/PATH wiring works; top up Grok Build for live demos.
+Use `--model pro` when Grok **usage** is out (not the same as a missing `grok login`).
 
 Current commands: `health`, `start`, `jobs`, `status`, `capture`, `send`, `attach`, `kill`, `sessions`, `clean`.
 Headless demos (no tmux) use `--no-tmux` and `capture`/`status` instead of `attach`/`send`.

package/llms.txt

@@ -1,6 +1,6 @@
 # cursor-route
 
-> Cursor stays the planner. DeepSeek (mid) and Grok CLI (hard) 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.
 
 MIT CLI + Cursor skill. npm: https://www.npmjs.com/package/cursor-route  
 GitHub: https://github.com/cemini23/cursor-route
@@ -8,19 +8,19 @@ 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, and Grok CLI handles the hard lane.
+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).
 
 ### 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.
 
 ### Does mid lane use Anthropic Claude?
-No. The mid worker is DeepSeek. Claude Code is the harness, configured with `ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic` and a DeepSeek key in `ANTHROPIC_AUTH_TOKEN`.
+No. The mid worker is DeepSeek. Claude Code is the harness, configured with `ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic` and a DeepSeek key in `ANTHROPIC_AUTH_TOKEN`. Default model is Flash (`--model flash`); use `--model pro` for harder mid work or when Grok usage is exhausted (not the same as a missing `grok login`).
 
 ### How do I install?
 Run `npm i -g cursor-route`, install tmux if needed, then run `cursor-route health`. The package is available at https://www.npmjs.com/package/cursor-route, and the source is at https://github.com/cemini23/cursor-route.
 
 ### Is it free?
-The cursor-route code is open source under MIT. It does not make the worker services free. Your costs depend on Cursor, DeepSeek API usage, and the Grok access or balance available to you.
+The 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`).
 
 ## Install
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cursor-route",
-  "version": "0.1.4",
-  "description": "Cursor stays the brain. Grok CLI + DeepSeek (claude-ds) are the parallel army \u2014 lane-aware /route orchestration in tmux.",
+  "version": "0.1.6",
+  "description": "Cursor stays the brain. Grok CLI + DeepSeek (claude-ds) + OpenRouter easy lane are the parallel army \u2014 lane-aware /route orchestration in tmux.",
   "type": "module",
   "license": "MIT",
   "bin": {
@@ -17,6 +17,7 @@
     "skills",
     "docs/DEMO_GIF.md",
     "docs/demo-notes.md",
+    "docs/briefs/WORKING.md",
     "docs/fixtures",
     "LICENSE",
     "SECURITY.md",
@@ -38,6 +39,7 @@
     "grok",
     "deepseek",
     "claude-ds",
+    "openrouter",
     "tmux",
     "orchestrator",
     "agents",

package/skills/route-orch/SKILL.md

@@ -1,10 +1,11 @@
 ---
 name: route-orch
 description: >-
-  Delegate coding work from Cursor to parallel Grok CLI / claude-ds (DeepSeek)
-  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.
+  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.
 ---
 
 # route-orch (cursor-route)
@@ -23,10 +24,27 @@ 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 |
 | `mid` | `claude-ds` (DeepSeek via Claude Code harness) | Standard implement / refactor |
 | `hard` | `grok` | Premium plan in Cursor → Grok implement |
 
-Easy/OpenRouter is **not** in v0 — keep secrets off free models.
+Free OpenRouter models may log prompts — keep secrets off the easy lane (the CLI refuse gate still applies).
+
+## 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`) |
+
+```bash
+cursor-route start --lane mid --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.
 
 ## Workflow
 
@@ -45,7 +63,7 @@ EOF
 )"
 ```
 
-Or `--worker grok` / `--worker claude-ds`. Use `--no-tmux` only when tmux is unavailable.
+Or `--worker grok` / `--worker claude-ds` / `--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”. If verify fails, `send` a correction or spawn a follow-up — do not invent success.

package/src/adapters/claude-ds.ts

@@ -3,6 +3,12 @@ import { readFileSync, existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import type { Adapter, WorkerHealth } from "./types.ts";
+import {
+  DS_MODEL_IDS,
+  type DsModelAlias,
+  config,
+  resolveDsModelAlias,
+} from "../config.ts";
 import { shellQuote } from "../util.ts";
 
 /**
@@ -114,22 +120,37 @@ function resolveClaudeDs(): { binary: string; mode: string } | null {
   return null;
 }
 
+function pickModelAlias(requested?: DsModelAlias): DsModelAlias {
+  if (requested) return requested;
+  // Env override for power users who already export ANTHROPIC_MODEL
+  const fromEnv = process.env.CURSOR_ROUTE_DS_MODEL || process.env.ANTHROPIC_MODEL;
+  if (fromEnv) {
+    try {
+      return resolveDsModelAlias(fromEnv);
+    } catch {
+      /* fall through to default */
+    }
+  }
+  return config.defaultDsModel;
+}
+
 /**
  * Env that must reach stock `claude` for DeepSeek routing.
  * Passed via process/tmux env — never interpolated into the printed command.
  */
-function deepSeekWorkerEnv(): Record<string, string> | undefined {
+function deepSeekWorkerEnv(modelId: string): Record<string, string> | undefined {
   const base = resolvedDeepSeekBaseUrl();
   if (!base) return undefined;
-  const env: Record<string, string> = { ANTHROPIC_BASE_URL: base };
+  const env: Record<string, string> = {
+    ANTHROPIC_BASE_URL: base,
+    ANTHROPIC_MODEL: modelId,
+  };
   const token =
     process.env.ANTHROPIC_AUTH_TOKEN ||
     process.env.ANTHROPIC_API_KEY ||
     process.env.DEEPSEEK_API_KEY ||
     "";
   if (token) env.ANTHROPIC_AUTH_TOKEN = token;
-  const model = process.env.ANTHROPIC_MODEL;
-  if (model) env.ANTHROPIC_MODEL = model;
   return env;
 }
 
@@ -153,27 +174,33 @@ export const claudeDsAdapter: Adapter = {
       worker: "claude-ds",
       ok: true,
       binary: resolved.binary,
-      detail: `ok (${resolved.mode})`,
+      detail: `ok (${resolved.mode}; default model ${DS_MODEL_IDS[config.defaultDsModel]})`,
     };
   },
-  buildLaunch({ promptFile, cwd, alwaysApprove }) {
+  buildLaunch({ promptFile, cwd, alwaysApprove, model }) {
     const resolved = resolveClaudeDs();
     if (!resolved) {
       throw new Error("DeepSeek worker not available — run: cursor-route health");
     }
 
+    const alias = pickModelAlias(model);
+    const modelId = DS_MODEL_IDS[alias];
+
     const ask = process.env.CURSOR_ROUTE_ASK === "1" || process.env.CLAUDE_DS_ASK === "1";
     const skip = alwaysApprove && !ask;
     // Stock `claude` needs DeepSeek env injected into the worker process
     // (tmux panes may not inherit client env from a long-lived server).
-    const env =
-      resolved.mode.startsWith("claude → DeepSeek") ? deepSeekWorkerEnv() : undefined;
+    const env = resolved.mode.startsWith("claude → DeepSeek")
+      ? deepSeekWorkerEnv(modelId)
+      : undefined;
 
-    if (resolved.mode.startsWith("claude-ds")) {
+    if (resolved.mode.startsWith("claude-ds") || resolved.mode.startsWith("deepseek-claude")) {
       const parts = [
         shellQuote(resolved.binary),
         "-PromptFile",
         shellQuote(promptFile),
+        "-Model",
+        shellQuote(modelId),
       ];
       if (skip) parts.push("--dangerously-skip-permissions");
       return {
@@ -188,6 +215,8 @@ export const claudeDsAdapter: Adapter = {
       shellQuote(resolved.binary),
       "-p",
       `"$(cat ${shellQuote(promptFile)})"`,
+      "--model",
+      shellQuote(modelId),
     ];
     if (skip) parts.push("--dangerously-skip-permissions");
     return {

package/src/adapters/deepseek.ts

@@ -0,0 +1,24 @@
+import type { Adapter, WorkerHealth } from "./types.ts";
+
+/**
+ * Reserved slot for the official DeepSeek coding harness when it ships.
+ * Mid lane stays on claude-ds until then — do not route jobs here.
+ */
+export const deepseekAdapter: Adapter = {
+  kind: "deepseek",
+  label: "Official DeepSeek harness (unreleased)",
+  health(): WorkerHealth {
+    return {
+      worker: "deepseek",
+      ok: false,
+      binary: null,
+      detail:
+        "unreleased — mid lane uses claude-ds (DeepSeek behind Claude Code). See README.",
+    };
+  },
+  buildLaunch() {
+    throw new Error(
+      "Official DeepSeek harness is not available yet — use --lane mid / --worker claude-ds",
+    );
+  },
+};

package/src/adapters/index.ts

@@ -2,10 +2,14 @@ import type { WorkerKind } from "../config.ts";
 import type { Adapter } from "./types.ts";
 import { grokAdapter } from "./grok.ts";
 import { claudeDsAdapter } from "./claude-ds.ts";
+import { openRouterAdapter } from "./openrouter.ts";
+import { deepseekAdapter } from "./deepseek.ts";
 
 const registry: Record<WorkerKind, Adapter> = {
   grok: grokAdapter,
   "claude-ds": claudeDsAdapter,
+  openrouter: openRouterAdapter,
+  deepseek: deepseekAdapter,
 };
 
 export function getAdapter(worker: WorkerKind): Adapter {

package/src/adapters/openrouter.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, test, afterEach } from "bun:test";
+import { openRouterAdapter } from "./openrouter.ts";
+
+const KEY = "sk-or-v1-local-test-value-000000000000";
+
+function setKey(): void {
+  process.env.OPENROUTER_API_KEY = KEY;
+}
+
+afterEach(() => {
+  delete process.env.OPENROUTER_API_KEY;
+  delete process.env.CURSOR_ROUTE_OPENROUTER_MODEL;
+  delete process.env.OPENROUTER_BASE_URL;
+});
+
+describe("openrouter adapter", () => {
+  test("health fails without OPENROUTER_API_KEY", () => {
+    delete process.env.OPENROUTER_API_KEY;
+    const h = openRouterAdapter.health();
+    expect(h.worker).toBe("openrouter");
+    expect(h.ok).toBe(false);
+    expect(h.detail).toContain("OPENROUTER_API_KEY");
+  });
+
+  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");
+  });
+
+  test("buildLaunch passes key via env and never echoes it in the command", () => {
+    setKey();
+    const plan = openRouterAdapter.buildLaunch({
+      promptFile: "/tmp/abc123.prompt",
+      cwd: "/tmp",
+      alwaysApprove: true,
+    });
+    expect(plan.worker).toBe("openrouter");
+    expect(plan.command).toContain("--prompt-file");
+    expect(plan.command).not.toContain(KEY);
+    expect(plan.env?.OPENROUTER_API_KEY).toBe(KEY);
+    // No approval concept for a pure HTTP call.
+    expect(plan.alwaysApprove).toBe(false);
+  });
+
+  test("buildLaunch without key still prints a command (dry-run friendly) and no env", () => {
+    delete process.env.OPENROUTER_API_KEY;
+    const plan = openRouterAdapter.buildLaunch({
+      promptFile: "/tmp/abc123.prompt",
+      cwd: "/tmp",
+      alwaysApprove: true,
+    });
+    expect(plan.command).toContain("--prompt-file");
+    expect(plan.env).toBeUndefined();
+  });
+});

package/src/adapters/openrouter.ts

@@ -0,0 +1,80 @@
+import { existsSync } from "node:fs";
+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";
+
+/**
+ * Resolve how to invoke the one-shot runner. Prefer the compiled dist via node
+ * (no loader); else Bun on src. No npx/tsx — same policy as mark-complete.
+ */
+function resolveRunner(): { command: string } | null {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const compiled = join(here, "..", "..", "dist", "openrouter-run.js");
+  if (existsSync(compiled)) {
+    return { command: `node ${shellQuote(compiled)}` };
+  }
+  const srcFile = join(here, "..", "openrouter-run.ts");
+  if (existsSync(srcFile)) {
+    return { command: `bun ${shellQuote(srcFile)}` };
+  }
+  return null;
+}
+
+function openRouterEnv(): 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;
+  if (model) env.CURSOR_ROUTE_OPENROUTER_MODEL = model;
+  const base = process.env.OPENROUTER_BASE_URL;
+  if (base) env.OPENROUTER_BASE_URL = base;
+  return env;
+}
+
+export const openRouterAdapter: Adapter = {
+  kind: "openrouter",
+  label: "OpenRouter (free easy lane)",
+  health(): WorkerHealth {
+    const runner = resolveRunner();
+    if (!process.env.OPENROUTER_API_KEY) {
+      return {
+        worker: "openrouter",
+        ok: false,
+        binary: runner?.command ?? null,
+        detail:
+          "OPENROUTER_API_KEY not set — export your OpenRouter key (easy lane model defaults to openrouter/free)",
+      };
+    }
+    if (!runner) {
+      return {
+        worker: "openrouter",
+        ok: false,
+        binary: null,
+        detail: "openrouter-run not found — run bun run build (or use Bun from a source clone)",
+      };
+    }
+    return {
+      worker: "openrouter",
+      ok: true,
+      binary: runner.command,
+      detail: `ok (model ${openRouterModel()} @ ${openRouterBaseUrl()})`,
+    };
+  },
+  buildLaunch({ promptFile }) {
+    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();
+
+    // No interactive approval concept for a pure HTTP call — nothing to auto-approve.
+    return {
+      worker: "openrouter",
+      command: `${runner.command} --prompt-file ${shellQuote(promptFile)}`,
+      alwaysApprove: false,
+      env,
+    };
+  },
+};

package/src/adapters/types.ts

@@ -1,4 +1,4 @@
-import type { WorkerKind } from "../config.ts";
+import type { WorkerKind, DsModelAlias } from "../config.ts";
 
 export interface WorkerHealth {
   worker: WorkerKind;
@@ -24,5 +24,7 @@ export interface Adapter {
     promptFile: string;
     cwd: string;
     alwaysApprove: boolean;
+    /** Mid-lane DeepSeek flash|pro (ignored by other workers). */
+    model?: DsModelAlias;
   }): LaunchPlan;
 }