cursor-route 0.1.5 → 0.1.7

package/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+
+## 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,30 @@
 ```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"
 ```
 
+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,21 +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/
 ```
 
-Then say **`/route-orch`** or **spawn workers** in Cursor — the skill delegates to `cursor-route` (does not replace private Cemini `/route`).
+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). 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 |
@@ -102,11 +107,30 @@ 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 |
+| `mid` | `claude-ds` | Default implement on DeepSeek (**Flash** by default) |
 | `hard` | `grok` | Hard implement on Grok CLI |
 
 Always-approve is **on** by default. Opt out: `--ask` or `CURSOR_ROUTE_ASK=1`.
 
+### Mid models (Flash vs Pro)
+
+| Flag | Model id | When |
+|------|----------|------|
+| `--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.
@@ -118,17 +142,20 @@ npm i -g @anthropic-ai/claude-code
 
 export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
 export ANTHROPIC_AUTH_TOKEN=YOUR_DEEPSEEK_API_KEY   # from platform.deepseek.com
-export ANTHROPIC_MODEL=deepseek-v4-pro[1m]
+# Optional shell defaults (CLI --model overrides ANTHROPIC_MODEL for the job):
 export ANTHROPIC_DEFAULT_HAIKU_MODEL=deepseek-v4-flash
 export CLAUDE_CODE_SUBAGENT_MODEL=deepseek-v4-flash
 
 cursor-route health          # worker:claude-ds should be ✓
-cursor-route start --lane mid "…"
+cursor-route start --lane mid "…"                 # Flash (default)
+cursor-route start --lane mid --model pro "…"     # Pro when you need it
 ```
 
 Persist the same vars under `~/.claude/settings.json` → `"env": { … }` if you want them every shell.
 
-**Also accepted:** `claude-ds` or `deepseek-claude` on PATH (Cemini shims).
+**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`.
 
 **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`.
 
@@ -173,7 +200,7 @@ 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`).
 
 **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.
@@ -183,6 +210,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)

package/dist/adapters/claude-ds.js

@@ -2,6 +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, resolveDsModel, } from "../config.js";
 import { shellQuote } from "../util.js";
 /**
  * Mid-lane = DeepSeek (cheap). The Claude Code binary is only a harness —
@@ -19,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 {
@@ -54,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() {
@@ -104,24 +108,35 @@ function resolveClaudeDs() {
     }
     return null;
 }
+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);
+}
 /**
  * Env that must reach stock `claude` for DeepSeek routing.
  * Passed via process/tmux env — never interpolated into the printed command.
  */
