cursor-route 0.1.6 → 0.1.8

package/CHANGELOG.md

@@ -0,0 +1,40 @@
+# Changelog
+
+## 0.1.8 — 2026-08-14
+
+- Experimental `--worker deepseek`: official DeepSeek Harness (`dsh`, `@deepseek-ai/dsh`) runs headless — `dsh --profile headless` with a per-job Cordis patch pinning the model. Not a mid default: `laneWorkers.mid` stays `claude-ds`.
+- `--model flash|pro` (and `deepseek-v4-pro[1m]`) now applies to both `claude-ds` and `deepseek`; patch sets `agent-default-model` → `provider: deepseek-official` (never rewrites `~/.dsh/settings.yaml`, so parallel jobs don't race).
+- Always-approve → `DSH_PERMISSION_MODE=danger-full-access`; `--ask` → `workspace-write`. `DEEPSEEK_API_KEY` travels via env only — never in the launch command or patch.
+- Health: `worker:deepseek` ✓ only when `dsh` is on PATH (override `CURSOR_ROUTE_DSH_BIN`) **and** `DEEPSEEK_API_KEY` is set.
+- Dry-run for `--worker deepseek` works without `dsh` installed (falls back to plain `dsh` in the printed command); real starts stay gated by health.
+- `clean` also removes leftover `.dsh-patch.yml` files; patch path never overwrites a non-`.prompt` prompt file.
+
+## 0.1.7 — 2026-08-12
+
+- Fix: `CURSOR_ROUTE_DS_MODEL` / `ANTHROPIC_MODEL` now apply on the `start` product path (live default)
+- Fix: Anthropic escape hatch (`CURSOR_ROUTE_ALLOW_ANTHROPIC=1`) no longer passes DeepSeek `--model` ids
+- Fix: preserve `deepseek-v4-pro[1m]` (no silent SKU strip)
+- `--model` validated only for `claude-ds`; ignored for grok/openrouter (including invalid values)
+- `jobs` / `status` text output show `model` when set
+- Tests cover env default via `startJob`, deepseek slot, Anthropic hatch, health OR-gate
+
+## 0.1.6 — 2026-08-12
+
+- Mid lane defaults to DeepSeek **Flash** (`deepseek-v4-flash`)
+- `cursor-route start --model flash|pro` (aliases / full ids accepted)
+- `claude-ds` adapter passes `-Model`; stock `claude` → DeepSeek gets `--model`
+- Reserved `deepseek` worker slot (unreleased official harness; mid stays on `claude-ds`)
+- Docs: Grok **auth** (`grok login`) ≠ usage/quota out → use `--model pro`
+- `route-orch` skill Flash/Pro table; living brief in `docs/briefs/WORKING.md`
+
+## 0.1.5
+
+- OpenRouter free easy lane (`--lane easy` / `--worker openrouter`)
+
+## 0.1.4
+
+- Compiled `dist/` happy path, integration tests, `CURSOR_ROUTE_MAX_JOBS`
+
+## Earlier
+
+See git tags `v0.1.1`–`v0.1.3` for security/hardening and first npm ship notes.

package/CONTRIBUTING.md

@@ -5,22 +5,31 @@
 ```bash
 bun install
 bun test
+bun run typecheck
 ./bin/cursor-route health
 CURSOR_ROUTE_RELAXED=1 ./bin/cursor-route health   # without tmux
 ./bin/cursor-route start --dry-run --worker grok "ping"
+./bin/cursor-route start --dry-run --lane mid --model flash "ping"
+./bin/cursor-route start --dry-run --lane mid --model pro "ping"
+./bin/cursor-route start --dry-run --worker deepseek --model flash "ping"   # needs dsh + DEEPSEEK_API_KEY for real starts
 ```
 
+Keep `skills/route-orch/SKILL.md` and `.cursor/skills/route-orch/SKILL.md` identical when editing the skill.
+
 ## Rules
 
 - No secrets in prompts, fixtures, or commits
 - Do not vendor private `agent-toolkit` paths
 - Prefer adapters over rewriting the job core
 - Always-approve defaults stay documented + opt-out (`--ask` / `CURSOR_ROUTE_ASK=1`)
+- Mid default is Flash; document Pro only as harder mid / Grok **usage** stand-in (not missing `grok login`)
 
 ## Release checklist
 
-1. `bun test`
-2. `cursor-route health` (tmux + ≥1 worker)
-3. One real `start` smoke (grok or claude-ds)
-4. `npm pack --dry-run` — no secrets, no `node_modules`
-5. Tag `v0.x.y` then `npm publish --access public` (maintainers)
+1. Update `package.json` version + [CHANGELOG.md](./CHANGELOG.md) + [docs/briefs/WORKING.md](./docs/briefs/WORKING.md)
+2. `bun test` && `bun run typecheck` && `bun run build`
+3. `cursor-route health` (tmux + ≥1 worker)
+4. One real `start` smoke (grok or claude-ds); dry-run both `--model flash` and `--model pro`
+5. `npm pack --dry-run` — no secrets, no `node_modules`
+6. Commit, tag `v0.x.y`, push
+7. `npm publish --access public` with an isolated `--userconfig` Automation token (Bypass 2FA); **revoke** any chat-pasted token after

package/README.md

@@ -27,7 +27,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 |
+| DeepSeek via claude-ds | DeepSeek API / plan | `--lane mid` implement (**Flash** default; `--model pro` when needed) |
 | 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 |
 
@@ -73,23 +73,26 @@ cd cursor-route && bun install
 
 ### Cursor skill
 
-Copy the skill into your project or user skills:
+After `npm i -g cursor-route`, copy the packaged skill into a project (or user skills):
 
 ```bash
+PKG="$(npm root -g)/cursor-route"
 mkdir -p .cursor/skills
-cp -R ~/.cursor-route-src/skills/route-orch .cursor/skills/
+cp -R "$PKG/skills/route-orch" .cursor/skills/
 ```
 
+From a git clone: `cp -R skills/route-orch .cursor/skills/`.
+
 Then say **`/route-orch`** or **spawn workers** in Cursor — the skill delegates to `cursor-route` (does not replace a private in-house `/route` skill).
 
-Working notes for this repo (edit in place): [docs/briefs/WORKING.md](./docs/briefs/WORKING.md).
+Working notes for this repo (edit in place): [docs/briefs/WORKING.md](./docs/briefs/WORKING.md). See [CHANGELOG.md](./CHANGELOG.md) for release notes.
 
 ## Commands
 
 | Command | Description |
 |---------|-------------|
 | `health` | Gate #1 — tmux, runtime, workers |
-| `start <prompt>` | Spawn worker job (`--worker` / `--lane` / `--dir` / `--ask` / `--dry-run` / `--no-tmux`) |
+| `start <prompt>` | Spawn worker job (`--worker` / `--lane` / `--model` / `--dir` / `--ask` / `--dry-run` / `--no-tmux`) |
 | `jobs [--json]` | List jobs |
 | `status <id>` | Job + sessionAlive |
 | `capture <id> [n]` | Last n pane/log lines |
@@ -99,6 +102,36 @@ Working notes for this repo (edit in place): [docs/briefs/WORKING.md](./docs/bri
 | `sessions` | Managed tmux sessions |
 | `clean [--days N]` | Drop old job files |
 
+## Demo
+
+A dry-run capture (no live workers, no secrets) is committed as a reproducible fixture:
+
+```bash
+# Needs Bun or Node 20+ and a runnable ./bin/cursor-route (clone: bun install)
+docs/fixtures/generate-hero-demo.sh      # regenerate docs/fixtures/hero-demo.log
+```
+
+```text
+$ cursor-route --version
+0.1.8
+
+$ CURSOR_ROUTE_RELAXED=1 cursor-route health
+cursor-route v0.1.8
+health: OK
+
+$ cursor-route start --lane mid --model flash --dry-run "Add a unit test for shellQuote"
+dry-run job a1b2c3d4
+worker: claude-ds
+model:  flash
+command: cd '~/Projects/cursor-route' && '~/.local/bin/claude-ds' -PromptFile '~/.local/share/cursor-route/jobs/a1b2c3d4.prompt' -Model 'deepseek-v4-flash' --dangerously-skip-permissions
+
+$ cursor-route jobs --json
+[]
+```
+
+Full capture: [docs/fixtures/hero-demo.log](./docs/fixtures/hero-demo.log).
+A real hero GIF is still pending — recording steps live in [docs/DEMO_GIF.md](./docs/DEMO_GIF.md).
+
 ## Lanes
 
 | Lane | Worker | Intent |
@@ -115,14 +148,19 @@ Always-approve is **on** by default. Opt out: `--ask` or `CURSOR_ROUTE_ASK=1`.
 |------|----------|------|
 | `--model flash` (default) | `deepseek-v4-flash` | Cheap mid execute |
 | `--model pro` | `deepseek-v4-pro` | Harder mid / Grok **usage** stand-in |
+| `--model deepseek-v4-pro[1m]` | `deepseek-v4-pro[1m]` | Large-context Pro (SKU preserved) |
 
 ```bash
 cursor-route start --lane mid "…"                    # Flash
 cursor-route start --lane mid --model pro "…"        # Pro
+# Or set default without a flag:
+export CURSOR_ROUTE_DS_MODEL=pro   # also honors ANTHROPIC_MODEL; --model overrides
 ```
 
 **Grok auth ≠ usage-out:** if `cursor-route health` shows `worker:grok` ✗, run `grok login` (or set `XAI_API_KEY`). That is auth. Quota / subscription usage exhausted is different — use `--lane mid --model pro` as the stand-in, not a missing login.
 
+`CURSOR_ROUTE_ALLOW_ANTHROPIC=1` is an expensive escape hatch: it does **not** pass DeepSeek `--model` ids (Anthropic would reject them).
+
 ## DeepSeek setup (the cheap mid-lane — this is the point)
 
 `cursor-route` mid lane runs **DeepSeek**, not Anthropic. Claude Code is only the terminal harness; bills go to DeepSeek when `ANTHROPIC_BASE_URL` points at them.
@@ -147,7 +185,18 @@ Persist the same vars under `~/.claude/settings.json` → `"env": { … }` if yo
 
 **Also accepted:** `claude-ds` or `deepseek-claude` on PATH (Cemini shims). The adapter passes `-Model deepseek-v4-flash|deepseek-v4-pro`.
 
-**Reserved:** `--worker deepseek` is a slot for an official DeepSeek coding harness — not wired yet. Mid stays on `claude-ds`.
+**Experimental:** `--worker deepseek` runs the official DeepSeek Harness (`dsh`, npm `@deepseek-ai/dsh`) as an opt-in worker — **mid stays on `claude-ds`**; don't default lanes here.
+
+```bash
+npm i -g @deepseek-ai/dsh
+export DEEPSEEK_API_KEY=YOUR_DEEPSEEK_API_KEY   # from platform.deepseek.com
+
+cursor-route health                              # worker:deepseek should be ✓
+cursor-route start --worker deepseek "…"         # Flash (default)
+cursor-route start --worker deepseek --model pro "…"   # Pro when you need it
+```
+
+The adapter launches `dsh --profile headless` with a **per-job Cordis patch** (`jobs/<id>.dsh-patch.yml`, mode 0600) that pins `--model flash|pro` (`deepseek-v4-pro[1m]` preserved) — it never rewrites `~/.dsh/settings.yaml`, so parallel jobs don't race. Always-approve maps to `DSH_PERMISSION_MODE=danger-full-access`; `--ask` drops to `workspace-write`. Your `DEEPSEEK_API_KEY` travels via env only — never in the launch command or patch. Override the binary with `CURSOR_ROUTE_DSH_BIN`.
 
 **Not the default:** bare `claude` still talking to Anthropic. Health refuses that so a misconfigured install cannot silently burn frontier $ rates. Escape hatch only: `CURSOR_ROUTE_ALLOW_ANTHROPIC=1`.
 
@@ -202,6 +251,7 @@ The cursor-route code is open source under MIT. It does not make the worker serv
 
 ## Related
 
+- Changelog: [CHANGELOG.md](./CHANGELOG.md)
 - Newsletter: [Outlier Weekly](https://outlierweekly.substack.com)
 - YouTube: [@Cemini23](https://www.youtube.com/@Cemini23)
 - Agent meta-wiki: [cemini-claude-code-CCC](https://github.com/cemini23/cemini-claude-code-CCC)
@@ -240,8 +290,8 @@ MIT © Cemini — see [LICENSE](LICENSE).
 
 ## Roadmap (explicitly later)
 
-- Homebrew tap  
-- Native DeepSeek harness adapter  
-- Codebase map injection (`--map`)  
-- Cursor CLI `agent` as alternate supervisor  
+- Homebrew tap
+- Stabilize the DeepSeek harness adapter (experimental `--worker deepseek` since 0.1.8)
+- Codebase map injection (`--map`)
+- Cursor CLI `agent` as alternate supervisor
 - Web UI / CAO-style MCP supervisor

package/dist/adapters/claude-ds.js

@@ -2,7 +2,7 @@ import { execSync } from "node:child_process";
 import { readFileSync, existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { DS_MODEL_IDS, config, resolveDsModelAlias, } from "../config.js";
+import { DS_MODEL_IDS, config, resolveDsModel, } from "../config.js";
 import { shellQuote } from "../util.js";
 /**
  * Mid-lane = DeepSeek (cheap). The Claude Code binary is only a harness —
@@ -20,6 +20,8 @@ function which(cmd) {
         return (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 {
@@ -55,15 +57,16 @@ function deepseekBaseFromSettings() {
 }
 /** Resolved DeepSeek base URL for the mid-lane harness, or null. */
 export function resolvedDeepSeekBaseUrl() {
+    // 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). */
 export function isDeepSeekRouted() {
@@ -105,20 +108,16 @@ function resolveClaudeDs() {
     }
     return null;
 }
-function pickModelAlias(requested) {
-    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 */
-        }
+function pickModel(requested, modelId) {
+    if (modelId) {
+        const alias = requested ?? resolveDsModel(modelId).alias;
+        return { alias, id: modelId };
     }
-    return config.defaultDsModel;
+    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.
@@ -163,27 +162,41 @@ export const claudeDsAdapter = {
             detail: `ok (${resolved.mode}; default model ${DS_MODEL_IDS[config.defaultDsModel]})`,
         };
     },
-    buildLaunch({ promptFile, cwd, alwaysApprove, model }) {
+    buildLaunch({ promptFile, cwd, alwaysApprove, model, modelId }) {
         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(modelId)
-            : undefined;
-        if (resolved.mode.startsWith("claude-ds") || resolved.mode.startsWith("deepseek-claude")) {
+        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 (isShim) {
             const parts = [
                 shellQuote(resolved.binary),
                 "-PromptFile",
                 shellQuote(promptFile),
                 "-Model",
-                shellQuote(modelId),
+                shellQuote(choice.id),
             ];
             if (skip)
                 parts.push("--dangerously-skip-permissions");
@@ -194,12 +207,13 @@ export const claudeDsAdapter = {
                 env,
             };
         }
+        // Stock claude → DeepSeek
         const parts = [
             shellQuote(resolved.binary),
             "-p",
             `"$(cat ${shellQuote(promptFile)})"`,
             "--model",
-            shellQuote(modelId),
+            shellQuote(choice.id),
         ];
         if (skip)
             parts.push("--dangerously-skip-permissions");

package/dist/adapters/deepseek.js

@@ -1,19 +1,138 @@
+import { execSync } from "node:child_process";
+import { existsSync, writeFileSync, unlinkSync } from "node:fs";
+import { shellQuote } from "../util.js";
+import { DS_MODEL_IDS, resolveDsModel, } from "../config.js";
 /**
- * Reserved slot for the official DeepSeek coding harness when it ships.
- * Mid lane stays on claude-ds until then — do not route jobs here.
+ * Experimental official DeepSeek Harness (`dsh`, npm @deepseek-ai/dsh) as a
+ * coding worker — `dsh --profile headless` with a per-job Cordis patch that
+ * pins the model. Mid lane stays on claude-ds; this is an opt-in worker only
+ * (`--worker deepseek`), not a mid replacement.
+ *
+ * We never write ~/.dsh/settings.yaml (parallel jobs would race) and never
+ * put DEEPSEEK_API_KEY in the command or patch — the key travels via plan.env.
  */
+function findDsh() {
+    // Env override lets tests pin a fake dsh — but it must exist, so a stale
+    // override cannot pass health with a dangling path.
+    const override = process.env.CURSOR_ROUTE_DSH_BIN;
+    if (override)
+        return existsSync(override) ? override : null;
+    try {
+        return (execSync("command -v dsh", {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            // Bun may ignore mutated process.env.PATH unless env is passed explicitly
+            env: { ...process.env },
+        }).trim() || null);
+    }
+    catch {
+        return null;
+    }
+}
+/** Same resolution as claude-ds: passed model/modelId wins, else env, else Flash. */
+function pickModel(requested, modelId) {
+    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);
+}
+/** Whitelist model ids before interpolating into YAML (no newlines / injection). */
+function assertPatchModelId(modelId) {
+    if (!/^[a-z0-9][a-z0-9.\-[\]]*$/i.test(modelId)) {
+        throw new Error(`Invalid DeepSeek model id for dsh patch: ${modelId}`);
+    }
+    return modelId;
+}
+/** Per-job Cordis patch path. Never reuse the prompt path (would overwrite it). */
+export function patchPathForPrompt(promptFile) {
+    return promptFile.endsWith(".prompt")
+        ? promptFile.replace(/\.prompt$/, ".dsh-patch.yml")
+        : `${promptFile}.dsh-patch.yml`;
+}
+/** Per-job Cordis patch (whole-row replace). `name` is required or dsh silently skips. */
+function patchYaml(modelId) {
+    const id = assertPatchModelId(modelId);
+    return [
+        "- id: agent-default-model",
+        "  name: '@deepseek-ai/dsh-agent-default-model'",
+        "  config:",
+        "    provider: deepseek-official",
+        `    model: '${id}'`,
+    ].join("\n") + "\n";
+}
 export const deepseekAdapter = {
     kind: "deepseek",
-    label: "Official DeepSeek harness (unreleased)",
+    label: "Official DeepSeek Harness (dsh)",
     health() {
+        const binary = findDsh();
+        if (!binary) {
+            return {
+                worker: "deepseek",
+                ok: false,
+                binary: null,
+                detail: "dsh (@deepseek-ai/dsh) not found — install: npm i -g @deepseek-ai/dsh. Mid default remains claude-ds.",
+            };
+        }
+        if (!process.env.DEEPSEEK_API_KEY) {
+            return {
+                worker: "deepseek",
+                ok: false,
+                binary,
+                detail: "DEEPSEEK_API_KEY not set — export your DeepSeek API key to use dsh (@deepseek-ai/dsh). Mid default remains claude-ds.",
+            };
+        }
         return {
             worker: "deepseek",
-            ok: false,
-            binary: null,
-            detail: "unreleased — mid lane uses claude-ds (DeepSeek behind Claude Code). See README.",
+            ok: true,
+            binary,
+            detail: "ok (dsh @deepseek-ai/dsh headless; mid default remains claude-ds)",
         };
     },
-    buildLaunch() {
-        throw new Error("Official DeepSeek harness is not available yet — use --lane mid / --worker claude-ds");
+    buildLaunch({ promptFile, cwd, alwaysApprove, model, modelId, dryRun }) {
+        // Missing dsh is tolerated here so `--dry-run` can still print the command;
+        // real starts are gated by the health preflight (binary + DEEPSEEK_API_KEY).
+        const binary = findDsh() || "dsh";
+        const choice = pickModel(model, modelId);
+        // Per-job patch next to the prompt file (never touch ~/.dsh/settings.yaml).
+        const patchFile = patchPathForPrompt(promptFile);
+        writeFileSync(patchFile, patchYaml(choice.id), { mode: 0o600 });
+        if (dryRun) {
+            // Dry-run keeps no durable artifacts (jobs.ts removes the prompt likewise).
+            try {
+                unlinkSync(patchFile);
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        // Launcher flags before the task; prompt inlined via cat (never the key).
+        const parts = [
+            shellQuote(binary),
+            "--profile",
+            "headless",
+            "--patch",
+            shellQuote(patchFile),
+            `"$(cat ${shellQuote(promptFile)})"`,
+        ];
+        const ask = process.env.CURSOR_ROUTE_ASK === "1";
+        const skip = alwaysApprove && !ask;
+        const env = {
+            DSH_PERMISSION_MODE: skip ? "danger-full-access" : "workspace-write",
+        };
+        // Key travels via env only — never interpolated into command or patch.
+        if (process.env.DEEPSEEK_API_KEY) {
+            env.DEEPSEEK_API_KEY = process.env.DEEPSEEK_API_KEY;
+        }
+        return {
+            worker: "deepseek",
+            command: `cd ${shellQuote(cwd)} && ${parts.join(" ")}`,
+            alwaysApprove: skip,
+            env,
+        };
     },
 };

package/dist/cli.js

@@ -4,7 +4,7 @@
  */
 import { readFileSync, existsSync, realpathSync, statSync } from "node:fs";
 import { resolve, basename } from "node:path";
-import { config, WORKERS, LANES, resolveDsModelAlias, } from "./config.js";
+import { config, WORKERS, LANES, resolveDsModel, } from "./config.js";
 import { runHealth, printHealth } from "./health.js";
 import { startJob, listJobs, readJob, killJob, cleanJobs, jobPaths, refreshStatus, } from "./jobs.js";
 import { capturePane, sendKeys, attachHint, listManagedSessions, sessionExists, } from "./tmux.js";
@@ -29,9 +29,9 @@ Usage:
   cursor-route clean [--days N]
 
 Start options:
-  --worker <grok|claude-ds|openrouter>  Worker adapter (default: grok; deepseek = reserved slot)
+  --worker <grok|claude-ds|openrouter|deepseek>  Worker adapter (default: grok; deepseek = experimental official dsh)
   --lane <easy|mid|hard>                Lane → worker (easy=openrouter, mid=claude-ds, hard=grok)
-  --model <flash|pro>                   Mid DeepSeek model (default: flash). Ignored by grok/openrouter
+  --model <flash|pro>                   Mid DeepSeek only (default: flash / CURSOR_ROUTE_DS_MODEL). Parsed for claude-ds + deepseek
   --dir <path>                          Working directory (default: cwd)
   --ask                                 Disable always-approve for this job
   --dry-run                             Print launch command; do not start
@@ -43,10 +43,12 @@ Env:
   CURSOR_ROUTE_JOBS_DIR              Override jobs dir (default: ~/.local/share/cursor-route/jobs)
   CURSOR_ROUTE_MAX_JOBS              Max active jobs (default: 50)
   CURSOR_ROUTE_RELAXED=1             health OK without tmux/workers (CI / infra smoke)
-  CURSOR_ROUTE_ALLOW_ANTHROPIC=1     Allow mid-lane on Anthropic Claude (expensive; not default)
-  CURSOR_ROUTE_DS_MODEL              Default mid model flash|pro (overridden by --model)
+  CURSOR_ROUTE_ALLOW_ANTHROPIC=1     Allow mid-lane on Anthropic Claude (expensive; not default; --model ignored)
+  CURSOR_ROUTE_DS_MODEL              Default mid model flash|pro (or deepseek-v4-pro[1m]); overridden by --model
   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)
+  CURSOR_ROUTE_DSH_BIN               Override the dsh binary path (tests / power users)
+  DEEPSEEK_API_KEY                   DeepSeek API key (required for --worker deepseek)
   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)
@@ -141,12 +143,12 @@ function asLane(v) {
         return v;
     throw new Error(`Invalid --lane ${v}; expected ${LANES.join("|")}`);
 }
-function asDsModel(v) {
+function asDsModelChoice(v) {
     if (v === undefined || v === true)
         return undefined;
     if (typeof v !== "string")
         throw new Error(`Invalid --model; expected flash|pro`);
-    return resolveDsModelAlias(v);
+    return resolveDsModel(v);
 }
 function refuseSecrets(text, context) {
     if (looksLikeSecretMaterial(text)) {
@@ -208,14 +210,34 @@ async function main() {
         requireStringFlag(f, "model");
         const promptFile = requireStringFlag(f, "prompt-file");
         const dirFlag = requireStringFlag(f, "dir");
-        let model;
+        let worker;
+        let lane;
         try {
-            model = asDsModel(f.model);
+            worker = asWorker(f.worker);
+            lane = asLane(f.lane);
         }
         catch (e) {
             console.error(e.message);
             process.exit(2);
         }
+        const resolvedWorker = worker ?? (lane ? config.laneWorkers[lane] : config.defaultWorker);
+        let model;
+        let modelId;
+        // --model is DeepSeek-only (claude-ds mid lane + experimental deepseek worker);
+        // ignore (do not validate) for other workers
+        if (f.model !== undefined && (resolvedWorker === "claude-ds" || resolvedWorker === "deepseek")) {
+            try {
+                const choice = asDsModelChoice(f.model);
+                if (choice) {
+                    model = choice.alias;
+                    modelId = choice.id;
+                }
+            }
+            catch (e) {
+                console.error(e.message);
+                process.exit(2);
+            }
+        }
         let prompt = "";
         if (promptFile) {
             const p = resolve(promptFile);
@@ -250,9 +272,10 @@ async function main() {
         }
         const result = startJob({
             prompt,
-            worker: asWorker(f.worker),
-            lane: asLane(f.lane),
+            worker,
+            lane,
             model,
+            modelId,
             cwd,
             alwaysApprove: !f.ask,
             dryRun: Boolean(f.dryRun),
@@ -304,7 +327,8 @@ async function main() {
         else {
             for (const j of jobs) {
                 const age = j.startedAt || j.createdAt;
-                console.log(`${j.id}  ${j.status.padEnd(10)}  ${j.worker.padEnd(10)}  ${age}  ${j.prompt.slice(0, 48).replace(/\n/g, " ")}`);
+                const modelCol = j.model ? j.model.padEnd(6) : "".padEnd(6);
+                console.log(`${j.id}  ${j.status.padEnd(10)}  ${j.worker.padEnd(10)}  ${modelCol}  ${age}  ${j.prompt.slice(0, 48).replace(/\n/g, " ")}`);
             }
         }
         return;
@@ -336,7 +360,7 @@ async function main() {
         if (json)
             console.log(JSON.stringify(view, null, 2));
         else {
-            console.log(`${job.id}  ${job.status}  worker=${job.worker}  sessionAlive=${alive}`);
+            console.log(`${job.id}  ${job.status}  worker=${job.worker}${job.model ? `  model=${job.model}` : ""}  sessionAlive=${alive}`);
             if (job.error)
                 console.log(`error: ${job.error}`);
         }