cursor-route 0.1.8 → 0.1.9

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## Unreleased
+
+_(none)_
+
+## 0.1.9 — 2026-08-18
+
+- Health proves mid DeepSeek: dedicated `lane:mid` check is ✓ only when mid is a `claude-ds` / `deepseek-claude` shim or stock `claude` with DeepSeek `ANTHROPIC_BASE_URL`. `CURSOR_ROUTE_ALLOW_ANTHROPIC=1` is not proof. Overall `ok` still uses the existing OR-gate (any worker + `CURSOR_ROUTE_RELAXED=1`); grok-only installs stay OK with `lane:mid` ✗ plus a fix tip.
+- Health JSON includes `lanes.mid.{ worker, deepseek, detail }` (`worker` is always `"claude-ds"`).
+- `status --json` adds an evidence tree (`spawn` / `execute` / `verify`). `verify.claim` is always `"unverified"` — the parent must capture; status never auto-greens.
+- Headless pid liveness: if `ps` is unreadable (`EPERM` / non-zero), treat the pid as **alive** (fail-safe), not dead — avoids false-completed kills on sandboxed `ps`.
+- `route-orch` skill: health-before-mid, evidence-tree closeout, always-approve is coding-worktrees-only (not LIVE Discord/trading), do not fork the mid harness; `--worker deepseek` stays experimental / cheap-to-abandon.
+- Docs: `route-orch` **Eval & skill hygiene** (folded from Unreleased) — external eval contract (AutoDesign): never rewrite Verify / Success criteria mid-run to make a failing job look green (capture + exit status are the contract); skill misevolution: no auto-edit / promote skill variants from worker trajectories without operator HITL (write-time approval ≠ safe retrieval later); verify fail → prefer reconsidering the plan/definition over grinding the same tactic, with stage attribution when possible (spawn vs execute vs verify). Mid stays `claude-ds`.
+
 ## 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`.

package/README.md

