cursor-route 0.1.5 → 0.1.7

package/docs/briefs/WORKING.md

@@ -0,0 +1,61 @@
+---
+title: cursor-route workspace — working brief (edit in place)
+repo: ~/Projects/cursor-route
+npm: cursor-route@0.1.7 (LIVE on npm latest)
+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**; `--model pro` when needed) |
+| `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.
+
+Install: `npm i -g cursor-route` → **0.1.7**. Release notes: [CHANGELOG.md](../../CHANGELOG.md).
+
+## Open (edit / check off)
+
+- [x] **Flash vs Pro on the CLI** — public default **Flash**; `--model pro` → `deepseek-v4-pro` (LIVE 0.1.6+)
+  - [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
+- [x] **0.1.7 debug fixes** — env default wired through `startJob`; Anthropic hatch omits DS ids; preserve `[1m]`
+- [ ] **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 |
+| `CHANGELOG.md` | Release notes |
+| `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. |
+| 2026-08-12 | npm `cursor-route@0.1.6` LIVE; CHANGELOG + README skill-install path fixed. |
+| 2026-08-12 | Grok debug → 0.1.7: env DS default, Anthropic hatch, `[1m]` preserve. |

package/docs/demo-notes.md

@@ -4,10 +4,10 @@ Simulated capture output for README / tweet assets — replace with a real GIF o
 
 ```
 $ cursor-route --version
-0.1.5
+0.1.6
 
 $ cursor-route health
-cursor-route v0.1.5
+cursor-route v0.1.6
 health: OK
   ✓ tmux
   ✓ runtime          bun ok
@@ -15,19 +15,21 @@ health: OK
   ✓ 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

@@ -2,7 +2,7 @@
 
 > 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  
+MIT CLI + Cursor skill. npm: https://www.npmjs.com/package/cursor-route (latest **0.1.7**)  
 GitHub: https://github.com/cemini23/cursor-route
 
 ## FAQ
@@ -14,10 +14,16 @@ cursor-route is a public MIT CLI and Cursor skill that runs parallel coding work
 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`).
+
+### Flash vs Pro?
+| Flag | Model | When |
+|------|-------|------|
+| `--model flash` (default) | `deepseek-v4-flash` | Cheap mid execute |
+| `--model pro` | `deepseek-v4-pro` | Harder mid / Grok usage stand-in |
 
 ### 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.
+Run `npm i -g cursor-route`, install tmux if needed, then run `cursor-route health`. Copy the Cursor skill from `$(npm root -g)/cursor-route/skills/route-orch`. Source: https://github.com/cemini23/cursor-route
 
 ### Is it free?
 The cursor-route code is open source under MIT. It does not make the worker services free. Your costs depend on Cursor, DeepSeek API usage, and the Grok access or balance available to you. The easy lane can be free on OpenRouter's free-model route (`openrouter/free`).
@@ -26,4 +32,5 @@ The cursor-route code is open source under MIT. It does not make the worker serv
 
 - npm: `npm i -g cursor-route`
 - Health: `cursor-route health`
+- Mid: `cursor-route start --lane mid "…"` (Flash) · `--model pro` when needed
 - Skill: `/route-orch` (Cursor)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-route",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "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",
@@ -17,11 +17,13 @@
     "skills",
     "docs/DEMO_GIF.md",
     "docs/demo-notes.md",
+    "docs/briefs/WORKING.md",
     "docs/fixtures",
     "LICENSE",
     "SECURITY.md",
     "SUPPORT.md",
     "CONTRIBUTING.md",
+    "CHANGELOG.md",
     "README.md",
     "llms.txt"
   ],

package/skills/route-orch/SKILL.md

