cursor-route 0.1.6 → 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,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 |
@@ -115,14 +118,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.
@@ -202,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,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/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";
@@ -31,7 +31,7 @@ Usage:
 Start options:
   --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 model (default: flash). Ignored by grok/openrouter
+  --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
@@ -43,8 +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_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)
   OPENROUTER_API_KEY                 OpenRouter key (required for --worker openrouter / --lane easy)
@@ -141,12 +141,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 +208,33 @@ 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/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);
@@ -250,9 +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),
@@ -304,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;
@@ -336,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

@@ -8,17 +8,39 @@ export const DS_MODEL_IDS = {
     flash: "deepseek-v4-flash",
     pro: "deepseek-v4-pro",
 };
-/** Resolve --model flash|pro (or full deepseek-v4-* id) to a CLI alias. Default: flash. */
-export function resolveDsModelAlias(raw) {
-    if (!raw || !raw.trim())
-        return "flash";
+/**
+ * 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 "flash";
-    if (v === "pro" || v === "deepseek-v4-pro" || v === "deepseek-v4-pro[1m]")
-        return "pro";
+    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";
@@ -43,7 +65,7 @@ function maxConcurrentJobsFromEnv() {
  */
 export const config = {
     product: "cursor-route",
-    version: "0.1.6",
+    version: "0.1.7",
     get jobsDir() {
         return defaultJobsDir();
     },
@@ -55,8 +77,19 @@ export const config = {
         mid: "claude-ds",
         hard: "grok",
     },
-    /** Default mid DeepSeek model (Flash = cheap execute). Override: --model pro */
-    defaultDsModel: "flash",
+    /**
+     * 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,7 +217,30 @@ export function startJob(opts) {
     const id = newJobId();
     const paths = jobPaths(id);
     writeSecure(paths.prompt, opts.prompt);
-    const model = worker === "claude-ds" ? opts.model ?? config.defaultDsModel : undefined;
+    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({
@@ -225,6 +248,7 @@ export function startJob(opts) {
             cwd,
             alwaysApprove,
             model,
+            modelId,
         });
     }
     catch (e) {

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

package/docs/briefs/WORKING.md

@@ -1,7 +1,7 @@
 ---
 title: cursor-route workspace — working brief (edit in place)
 repo: ~/Projects/cursor-route
-npm: cursor-route@0.1.6
+npm: cursor-route@0.1.7 (LIVE on npm latest)
 created: 2026-08-12
 updated: 2026-08-12
 ---
@@ -19,19 +19,22 @@ 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**) |
+| `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`
+- [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
 
@@ -45,6 +48,7 @@ Always-approve on (`--ask` / `CURSOR_ROUTE_ASK=1` to opt out). Jobs live in `~/.
 | `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
@@ -53,3 +57,5 @@ Always-approve on (`--ask` / `CURSOR_ROUTE_ASK=1` to opt out). Jobs live in `~/.
 |------|--------|
 | 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/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
@@ -16,8 +16,14 @@ It uses the familiar strategist and worker-pane shape, but it is not a Codex clo
 ### 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`. 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.6",
+  "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",
@@ -23,6 +23,7 @@
     "SECURITY.md",
     "SUPPORT.md",
     "CONTRIBUTING.md",
+    "CHANGELOG.md",
     "README.md",
     "llms.txt"
   ],

package/src/adapters/claude-ds.ts

@@ -7,7 +7,7 @@ import {
   DS_MODEL_IDS,
   type DsModelAlias,
   config,
-  resolveDsModelAlias,
+  resolveDsModel,
 } from "../config.ts";
 import { shellQuote } from "../util.ts";
 
@@ -29,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 {
@@ -65,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). */
@@ -120,18 +124,16 @@ function resolveClaudeDs(): { binary: string; mode: string } | null {
   return null;
 }
 
-function pickModelAlias(requested?: DsModelAlias): DsModelAlias {
-  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?: 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] };
   }