@@ -91,10 +91,10 @@ Working notes for this repo (edit in place): [docs/briefs/WORKING.md](./docs/bri
 
 | Command | Description |
 |---------|-------------|
-| `health` | Gate #1 — tmux, runtime, workers |
+| `health` | Gate #1 — tmux, runtime, workers; proves `lane:mid` is DeepSeek (`lanes.mid` in `--json`) |
 | `start <prompt>` | Spawn worker job (`--worker` / `--lane` / `--model` / `--dir` / `--ask` / `--dry-run` / `--no-tmux`) |
 | `jobs [--json]` | List jobs |
-| `status <id>` | Job + sessionAlive |
+| `status <id>` | Job + sessionAlive; `--json` includes evidence tree (`spawn` / `execute` / `verify`) |
 | `capture <id> [n]` | Last n pane/log lines |
 | `send <id> <msg>` | Mid-task redirect (tmux send-keys) |
 | `attach <id>` | Print `tmux attach` hint |
@@ -113,10 +113,10 @@ docs/fixtures/generate-hero-demo.sh      # regenerate docs/fixtures/hero-demo.lo
 
 ```text
 $ cursor-route --version
-0.1.8
+0.1.9
 
 $ CURSOR_ROUTE_RELAXED=1 cursor-route health
-cursor-route v0.1.8
+cursor-route v0.1.9
 health: OK
 
 $ cursor-route start --lane mid --model flash --dry-run "Add a unit test for shellQuote"
@@ -140,7 +140,7 @@ A real hero GIF is still pending — recording steps live in [docs/DEMO_GIF.md](
 | `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`.
+Always-approve is **on** by default for **coding worktrees only**. It does not authorize LIVE Discord, trading, or irreversible SaaS. Opt out: `--ask` or `CURSOR_ROUTE_ASK=1`.
 
 ### Mid models (Flash vs Pro)
 
@@ -163,7 +163,7 @@ export CURSOR_ROUTE_DS_MODEL=pro   # also honors ANTHROPIC_MODEL; --model overri
 
 ## 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.
+`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. `cursor-route health` shows `lane:mid` ✓ only when DeepSeek is proven (`claude-ds` / `deepseek-claude` shim, or stock `claude` with DeepSeek `ANTHROPIC_BASE_URL`) — `CURSOR_ROUTE_ALLOW_ANTHROPIC=1` is not proof.
 
 **Recommended (official DeepSeek → Claude Code):**
 
@@ -176,7 +176,7 @@ export ANTHROPIC_AUTH_TOKEN=YOUR_DEEPSEEK_API_KEY   # from platform.deepseek.com
 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 health          # worker:claude-ds should be ✓; `lane:mid` is ✓ only when DeepSeek is proven
 cursor-route start --lane mid "…"                 # Flash (default)
 cursor-route start --lane mid --model pro "…"     # Pro when you need it
 ```
@@ -276,6 +276,7 @@ If you’d like to tip, use the **donation-only** addresses below (not trading o
 
 | Chain family | Address |
 |--------------|---------|
+| **X Money** (fiat, US) | Request [@Cemini23](https://x.com/Cemini23) in the X app — scan the Request QR |
 | **EVM** (Ethereum, Polygon, Base, Arbitrum, …) | `0x444C5C2eC439E0382aa5a17F70313c536BcC5D58` |
 | **Solana / SVM** | `J4zNn4hK9jTrKBFY8sbAGJHLoZvXvQf4B9pQSbSrocZE` |
 | **Polymarket** (referral) | [polymarket.com/?r=Cemini23](https://polymarket.com/?r=Cemini23) |

package/SUPPORT.md

@@ -6,6 +6,7 @@ Voluntary tips fund wikis, OSS tooling, and public research. **Donation-only add
 
 | Chain family | Address |
 |--------------|---------|
+| **X Money** (fiat, US) | Request [@Cemini23](https://x.com/Cemini23) in the X app — scan the Request QR |
 | **EVM** (Ethereum, Polygon, Base, Arbitrum, …) | `0x444C5C2eC439E0382aa5a17F70313c536BcC5D58` |
 | **Solana / SVM** | `J4zNn4hK9jTrKBFY8sbAGJHLoZvXvQf4B9pQSbSrocZE` |
 | **Polymarket** (referral) | [polymarket.com/?r=Cemini23](https://polymarket.com/?r=Cemini23) |

package/dist/adapters/claude-ds.js

@@ -108,6 +108,24 @@ function resolveClaudeDs() {
     }
     return null;
 }
+/**
+ * Mid lane is proven DeepSeek only via shim (`claude-ds` / `deepseek-claude`)
+ * or stock `claude` routed to DeepSeek. The Anthropic escape hatch is not proof.
+ */
+export function isMidDeepSeekProven() {
+    const resolved = resolveClaudeDs();
+    if (!resolved)
+        return false;
+    return !resolved.mode.startsWith("claude → Anthropic");
+}
+/** Human detail for health `lane:mid` (mode when proven; install hint otherwise). */
+export function midDeepSeekProofDetail() {
+    const resolved = resolveClaudeDs();
+    if (!resolved || resolved.mode.startsWith("claude → Anthropic")) {
+        return "mid not proven DeepSeek — install claude-ds / set ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic. CURSOR_ROUTE_ALLOW_ANTHROPIC=1 is not proof.";
+    }
+    return `DeepSeek proven (${resolved.mode})`;
+}
 function pickModel(requested, modelId) {
     if (modelId) {
         const alias = requested ?? resolveDsModel(modelId).alias;

package/dist/cli.js

@@ -6,7 +6,7 @@ import { readFileSync, existsSync, realpathSync, statSync } from "node:fs";
 import { resolve, basename } from "node:path";
 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 { startJob, listJobs, readJob, killJob, cleanJobs, jobPaths, refreshStatus, jobEvidence, } from "./jobs.js";
 import { capturePane, sendKeys, attachHint, listManagedSessions, sessionExists, } from "./tmux.js";
 import { looksLikeSecretMaterial, redactSecrets } from "./secrets.js";
 function usage(exitCode = 0) {
@@ -16,11 +16,11 @@ Cursor stays the brain. Grok CLI + DeepSeek (claude-ds) + OpenRouter (easy) are
 
 Usage:
   cursor-route --version
-  cursor-route health [--json]
+  cursor-route health [--json]          # JSON includes lanes.mid (DeepSeek proof)
   cursor-route start <prompt> [options]
   cursor-route start --prompt-file <path> [options]
   cursor-route jobs [--json] [--limit N]
-  cursor-route status <jobId> [--json]
+  cursor-route status <jobId> [--json]  # JSON includes evidence spawn/execute/verify
   cursor-route capture <jobId> [lines]
   cursor-route send <jobId> <message>
   cursor-route attach <jobId>
@@ -356,11 +356,13 @@ async function main() {
                 }
             })())
             : sessionExists(job.tmuxSession);
-        const view = { ...job, sessionAlive: alive };
+        const evidence = jobEvidence(job, alive);
+        const view = { ...job, sessionAlive: alive, evidence };
         if (json)
             console.log(JSON.stringify(view, null, 2));
         else {
             console.log(`${job.id}  ${job.status}  worker=${job.worker}${job.model ? `  model=${job.model}` : ""}  sessionAlive=${alive}`);
+            console.log("evidence: spawn/execute/verify (claim=unverified)");
             if (job.error)
                 console.log(`error: ${job.error}`);
         }

package/dist/config.js

@@ -65,7 +65,7 @@ function maxConcurrentJobsFromEnv() {
  */
 export const config = {
     product: "cursor-route",
-    version: "0.1.8",
+    version: "0.1.9",
     get jobsDir() {
         return defaultJobsDir();
     },

package/dist/health.js

@@ -1,5 +1,6 @@
 import { execSync } from "node:child_process";
 import { allAdapters } from "./adapters/index.js";
+import { isMidDeepSeekProven, midDeepSeekProofDetail } from "./adapters/claude-ds.js";
 import { config } from "./config.js";
 import { isTmuxAvailable } from "./tmux.js";
 import { commandExists } from "./util.js";
@@ -42,6 +43,14 @@ export function runHealth() {
             detail: h.binary ? `${h.detail} @ ${h.binary}` : h.detail,
         });
     }
+    // Informational: mid is proven DeepSeek (not the overall OR-gate).
+    const midOk = isMidDeepSeekProven();
+    const midDetail = midDeepSeekProofDetail();
+    checks.push({
+        name: "lane:mid",
+        ok: midOk,
+        detail: midDetail,
+    });
     // Optional supervisor probe (v0 skill-only; Cursor CLI agent is informational)
     const agentBin = (commandExists("agent") && "agent") ||
         (commandExists("cursor-agent") && "cursor-agent") ||
@@ -78,6 +87,9 @@ export function runHealth() {
         product: config.product,
         version: config.version,
         checks,
+        lanes: {
+            mid: { worker: "claude-ds", deepseek: midOk, detail: midDetail },
+        },
     };
 }
 export function printHealth(report, asJson) {
@@ -97,4 +109,8 @@ export function printHealth(report, asJson) {
         console.log("Fix the ✗ items, then re-run: cursor-route health");
         console.log("Tip: start with one worker (grok OR claude-ds) before parallel demos.");
     }
+    else if (report.checks.some((c) => c.name === "lane:mid" && !c.ok)) {
+        console.log("");
+        console.log("Tip: health OK without a DeepSeek mid — --lane mid will fail until lane:mid is ✓.");
+    }
 }

package/dist/jobs.js

@@ -59,6 +59,29 @@ export function readJob(id) {
 export function writeJob(job) {
     writeSecure(jobPaths(job.id).json, JSON.stringify(job, null, 2));
 }
+export function jobEvidence(job, sessionAlive) {
+    return {
+        spawn: {
+            jobId: job.id,
+            worker: job.worker,
+            lane: job.lane ?? null,
+            model: job.model ?? null,
+            startedAt: job.startedAt ?? job.createdAt,
+        },
+        execute: {
+            status: job.status,
+            exitCode: job.exitCode ?? null,
+            tmuxSession: job.tmuxSession,
+            pid: job.pid ?? null,
+            sessionAlive,
+        },
+        verify: {
+            captureHint: `cursor-route capture ${job.id}`,
+            logBytes: job.logBytes ?? null,
+            claim: "unverified",
+        },
+    };
+}
 function pidAlive(pid) {
     try {
         process.kill(pid, 0);
@@ -73,6 +96,9 @@ function pidAlive(pid) {
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
         });
+        // spawnSync does not throw on EPERM (macOS sandbox); empty stdout is not "dead".
+        if (r.error || r.status !== 0)
+            return true;
         const state = (r.stdout || "").trim();
         return state !== "" && !state.startsWith("Z");
     }

package/docs/briefs/WORKING.md

@@ -1,9 +1,9 @@
 ---
 title: cursor-route workspace — working brief (edit in place)
 repo: ~/Projects/cursor-route
-npm: cursor-route@0.1.8 (LIVE on npm latest)
+npm: cursor-route@0.1.9 (not published — this WorkDir only)
 created: 2026-08-12
-updated: 2026-08-14
+updated: 2026-08-18
 ---
 
 # cursor-route — living brief
@@ -22,9 +22,9 @@ Cursor Agent plans. Workers run in tmux via `cursor-route`:
 | `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.
+Always-approve on for coding worktrees (`--ask` / `CURSOR_ROUTE_ASK=1` to opt out) — not LIVE Discord/trading. Jobs live in `~/.local/share/cursor-route/jobs`, not in this clone.
 
-Install: `npm i -g cursor-route` → **0.1.8**. Release notes: [CHANGELOG.md](../../CHANGELOG.md).
+Install: `npm i -g cursor-route` → **0.1.9** once published. Release notes: [CHANGELOG.md](../../CHANGELOG.md).
 
 ## Open (edit / check off)
 
@@ -36,6 +36,8 @@ Install: `npm i -g cursor-route` → **0.1.8**. Release notes: [CHANGELOG.md](..
 - [x] **Official DeepSeek Harness** — `deepseek` adapter slot present; `@deepseek-ai/dsh` 0.1.0-rc.6 (2026-08-13, github.com/deepseek-ai/deepseek-harness, MIT) is a developer-preview plugin kernel (web UI + `dsh --profile headless "job"`), not a Claude Code replacement; mid does not swap
 - [x] **0.1.7 debug fixes** — env default wired through `startJob`; Anthropic hatch omits DS ids; preserve `[1m]`
 - [x] **Experimental `--worker deepseek`** — 0.1.8: real dsh adapter (`dsh --profile headless` + per-job Cordis patch pins the model; never writes `~/.dsh/settings.yaml`). Always-approve → `DSH_PERMISSION_MODE=danger-full-access`, `--ask` → `workspace-write`; key via env only. Health ✓ needs `dsh` + `DEEPSEEK_API_KEY` (override `CURSOR_ROUTE_DSH_BIN`). Mid stays **claude-ds**.
+- [x] **route-orch brief steals (2026-08-14)** — AutoDesign / misevolution / Vero habits into the public skill: **Verify / claim closeout** (external eval contract; activity ≠ verification), **Eval & skill hygiene** (mid-run Verify-rewrite ban; skill misevolution HITL — no auto-promotion of worker-trajectory variants; verify-fail → reconsider plan/definition + stage attribution spawn/execute/verify); handoff shape Success criteria + Verify + NEVER; skills synced; mid stays claude-ds.
+- [x] **Health proves mid DeepSeek + evidence tree** — 0.1.9: `lane:mid` ✓ only when DeepSeek is proven (shim or DeepSeek `ANTHROPIC_BASE_URL`; Anthropic hatch is not proof); health JSON `lanes.mid`; `status --json` evidence tree (`spawn` / `execute` / `verify.claim=unverified`); skill health-before-mid + evidence-tree closeout. Mid stays **claude-ds**.
 - [ ] **Hero GIF** — still outstanding; dry-run fixture ships as the substitute for now (`docs/fixtures/hero-demo.log` — see `docs/DEMO_GIF.md`)
 - [x] **Do not** paste private `ROUTE_KIT`, SIP, prod paths, or hang-watchdog env into this public repo
 
@@ -64,3 +66,5 @@ Install: `npm i -g cursor-route` → **0.1.8**. Release notes: [CHANGELOG.md](..
 | 2026-08-13 | GPTSOL fixes: scrub inherited env/paths, stable job ids, ignore `docs/briefs/handoffs/`, GIF checkbox wording. |
 | 2026-08-14 | DeepSeek Harness eval: `@deepseek-ai/dsh` 0.1.0-rc.6 is a developer-preview plugin kernel, not a mid replacement; `--worker deepseek` stays unhealthy; mid remains claude-ds (docs-only, no version bump). |
 | 2026-08-14 | Experimental `--worker deepseek` wired to official dsh (headless + per-job patch + `DSH_PERMISSION_MODE` + key-via-env); `--model` applies to claude-ds + deepseek; mid stays claude-ds → 0.1.8 LIVE. |
+| 2026-08-14 | route-orch brief steals (AutoDesign / misevolution / Vero): **Verify / claim closeout** + **Eval & skill hygiene**; handoff Success criteria + Verify + NEVER; both skill copies synced; mid stays claude-ds. Docs-only, no version bump. |
+| 2026-08-18 | Health `lane:mid` + `lanes.mid` prove DeepSeek; status evidence tree (`verify.claim` stays unverified); skill health-before-mid + closeout tree; mid stays claude-ds → 0.1.9 (not published). |

package/docs/demo-notes.md

@@ -6,10 +6,10 @@ Simulated capture output for README / tweet assets — replace with a real GIF o
 
 ```
 $ cursor-route --version
-0.1.8
+0.1.9
 
 $ cursor-route health
-cursor-route v0.1.8
+cursor-route v0.1.9
 health: OK
   ✓ tmux
   ✓ runtime          bun ok
@@ -18,6 +18,7 @@ health: OK
   ✓ worker:claude-ds
   ✓ worker:openrouter
   ✗ worker:deepseek  dsh not found — mid default remains claude-ds
+  ✓ lane:mid         DeepSeek proven (claude-ds (DeepSeek shim))
   ✓ jobs_dir         ~/.local/share/cursor-route/jobs
 
 $ cursor-route start --lane mid "Add a failing test then make it pass"

package/docs/fixtures/hero-demo.log

@@ -1,8 +1,8 @@
 $ cursor-route --version
-0.1.8
+0.1.9
 
 $ CURSOR_ROUTE_RELAXED=1 cursor-route health
-cursor-route v0.1.8
+cursor-route v0.1.9
 health: OK
 
   ✓ tmux             ok
@@ -12,6 +12,7 @@ health: OK
   ✓ worker:claude-ds ok (claude-ds (DeepSeek shim); default model deepseek-v4-flash) @ ~/.local/bin/claude-ds
   ✗ worker:openrouter OPENROUTER_API_KEY not set — export your OpenRouter key (easy lane model defaults to openrouter/free) @ node '~/Projects/cursor-route/dist/openrouter-run.js'
   ✗ worker:deepseek  dsh (@deepseek-ai/dsh) not found — install: npm i -g @deepseek-ai/dsh. Mid default remains claude-ds.
+  ✓ lane:mid         DeepSeek proven (claude-ds (DeepSeek shim))
   ✓ cursor_cli       optional ok (agent on PATH) — v0 supervisor is Cursor skill, not CLI
   ✓ relaxed          CURSOR_ROUTE_RELAXED=1 — tmux optional (headless OK)
   ✓ jobs_dir         ~/.local/share/cursor-route/jobs

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 (latest **0.1.8**)
+MIT CLI + Cursor skill. npm: https://www.npmjs.com/package/cursor-route (latest **0.1.9**)
 GitHub: https://github.com/cemini23/cursor-route
 
 ## FAQ

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-route",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "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",

package/skills/route-orch/SKILL.md

@@ -18,7 +18,7 @@ You are the **orchestrator**. Do **not** implement bulk code in this Cursor sess
 - Mid/hard implementation that should run on a subscription worker (Grok CLI / claude-ds)
 - Multi-file investigation that benefits from parallel panes
 
-**Do not steal federation `/route`.** Private Cemini `/route` (route-task → SIP → verify → Grok/claude-ds chain) is a different skill. This public skill only drives the `cursor-route` CLI.
+**Do not steal federation `/route`.** Private Cemini `/route` (route-task → verify → Grok/claude-ds chain) is a different skill. This public skill only drives the `cursor-route` CLI.
 
 ## Lanes (public core)
 
@@ -61,8 +61,8 @@ Health ✓ needs `dsh` on PATH and `DEEPSEEK_API_KEY` set. The adapter pins `--m
 
 ## Workflow
 
-1. Run `cursor-route health` (or `CURSOR_ROUTE_RELAXED=1` for headless). If the **target worker** is unhealthy, fix before spawning.
-2. Write a clear handoff prompt with **verify criteria** (no secrets, no LIVE Discord).
+1. Run `cursor-route health` (or `CURSOR_ROUTE_RELAXED=1` for headless). If the **target worker** is unhealthy, fix before spawning. If targeting **mid**, require `lane:mid` ✓ (or health JSON `lanes.mid.deepseek`) before spawn — `CURSOR_ROUTE_ALLOW_ANTHROPIC=1` is not DeepSeek proof.
+2. Write a clear handoff prompt with **Success criteria** + **Verify** + **NEVER** (no secrets, no LIVE Discord).
 3. Spawn:
 
 ```bash
@@ -70,8 +70,14 @@ cursor-route start --lane hard --dir "$PWD" "$(cat <<'EOF'
 ## Task
 ...
 
+## Success criteria
+- [ ] ...
+
 ## Verify
 - [ ] ...
+
+## NEVER
+- ...
 EOF
 )"
 ```
@@ -79,15 +85,33 @@ EOF
 Or `--worker grok` / `--worker claude-ds` / `--worker deepseek` (experimental) / `--worker openrouter` (or `--lane easy`). Use `--no-tmux` only when tmux is unavailable.
 
 4. Monitor: `cursor-route jobs --json` · `cursor-route capture <id>` · `cursor-route send <id> "…"` (tmux only).
-5. Summarize worker results with **verify evidence** — no status-only “done”. If verify fails, `send` a correction or spawn a follow-up — do not invent success.
+5. Summarize worker results with **verify evidence** — no status-only “done” (see Verify / claim closeout). If verify fails, reconsider the plan/definition (not only retry) — `send` a correction or spawn a follow-up; do not invent success.
+
+## Verify / claim closeout
+
+Verify criteria are an **external eval contract** (AutoDesign pattern), fixed by the parent — not a checklist the worker may rewrite:
+
+- Workers must **not rewrite Success criteria / Verify** to claim done
+- Parent closeout is an **evidence tree**: report **spawn** (job id, worker, lane, model) + **execute** (status, exit) + **verify** (`capture` excerpt / exit). A single “done” scalar is not enough.
+- Parent closes a job only on **capture / exit evidence** (`cursor-route capture <id>`, job exit status)
+- `cursor-route status --json` `.evidence.verify.claim` stays `"unverified"` until the parent reads capture
+- **activity ≠ verification** — busy panes, many tool calls, or long transcripts do not make a claim true
+
+## Eval & skill hygiene
+
+- **External eval contract (AutoDesign):** do not rewrite Verify / Success criteria mid-run to make a failing job look green — capture + exit status are the contract (see Verify / claim closeout).
+- **Skill misevolution:** do not auto-edit `route-orch` or promote skill variants from worker trajectories without operator HITL — write-time approval ≠ safe retrieval later.
+- **On verify fail:** prefer reconsidering the plan/definition (wrong approach) over grinding the same tactic; attribute failure to stage when possible (spawn vs execute vs verify).
 
 ## Always-approve
 
-Defaults on for workers. Opt out: `cursor-route start … --ask` or `CURSOR_ROUTE_ASK=1`.
+Defaults on for workers. Opt out: `cursor-route start … --ask` or `CURSOR_ROUTE_ASK=1`. Always-approve is for **coding worktrees only** — it does not authorize LIVE Discord, trading, or irreversible SaaS.
 
 ## Anti-patterns
 
 - Do not paste API keys / private keys into prompts or `send`
-- Do not claim the official DeepSeek harness (`@deepseek-ai/dsh`) is the mid default — `--worker deepseek` is experimental only; mid stays **claude-ds**
-- Do not open-source or dump private Cemini `agent-toolkit` paths into public handoffs
+- Do not claim the official DeepSeek harness (`@deepseek-ai/dsh`) is the mid default — `--worker deepseek` is an opt-in experiment (cheap to abandon), not a product fork; mid stays **claude-ds**
+- Do not fork a second mid harness
+- Do not open-source or dump private cemini `agent-toolkit` paths into public handoffs
 - Do not mark done without reading `capture` / exit status
+- When editing this skill itself, treat changes as **skill-evolution** — do not auto-promote harmful instructions; prefer **HITL** (no unattended promote from worker trajectories)

package/src/adapters/claude-ds.ts

@@ -124,6 +124,25 @@ function resolveClaudeDs(): { binary: string; mode: string } | null {
   return null;
 }
 
+/**
+ * Mid lane is proven DeepSeek only via shim (`claude-ds` / `deepseek-claude`)
+ * or stock `claude` routed to DeepSeek. The Anthropic escape hatch is not proof.
+ */
+export function isMidDeepSeekProven(): boolean {
+  const resolved = resolveClaudeDs();
+  if (!resolved) return false;
+  return !resolved.mode.startsWith("claude → Anthropic");
+}
+
+/** Human detail for health `lane:mid` (mode when proven; install hint otherwise). */
+export function midDeepSeekProofDetail(): string {
+  const resolved = resolveClaudeDs();
+  if (!resolved || resolved.mode.startsWith("claude → Anthropic")) {
+    return "mid not proven DeepSeek — install claude-ds / set ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic. CURSOR_ROUTE_ALLOW_ANTHROPIC=1 is not proof.";
+  }
+  return `DeepSeek proven (${resolved.mode})`;
+}
+
 function pickModel(requested?: DsModelAlias, modelId?: string): { alias: DsModelAlias; id: string } {
   if (modelId) {
     const alias = requested ?? resolveDsModel(modelId).alias;

package/src/cli.test.ts

@@ -10,12 +10,17 @@ import {
 } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { resolveWorker, startJob } from "./jobs.ts";
+import { resolveWorker, startJob, jobEvidence, type Job } 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 {
+  isDeepSeekRouted,
+  isDeepSeekBaseUrl,
+  claudeDsAdapter,
+  isMidDeepSeekProven,
+} from "./adapters/claude-ds.ts";
 import { deepseekAdapter, patchPathForPrompt } from "./adapters/deepseek.ts";
 import { grokAdapter } from "./adapters/grok.ts";
 
@@ -610,14 +615,18 @@ describe("health", () => {
   test("returns structured report", () => {
     const r = runHealth();
     expect(r.product).toBe("cursor-route");
-    expect(r.version).toBe("0.1.8");
+    expect(r.version).toBe("0.1.9");
     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);
+    const mid = r.checks.find((c) => c.name === "lane:mid");
+    expect(mid).toBeDefined();
+    expect(r.lanes.mid.worker).toBe("claude-ds");
+    expect(r.lanes.mid.deepseek).toBe(mid!.ok);
   });
 
-  test("config version is 0.1.8", () => {
-    expect(config.version).toBe("0.1.8");
+  test("config version is 0.1.9", () => {
+    expect(config.version).toBe("0.1.9");
   });
 
   test("OR-gate: ok can be true while worker:deepseek is false", () => {
@@ -657,4 +666,98 @@ describe("health", () => {
       else process.env.CURSOR_ROUTE_RELAXED = prev;
     }
   });
+
+  test("CURSOR_ROUTE_CLAUDE_DS_BIN pointing at an existing file proves mid DeepSeek", () => {
+    const prev = process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+    const fake = join(tmpdir(), `cr-mid-proof-${process.pid}`);
+    writeFileSync(fake, "#!/bin/sh\necho ok\n");
+    chmodSync(fake, 0o755);
+    process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = fake;
+    try {
+      expect(isMidDeepSeekProven()).toBe(true);
+    } finally {
+      if (prev === undefined) delete process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+      else process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = prev;
+      rmSync(fake, { force: true });
+    }
+  });
+
+  test("Anthropic hatch is not DeepSeek proof (shim on PATH still is)", () => {
+    const shimDir = join(tmpdir(), `cr-mid-hatch-${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,
+      crBase: process.env.CURSOR_ROUTE_ANTHROPIC_BASE_URL,
+      path: process.env.PATH,
+    };
+    delete process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+    delete process.env.CURSOR_ROUTE_ANTHROPIC_BASE_URL;
+    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 detail = claudeDsAdapter.health().detail;
+      if (detail.includes("Anthropic")) {
+        expect(isMidDeepSeekProven()).toBe(false);
+        const r = runHealth();
+        const mid = r.checks.find((c) => c.name === "lane:mid");
+        expect(mid?.ok).toBe(false);
+        expect(r.lanes.mid.deepseek).toBe(false);
+      } else {
+        // Real claude-ds / deepseek-claude on PATH is proof (hatch never engages).
+        expect(isMidDeepSeekProven()).toBe(true);
+      }
+    } 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;
+      if (prev.crBase === undefined) delete process.env.CURSOR_ROUTE_ANTHROPIC_BASE_URL;
+      else process.env.CURSOR_ROUTE_ANTHROPIC_BASE_URL = prev.crBase;
+      process.env.PATH = prev.path || "";
+      rmSync(shimDir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("jobEvidence", () => {
+  test("verify.claim is always unverified; spawn/execute keys exist", () => {
+    const job: Job = {
+      id: "abcd1234",
+      schema: "cursor-route.job.v1",
+      status: "running",
+      worker: "claude-ds",
+      lane: "mid",
+      model: "flash",
+      prompt: "ping",
+      cwd: "/tmp",
+      alwaysApprove: true,
+      tmuxSession: "cursor-route-abcd1234",
+      createdAt: "2026-08-18T00:00:00.000Z",
+      startedAt: "2026-08-18T00:00:01.000Z",
+      logBytes: 42,
+    };
+    const ev = jobEvidence(job, true);
+    expect(ev.verify.claim).toBe("unverified");
+    expect(ev.verify.captureHint).toBe("cursor-route capture abcd1234");
+    expect(ev.verify.logBytes).toBe(42);
+    expect(ev.spawn.jobId).toBe("abcd1234");
+    expect(ev.spawn.worker).toBe("claude-ds");
+    expect(ev.spawn.lane).toBe("mid");
+    expect(ev.spawn.model).toBe("flash");
+    expect(ev.spawn.startedAt).toBe("2026-08-18T00:00:01.000Z");
+    expect(ev.execute.status).toBe("running");
+    expect(ev.execute.exitCode).toBe(null);
+    expect(ev.execute.tmuxSession).toBe("cursor-route-abcd1234");
+    expect(ev.execute.pid).toBe(null);
+    expect(ev.execute.sessionAlive).toBe(true);
+  });
 });

package/src/cli.ts

@@ -22,6 +22,7 @@ import {
   cleanJobs,
   jobPaths,
   refreshStatus,
+  jobEvidence,
 } from "./jobs.ts";
 import {
   capturePane,
@@ -39,11 +40,11 @@ Cursor stays the brain. Grok CLI + DeepSeek (claude-ds) + OpenRouter (easy) are
 
 Usage:
   cursor-route --version
-  cursor-route health [--json]
+  cursor-route health [--json]          # JSON includes lanes.mid (DeepSeek proof)
   cursor-route start <prompt> [options]
   cursor-route start --prompt-file <path> [options]
   cursor-route jobs [--json] [--limit N]
-  cursor-route status <jobId> [--json]
+  cursor-route status <jobId> [--json]  # JSON includes evidence spawn/execute/verify
   cursor-route capture <jobId> [lines]
   cursor-route send <jobId> <message>
   cursor-route attach <jobId>
@@ -389,12 +390,14 @@ async function main() {
           }
         })())
       : sessionExists(job.tmuxSession);
-    const view = { ...job, sessionAlive: alive };
+    const evidence = jobEvidence(job, alive);
+    const view = { ...job, sessionAlive: alive, evidence };
     if (json) console.log(JSON.stringify(view, null, 2));
     else {
       console.log(
         `${job.id}  ${job.status}  worker=${job.worker}${job.model ? `  model=${job.model}` : ""}  sessionAlive=${alive}`,
       );
+      console.log("evidence: spawn/execute/verify (claim=unverified)");
       if (job.error) console.log(`error: ${job.error}`);
     }
     return;

package/src/config.ts

@@ -89,7 +89,7 @@ function maxConcurrentJobsFromEnv(): number {
  */
 export const config = {
   product: "cursor-route",
-  version: "0.1.8",
+  version: "0.1.9",
   get jobsDir(): string {
     return defaultJobsDir();
   },

package/src/health.ts

@@ -1,5 +1,6 @@
 import { execSync } from "node:child_process";
 import { allAdapters } from "./adapters/index.ts";
+import { isMidDeepSeekProven, midDeepSeekProofDetail } from "./adapters/claude-ds.ts";
 import { config } from "./config.ts";
 import { isTmuxAvailable } from "./tmux.ts";
 import { commandExists } from "./util.ts";
@@ -13,6 +14,9 @@ export interface HealthReport {
     ok: boolean;
     detail: string;
   }>;
+  lanes: {
+    mid: { worker: "claude-ds"; deepseek: boolean; detail: string };
+  };
 }
 
 export function runHealth(): HealthReport {
@@ -58,6 +62,15 @@ export function runHealth(): HealthReport {
     });
   }
 
+  // Informational: mid is proven DeepSeek (not the overall OR-gate).
+  const midOk = isMidDeepSeekProven();
+  const midDetail = midDeepSeekProofDetail();
+  checks.push({
+    name: "lane:mid",
+    ok: midOk,
+    detail: midDetail,
+  });
+
   // Optional supervisor probe (v0 skill-only; Cursor CLI agent is informational)
   const agentBin =
     (commandExists("agent") && "agent") ||
@@ -99,6 +112,9 @@ export function runHealth(): HealthReport {
     product: config.product,
     version: config.version,
     checks,
+    lanes: {
+      mid: { worker: "claude-ds", deepseek: midOk, detail: midDetail },
+    },
   };
 }
 
@@ -118,5 +134,10 @@ export function printHealth(report: HealthReport, asJson: boolean): void {
     console.log("");
     console.log("Fix the ✗ items, then re-run: cursor-route health");
     console.log("Tip: start with one worker (grok OR claude-ds) before parallel demos.");
+  } else if (report.checks.some((c) => c.name === "lane:mid" && !c.ok)) {
+    console.log("");
+    console.log(
+      "Tip: health OK without a DeepSeek mid — --lane mid will fail until lane:mid is ✓.",
+    );
   }
 }

package/src/jobs.ts

@@ -105,6 +105,53 @@ export function writeJob(job: Job): void {
   writeSecure(jobPaths(job.id).json, JSON.stringify(job, null, 2));
 }
 
+/** Evidence tree for status --json. Parent must capture; claim is never auto-green. */
+export interface JobEvidence {
+  spawn: {
+    jobId: string;
+    worker: WorkerKind;
+    lane: Lane | null;
+    model: DsModelAlias | null;
+    startedAt: string;
+  };
+  execute: {
+    status: JobStatus;
+    exitCode: number | null;
+    tmuxSession: string;
+    pid: number | null;
+    sessionAlive: boolean;
+  };
+  verify: {
+    captureHint: string;
+    logBytes: number | null;
+    claim: "unverified";
+  };
+}
+
+export function jobEvidence(job: Job, sessionAlive: boolean): JobEvidence {
+  return {
+    spawn: {
+      jobId: job.id,
+      worker: job.worker,
+      lane: job.lane ?? null,
+      model: job.model ?? null,
+      startedAt: job.startedAt ?? job.createdAt,
+    },
+    execute: {
+      status: job.status,
+      exitCode: job.exitCode ?? null,
+      tmuxSession: job.tmuxSession,
+      pid: job.pid ?? null,
+      sessionAlive,
+    },
+    verify: {
+      captureHint: `cursor-route capture ${job.id}`,
+      logBytes: job.logBytes ?? null,
+      claim: "unverified",
+    },
+  };
+}
+
 function pidAlive(pid: number): boolean {
   try {
     process.kill(pid, 0);
@@ -118,6 +165,8 @@ function pidAlive(pid: number): boolean {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
     });
+    // spawnSync does not throw on EPERM (macOS sandbox); empty stdout is not "dead".
+    if (r.error || r.status !== 0) return true;
     const state = (r.stdout || "").trim();
     return state !== "" && !state.startsWith("Z");
   } catch {