-function deepSeekWorkerEnv() {
+function deepSeekWorkerEnv(modelId) {
     const base = resolvedDeepSeekBaseUrl();
     if (!base)
         return undefined;
-    const env = { ANTHROPIC_BASE_URL: base };
+    const env = {
+        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;
 }
 export const claudeDsAdapter = {
@@ -144,24 +159,44 @@ export const claudeDsAdapter = {
             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");
         }
         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 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(choice.id),
             ];
             if (skip)
                 parts.push("--dangerously-skip-permissions");
@@ -172,10 +207,13 @@ export const claudeDsAdapter = {
                 env,
             };
         }
+        // Stock claude → DeepSeek
         const parts = [
             shellQuote(resolved.binary),
             "-p",
             `"$(cat ${shellQuote(promptFile)})"`,
+            "--model",
+            shellQuote(choice.id),
         ];
         if (skip)
             parts.push("--dangerously-skip-permissions");

package/dist/adapters/deepseek.js

@@ -0,0 +1,19 @@
+/**
+ * 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 = {
+    kind: "deepseek",
+    label: "Official DeepSeek harness (unreleased)",
+    health() {
+        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/dist/adapters/index.js

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

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 } 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,8 +29,9 @@ Usage:
   cursor-route clean [--days N]
 
 Start options:
-  --worker <grok|claude-ds|openrouter>  Worker adapter (default: grok)
+  --worker <grok|claude-ds|openrouter>  Worker adapter (default: grok; deepseek = reserved slot)
   --lane <easy|mid|hard>                Lane → worker (easy=openrouter, mid=claude-ds, hard=grok)
+  --model <flash|pro>                   Mid DeepSeek only (default: flash / CURSOR_ROUTE_DS_MODEL). Parsed only for claude-ds
   --dir <path>                          Working directory (default: cwd)
   --ask                                 Disable always-approve for this job
   --dry-run                             Print launch command; do not start
@@ -42,7 +43,8 @@ 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_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)
   OPENROUTER_API_KEY                 OpenRouter key (required for --worker openrouter / --lane easy)
@@ -139,6 +141,13 @@ function asLane(v) {
         return v;
     throw new Error(`Invalid --lane ${v}; expected ${LANES.join("|")}`);
 }
+function asDsModelChoice(v) {
+    if (v === undefined || v === true)
+        return undefined;
+    if (typeof v !== "string")
+        throw new Error(`Invalid --model; expected flash|pro`);
+    return resolveDsModel(v);
+}
 function refuseSecrets(text, context) {
     if (looksLikeSecretMaterial(text)) {
         console.error(`Refusing ${context}: looks like secret key material. Remove tokens/keys and retry.`);
@@ -196,8 +205,36 @@ async function main() {
     if (cmd === "start") {
         requireStringFlag(f, "worker");
         requireStringFlag(f, "lane");
+        requireStringFlag(f, "model");
         const promptFile = requireStringFlag(f, "prompt-file");
         const dirFlag = requireStringFlag(f, "dir");
+        let worker;
+        let lane;
+        try {
+            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/claude-ds only; ignore (do not validate) for other workers
+        if (f.model !== undefined && resolvedWorker === "claude-ds") {
+            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);
@@ -232,8 +269,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),
@@ -252,10 +291,13 @@ async function main() {
         else if (result.dryRun) {
             console.log(`dry-run job ${result.job.id}`);
             console.log(`worker: ${result.job.worker}`);
+            if (result.job.model)
+                console.log(`model:  ${result.job.model}`);
             console.log(`command: ${redactSecrets(result.command || "")}`);
         }
         else {
-            console.log(`started ${result.job.id} (${result.job.worker})`);
+            const modelNote = result.job.model ? `/${result.job.model}` : "";
+            console.log(`started ${result.job.id} (${result.job.worker}${modelNote})`);
             console.log(`session: ${result.job.tmuxSession}`);
             if (String(result.job.tmuxSession).startsWith("headless-")) {
                 console.log(`mode:    headless (--no-tmux); use capture/status (no attach/send)`);
@@ -282,7 +324,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;
@@ -314,7 +357,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}`);
         }

package/dist/config.js

@@ -1,8 +1,46 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { defaultJobsDir } from "./runtime.js";
-export const WORKERS = ["grok", "claude-ds", "openrouter"];
+export const WORKERS = ["grok", "claude-ds", "openrouter", "deepseek"];
 export const LANES = ["easy", "mid", "hard"];
+export const DS_MODELS = ["flash", "pro"];
+export const DS_MODEL_IDS = {
+    flash: "deepseek-v4-flash",
+    pro: "deepseek-v4-pro",
+};
+/**
+ * Resolve --model / env to alias + concrete model id.
+ * Preserves `deepseek-v4-pro[1m]` (does not silently strip the SKU).
+ * Empty → Flash.
+ */
+export function resolveDsModel(raw) {
+    if (!raw || !raw.trim()) {
+        return { alias: "flash", id: DS_MODEL_IDS.flash };
+    }
+    const v = raw.trim().toLowerCase();
+    if (v === "flash" || v === "deepseek-v4-flash") {
+        return { alias: "flash", id: DS_MODEL_IDS.flash };
+    }
+    if (v === "pro" || v === "deepseek-v4-pro") {
+        return { alias: "pro", id: DS_MODEL_IDS.pro };
+    }
+    if (v === "deepseek-v4-pro[1m]") {
+        return { alias: "pro", id: "deepseek-v4-pro[1m]" };
+    }
+    throw new Error(`Invalid --model ${raw}; expected flash|pro`);
+}
+/** Alias-only helper (tests / callers that do not need the concrete id). */
+export function resolveDsModelAlias(raw) {
+    return resolveDsModel(raw).alias;
+}
+/**
+ * Mid default from env: CURSOR_ROUTE_DS_MODEL, else ANTHROPIC_MODEL, else flash.
+ * Throws if the env value is set but invalid (fail loud on start).
+ */
+export function defaultDsModelFromEnv() {
+    const raw = process.env.CURSOR_ROUTE_DS_MODEL || process.env.ANTHROPIC_MODEL;
+    return resolveDsModel(raw);
+}
 /** OpenRouter model for the easy lane (env CURSOR_ROUTE_OPENROUTER_MODEL). */
 export function openRouterModel() {
     return process.env.CURSOR_ROUTE_OPENROUTER_MODEL || "openrouter/free";
@@ -27,7 +65,7 @@ function maxConcurrentJobsFromEnv() {
  */
 export const config = {
     product: "cursor-route",
-    version: "0.1.5",
+    version: "0.1.7",
     get jobsDir() {
         return defaultJobsDir();
     },
@@ -39,6 +77,19 @@ export const config = {
         mid: "claude-ds",
         hard: "grok",
     },
+    /**
+     * Default mid DeepSeek model (Flash = cheap execute).
+     * Live: CURSOR_ROUTE_DS_MODEL / ANTHROPIC_MODEL; invalid env → flash (health-safe).
+     * Override on start: --model. startJob uses defaultDsModelFromEnv() and fails on invalid env.
+     */
+    get defaultDsModel() {
+        try {
+            return defaultDsModelFromEnv().alias;
+        }
+        catch {
+            return "flash";
+        }
+    },
     jobsListLimit: 20,
     /** Max simultaneously active (running|pending) jobs. Override: CURSOR_ROUTE_MAX_JOBS. */
     get maxConcurrentJobs() {

package/dist/jobs.js

@@ -2,7 +2,7 @@ import { mkdirSync, writeFileSync, readFileSync, readdirSync, existsSync, unlink
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { dirname } from "node:path";
-import { config, sessionName } from "./config.js";
+import { config, sessionName, defaultDsModelFromEnv, DS_MODEL_IDS, } from "./config.js";
 import { getAdapter } from "./adapters/index.js";
 import { spawn } from "node:child_process";
 import { spawnSync } from "node:child_process";
@@ -217,12 +217,38 @@ export function startJob(opts) {
     const id = newJobId();
     const paths = jobPaths(id);
     writeSecure(paths.prompt, opts.prompt);
+    let model;
+    let modelId;
+    if (worker === "claude-ds") {
+        if (opts.model) {
+            model = opts.model;
+            modelId = opts.modelId ?? DS_MODEL_IDS[opts.model];
+        }
+        else {
+            try {
+                const choice = defaultDsModelFromEnv();
+                model = choice.alias;
+                modelId = opts.modelId ?? choice.id;
+            }
+            catch (e) {
+                try {
+                    unlinkSync(paths.prompt);
+                }
+                catch {
+                    /* ignore */
+                }
+                return { ok: false, error: e.message };
+            }
+        }
+    }
     let plan;
     try {
         plan = adapter.buildLaunch({
             promptFile: paths.prompt,
             cwd,
             alwaysApprove,
+            model,
+            modelId,
         });
     }
     catch (e) {
@@ -240,6 +266,7 @@ export function startJob(opts) {
         status: "pending",
         worker,
         lane: opts.lane,
+        model,
         prompt: opts.prompt,
         cwd,
         alwaysApprove: plan.alwaysApprove,

package/docs/DEMO_GIF.md

@@ -13,7 +13,8 @@ cursor-route health
 
 # 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"
+cursor-route start --lane mid --dir "$PWD" "Add a unit test for shellQuote"   # Flash default
+# Optional: cursor-route start --lane mid --model pro --dir "$PWD" "…"
 cursor-route start --worker grok --dir "$PWD" "List open TODOs in src/"
 
 # Terminal B — watch