@@ -30,6 +30,22 @@ You are the **orchestrator**. Do **not** implement bulk code in this Cursor sess
 
 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
 
 1. Run `cursor-route health` (or `CURSOR_ROUTE_RELAXED=1` for headless). If the **target worker** is unhealthy, fix before spawning.

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,
+  resolveDsModel,
+} from "../config.ts";
 import { shellQuote } from "../util.ts";
 
 /**
@@ -23,6 +29,8 @@ function which(cmd: string): string | null {
       execSync(`command -v ${shellQuote(cmd)}`, {
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"],
+        // Bun may ignore mutated process.env.PATH unless env is passed explicitly
+        env: { ...process.env },
       }).trim() || null
     );
   } catch {
@@ -59,14 +67,16 @@ function deepseekBaseFromSettings(): string | null {
 
 /** Resolved DeepSeek base URL for the mid-lane harness, or null. */
 export function resolvedDeepSeekBaseUrl(): string | null {
+  // Explicit env wins: a non-DeepSeek ANTHROPIC_BASE_URL must not fall through to settings.
   for (const candidate of [
     process.env.ANTHROPIC_BASE_URL,
     process.env.CURSOR_ROUTE_ANTHROPIC_BASE_URL,
-    deepseekBaseFromSettings(),
   ]) {
-    if (candidate && isDeepSeekBaseUrl(candidate)) return candidate;
+    if (candidate) {
+      return isDeepSeekBaseUrl(candidate) ? candidate : null;
+    }
   }
-  return null;
+  return deepseekBaseFromSettings();
 }
 
 /** True when Claude Code harness is routed to DeepSeek (cheap path). */
@@ -114,22 +124,35 @@ function resolveClaudeDs(): { binary: string; mode: string } | null {
   return null;
 }
 
+function pickModel(requested?: DsModelAlias, modelId?: string): { alias: DsModelAlias; id: string } {
+  if (modelId) {
+    const alias = requested ?? resolveDsModel(modelId).alias;
+    return { alias, id: modelId };
+  }
+  if (requested) {
+    return { alias: requested, id: DS_MODEL_IDS[requested] };
+  }
+  // Env default (startJob normally resolves this; kept for direct buildLaunch callers)
+  return resolveDsModel(process.env.CURSOR_ROUTE_DS_MODEL || process.env.ANTHROPIC_MODEL);
+}
+
 /**
  * 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,10 +176,10 @@ 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, modelId }) {
     const resolved = resolveClaudeDs();
     if (!resolved) {
       throw new Error("DeepSeek worker not available — run: cursor-route health");
@@ -164,16 +187,37 @@ 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;
+    const isAnthropicEscape = resolved.mode.startsWith("claude → Anthropic");
+    const isDeepSeekStock = resolved.mode.startsWith("claude → DeepSeek");
+    const isShim =
+      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.
+    if (isAnthropicEscape) {
+      const parts = [
+        shellQuote(resolved.binary),
+        "-p",
+        `"$(cat ${shellQuote(promptFile)})"`,
+      ];
+      if (skip) parts.push("--dangerously-skip-permissions");
+      return {
+        worker: "claude-ds",
+        command: `cd ${shellQuote(cwd)} && ${parts.join(" ")}`,
+        alwaysApprove: skip,
+      };
+    }
+
+    const choice = pickModel(model, modelId);
+    const env = isDeepSeekStock ? deepSeekWorkerEnv(choice.id) : undefined;
 
-    if (resolved.mode.startsWith("claude-ds")) {
+    if (isShim) {
       const parts = [
         shellQuote(resolved.binary),
         "-PromptFile",
         shellQuote(promptFile),
+        "-Model",
+        shellQuote(choice.id),
       ];
       if (skip) parts.push("--dangerously-skip-permissions");
       return {
@@ -184,10 +228,13 @@ export const claudeDsAdapter: Adapter = {
       };
     }
 
+    // Stock claude → DeepSeek
     const parts = [
       shellQuote(resolved.binary),
       "-p",
       `"$(cat ${shellQuote(promptFile)})"`,
+      "--model",
+      shellQuote(choice.id),
     ];
     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

@@ -3,11 +3,13 @@ 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/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,9 @@ export interface Adapter {
     promptFile: string;
     cwd: string;
     alwaysApprove: boolean;
+    /** Mid-lane DeepSeek flash|pro (ignored by other workers / Anthropic escape hatch). */
+    model?: DsModelAlias;
+    /** Concrete DeepSeek model id for -Model/--model (preserves pro[1m]). */
+    modelId?: string;
   }): LaunchPlan;
 }

