cursor-route 0.1.1 → 0.1.5

package/dist/tmux.js

@@ -0,0 +1,117 @@
+import { spawnSync, execSync } from "node:child_process";
+import { config, sessionName } from "./config.js";
+import { shellQuote } from "./util.js";
+import { markCompleteInvoker } from "./runtime.js";
+export function isTmuxAvailable() {
+    try {
+        execSync("command -v tmux", { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function sessionExists(name) {
+    try {
+        execSync(`tmux has-session -t ${shellQuote(name)} 2>/dev/null`, {
+            stdio: "ignore",
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function listManagedSessions() {
+    try {
+        const out = execSync('tmux list-sessions -F "#{session_name}" 2>/dev/null', {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (!out)
+            return [];
+        return out.split("\n").filter((n) => n.startsWith(`${config.tmuxPrefix}-`));
+    }
+    catch {
+        return [];
+    }
+}
+export function capturePane(name, lines = 50) {
+    try {
+        return execSync(`tmux capture-pane -t ${shellQuote(name)} -p -S -${Math.max(1, lines)}`, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    }
+    catch {
+        return "";
+    }
+}
+export function sendKeys(name, message) {
+    if (!sessionExists(name))
+        return false;
+    // Reject embedded newlines — they would submit early even with -l
+    if (/[\r\n]/.test(message))
+        return false;
+    try {
+        // -l = literal keys (so "C-c" types text, does not SIGINT the worker)
+        execSync(`tmux send-keys -l -t ${shellQuote(name)} -- ${shellQuote(message)}`, { stdio: "ignore" });
+        spawnSync("sleep", ["0.25"]);
+        execSync(`tmux send-keys -t ${shellQuote(name)} Enter`, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function killSession(name) {
+    try {
+        execSync(`tmux kill-session -t ${shellQuote(name)}`, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function attachHint(jobId) {
+    return `tmux attach -t ${sessionName(jobId)}`;
+}
+/**
+ * Create a detached tmux session that runs `workerCmd` via `sh -c` under `script`,
+ * then marks the job complete and exits the session.
+ * Always quote the shell expression so macOS BSD `script` does not split `cd && …`.
+ */
+export function createWorkerSession(options) {
+    const name = sessionName(options.jobId);
+    const isLinux = process.platform === "linux";
+    const invoker = markCompleteInvoker(options.markCompleteScript);
+    const completion = [
+        `exit_code=$?`,
+        `${invoker} ${shellQuote(options.jobFile)} "$exit_code" ${shellQuote(options.logFile)}`,
+        `echo ""`,
+        `echo "[cursor-route: session complete — closing in 5s]"`,
+        `sleep 5`,
+        `tmux kill-session -t ${shellQuote(name)} 2>/dev/null || true`,
+    ].join("; ");
+    // Always run workerCmd under sh -c so `cd … && …` stays one expression.
+    // Linux script: script -q -e -c '<cmd>' <logfile>
+    // macOS script: script -q <logfile> <cmd> <args...>
+    const wrapped = isLinux
+        ? `script -q -e -c ${shellQuote(`/bin/sh -c ${shellQuote(options.workerCmd)}`)} ${shellQuote(options.logFile)}; ${completion}`
+        : `script -q ${shellQuote(options.logFile)} /bin/sh -c ${shellQuote(options.workerCmd)}; ${completion}`;
+    const args = ["new-session", "-d", "-s", name, "-c", options.cwd];
+    if (options.env) {
+        for (const [k, v] of Object.entries(options.env)) {
+            args.push("-e", `${k}=${v}`);
+        }
+    }
+    args.push(wrapped);
+    const r = spawnSync("tmux", args, {
+        encoding: "utf8",
+        cwd: options.cwd,
+    });
+    if (r.status !== 0) {
+        return {
+            ok: false,
+            error: (r.stderr || r.stdout || "tmux new-session failed").toString().trim(),
+        };
+    }
+    return { ok: true, session: name };
+}

package/dist/util.js

@@ -0,0 +1,21 @@
+import { spawnSync } from "node:child_process";
+/** Shell-escape a string for single-quoted POSIX use. */
+export function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+/** Short job id (8 hex chars). */
+export function newJobId() {
+    const bytes = crypto.getRandomValues(new Uint8Array(4));
+    return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+export function commandExists(cmd) {
+    try {
+        const r = spawnSync("sh", ["-c", `command -v ${shellQuote(cmd)}`], {
+            encoding: "utf8",
+        });
+        return r.status === 0 && Boolean(r.stdout?.trim());
+    }
+    catch {
+        return false;
+    }
+}

package/docs/DEMO_GIF.md

@@ -3,10 +3,14 @@
 tmux is required for the viral attach/send demo. On this laptop brew needs sudo — record after:
 
 ```bash
-brew install tmux
-export PATH="$HOME/.cursor-route/bin:$PATH"
+# tmux may live at ~/.local/bin/tmux (already on PATH in this setup); otherwise:
+# brew install tmux
+command -v tmux
 cursor-route health
 
+# Jobs live under the XDG data dir, not a git clone:
+# ~/.local/share/cursor-route/jobs  (override: CURSOR_ROUTE_JOBS_DIR)
+
 # Terminal A — three parallel jobs
 cursor-route start --lane hard --dir "$PWD" "Add README section Demo"
 cursor-route start --lane mid --dir "$PWD" "Add a unit test for shellQuote"
@@ -17,6 +21,9 @@ cursor-route jobs --json
 # Attach one pane for the GIF: tmux attach -t cursor-route-<id>
 ```
 
+If you previously exported `$HOME/.cursor-route/bin`, that dir is stale — remove it:
+`rm -rf ~/.cursor-route/bin` (the launcher lives in the installed package, not there).
+
 Record with [asciinema](https://asciinema.org/) or CleanShot → export GIF → `docs/fixtures/hero.gif`.
 
 Until then, use `docs/fixtures/claude-ds-smoke.log` as the committed proof fixture.

package/docs/demo-notes.md

@@ -3,14 +3,19 @@
 Simulated capture output for README / tweet assets — replace with a real GIF once tmux is available.
 
 ```
+$ cursor-route --version
+0.1.5
+
 $ cursor-route health
-cursor-route v0.1.0
+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"
 started a1b2c3d4 (claude-ds)
@@ -23,3 +28,6 @@ $ cursor-route jobs --json
 
 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.
+
+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/docs/fixtures/claude-ds-smoke.log

@@ -1,5 +1,5 @@
 claude-ds - DeepSeek Claude Code (model=deepseek-v4-flash)
 Install: ~/.deepseek-claude
-PromptFile: ~/.cursor-route/jobs/e7567d1f.prompt
+PromptFile: ~/.local/share/cursor-route/jobs/e7567d1f.prompt
 WorkDir: ~/Projects/cursor-route
 CURSOR_ROUTE_SMOKE_OK

package/llms.txt

@@ -0,0 +1,29 @@
+# cursor-route
+
+> 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
+
+## 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).
+
+### 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`.
+
+### 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 easy lane can be free on OpenRouter's free-model route (`openrouter/free`).
+
+## Install
+
+- npm: `npm i -g cursor-route`
+- Health: `cursor-route health`
+- Skill: `/route-orch` (Cursor)

package/package.json

@@ -1,37 +1,44 @@
 {
   "name": "cursor-route",
-  "version": "0.1.1",
-  "description": "Cursor stays the brain. Grok CLI + DeepSeek (claude-ds) are the parallel army — 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": {
-    "cursor-route": "./bin/cursor-route.js"
+    "cursor-route": "./bin/cursor-route"
   },
   "engines": {
     "node": ">=20"
   },
   "files": [
     "bin",
+    "dist",
     "src",
     "skills",
-    "docs",
+    "docs/DEMO_GIF.md",
+    "docs/demo-notes.md",
+    "docs/fixtures",
     "LICENSE",
     "SECURITY.md",
+    "SUPPORT.md",
     "CONTRIBUTING.md",
-    "README.md"
+    "README.md",
+    "llms.txt"
   ],
   "scripts": {
     "start": "bun run src/cli.ts",
     "health": "bun run src/cli.ts health",
     "test": "bun test",
     "typecheck": "tsc --noEmit",
-    "prepublishOnly": "bun test && bun run typecheck"
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "bun test && bun run typecheck && bun run build"
   },
   "keywords": [
     "cursor",
     "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/claude-ds.ts

@@ -20,7 +20,7 @@ import { shellQuote } from "../util.ts";
 function which(cmd: string): string | null {
   try {
     return (
-      execSync(`command -v ${cmd}`, {
+      execSync(`command -v ${shellQuote(cmd)}`, {
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"],
       }).trim() || null
@@ -30,37 +30,58 @@ function which(cmd: string): string | null {
   }
 }
 
+/** True when URL hostname is deepseek.com (or a subdomain). */
+export function isDeepSeekBaseUrl(url: string): boolean {
+  try {
+    const u = new URL(url);
+    const host = u.hostname.toLowerCase();
+    return host === "deepseek.com" || host.endsWith(".deepseek.com");
+  } catch {
+    return false;
+  }
+}
+
 function deepseekBaseFromSettings(): string | null {
-  const candidates = [
-    join(homedir(), ".claude", "settings.json"),
-    join(process.cwd(), ".claude", "settings.json"),
-  ];
-  for (const p of candidates) {
-    if (!existsSync(p)) continue;
-    try {
-      const j = JSON.parse(readFileSync(p, "utf8")) as {
-        env?: Record<string, string>;
-      };
-      const url = j.env?.ANTHROPIC_BASE_URL;
-      if (url) return url;
-    } catch {
-      /* ignore */
-    }
+  // Home settings only — do not trust cwd/.claude/settings.json (spoof / exfil risk)
+  const p = join(homedir(), ".claude", "settings.json");
+  if (!existsSync(p)) return null;
+  try {
+    const j = JSON.parse(readFileSync(p, "utf8")) as {
+      env?: Record<string, string>;
+    };
+    const url = j.env?.ANTHROPIC_BASE_URL;
+    if (url && isDeepSeekBaseUrl(url)) return url;
+  } catch {
+    /* ignore */
+  }
+  return null;
+}
+
+/** Resolved DeepSeek base URL for the mid-lane harness, or null. */
+export function resolvedDeepSeekBaseUrl(): string | null {
+  for (const candidate of [
+    process.env.ANTHROPIC_BASE_URL,
+    process.env.CURSOR_ROUTE_ANTHROPIC_BASE_URL,
+    deepseekBaseFromSettings(),
+  ]) {
+    if (candidate && isDeepSeekBaseUrl(candidate)) return candidate;
   }
   return null;
 }
 
 /** True when Claude Code harness is routed to DeepSeek (cheap path). */
 export function isDeepSeekRouted(): boolean {
-  const url =
-    process.env.ANTHROPIC_BASE_URL ||
-    process.env.CURSOR_ROUTE_ANTHROPIC_BASE_URL ||
-    deepseekBaseFromSettings() ||
-    "";
-  return /deepseek\.com/i.test(url);
+  return Boolean(resolvedDeepSeekBaseUrl());
 }
 
 function resolveClaudeDs(): { binary: string; mode: string } | null {
+  // Env override lets tests pin a fake claude-ds (and power users pick a specific binary).
+  if (process.env.CURSOR_ROUTE_CLAUDE_DS_BIN) {
+    return {
+      binary: process.env.CURSOR_ROUTE_CLAUDE_DS_BIN,
+      mode: "claude-ds (CURSOR_ROUTE_CLAUDE_DS_BIN override)",
+    };
+  }
   for (const c of [
     { cmd: "claude-ds", mode: "claude-ds (DeepSeek shim)" },
     { cmd: "deepseek-claude", mode: "deepseek-claude" },
@@ -93,6 +114,25 @@ function resolveClaudeDs(): { binary: string; mode: string } | null {
   return null;
 }
 
+/**
+ * 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 {
+  const base = resolvedDeepSeekBaseUrl();
+  if (!base) return undefined;
+  const env: Record<string, string> = { ANTHROPIC_BASE_URL: base };
+  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;
+}
+
 export const claudeDsAdapter: Adapter = {
   kind: "claude-ds",
   label: "DeepSeek (via Claude Code harness)",
@@ -124,6 +164,10 @@ export const claudeDsAdapter: Adapter = {
 
     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;
 
     if (resolved.mode.startsWith("claude-ds")) {
       const parts = [
@@ -136,6 +180,7 @@ export const claudeDsAdapter: Adapter = {
         worker: "claude-ds",
         command: `cd ${shellQuote(cwd)} && ${parts.join(" ")}`,
         alwaysApprove: skip,
+        env,
       };
     }
 
@@ -149,6 +194,7 @@ export const claudeDsAdapter: Adapter = {
       worker: "claude-ds",
       command: `cd ${shellQuote(cwd)} && ${parts.join(" ")}`,
       alwaysApprove: skip,
+      env,
     };
   },
 };

package/src/adapters/grok.ts

@@ -3,11 +3,15 @@ import type { Adapter, WorkerHealth } from "./types.ts";
 import { shellQuote } from "../util.ts";
 
 function findGrok(): string | null {
+  // Env override lets tests pin a fake grok (and power users pick a specific binary).
+  if (process.env.CURSOR_ROUTE_GROK_BIN) return process.env.CURSOR_ROUTE_GROK_BIN;
   try {
-    return execSync("command -v grok", {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim() || null;
+    return (
+      execSync("command -v grok", {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+      }).trim() || null
+    );
   } catch {
     return null;
   }
@@ -34,8 +38,9 @@ export const grokAdapter: Adapter = {
     };
   },
   buildLaunch({ promptFile, cwd, alwaysApprove }) {
+    const binary = findGrok() || "grok";
     const parts = [
-      "grok",
+      shellQuote(binary),
       "-p",
       `"$(cat ${shellQuote(promptFile)})"`,
       "--cwd",

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/adapters/types.ts

@@ -12,6 +12,8 @@ export interface LaunchPlan {
   /** Full shell command to run inside tmux (prompt already inlined via cat). */
   command: string;
   alwaysApprove: boolean;
+  /** Extra env for the worker process (never print secret values). */
+  env?: Record<string, string>;
 }
 
 export interface Adapter {