-  return config.defaultDsModel;
+  // Env default (startJob normally resolves this; kept for direct buildLaunch callers)
+  return resolveDsModel(process.env.CURSOR_ROUTE_DS_MODEL || process.env.ANTHROPIC_MODEL);
 }
 
 /**
@@ -177,30 +179,45 @@ export const claudeDsAdapter: Adapter = {
       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;
+    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") || resolved.mode.startsWith("deepseek-claude")) {
+    if (isShim) {
       const parts = [
         shellQuote(resolved.binary),
         "-PromptFile",
         shellQuote(promptFile),
         "-Model",
-        shellQuote(modelId),
+        shellQuote(choice.id),
       ];
       if (skip) parts.push("--dangerously-skip-permissions");
       return {
@@ -211,12 +228,13 @@ export const claudeDsAdapter: Adapter = {
       };
     }
 
+    // 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");
     return {

package/src/adapters/types.ts

@@ -24,7 +24,9 @@ export interface Adapter {
     promptFile: string;
     cwd: string;
     alwaysApprove: boolean;
-    /** Mid-lane DeepSeek flash|pro (ignored by other workers). */
+    /** 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,11 +1,15 @@
 import { describe, expect, test } from "bun:test";
-import { resolveWorker } from "./jobs.ts";
-import { config, resolveDsModelAlias } 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, claudeDsAdapter } from "./adapters/claude-ds.ts";
 import { deepseekAdapter } from "./adapters/deepseek.ts";
+import { grokAdapter } from "./adapters/grok.ts";
 
 describe("resolveWorker", () => {
   test("lane easy → openrouter", () => {
@@ -30,27 +34,32 @@ describe("resolveWorker", () => {
   });
 });
 
-describe("resolveDsModelAlias", () => {
+describe("resolveDsModel", () => {
   test("defaults to flash", () => {
-    expect(resolveDsModelAlias()).toBe("flash");
+    expect(resolveDsModel()).toEqual({ alias: "flash", id: "deepseek-v4-flash" });
     expect(resolveDsModelAlias("")).toBe("flash");
   });
   test("accepts aliases and full ids", () => {
-    expect(resolveDsModelAlias("flash")).toBe("flash");
-    expect(resolveDsModelAlias("pro")).toBe("pro");
-    expect(resolveDsModelAlias("deepseek-v4-flash")).toBe("flash");
-    expect(resolveDsModelAlias("deepseek-v4-pro")).toBe("pro");
-    expect(resolveDsModelAlias("deepseek-v4-pro[1m]")).toBe("pro");
+    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(() => resolveDsModelAlias("opus")).toThrow(/flash\|pro/);
+    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",
@@ -62,6 +71,10 @@ describe("claude-ds -Model", () => {
     } 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", () => {
@@ -81,6 +94,130 @@ describe("claude-ds -Model", () => {
       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", () => {
@@ -153,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";

package/src/cli.ts

@@ -8,7 +8,7 @@ import {
   config,
   WORKERS,
   LANES,
-  resolveDsModelAlias,
+  resolveDsModel,
   type WorkerKind,
   type Lane,
   type DsModelAlias,
@@ -54,7 +54,7 @@ Usage:
 Start options:
   --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 model (default: flash). Ignored by grok/openrouter
+  --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
@@ -66,8 +66,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_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)
   OPENROUTER_API_KEY                 OpenRouter key (required for --worker openrouter / --lane easy)
@@ -162,10 +162,10 @@ function asLane(v: unknown): Lane | undefined {
   throw new Error(`Invalid --lane ${v}; expected ${LANES.join("|")}`);
 }
 
-function asDsModel(v: unknown): DsModelAlias | undefined {
+function asDsModelChoice(v: unknown): { alias: DsModelAlias; id: string } | undefined {
   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: string, context: string): void {
@@ -235,13 +235,34 @@ async function main() {
     requireStringFlag(f, "model");
     const promptFile = requireStringFlag(f, "prompt-file");
     const dirFlag = requireStringFlag(f, "dir");
-    let model: DsModelAlias | undefined;
+
+    let worker: WorkerKind | undefined;
+    let lane: Lane | undefined;
     try {
-      model = asDsModel(f.model);
+      worker = asWorker(f.worker);
+      lane = asLane(f.lane);
     } catch (e) {
       console.error((e as Error).message);
       process.exit(2);
     }
+    const resolvedWorker =
+      worker ?? (lane ? config.laneWorkers[lane] : config.defaultWorker);
+
+    let model: DsModelAlias | undefined;
+    let modelId: string | undefined;
+    // --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 as Error).message);
+        process.exit(2);
+      }
+    }
 
     let prompt = "";
     if (promptFile) {
@@ -277,9 +298,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),
@@ -333,8 +355,9 @@ async function main() {
     } else {
       for (const j of jobs) {
         const age = j.startedAt || j.createdAt;
+        const modelCol = j.model ? j.model.padEnd(6) : "".padEnd(6);
         console.log(
-          `${j.id}  ${j.status.padEnd(10)}  ${j.worker.padEnd(10)}  ${age}  ${j.prompt.slice(0, 48).replace(/\n/g, " ")}`,
+          `${j.id}  ${j.status.padEnd(10)}  ${j.worker.padEnd(10)}  ${modelCol}  ${age}  ${j.prompt.slice(0, 48).replace(/\n/g, " ")}`,
         );
       }
     }
@@ -366,7 +389,9 @@ async function main() {
     const view = { ...job, sessionAlive: alive };
     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}`);
     }
     return;

package/src/config.ts

@@ -9,6 +9,12 @@ export type Lane = "easy" | "mid" | "hard";
 /** Public CLI aliases for mid-lane DeepSeek models. */
 export type DsModelAlias = "flash" | "pro";
 
