cursor-route 0.1.4 → 0.1.5

package/README.md

@@ -1,6 +1,6 @@
 # cursor-route
 
-**Cursor stays the brain. Grok CLI + DeepSeek (claude-ds) are the parallel army.**
+**Cursor stays the brain. Grok CLI + DeepSeek (claude-ds) + OpenRouter (easy) are the parallel army.**
 
 Lane-aware `/route` orchestration in tmux — not another multi-provider fleet, not a Codex clone.
 
@@ -17,7 +17,7 @@ cursor-route capture <jobId>
 |---------|-------|---------|------|
 | [codex-orchestrator](https://github.com/kingbootoshi/codex-orchestrator) | Claude Code | Codex | Viral tmux panes |
 | [CAO](https://github.com/awslabs/cli-agent-orchestrator) | Supervisor CLI | Many (incl. Cursor CLI) | Enterprise MCP + Web UI |
-| **cursor-route** | **Cursor Agent** | **Grok CLI + claude-ds** | Cost-aware lanes you already pay for |
+| **cursor-route** | **Cursor Agent** | **Grok CLI + claude-ds + OpenRouter (easy)** | Cost-aware lanes you already pay for |
 
 If you already live in Cursor, X Premium (Grok CLI), and DeepSeek — stop paying a third coding agent just to parallelize.
 
@@ -28,6 +28,7 @@ If you already live in Cursor, X Premium (Grok CLI), and DeepSeek — stop payin
 | Cursor | Premium plan | Plan / synthesize / verify (orchestrator) |
 | Grok CLI | X Premium | `--lane hard` implement |
 | DeepSeek via claude-ds | DeepSeek API / plan | `--lane mid` implement |
+| OpenRouter free models | OpenRouter API (free tier) | `--lane easy` wording/drafts — non-secret prompts only (see Security) |
 | Codex / extra Claude | Optional | Not required for v0 |
 
 Exact dollars vary — the point is **reuse subscriptions you already have**.
@@ -41,6 +42,7 @@ Exact dollars vary — the point is **reuse subscriptions you already have**.
 | [tmux](https://github.com/tmux/tmux) | Worker panes |
 | [Bun](https://bun.sh) *(or Node 20+)* | Runs the CLI |
 | [Grok CLI](https://x.ai/cli) and/or Claude Code + DeepSeek (`claude-ds`) | Workers |
+| OpenRouter API key (`OPENROUTER_API_KEY`) | Easy lane (`--lane easy` / `--worker openrouter`) |
 | `script(1)` | Job logs (macOS/Linux) |
 
 ```bash
@@ -54,6 +56,7 @@ npm i -g cursor-route
 # Auth workers
 grok login                 # if using Grok
 # configure claude-ds — see DeepSeek setup below
+export OPENROUTER_API_KEY=...   # if using the easy lane (see OpenRouter setup below)
 
 cursor-route health
 # without tmux / workers (CI / headless infra smoke):
@@ -98,6 +101,7 @@ Then say **`/route-orch`** or **spawn workers** in Cursor — the skill delegate
 
 | Lane | Worker | Intent |
 |------|--------|--------|
+| `easy` | `openrouter` | Wording / drafts on OpenRouter free models (non-secret prompts only — see Security) |
 | `mid` | `claude-ds` | Default implement on DeepSeek |
 | `hard` | `grok` | Hard implement on Grok CLI |
 
@@ -130,6 +134,25 @@ Persist the same vars under `~/.claude/settings.json` → `"env": { … }` if yo
 
 No DeepSeek yet? Use `--lane hard` / `--worker grok` (X Premium).
 
+## OpenRouter setup (the free easy lane)
+
+`--lane easy` / `--worker openrouter` sends wording/draft prompts to OpenRouter's
+free model route (`openrouter/free`). Get a key at [openrouter.ai/keys](https://openrouter.ai/keys).
+
+```bash
+export OPENROUTER_API_KEY=sk-or-v1-...        # from openrouter.ai/keys
+# optional:
+export CURSOR_ROUTE_OPENROUTER_MODEL=openrouter/free   # default
+export OPENROUTER_BASE_URL=https://openrouter.ai/api/v1  # default
+
+cursor-route health          # worker:openrouter should be ✓
+cursor-route start --lane easy "Rewrite this FAQ answer in 3 sentences"
+```
+
+**Non-secret prompts only:** free OpenRouter models may log prompts, so the easy lane is for
+**wording/drafts without credentials**. The same refuse gate as every lane blocks
+key-shaped material in `start` / `send`, and the runner re-checks the prompt file.
+
 ## Jobs directory
 
 Jobs default to `~/.local/share/cursor-route/jobs` (override with `CURSOR_ROUTE_JOBS_DIR`).
@@ -144,7 +167,7 @@ This is **not** inside a git clone of this repo.
 ## 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 for wording/drafts.
 
 **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.
@@ -156,7 +179,7 @@ No. The mid worker is DeepSeek. Claude Code is the harness, configured with `ANT
 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`).
 
 ## Related
 
@@ -202,5 +225,4 @@ MIT © Cemini — see [LICENSE](LICENSE).
 - Native DeepSeek harness adapter  
 - Codebase map injection (`--map`)  
 - Cursor CLI `agent` as alternate supervisor  
-- Web UI / CAO-style MCP supervisor  
-- OpenRouter easy lane (secrets-safe)
+- Web UI / CAO-style MCP supervisor

package/SECURITY.md

@@ -14,14 +14,15 @@ Do **not** open a public issue for credential leaks or RCE-class bugs.
 ## Hard rules for users and agents
 
 1. **No secrets in prompts or job files.** Do not paste API keys, SSH private keys, Discord tokens, or `.env` contents into `cursor-route start` / `send` prompts.
-2. **Always-approve is powerful.** Default headless workers skip interactive permission prompts (`--always-approve` / `--dangerously-skip-permissions`). Opt out with `--ask` / `CURSOR_ROUTE_ASK=1` when you need HITL.
-3. **Install from known channels only.** Prefer `npm i -g cursor-route` or a git clone of this repo. Do not pipe unknown `curl | bash` installers as the primary path.
-4. **Workers inherit your auth.** Grok CLI and Claude Code / claude-ds use *your* local login. Treat worker panes like you would treat your own shell.
-5. **No LIVE Discord / trading egress demos** from this tool. Orchestration is local.
+2. **Free OpenRouter easy-lane models may log prompts.** `--lane easy` / `--worker openrouter` is for **non-secret** wording/drafts only. The refuse gate (`start` / `send`, plus the runner's re-check) applies to every lane — never send key-shaped material to the easy lane.
+3. **Always-approve is powerful.** Default headless workers skip interactive permission prompts (`--always-approve` / `--dangerously-skip-permissions`). Opt out with `--ask` / `CURSOR_ROUTE_ASK=1` when you need HITL.
+4. **Install from known channels only.** Prefer `npm i -g cursor-route` or a git clone of this repo. Do not pipe unknown `curl | bash` installers as the primary path.
+5. **Workers inherit your auth.** Grok CLI and Claude Code / claude-ds use *your* local login. Treat worker panes like you would treat your own shell.
+6. **No LIVE Discord / trading egress demos** from this tool. Orchestration is local.
 
 ## Supply chain
 
-- Declared runtime npm dependencies: **none**. System needs: Node ≥20 or Bun, `tmux`, and worker CLIs (Grok / claude-ds).
+- Declared runtime npm dependencies: **none**. System needs: Node ≥20 or Bun, `tmux`, worker CLIs (Grok / claude-ds), and an OpenRouter API key for the easy lane.
 - The npm package ships a compiled `dist/` (plain JS, no loader). The bin shim and the completion hook run the compiled JS via `node`; there is **no network fetch of `tsx` on the happy path**.
 - Running from a git clone without a build uses Bun to execute `src/` directly (Bun runs TypeScript natively) — also offline-friendly.
 - Review `package.json` before upgrading.

package/dist/adapters/index.js

@@ -1,8 +1,10 @@
 import { grokAdapter } from "./grok.js";
 import { claudeDsAdapter } from "./claude-ds.js";
+import { openRouterAdapter } from "./openrouter.js";
 const registry = {
     grok: grokAdapter,
     "claude-ds": claudeDsAdapter,
+    openrouter: openRouterAdapter,
 };
 export function getAdapter(worker) {
     const a = registry[worker];

package/dist/adapters/openrouter.js

@@ -0,0 +1,78 @@
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { shellQuote } from "../util.js";
+import { openRouterModel, openRouterBaseUrl } from "../config.js";
+/**
+ * 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() {
+    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() {
+    const key = process.env.OPENROUTER_API_KEY;
+    if (!key)
+        return undefined;
+    const env = { 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 = {
+    kind: "openrouter",
+    label: "OpenRouter (free easy lane)",
+    health() {
+        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/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 /**
- * cursor-route CLI — Cursor brain, Grok + DeepSeek workers in tmux.
+ * cursor-route CLI — Cursor brain, Grok + DeepSeek + OpenRouter (easy) workers in tmux.
  */
 import { readFileSync, existsSync, realpathSync, statSync } from "node:fs";
 import { resolve, basename } from "node:path";
@@ -12,7 +12,7 @@ import { looksLikeSecretMaterial, redactSecrets } from "./secrets.js";
 function usage(exitCode = 0) {
     console.log(`cursor-route v${config.version}
 
-Cursor stays the brain. Grok CLI + DeepSeek (claude-ds) are the parallel army.
+Cursor stays the brain. Grok CLI + DeepSeek (claude-ds) + OpenRouter (easy) are the parallel army.
 
 Usage:
   cursor-route --version
@@ -29,13 +29,13 @@ Usage:
   cursor-route clean [--days N]
 
 Start options:
-  --worker <grok|claude-ds>   Worker adapter (default: grok)
-  --lane <mid|hard>           Lane → worker (mid=claude-ds, hard=grok)
-  --dir <path>                Working directory (default: cwd)
-  --ask                       Disable always-approve for this job
-  --dry-run                   Print launch command; do not start
-  --no-tmux                   Headless background process (no attach/send)
-  --json                      JSON output where supported
+  --worker <grok|claude-ds|openrouter>  Worker adapter (default: grok)
+  --lane <easy|mid|hard>                Lane → worker (easy=openrouter, mid=claude-ds, hard=grok)
+  --dir <path>                          Working directory (default: cwd)
+  --ask                                 Disable always-approve for this job
+  --dry-run                             Print launch command; do not start
+  --no-tmux                             Headless background process (no attach/send)
+  --json                                JSON output where supported
 
 Env:
   CURSOR_ROUTE_ASK=1                 Opt out of always-approve
@@ -45,6 +45,9 @@ Env:
   CURSOR_ROUTE_ALLOW_ANTHROPIC=1     Allow mid-lane on Anthropic Claude (expensive; not default)
   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)
+  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)
 `);
     process.exit(exitCode);
 }

package/dist/config.js

@@ -1,8 +1,16 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { defaultJobsDir } from "./runtime.js";
-export const WORKERS = ["grok", "claude-ds"];
-export const LANES = ["mid", "hard"];
+export const WORKERS = ["grok", "claude-ds", "openrouter"];
+export const LANES = ["easy", "mid", "hard"];
+/** OpenRouter model for the easy lane (env CURSOR_ROUTE_OPENROUTER_MODEL). */
+export function openRouterModel() {
+    return process.env.CURSOR_ROUTE_OPENROUTER_MODEL || "openrouter/free";
+}
+/** OpenRouter API base URL (env OPENROUTER_BASE_URL). */
+export function openRouterBaseUrl() {
+    return process.env.OPENROUTER_BASE_URL || "https://openrouter.ai/api/v1";
+}
 function maxConcurrentJobsFromEnv() {
     const raw = process.env.CURSOR_ROUTE_MAX_JOBS;
     if (raw) {
@@ -19,7 +27,7 @@ function maxConcurrentJobsFromEnv() {
  */
 export const config = {
     product: "cursor-route",
-    version: "0.1.4",
+    version: "0.1.5",
     get jobsDir() {
         return defaultJobsDir();
     },
@@ -27,6 +35,7 @@ export const config = {
     defaultWorker: "grok",
     /** Lane → default worker (Cemini /route public core). */
     laneWorkers: {
+        easy: "openrouter",
         mid: "claude-ds",
         hard: "grok",
     },

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/demo-notes.md

@@ -4,16 +4,17 @@ Simulated capture output for README / tweet assets — replace with a real GIF o
 
 ```
 $ cursor-route --version
-0.1.4
+0.1.5
 
 $ cursor-route health
-cursor-route v0.1.4
+cursor-route v0.1.5
 health: OK
   ✓ tmux
   ✓ runtime          bun ok
   ✓ script(1)
   ✓ worker:grok
   ✓ worker:claude-ds
+  ✓ worker:openrouter
   ✓ jobs_dir         ~/.local/share/cursor-route/jobs
 
 $ cursor-route start --lane mid "Add a failing test then make it pass"

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,7 +8,7 @@ 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.
@@ -20,7 +20,7 @@ No. The mid worker is DeepSeek. Claude Code is the harness, configured with `ANT
 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.5",
+  "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": {
@@ -38,6 +38,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,11 @@ 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).
 
 ## Workflow
 
@@ -45,7 +47,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/index.ts

@@ -2,10 +2,12 @@ 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";
 
 const registry: Record<WorkerKind, Adapter> = {
   grok: grokAdapter,
   "claude-ds": claudeDsAdapter,
+  openrouter: openRouterAdapter,
 };
 
 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/cli.test.ts

@@ -7,6 +7,9 @@ import { looksLikeSecretMaterial, redactSecrets } from "./secrets.ts";
 import { isDeepSeekRouted, isDeepSeekBaseUrl } from "./adapters/claude-ds.ts";
 
 describe("resolveWorker", () => {
+  test("lane easy → openrouter", () => {
+    expect(resolveWorker({ prompt: "x", lane: "easy" })).toBe("openrouter");
+  });
   test("lane mid → claude-ds", () => {
     expect(resolveWorker({ prompt: "x", lane: "mid" })).toBe("claude-ds");
   });
@@ -17,6 +20,9 @@ describe("resolveWorker", () => {
     expect(resolveWorker({ prompt: "x", lane: "hard", worker: "claude-ds" })).toBe(
       "claude-ds",
     );
+    expect(resolveWorker({ prompt: "x", lane: "mid", worker: "openrouter" })).toBe(
+      "openrouter",
+    );
   });
   test("default worker", () => {
     expect(resolveWorker({ prompt: "x" })).toBe(config.defaultWorker);

package/src/cli.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 /**
- * cursor-route CLI — Cursor brain, Grok + DeepSeek workers in tmux.
+ * cursor-route CLI — Cursor brain, Grok + DeepSeek + OpenRouter (easy) workers in tmux.
  */
 import { readFileSync, existsSync, realpathSync, statSync } from "node:fs";
 import { resolve, basename } from "node:path";
@@ -27,7 +27,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) are the parallel army.
+Cursor stays the brain. Grok CLI + DeepSeek (claude-ds) + OpenRouter (easy) are the parallel army.
 
 Usage:
   cursor-route --version
@@ -44,13 +44,13 @@ Usage:
   cursor-route clean [--days N]
 
 Start options:
-  --worker <grok|claude-ds>   Worker adapter (default: grok)
-  --lane <mid|hard>           Lane → worker (mid=claude-ds, hard=grok)
-  --dir <path>                Working directory (default: cwd)
-  --ask                       Disable always-approve for this job
-  --dry-run                   Print launch command; do not start
-  --no-tmux                   Headless background process (no attach/send)
-  --json                      JSON output where supported
+  --worker <grok|claude-ds|openrouter>  Worker adapter (default: grok)
+  --lane <easy|mid|hard>                Lane → worker (easy=openrouter, mid=claude-ds, hard=grok)
+  --dir <path>                          Working directory (default: cwd)
+  --ask                                 Disable always-approve for this job
+  --dry-run                             Print launch command; do not start
+  --no-tmux                             Headless background process (no attach/send)
+  --json                                JSON output where supported
 
 Env:
   CURSOR_ROUTE_ASK=1                 Opt out of always-approve
@@ -60,6 +60,9 @@ Env:
   CURSOR_ROUTE_ALLOW_ANTHROPIC=1     Allow mid-lane on Anthropic Claude (expensive; not default)
   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)
+  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)
 `);
   process.exit(exitCode);
 }

package/src/config.ts

@@ -2,11 +2,21 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { defaultJobsDir } from "./runtime.ts";
 
-export type WorkerKind = "grok" | "claude-ds";
-export type Lane = "mid" | "hard";
+export type WorkerKind = "grok" | "claude-ds" | "openrouter";
+export type Lane = "easy" | "mid" | "hard";
 
-export const WORKERS: WorkerKind[] = ["grok", "claude-ds"];
-export const LANES: Lane[] = ["mid", "hard"];
+export const WORKERS: WorkerKind[] = ["grok", "claude-ds", "openrouter"];
+export const LANES: Lane[] = ["easy", "mid", "hard"];
+
+/** OpenRouter model for the easy lane (env CURSOR_ROUTE_OPENROUTER_MODEL). */
+export function openRouterModel(): string {
+  return process.env.CURSOR_ROUTE_OPENROUTER_MODEL || "openrouter/free";
+}
+
+/** OpenRouter API base URL (env OPENROUTER_BASE_URL). */
+export function openRouterBaseUrl(): string {
+  return process.env.OPENROUTER_BASE_URL || "https://openrouter.ai/api/v1";
+}
 
 function maxConcurrentJobsFromEnv(): number {
   const raw = process.env.CURSOR_ROUTE_MAX_JOBS;
@@ -24,7 +34,7 @@ function maxConcurrentJobsFromEnv(): number {
  */
 export const config = {
   product: "cursor-route",
-  version: "0.1.4",
+  version: "0.1.5",
   get jobsDir(): string {
     return defaultJobsDir();
   },
@@ -32,6 +42,7 @@ export const config = {
   defaultWorker: "grok" as WorkerKind,
   /** Lane → default worker (Cemini /route public core). */
   laneWorkers: {
+    easy: "openrouter" as WorkerKind,
     mid: "claude-ds" as WorkerKind,
     hard: "grok" as WorkerKind,
   },

package/src/integration.test.ts

@@ -134,6 +134,13 @@ describe("fake-worker integration (headless, no tmux)", () => {
     20000,
   );
 
+  test("openrouter worker without key refuses start (preflight)", () => {
+    delete process.env.OPENROUTER_API_KEY;
+    const r = startJob({ prompt: "say ok", worker: "openrouter", noTmux: true });
+    expect(r.ok).toBe(false);
+    if (!r.ok) expect(r.error).toContain("openrouter");
+  });
+
   test(
     "concurrent limit: refuses start once active jobs reach CURSOR_ROUTE_MAX_JOBS",
     async () => {

package/src/openrouter-run.ts

@@ -0,0 +1,102 @@
+#!/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.ts";
+import { looksLikeSecretMaterial } from "./secrets.ts";
+
+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: string, code: number): never {
+  console.error(`cursor-route/openrouter-run: ${msg}`);
+  process.exit(code);
+}
+
+function parseArgs(argv: string[]): { promptFile?: string } {
+  const flags: { promptFile?: string } = {};
+  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(): Promise<void> {
+  const { promptFile } = parseArgs(process.argv.slice(2));
+  if (!promptFile) fail("--prompt-file <path> is required", 2);
+
+  let prompt: string;
+  try {
+    prompt = readFileSync(promptFile, "utf8");
+  } catch (e) {
+    fail(`cannot read prompt file: ${(e as Error).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: Response;
+  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 as Error).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()) as {
+    choices?: Array<{ message?: { content?: string } }>;
+  };
+  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));