cursor-route 0.1.1

package/CONTRIBUTING.md

@@ -0,0 +1,26 @@
+# Contributing
+
+## Dev
+
+```bash
+bun install
+bun test
+./bin/cursor-route health
+CURSOR_ROUTE_RELAXED=1 ./bin/cursor-route health   # without tmux
+./bin/cursor-route start --dry-run --worker grok "ping"
+```
+
+## 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`)
+
+## 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)

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cemini
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,161 @@
+# cursor-route
+
+**Cursor stays the brain. Grok CLI + DeepSeek (claude-ds) are the parallel army.**
+
+Lane-aware `/route` orchestration in tmux — not another multi-provider fleet, not a Codex clone.
+
+```bash
+cursor-route health
+cursor-route start --lane hard "Refactor auth module; run tests; report verify evidence"
+cursor-route jobs --json
+cursor-route capture <jobId>
+```
+
+## Why this exists
+
+| Product | Brain | Workers | Feel |
+|---------|-------|---------|------|
+| [codex-orchestrator](https://github.com/kingbootoshi/codex-orchestrator) | Claude Code | Codex | Viral tmux panes |
+| [CAO](https://github.com/awslabs/cli-agent-orchestrator) | Supervisor CLI | Many (incl. Cursor CLI) | Enterprise MCP + Web UI |
+| **cursor-route** | **Cursor Agent** | **Grok CLI + claude-ds** | Cost-aware lanes you already pay for |
+
+If you already live in Cursor, X Premium (Grok CLI), and DeepSeek — stop paying a third coding agent just to parallelize.
+
+## Cost table (orienting)
+
+| Role | Typical bill | cursor-route use |
+|------|----------------|------------------|
+| Cursor | Premium plan | Plan / synthesize / verify (orchestrator) |
+| Grok CLI | X Premium | `--lane hard` implement |
+| DeepSeek via claude-ds | DeepSeek API / plan | `--lane mid` implement |
+| Codex / extra Claude | Optional | Not required for v0 |
+
+Exact dollars vary — the point is **reuse subscriptions you already have**.
+
+## Install (60 seconds)
+
+**Prerequisites**
+
+| Dep | Why |
+|-----|-----|
+| [tmux](https://github.com/tmux/tmux) | Worker panes |
+| [Bun](https://bun.sh) *(or Node 20+)* | Runs the CLI |
+| [Grok CLI](https://x.ai/cli) and/or Claude Code + DeepSeek (`claude-ds`) | Workers |
+| `script(1)` | Job logs (macOS/Linux) |
+
+```bash
+# Prerequisites
+brew install tmux          # or build tmux into ~/.local
+# Bun optional — Node 20+ works via pinned tsx
+
+# Preferred install
+npm i -g cursor-route
+
+# Auth workers
+grok login                 # if using Grok
+# configure claude-ds — see DeepSeek setup below
+
+cursor-route health
+# without tmux (CI / headless):
+CURSOR_ROUTE_RELAXED=1 cursor-route health
+```
+
+**From source (dev):**
+
+```bash
+git clone https://github.com/cemini23/cursor-route.git
+cd cursor-route && bun install
+./bin/cursor-route health
+```
+
+### Cursor skill
+
+Copy the skill into your project or user skills:
+
+```bash
+mkdir -p .cursor/skills
+cp -R ~/.cursor-route-src/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`).
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `health` | Gate #1 — tmux, runtime, workers |
+| `start <prompt>` | Spawn worker job (`--worker` / `--lane` / `--dir` / `--ask` / `--dry-run` / `--no-tmux`) |
+| `jobs [--json]` | List jobs |
+| `status <id>` | Job + sessionAlive |
+| `capture <id> [n]` | Last n pane/log lines |
+| `send <id> <msg>` | Mid-task redirect (tmux send-keys) |
+| `attach <id>` | Print `tmux attach` hint |
+| `kill <id>` | Stop session |
+| `sessions` | Managed tmux sessions |
+| `clean [--days N]` | Drop old job files |
+
+## Lanes
+
+| Lane | Worker | Intent |
+|------|--------|--------|
+| `mid` | `claude-ds` | Default implement on DeepSeek |
+| `hard` | `grok` | Hard implement on Grok CLI |
+
+Always-approve is **on** by default. Opt out: `--ask` or `CURSOR_ROUTE_ASK=1`.
+
+## 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.
+
+**Recommended (official DeepSeek → Claude Code):**
+
+```bash
+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]
+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 "…"
+```
+
+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).
+
+**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`.
+
+No DeepSeek yet? Use `--lane hard` / `--worker grok` (X Premium).
+
+## Jobs directory
+
+Jobs default to `~/.local/share/cursor-route/jobs` (override with `CURSOR_ROUTE_JOBS_DIR`).
+This is **not** inside a git clone of this repo.
+
+## Safety
+
+- No secrets in prompts (CLI soft-refuses common key patterns)
+- See [SECURITY.md](./SECURITY.md)
+- Local orchestration only — no LIVE Discord / trading egress demos
+
+## Also from Cemini
+
+- [Atto](https://youratto.com) — genealogy / archival agents  
+- [GuruWatcher](https://guruwatcher.com) — alert workflows  
+- Cemini research & trading tooling (private)
+
+## License
+
+MIT © Cemini
+
+## Roadmap (explicitly later)
+
+- npm publish + Homebrew tap  
+- Native DeepSeek harness adapter  
+- Codebase map injection (`--map`)  
+- Cursor CLI `agent` as alternate supervisor  
+- Web UI / CAO-style MCP supervisor  
+- OpenRouter easy lane (secrets-safe)

package/SECURITY.md

@@ -0,0 +1,26 @@
+# Security Policy
+
+## Supported versions
+
+| Version | Supported |
+|---------|-----------|
+| 0.x     | Yes       |
+
+## Reporting a vulnerability
+
+Email security reports to the maintainers via GitHub Security Advisories on this repo.
+Do **not** open a public issue for credential leaks or RCE-class bugs.
+
+## Hard rules for users and agents
+
+1. **No secrets in prompts or job files.** Do not paste API keys, SSH private keys, Discord tokens, or `.env` contents into `cursor-route start` / `send` prompts.
+2. **Always-approve is powerful.** Default headless workers skip interactive permission prompts (`--always-approve` / `--dangerously-skip-permissions`). Opt out with `--ask` / `CURSOR_ROUTE_ASK=1` when you need HITL.
+3. **Install from known channels only.** Prefer `npm i -g cursor-route` or a git clone of this repo. Do not pipe unknown `curl | bash` installers as the primary path.
+4. **Workers inherit your auth.** Grok CLI and Claude Code / claude-ds use *your* local login. Treat worker panes like you would treat your own shell.
+5. **No LIVE Discord / trading egress demos** from this tool. Orchestration is local.
+
+## Supply chain
+
+- Runtime dependencies: **none** (Node/Bun + system `tmux` + worker CLIs).
+- Review `package.json` before upgrading.
+- Prefer pinned git tags for production installs.

package/bin/cursor-route

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# cursor-route — thin launcher (Bun preferred, Node+tsx fallback)
+set -euo pipefail
+SOURCE="${BASH_SOURCE[0]}"
+while [ -L "$SOURCE" ]; do
+  DIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
+  SOURCE="$(readlink "$SOURCE")"
+  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE"
+done
+SCRIPT_DIR="$(cd -P "$(dirname "$SOURCE")" && pwd)"
+ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+CLI="$ROOT/src/cli.ts"
+
+if command -v bun >/dev/null 2>&1; then
+  exec bun "$CLI" "$@"
+fi
+
+if command -v npx >/dev/null 2>&1; then
+  # Pin tsx for supply-chain predictability (no floating --yes latest)
+  exec npx --yes tsx@4.19.4 "$CLI" "$@"
+fi
+
+echo "cursor-route: need Bun (https://bun.sh) or Node 20+ with npx" >&2
+exit 127

package/bin/cursor-route.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+/**
+ * npm bin entry — prefers Bun, falls back to pinned tsx.
+ */
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const cli = join(root, "src", "cli.ts");
+const args = process.argv.slice(2);
+
+function run(cmd, cmdArgs) {
+  const r = spawnSync(cmd, cmdArgs, { stdio: "inherit", env: process.env });
+  if (r.error && r.error.code === "ENOENT") return null;
+  process.exit(r.status ?? 1);
+}
+
+const bun = spawnSync("bun", ["--version"], { encoding: "utf8" });
+if (bun.status === 0) {
+  run("bun", [cli, ...args]);
+}
+
+run("npx", ["--yes", "tsx@4.19.4", cli, ...args]);
+console.error("cursor-route: need Bun (https://bun.sh) or Node 20+ with npx");
+process.exit(127);

package/docs/DEMO_GIF.md

@@ -0,0 +1,22 @@
+# Hero demo recording (GIF)
+
+tmux is required for the viral attach/send demo. On this laptop brew needs sudo — record after:
+
+```bash
+brew install tmux
+export PATH="$HOME/.cursor-route/bin:$PATH"
+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 --worker grok --dir "$PWD" "List open TODOs in src/"
+
+# Terminal B — watch
+cursor-route jobs --json
+# Attach one pane for the GIF: tmux attach -t cursor-route-<id>
+```
+
+Record with [asciinema](https://asciinema.org/) or CleanShot → export GIF → `docs/fixtures/hero.gif`.
+
+Until then, use `docs/fixtures/claude-ds-smoke.log` as the committed proof fixture.

package/docs/audit-2026-08-10-sol-grok-kimi.md

@@ -0,0 +1,64 @@
+# Cursor audit — cursor-route v0.1.0→0.1.1
+
+**Mode:** `code-debug` · **Roles → models:** code-implementation→`gpt-5.6-sol-medium`, adversarial→`cursor-grok-4.5-high-fast`, third-lens→`kimi-k3-max`
+
+Auditors: [Sol](fad461d6-9be9-421e-b42e-081cd7888a56) · [Grok](79e70632-1de7-456e-871b-cdb66b7b72f1) · [Kimi](9a0b224f-eacf-4a2f-969c-6854db1d6876)
+
+## Verdict rollup (pre-fix)
+
+| Model | Verdict |
+|-------|---------|
+| GPTSOL | FAIL |
+| Cursor Grok | FAIL |
+| Kimi 3 | WARN |
+
+**Overall (pre-fix):** REWORK — then SHIP-WITH-FIXES after 0.1.1.
+
+## Consensus (≥2 auditors)
+
+1. Headless `kill` did not kill (no PID) — phantom killed
+2. `refreshStatus` inferred `completed` from missing tmux — lies on `--no-tmux`
+3. Completion hooks hard-coded `bun` vs Node fallback
+4. macOS `script` left `cd && …` unquoted
+5. Stock `claude` silent fallback for “claude-ds”
+6. Secret deny false-positive on prose “API key”; `send` bypass
+7. Missing DeepSeek setup docs / mid-lane dead end for public users
+8. Skill `/route` collision with federation `/route`
+
+## Unique
+
+- [Sol] Job-id path traversal; dry-run side effects; race before `running` write
+- [Grok] Always-approve + skill contract burns private SIP/verify; Grok sandbox missing
+- [Kimi] No hero.gif; typecheck red; jobsDir collided with clone path; no CI
+
+## Conflicts
+
+| Topic | Sol | Grok | Kimi | Resolution |
+|-------|-----|------|------|------------|
+| Overall ship | FAIL | FAIL | WARN | Fix criticals then soft-launch; GIF still deferred |
+| Skill name `/route` | — | critical rename | — | Renamed triggers to `/route-orch` |
+
+## Fixes shipped in `20b1580` (v0.1.1)
+
+- PID-tracked headless spawn + polled terminate on `kill`
+- No phantom `completed` from session absence; exit via mark-complete / failed unknown
+- `markCompleteInvoker` (bun or pinned `tsx@4.19.4`)
+- macOS/Linux `script` always via `/bin/sh -c`
+- Stock Claude only with `CURSOR_ROUTE_ALLOW_STOCK_CLAUDE=1`
+- Material-only secret deny on `start` + `send`
+- XDG jobs dir `~/.local/share/cursor-route/jobs`
+- README DeepSeek setup; skill deconflict; CI workflow; `--version`; typecheck green
+
+## Verify after fix
+
+- 11/11 tests · `tsc --noEmit` clean
+- Headless claude-ds → `CURSOR_ROUTE_SMOKE_OK2` · `exitCode: 0`
+- Headless `kill` → `status: killed`
+- Prose “API key” dry-run allowed; `sk-…` refused exit 3
+
+## Still open (not tweet-blockers for soft launch)
+
+- Real tmux attach/send GIF (`docs/DEMO_GIF.md`) — needs `brew install tmux` (sudo)
+- npm publish
+- Grok Build balance for live grok demos
+- Optional: grok `--sandbox`, `wait` command, remove skill file duplicate via symlink

package/docs/demo-notes.md

@@ -0,0 +1,25 @@
+# Demo fixture log (no secrets)
+
+Simulated capture output for README / tweet assets — replace with a real GIF once tmux is available.
+
+```
+$ cursor-route health
+cursor-route v0.1.0
+health: OK
+  ✓ tmux
+  ✓ runtime          bun ok
+  ✓ script(1)
+  ✓ worker:grok
+  ✓ worker:claude-ds
+
+$ cursor-route start --lane mid "Add a failing test then make it pass"
+started a1b2c3d4 (claude-ds)
+session: cursor-route-a1b2c3d4
+attach:  tmux attach -t cursor-route-a1b2c3d4
+
+$ cursor-route jobs --json
+[{ "id": "a1b2c3d4", "status": "running", "worker": "claude-ds", ... }]
+```
+
+Verified locally (2026-08-10): headless `claude-ds` smoke returned `CURSOR_ROUTE_SMOKE_OK`.
+Grok smoke hit 402 (Build usage balance exhausted) — auth/PATH wiring works; top up Grok Build for live demos.

package/docs/fixtures/claude-ds-smoke.log

@@ -0,0 +1,5 @@
+claude-ds - DeepSeek Claude Code (model=deepseek-v4-flash)
+Install: ~/.deepseek-claude
+PromptFile: ~/.cursor-route/jobs/e7567d1f.prompt
+WorkDir: ~/Projects/cursor-route
+CURSOR_ROUTE_SMOKE_OK

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "cursor-route",
+  "version": "0.1.1",
+  "description": "Cursor stays the brain. Grok CLI + DeepSeek (claude-ds) are the parallel army — lane-aware /route orchestration in tmux.",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "cursor-route": "./bin/cursor-route.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "bin",
+    "src",
+    "skills",
+    "docs",
+    "LICENSE",
+    "SECURITY.md",
+    "CONTRIBUTING.md",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "bun run src/cli.ts",
+    "health": "bun run src/cli.ts health",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun test && bun run typecheck"
+  },
+  "keywords": [
+    "cursor",
+    "grok",
+    "deepseek",
+    "claude-ds",
+    "tmux",
+    "orchestrator",
+    "agents",
+    "route"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cemini23/cursor-route.git"
+  },
+  "bugs": {
+    "url": "https://github.com/cemini23/cursor-route/issues"
+  },
+  "homepage": "https://github.com/cemini23/cursor-route#readme",
+  "devDependencies": {
+    "@types/bun": "^1.2.0",
+    "@types/node": "^22.15.0",
+    "typescript": "^5.8.0"
+  },
+  "dependencies": {}
+}

package/skills/route-orch/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: route-orch
+description: >-
+  Delegate coding work from Cursor to parallel Grok CLI / claude-ds (DeepSeek)
+  workers via cursor-route. Use when the user says /route-orch, spawn workers,
+  parallel agents with cursor-route, or explicitly asks to outsource
+  implementation to Grok/DeepSeek panes — not for private Cemini /route.
+---
+
+# route-orch (cursor-route)
+
+You are the **orchestrator**. Do **not** implement bulk code in this Cursor session when delegation fits.
+
+## When to activate
+
+- User says `/route-orch`, `spawn workers`, or asks for parallel Grok/DeepSeek via **cursor-route**
+- 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.
+
+## Lanes (public core)
+
+| Lane | Worker | Use when |
+|------|--------|----------|
+| `mid` | `claude-ds` (DeepSeek via Claude Code harness) | Standard implement / refactor |
+| `hard` | `grok` | Premium plan in Cursor → Grok implement |
+
+Easy/OpenRouter is **not** in v0 — keep secrets off free models.
+
+## 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).
+3. Spawn:
+
+```bash
+cursor-route start --lane hard --dir "$PWD" "$(cat <<'EOF'
+## Task
+...
+
+## Verify
+- [ ] ...
+EOF
+)"
+```
+
+Or `--worker grok` / `--worker claude-ds`. 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.
+
+## Always-approve
+
+Defaults on for workers. Opt out: `cursor-route start … --ask` or `CURSOR_ROUTE_ASK=1`.
+
+## Anti-patterns
+
+- Do not paste API keys / private keys into prompts or `send`
+- Do not claim DeepSeek-native harness until that adapter ships — today is **claude-ds**
+- Do not open-source or dump private Cemini `agent-toolkit` paths into public handoffs
+- Do not mark done without reading `capture` / exit status

package/src/adapters/claude-ds.ts

@@ -0,0 +1,154 @@
+import { execSync } from "node:child_process";
+import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { Adapter, WorkerHealth } from "./types.ts";
+import { shellQuote } from "../util.ts";
+
+/**
+ * Mid-lane = DeepSeek (cheap). The Claude Code binary is only a harness —
+ * requests must hit DeepSeek, not Anthropic.
+ *
+ * Resolution order:
+ * 1. claude-ds / deepseek-claude shims
+ * 2. stock `claude` when ANTHROPIC_BASE_URL (env or ~/.claude/settings.json)
+ *    points at api.deepseek.com — auto-ok, no opt-in
+ * 3. stock `claude` on Anthropic only if CURSOR_ROUTE_ALLOW_ANTHROPIC=1
+ *    (explicit expensive escape hatch — not the product default)
+ */
+
+function which(cmd: string): string | null {
+  try {
+    return (
+      execSync(`command -v ${cmd}`, {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+      }).trim() || null
+    );
+  } catch {
+    return null;
+  }
+}
+
+function deepseekBaseFromSettings(): string | null {
+  const candidates = [
+    join(homedir(), ".claude", "settings.json"),
+    join(process.cwd(), ".claude", "settings.json"),
+  ];
+  for (const p of candidates) {
+    if (!existsSync(p)) continue;
+    try {
+      const j = JSON.parse(readFileSync(p, "utf8")) as {
+        env?: Record<string, string>;
+      };
+      const url = j.env?.ANTHROPIC_BASE_URL;
+      if (url) return url;
+    } catch {
+      /* ignore */
+    }
+  }
+  return null;
+}
+
+/** True when Claude Code harness is routed to DeepSeek (cheap path). */
+export function isDeepSeekRouted(): boolean {
+  const url =
+    process.env.ANTHROPIC_BASE_URL ||
+    process.env.CURSOR_ROUTE_ANTHROPIC_BASE_URL ||
+    deepseekBaseFromSettings() ||
+    "";
+  return /deepseek\.com/i.test(url);
+}
+
+function resolveClaudeDs(): { binary: string; mode: string } | null {
+  for (const c of [
+    { cmd: "claude-ds", mode: "claude-ds (DeepSeek shim)" },
+    { cmd: "deepseek-claude", mode: "deepseek-claude" },
+  ] as const) {
+    const path = which(c.cmd);
+    if (path) return { binary: path, mode: c.mode };
+  }
+
+  const claude = which("claude");
+  if (!claude) return null;
+
+  if (isDeepSeekRouted()) {
+    return {
+      binary: claude,
+      mode: "claude → DeepSeek (ANTHROPIC_BASE_URL)",
+    };
+  }
+
+  // Expensive Anthropic path — opt-in only so we never silently bill frontier rates
+  if (
+    process.env.CURSOR_ROUTE_ALLOW_ANTHROPIC === "1" ||
+    process.env.CURSOR_ROUTE_ALLOW_STOCK_CLAUDE === "1" // legacy alias
+  ) {
+    return {
+      binary: claude,
+      mode: "claude → Anthropic (CURSOR_ROUTE_ALLOW_ANTHROPIC=1)",
+    };
+  }
+
+  return null;
+}
+
+export const claudeDsAdapter: Adapter = {
+  kind: "claude-ds",
+  label: "DeepSeek (via Claude Code harness)",
+  health(): WorkerHealth {
+    const resolved = resolveClaudeDs();
+    if (!resolved) {
+      const hasClaude = Boolean(which("claude"));
+      return {
+        worker: "claude-ds",
+        ok: false,
+        binary: null,
+        detail: hasClaude
+          ? "claude on PATH but ANTHROPIC_BASE_URL is not DeepSeek — set https://api.deepseek.com/anthropic (see README). Refusing Anthropic default so mid-lane stays cheap."
+          : "need claude-ds, deepseek-claude, or claude + DeepSeek ANTHROPIC_BASE_URL — see README DeepSeek setup",
+      };
+    }
+    return {
+      worker: "claude-ds",
+      ok: true,
+      binary: resolved.binary,
+      detail: `ok (${resolved.mode})`,
+    };
+  },
+  buildLaunch({ promptFile, cwd, alwaysApprove }) {
+    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;
+
+    if (resolved.mode.startsWith("claude-ds")) {
+      const parts = [
+        shellQuote(resolved.binary),
+        "-PromptFile",
+        shellQuote(promptFile),
+      ];
+      if (skip) parts.push("--dangerously-skip-permissions");
+      return {
+        worker: "claude-ds",
+        command: `cd ${shellQuote(cwd)} && ${parts.join(" ")}`,
+        alwaysApprove: skip,
+      };
+    }
+
+    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,
+    };
+  },
+};