cursor-route 0.1.6 → 0.1.8

package/src/cli.ts

@@ -8,7 +8,7 @@ import {
   config,
   WORKERS,
   LANES,
-  resolveDsModelAlias,
+  resolveDsModel,
   type WorkerKind,
   type Lane,
   type DsModelAlias,
@@ -52,9 +52,9 @@ Usage:
   cursor-route clean [--days N]
 
 Start options:
-  --worker <grok|claude-ds|openrouter>  Worker adapter (default: grok; deepseek = reserved slot)
+  --worker <grok|claude-ds|openrouter|deepseek>  Worker adapter (default: grok; deepseek = experimental official dsh)
   --lane <easy|mid|hard>                Lane → worker (easy=openrouter, mid=claude-ds, hard=grok)
-  --model <flash|pro>                   Mid DeepSeek model (default: flash). Ignored by grok/openrouter
+  --model <flash|pro>                   Mid DeepSeek only (default: flash / CURSOR_ROUTE_DS_MODEL). Parsed for claude-ds + deepseek
   --dir <path>                          Working directory (default: cwd)
   --ask                                 Disable always-approve for this job
   --dry-run                             Print launch command; do not start
@@ -66,10 +66,12 @@ Env:
   CURSOR_ROUTE_JOBS_DIR              Override jobs dir (default: ~/.local/share/cursor-route/jobs)
   CURSOR_ROUTE_MAX_JOBS              Max active jobs (default: 50)
   CURSOR_ROUTE_RELAXED=1             health OK without tmux/workers (CI / infra smoke)
-  CURSOR_ROUTE_ALLOW_ANTHROPIC=1     Allow mid-lane on Anthropic Claude (expensive; not default)
-  CURSOR_ROUTE_DS_MODEL              Default mid model flash|pro (overridden by --model)
+  CURSOR_ROUTE_ALLOW_ANTHROPIC=1     Allow mid-lane on Anthropic Claude (expensive; not default; --model ignored)
+  CURSOR_ROUTE_DS_MODEL              Default mid model flash|pro (or deepseek-v4-pro[1m]); overridden by --model
   CURSOR_ROUTE_GROK_BIN              Override the grok binary path (tests / power users)
   CURSOR_ROUTE_CLAUDE_DS_BIN         Override the claude-ds binary path (tests / power users)
+  CURSOR_ROUTE_DSH_BIN               Override the dsh binary path (tests / power users)
+  DEEPSEEK_API_KEY                   DeepSeek API key (required for --worker deepseek)
   OPENROUTER_API_KEY                 OpenRouter key (required for --worker openrouter / --lane easy)
   CURSOR_ROUTE_OPENROUTER_MODEL      OpenRouter model (default: openrouter/free)
   OPENROUTER_BASE_URL                OpenRouter API base (default: https://openrouter.ai/api/v1)
@@ -162,10 +164,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 +237,35 @@ 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-only (claude-ds mid lane + experimental deepseek worker);
+    // ignore (do not validate) for other workers
+    if (f.model !== undefined && (resolvedWorker === "claude-ds" || resolvedWorker === "deepseek")) {
+      try {
+        const choice = asDsModelChoice(f.model);
+        if (choice) {
+          model = choice.alias;
+          modelId = choice.id;
+        }
+      } catch (e) {
+        console.error((e as Error).message);
+        process.exit(2);
+      }
+    }
 
     let prompt = "";
     if (promptFile) {
@@ -277,9 +301,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 +358,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 +392,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

@@ -2,13 +2,22 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { defaultJobsDir } from "./runtime.ts";
 
-/** Workers with a live adapter. `deepseek` is a reserved slot (unreleased harness). */
+/**
+ * Workers with a live adapter. `deepseek` is the experimental official
+ * DeepSeek Harness (dsh) — an opt-in worker, not a mid default.
+ */
 export type WorkerKind = "grok" | "claude-ds" | "openrouter" | "deepseek";
 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 +27,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,20 +89,33 @@ function maxConcurrentJobsFromEnv(): number {
  */
 export const config = {
   product: "cursor-route",
-  version: "0.1.6",
+  version: "0.1.8",
   get jobsDir(): string {
     return defaultJobsDir();
   },
   tmuxPrefix: "cursor-route",
   defaultWorker: "grok" as WorkerKind,
-  /** Lane → default worker (Cemini /route public core). */
+  /**
+   * Lane → default worker (Cemini /route public core).
+   * `deepseek` is experimental only — mid stays on claude-ds.
+   */
   laneWorkers: {
     easy: "openrouter" as WorkerKind,
     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,
@@ -35,7 +37,7 @@ export interface Job {
   status: JobStatus;
   worker: WorkerKind;
   lane?: Lane;
-  /** Mid-lane DeepSeek model alias (flash|pro). Only set for claude-ds. */
+  /** Mid-lane DeepSeek model alias (flash|pro). Set for claude-ds and deepseek. */
   model?: DsModelAlias;
   prompt: string;
   cwd: string;
@@ -229,8 +231,10 @@ export interface StartOptions {
   prompt: string;
   worker?: WorkerKind;
   lane?: Lane;
-  /** Mid-lane DeepSeek: flash (default) | pro. Ignored by grok/openrouter. */
+  /** Mid-lane DeepSeek: flash (default) | pro (claude-ds + deepseek). 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" || worker === "deepseek") {
+    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,8 @@ export function startJob(opts: StartOptions): {
       cwd,
       alwaysApprove,
       model,
+      modelId,
+      dryRun: Boolean(opts.dryRun),
     });
   } catch (e) {
     try {
@@ -469,7 +494,7 @@ export function cleanJobs(olderThanDays = 7): number {
         t < cutoff &&
         (job.status === "completed" || job.status === "failed" || job.status === "killed")
       ) {
-        for (const ext of [".json", ".prompt", ".log"] as const) {
+        for (const ext of [".json", ".prompt", ".log", ".dsh-patch.yml"] as const) {
           const fp = underJobsDir(id, ext);
           if (existsSync(fp)) unlinkSync(fp);
         }