package/src/cli.test.ts

@@ -1,10 +1,15 @@
 import { describe, expect, test } from "bun:test";
-import { resolveWorker } from "./jobs.ts";
-import { config } from "./config.ts";
+import { mkdirSync, writeFileSync, chmodSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { resolveWorker, startJob } from "./jobs.ts";
+import { config, resolveDsModel, resolveDsModelAlias } from "./config.ts";
 import { shellQuote, newJobId } from "./util.ts";
 import { runHealth } from "./health.ts";
 import { looksLikeSecretMaterial, redactSecrets } from "./secrets.ts";
-import { isDeepSeekRouted, isDeepSeekBaseUrl } from "./adapters/claude-ds.ts";
+import { isDeepSeekRouted, isDeepSeekBaseUrl, claudeDsAdapter } from "./adapters/claude-ds.ts";
+import { deepseekAdapter } from "./adapters/deepseek.ts";
+import { grokAdapter } from "./adapters/grok.ts";
 
 describe("resolveWorker", () => {
   test("lane easy → openrouter", () => {
@@ -29,6 +34,205 @@ describe("resolveWorker", () => {
   });
 });
 
+describe("resolveDsModel", () => {
+  test("defaults to flash", () => {
+    expect(resolveDsModel()).toEqual({ alias: "flash", id: "deepseek-v4-flash" });
+    expect(resolveDsModelAlias("")).toBe("flash");
+  });
+  test("accepts aliases and full ids", () => {
+    expect(resolveDsModel("flash").id).toBe("deepseek-v4-flash");
+    expect(resolveDsModel("pro").id).toBe("deepseek-v4-pro");
+    expect(resolveDsModel("deepseek-v4-pro[1m]")).toEqual({
+      alias: "pro",
+      id: "deepseek-v4-pro[1m]",
+    });
+  });
+  test("rejects unknown", () => {
+    expect(() => resolveDsModel("opus")).toThrow(/flash\|pro/);
+  });
+});
+
+describe("claude-ds -Model", () => {
+  test("shim path passes -Model deepseek-v4-flash by default", () => {
+    const prev = process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+    const prevDs = process.env.CURSOR_ROUTE_DS_MODEL;
+    const prevAm = process.env.ANTHROPIC_MODEL;
+    process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = "/tmp/fake-claude-ds";
+    delete process.env.CURSOR_ROUTE_DS_MODEL;
+    delete process.env.ANTHROPIC_MODEL;
+    try {
+      const plan = claudeDsAdapter.buildLaunch({
+        promptFile: "/tmp/p.prompt",
+        cwd: "/tmp",
+        alwaysApprove: true,
+      });
+      expect(plan.command).toContain("-Model");
+      expect(plan.command).toContain("deepseek-v4-flash");
+    } finally {
+      if (prev === undefined) delete process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+      else process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = prev;
+      if (prevDs === undefined) delete process.env.CURSOR_ROUTE_DS_MODEL;
+      else process.env.CURSOR_ROUTE_DS_MODEL = prevDs;
+      if (prevAm === undefined) delete process.env.ANTHROPIC_MODEL;
+      else process.env.ANTHROPIC_MODEL = prevAm;
+    }
+  });
+  test("pro alias maps to deepseek-v4-pro", () => {
+    const prev = process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+    process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = "/tmp/fake-claude-ds";
+    try {
+      const plan = claudeDsAdapter.buildLaunch({
+        promptFile: "/tmp/p.prompt",
+        cwd: "/tmp",
+        alwaysApprove: true,
+        model: "pro",
+      });
+      expect(plan.command).toContain("deepseek-v4-pro");
+      expect(plan.command).not.toContain("deepseek-v4-flash");
+    } finally {
+      if (prev === undefined) delete process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+      else process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = prev;
+    }
+  });
+  test("preserves deepseek-v4-pro[1m] via modelId", () => {
+    const prev = process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+    process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = "/tmp/fake-claude-ds";
+    try {
+      const plan = claudeDsAdapter.buildLaunch({
+        promptFile: "/tmp/p.prompt",
+        cwd: "/tmp",
+        alwaysApprove: true,
+        model: "pro",
+        modelId: "deepseek-v4-pro[1m]",
+      });
+      expect(plan.command).toContain("deepseek-v4-pro[1m]");
+    } finally {
+      if (prev === undefined) delete process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+      else process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = prev;
+    }
+  });
+  test("Anthropic escape hatch omits DeepSeek --model", () => {
+    const shimDir = join(tmpdir(), `cr-anth-escape-${process.pid}`);
+    mkdirSync(shimDir, { recursive: true });
+    const claude = join(shimDir, "claude");
+    writeFileSync(claude, "#!/bin/sh\necho ok\n");
+    chmodSync(claude, 0o755);
+
+    const prev = {
+      bin: process.env.CURSOR_ROUTE_CLAUDE_DS_BIN,
+      allow: process.env.CURSOR_ROUTE_ALLOW_ANTHROPIC,
+      base: process.env.ANTHROPIC_BASE_URL,
+      path: process.env.PATH,
+    };
+    delete process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+    // Explicit non-DeepSeek base so ~/.claude/settings.json cannot force DeepSeek routing
+    process.env.ANTHROPIC_BASE_URL = "https://api.anthropic.com";
+    process.env.CURSOR_ROUTE_ALLOW_ANTHROPIC = "1";
+    process.env.PATH = `${shimDir}:/usr/bin:/bin`;
+    try {
+      const plan = claudeDsAdapter.buildLaunch({
+        promptFile: "/tmp/p.prompt",
+        cwd: "/tmp",
+        alwaysApprove: true,
+        model: "pro",
+      });
+      expect(plan.command).toContain(claude);
+      expect(plan.command).not.toContain("deepseek-v4");
+      expect(plan.command).not.toContain("--model");
+    } finally {
+      if (prev.bin === undefined) delete process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+      else process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = prev.bin;
+      if (prev.allow === undefined) delete process.env.CURSOR_ROUTE_ALLOW_ANTHROPIC;
+      else process.env.CURSOR_ROUTE_ALLOW_ANTHROPIC = prev.allow;
+      if (prev.base === undefined) delete process.env.ANTHROPIC_BASE_URL;
+      else process.env.ANTHROPIC_BASE_URL = prev.base;
+      process.env.PATH = prev.path || "";
+      rmSync(shimDir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("startJob product path", () => {
+  test("CURSOR_ROUTE_DS_MODEL=pro applies when --model unset", () => {
+    const prev = {
+      bin: process.env.CURSOR_ROUTE_CLAUDE_DS_BIN,
+      ds: process.env.CURSOR_ROUTE_DS_MODEL,
+      am: process.env.ANTHROPIC_MODEL,
+      jobs: process.env.CURSOR_ROUTE_JOBS_DIR,
+    };
+    const jobsDir = join(tmpdir(), `cr-jobs-ds-${process.pid}`);
+    mkdirSync(jobsDir, { recursive: true });
+    process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = "/tmp/fake-claude-ds";
+    process.env.CURSOR_ROUTE_DS_MODEL = "pro";
+    delete process.env.ANTHROPIC_MODEL;
+    process.env.CURSOR_ROUTE_JOBS_DIR = jobsDir;
+    try {
+      const result = startJob({
+        prompt: "ping",
+        lane: "mid",
+        dryRun: true,
+      });
+      expect(result.ok).toBe(true);
+      if (!result.ok) return;
+      expect(result.job.model).toBe("pro");
+      expect(result.command).toContain("deepseek-v4-pro");
+      expect(result.command).not.toContain("deepseek-v4-flash");
+    } finally {
+      if (prev.bin === undefined) delete process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+      else process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = prev.bin;
+      if (prev.ds === undefined) delete process.env.CURSOR_ROUTE_DS_MODEL;
+      else process.env.CURSOR_ROUTE_DS_MODEL = prev.ds;
+      if (prev.am === undefined) delete process.env.ANTHROPIC_MODEL;
+      else process.env.ANTHROPIC_MODEL = prev.am;
+      if (prev.jobs === undefined) delete process.env.CURSOR_ROUTE_JOBS_DIR;
+      else process.env.CURSOR_ROUTE_JOBS_DIR = prev.jobs;
+      rmSync(jobsDir, { recursive: true, force: true });
+    }
+  });
+
+  test("--worker deepseek dry-run fails", () => {
+    const result = startJob({
+      prompt: "ping",
+      worker: "deepseek",
+      dryRun: true,
+    });
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error).toMatch(/not available|claude-ds/i);
+  });
+
+  test("grok command never includes deepseek-v4", () => {
+    const prev = process.env.CURSOR_ROUTE_GROK_BIN;
+    process.env.CURSOR_ROUTE_GROK_BIN = "/tmp/fake-grok";
+    try {
+      const plan = grokAdapter.buildLaunch({
+        promptFile: "/tmp/p.prompt",
+        cwd: "/tmp",
+        alwaysApprove: true,
+        model: "pro",
+      });
+      expect(plan.command).not.toContain("deepseek-v4");
+      expect(plan.command).not.toMatch(/(^|[\s'-])Model\b/);
+    } finally {
+      if (prev === undefined) delete process.env.CURSOR_ROUTE_GROK_BIN;
+      else process.env.CURSOR_ROUTE_GROK_BIN = prev;
+    }
+  });
+});
+
+describe("deepseek adapter slot", () => {
+  test("health is not ok and buildLaunch throws", () => {
+    expect(deepseekAdapter.health().ok).toBe(false);
+    expect(() =>
+      deepseekAdapter.buildLaunch({
+        promptFile: "/tmp/p",
+        cwd: "/tmp",
+        alwaysApprove: true,
+      }),
+    ).toThrow(/not available/);
+  });
+});
+
 describe("util", () => {
   test("shellQuote", () => {
     expect(shellQuote("a b")).toBe("'a b'");
@@ -86,11 +290,26 @@ describe("health", () => {
   test("returns structured report", () => {
     const r = runHealth();
     expect(r.product).toBe("cursor-route");
+    expect(r.version).toBe("0.1.7");
     expect(r.checks.length).toBeGreaterThan(3);
     expect(r.checks.some((c) => c.name === "tmux")).toBe(true);
     expect(r.checks.some((c) => c.name === "cursor_cli")).toBe(true);
   });
 
+  test("OR-gate: ok can be true while worker:deepseek is false", () => {
+    const prev = process.env.CURSOR_ROUTE_RELAXED;
+    process.env.CURSOR_ROUTE_RELAXED = "1";
+    try {
+      const r = runHealth();
+      const ds = r.checks.find((c) => c.name === "worker:deepseek");
+      expect(ds?.ok).toBe(false);
+      expect(r.ok).toBe(true);
+    } finally {
+      if (prev === undefined) delete process.env.CURSOR_ROUTE_RELAXED;
+      else process.env.CURSOR_ROUTE_RELAXED = prev;
+    }
+  });
+
   test("relaxed env can pass without workers", () => {
     const prev = process.env.CURSOR_ROUTE_RELAXED;
     process.env.CURSOR_ROUTE_RELAXED = "1";