+export interface DsModelChoice {
+  alias: DsModelAlias;
+  /** Exact id passed to claude-ds `-Model` / stock `claude --model`. */
+  id: string;
+}
+
 export const WORKERS: WorkerKind[] = ["grok", "claude-ds", "openrouter", "deepseek"];
 export const LANES: Lane[] = ["easy", "mid", "hard"];
 export const DS_MODELS: DsModelAlias[] = ["flash", "pro"];
@@ -18,15 +24,42 @@ export const DS_MODEL_IDS: Record<DsModelAlias, string> = {
   pro: "deepseek-v4-pro",
 };
 
-/** Resolve --model flash|pro (or full deepseek-v4-* id) to a CLI alias. Default: flash. */
-export function resolveDsModelAlias(raw?: string | null): DsModelAlias {
-  if (!raw || !raw.trim()) return "flash";
+/**
+ * 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?: string | null): DsModelChoice {
+  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 "flash";
-  if (v === "pro" || v === "deepseek-v4-pro" || v === "deepseek-v4-pro[1m]") return "pro";
+  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?: string | null): DsModelAlias {
+  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(): DsModelChoice {
+  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(): string {
   return process.env.CURSOR_ROUTE_OPENROUTER_MODEL || "openrouter/free";
@@ -53,7 +86,7 @@ function maxConcurrentJobsFromEnv(): number {
  */
 export const config = {
   product: "cursor-route",
-  version: "0.1.6",
+  version: "0.1.7",
   get jobsDir(): string {
     return defaultJobsDir();
   },
@@ -65,8 +98,18 @@ export const config = {
     mid: "claude-ds" as WorkerKind,
     hard: "grok" as WorkerKind,
   },
-  /** Default mid DeepSeek model (Flash = cheap execute). Override: --model pro */
-  defaultDsModel: "flash" as DsModelAlias,
+  /**
+   * 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(): DsModelAlias {
+    try {
+      return defaultDsModelFromEnv().alias;
+    } catch {
+      return "flash";
+    }
+  },
   jobsListLimit: 20,
   /** Max simultaneously active (running|pending) jobs. Override: CURSOR_ROUTE_MAX_JOBS. */
   get maxConcurrentJobs(): number {

package/src/jobs.ts

@@ -15,6 +15,8 @@ import { dirname } from "node:path";
 import {
   config,
   sessionName,
+  defaultDsModelFromEnv,
+  DS_MODEL_IDS,
   type Lane,
   type WorkerKind,
   type DsModelAlias,
@@ -231,6 +233,8 @@ export interface StartOptions {
   lane?: Lane;
   /** Mid-lane DeepSeek: flash (default) | pro. Ignored by grok/openrouter. */
   model?: DsModelAlias;
+  /** Concrete DeepSeek id (preserves pro[1m]). Derived from --model / env when unset. */
+  modelId?: string;
   cwd?: string;
   alwaysApprove?: boolean;
   dryRun?: boolean;
@@ -278,8 +282,27 @@ export function startJob(opts: StartOptions): {
   const paths = jobPaths(id);
   writeSecure(paths.prompt, opts.prompt);
 
-  const model =
-    worker === "claude-ds" ? opts.model ?? config.defaultDsModel : undefined;
+  let model: DsModelAlias | undefined;
+  let modelId: string | undefined;
+  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 as Error).message };
+      }
+    }
+  }
 
   let plan;
   try {
@@ -288,6 +311,7 @@ export function startJob(opts: StartOptions): {
       cwd,
       alwaysApprove,
       model,
+      modelId,
     });
   } catch (e) {
     try {