cursor-route 0.1.10 → 0.1.13

package/src/cli.test.ts

@@ -11,7 +11,7 @@ import {
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { resolveWorker, startJob, jobEvidence, type Job } from "./jobs.ts";
-import { config, resolveDsModel, resolveDsModelAlias } from "./config.ts";
+import { config, promptLooksLikeVision, resolveDsModel, resolveDsModelAlias } from "./config.ts";
 import { shellQuote, newJobId } from "./util.ts";
 import { runHealth } from "./health.ts";
 import { looksLikeSecretMaterial, redactSecrets } from "./secrets.ts";
@@ -58,13 +58,37 @@ describe("resolveDsModel", () => {
   test("accepts aliases and full ids", () => {
     expect(resolveDsModel("flash").id).toBe("deepseek-v4-flash");
     expect(resolveDsModel("pro").id).toBe("deepseek-v4-pro");
+    expect(resolveDsModel("vision").id).toBe("deepseek-v4-flash-vision-exp");
+    expect(resolveDsModel("deepseek-v4-flash-vision-exp")).toEqual({
+      alias: "vision",
+      id: "deepseek-v4-flash-vision-exp",
+    });
     expect(resolveDsModel("deepseek-v4-pro[1m]")).toEqual({
       alias: "pro",
       id: "deepseek-v4-pro[1m]",
     });
   });
   test("rejects unknown", () => {
-    expect(() => resolveDsModel("opus")).toThrow(/flash\|pro/);
+    expect(() => resolveDsModel("opus")).toThrow(/flash\|pro\|vision/);
+  });
+});
+
+describe("promptLooksLikeVision", () => {
+  test("matches screenshot/image/png/jpg/jpeg/webp/ui mock/multimodal/vision", () => {
+    expect(promptLooksLikeVision("describe this screenshot")).toBe(true);
+    expect(promptLooksLikeVision("Look at this screenshot.png and describe it")).toBe(true);
+    expect(promptLooksLikeVision("review photo.jpg")).toBe(true);
+    expect(promptLooksLikeVision("open mock.jpeg")).toBe(true);
+    expect(promptLooksLikeVision("asset.webp")).toBe(true);
+    expect(promptLooksLikeVision("ui mock of the settings page")).toBe(true);
+    expect(promptLooksLikeVision("multimodal caption")).toBe(true);
+    expect(promptLooksLikeVision("use vision for this")).toBe(true);
+    expect(promptLooksLikeVision("describe the image")).toBe(true);
+  });
+  test("plain coding prompts stay false", () => {
+    expect(promptLooksLikeVision("fix the unit test")).toBe(false);
+    expect(promptLooksLikeVision("Add a unit test for shellQuote")).toBe(false);
+    expect(promptLooksLikeVision("fix the ImageMagick wrapper")).toBe(false);
   });
 });
 
@@ -93,6 +117,23 @@ describe("claude-ds -Model", () => {
       else process.env.ANTHROPIC_MODEL = prevAm;
     }
   });
+  test("vision alias maps to deepseek-v4-flash-vision-exp", () => {
+    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: "vision",
+      });
+      expect(plan.command).toContain("deepseek-v4-flash-vision-exp");
+      expect(plan.command).not.toContain("deepseek-v4-flash'");
+    } finally {
+      if (prev === undefined) delete process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
+      else process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = prev;
+    }
+  });
   test("pro alias maps to deepseek-v4-pro", () => {
     const prev = process.env.CURSOR_ROUTE_CLAUDE_DS_BIN;
     process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = "/tmp/fake-claude-ds";
@@ -206,6 +247,201 @@ describe("startJob product path", () => {
     }
   });
 
+  test("invalid ANTHROPIC_MODEL names the env vars, not --model", () => {
+    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-env-bad-${process.pid}`);
+    mkdirSync(jobsDir, { recursive: true });
+    process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = "/tmp/fake-claude-ds";
+    delete process.env.CURSOR_ROUTE_DS_MODEL;
+    process.env.ANTHROPIC_MODEL = "deepseek-chat";
+    process.env.CURSOR_ROUTE_JOBS_DIR = jobsDir;
+    try {
+      const result = startJob({
+        prompt: "fix the unit test",
+        lane: "mid",
+        dryRun: true,
+      });
+      expect(result.ok).toBe(false);
+      if (result.ok) return;
+      expect(result.error).toMatch(/ANTHROPIC_MODEL/);
+      expect(result.error).toMatch(/deepseek-chat/);
+      expect(result.error).not.toMatch(/Invalid --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.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("screenshot.png auto-picks vision when --model and env 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-vision-${process.pid}`);
+    mkdirSync(jobsDir, { recursive: true });
+    process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = "/tmp/fake-claude-ds";
+    delete process.env.CURSOR_ROUTE_DS_MODEL;
+    delete process.env.ANTHROPIC_MODEL;
+    process.env.CURSOR_ROUTE_JOBS_DIR = jobsDir;
+    try {
+      const result = startJob({
+        prompt: "describe screenshot.png",
+        lane: "mid",
+        dryRun: true,
+      });
+      expect(result.ok).toBe(true);
+      if (!result.ok) return;
+      expect(result.job.model).toBe("vision");
+      expect(result.command).toContain("deepseek-v4-flash-vision-exp");
+    } 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("plain prompt stays flash when env 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-flash-${process.pid}`);
+    mkdirSync(jobsDir, { recursive: true });
+    process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = "/tmp/fake-claude-ds";
+    delete process.env.CURSOR_ROUTE_DS_MODEL;
+    delete process.env.ANTHROPIC_MODEL;
+    process.env.CURSOR_ROUTE_JOBS_DIR = jobsDir;
+    try {
+      const result = startJob({
+        prompt: "fix the unit test",
+        lane: "mid",
+        dryRun: true,
+      });
+      expect(result.ok).toBe(true);
+      if (!result.ok) return;
+      expect(result.job.model).toBe("flash");
+      expect(result.command).toContain("deepseek-v4-flash");
+      expect(result.command).not.toContain("deepseek-v4-flash-vision-exp");
+    } 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("explicit --model flash wins over a vision-looking prompt", () => {
+    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-flashwin-${process.pid}`);
+    mkdirSync(jobsDir, { recursive: true });
+    process.env.CURSOR_ROUTE_CLAUDE_DS_BIN = "/tmp/fake-claude-ds";
+    delete process.env.CURSOR_ROUTE_DS_MODEL;
+    delete process.env.ANTHROPIC_MODEL;
+    process.env.CURSOR_ROUTE_JOBS_DIR = jobsDir;
+    try {
+      const result = startJob({
+        prompt: "Look at this screenshot.png and describe it",
+        lane: "mid",
+        model: "flash",
+        dryRun: true,
+      });
+      expect(result.ok).toBe(true);
+      if (!result.ok) return;
+      expect(result.job.model).toBe("flash");
+      expect(result.command).not.toContain("deepseek-v4-flash-vision-exp");
+    } 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("easy lane dry-run offline records the OpenRouter fallback id", () => {
+    const prev = {
+      jobs: process.env.CURSOR_ROUTE_JOBS_DIR,
+      model: process.env.CURSOR_ROUTE_OPENROUTER_MODEL,
+      offline: process.env.CURSOR_ROUTE_OR_OFFLINE,
+      json: process.env.CURSOR_ROUTE_OR_CATALOG_JSON,
+      cache: process.env.CURSOR_ROUTE_OR_CACHE_PATH,
+      refresh: process.env.CURSOR_ROUTE_OR_REFRESH,
+      key: process.env.OPENROUTER_API_KEY,
+    };
+    const jobsDir = join(tmpdir(), `cr-jobs-or-${process.pid}`);
+    mkdirSync(jobsDir, { recursive: true });
+    process.env.CURSOR_ROUTE_JOBS_DIR = jobsDir;
+    delete process.env.CURSOR_ROUTE_OPENROUTER_MODEL;
+    process.env.CURSOR_ROUTE_OR_OFFLINE = "1";
+    delete process.env.CURSOR_ROUTE_OR_CATALOG_JSON;
+    process.env.CURSOR_ROUTE_OR_CACHE_PATH = join(jobsDir, "or-cache.json");
+    process.env.CURSOR_ROUTE_OR_REFRESH = "1";
+    delete process.env.OPENROUTER_API_KEY;
+    try {
+      const result = startJob({
+        prompt: "Rewrite this FAQ",
+        lane: "easy",
+        dryRun: true,
+      });
+      expect(result.ok).toBe(true);
+      if (!result.ok) return;
+      expect(result.job.worker).toBe("openrouter");
+      expect(result.job.model).toBe("openrouter/free");
+    } finally {
+      if (prev.jobs === undefined) delete process.env.CURSOR_ROUTE_JOBS_DIR;
+      else process.env.CURSOR_ROUTE_JOBS_DIR = prev.jobs;
+      if (prev.model === undefined) delete process.env.CURSOR_ROUTE_OPENROUTER_MODEL;
+      else process.env.CURSOR_ROUTE_OPENROUTER_MODEL = prev.model;
+      if (prev.offline === undefined) delete process.env.CURSOR_ROUTE_OR_OFFLINE;
+      else process.env.CURSOR_ROUTE_OR_OFFLINE = prev.offline;
+      if (prev.json === undefined) delete process.env.CURSOR_ROUTE_OR_CATALOG_JSON;
+      else process.env.CURSOR_ROUTE_OR_CATALOG_JSON = prev.json;
+      if (prev.cache === undefined) delete process.env.CURSOR_ROUTE_OR_CACHE_PATH;
+      else process.env.CURSOR_ROUTE_OR_CACHE_PATH = prev.cache;
+      if (prev.refresh === undefined) delete process.env.CURSOR_ROUTE_OR_REFRESH;
+      else process.env.CURSOR_ROUTE_OR_REFRESH = prev.refresh;
+      if (prev.key === undefined) delete process.env.OPENROUTER_API_KEY;
+      else process.env.OPENROUTER_API_KEY = prev.key;
+      rmSync(jobsDir, { recursive: true, force: true });
+    }
+  });
+
   test("--worker deepseek dry-run succeeds with fake dsh + key", () => {
     const dir = join(tmpdir(), `cr-dsh-start-${process.pid}`);
     mkdirSync(dir, { recursive: true });
@@ -377,6 +613,31 @@ describe("deepseek adapter (dsh)", () => {
     rmSync(dir, { recursive: true, force: true });
   });
 
+  test("buildLaunch: vision model → deepseek-v4-flash-vision-exp in patch", () => {
+    const { dir, bin } = makeFakeDsh("vision");
+    const promptFile = join(dir, "job.prompt");
+    writeFileSync(promptFile, "ping");
+    withEnv(
+      {
+        CURSOR_ROUTE_DSH_BIN: bin,
+        DEEPSEEK_API_KEY: "test-key",
+        CURSOR_ROUTE_DS_MODEL: undefined,
+        ANTHROPIC_MODEL: undefined,
+      },
+      () => {
+        deepseekAdapter.buildLaunch({
+          promptFile,
+          cwd: dir,
+          alwaysApprove: true,
+          model: "vision",
+        });
+        const patch = readFileSync(join(dir, "job.dsh-patch.yml"), "utf8");
+        expect(patch).toContain("deepseek-v4-flash-vision-exp");
+      },
+    );
+    rmSync(dir, { recursive: true, force: true });
+  });
+
   test("buildLaunch: pro model → deepseek-v4-pro in patch", () => {
     const { dir, bin } = makeFakeDsh("pro");
     const promptFile = join(dir, "job.prompt");
@@ -618,7 +879,7 @@ describe("health", () => {
   test("returns structured report", () => {
     const r = runHealth();
     expect(r.product).toBe("cursor-route");
-    expect(r.version).toBe("0.1.10");
+    expect(r.version).toBe("0.1.13");
     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);
@@ -630,8 +891,8 @@ describe("health", () => {
     expect(r.checks.some((c) => c.name === "worker:deepseek")).toBe(true);
   });
 
-  test("config version is 0.1.10", () => {
-    expect(config.version).toBe("0.1.10");
+  test("config version is 0.1.13", () => {
+    expect(config.version).toBe("0.1.13");
   });
 
   test("OR-gate: ok can be true while worker:opencode is false", () => {

package/src/cli.ts

@@ -10,6 +10,7 @@ import {
   LANES,
   resolveDsModel,
   openCodeModel,
+  openRouterModel,
   type WorkerKind,
   type Lane,
   type DsModelAlias,
@@ -56,7 +57,7 @@ Usage:
 Start options:
   --worker <grok|claude-ds|openrouter|deepseek|opencode>  Worker adapter (default: grok; deepseek/opencode = opt-in)
   --lane <easy|mid|hard>                Lane → worker (easy=openrouter, mid=claude-ds, hard=grok)
-  --model <flash|pro|free|provider/model>  claude-ds/deepseek: flash|pro. opencode: free (default opencode/big-pickle) or provider/model
+  --model <flash|pro|vision|free|provider/model>  claude-ds/deepseek: flash|pro|vision. opencode/openrouter: free (live catalog pick) or provider/model
   --dir <path>                          Working directory (default: cwd)
   --ask                                 Disable always-approve for this job
   --dry-run                             Print launch command; do not start
@@ -69,16 +70,16 @@ Env:
   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; --model ignored)
-  CURSOR_ROUTE_DS_MODEL              Default mid model flash|pro (or deepseek-v4-pro[1m]); overridden by --model
+  CURSOR_ROUTE_DS_MODEL              Default mid model flash|pro|vision (or full ids / 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)
   CURSOR_ROUTE_OPENCODE_BIN          Override the opencode 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)
+  CURSOR_ROUTE_OPENROUTER_MODEL      OpenRouter pin (unset or free = live catalog pick at start; fetch-fail fallback openrouter/free)
   OPENROUTER_BASE_URL                OpenRouter API base (default: https://openrouter.ai/api/v1)
-  CURSOR_ROUTE_OPENCODE_MODEL        OpenCode model (default: opencode/big-pickle); --model overrides
+  CURSOR_ROUTE_OPENCODE_MODEL        OpenCode model pin (unset or free = live Zen free pick); --model overrides
 `);
   process.exit(exitCode);
 }
@@ -170,18 +171,26 @@ function asLane(v: unknown): Lane | 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`);
+  if (typeof v !== "string") throw new Error(`Invalid --model; expected flash|pro|vision`);
   return resolveDsModel(v);
 }
 
 function asOpenCodeModel(v: unknown): string | undefined {
   if (v === undefined || v === true) return undefined;
   if (typeof v !== "string") {
-    throw new Error(`Invalid --model; expected provider/model (e.g. opencode/big-pickle) or free`);
+    throw new Error(`Invalid --model; expected provider/model (e.g. opencode/x-preview-f-free) or free`);
   }
   return openCodeModel(v);
 }
 
+function asOpenRouterModel(v: unknown): string | undefined {
+  if (v === undefined || v === true) return undefined;
+  if (typeof v !== "string") {
+    throw new Error(`Invalid --model; expected provider/model or free (live OpenRouter catalog pick)`);
+  }
+  return openRouterModel(v);
+}
+
 function refuseSecrets(text: string, context: string): void {
   if (looksLikeSecretMaterial(text)) {
     console.error(
@@ -264,8 +273,8 @@ async function main() {
 
     let model: DsModelAlias | undefined;
     let modelId: string | undefined;
-    // --model: DeepSeek flash|pro for claude-ds/deepseek; provider/model (or free) for opencode;
-    // ignore (do not validate) for grok/openrouter
+    // --model: DeepSeek flash|pro|vision for claude-ds/deepseek;
+    // provider/model (or free) for opencode/openrouter; ignore for grok
     if (f.model !== undefined && (resolvedWorker === "claude-ds" || resolvedWorker === "deepseek")) {
       try {
         const choice = asDsModelChoice(f.model);
@@ -284,6 +293,13 @@ async function main() {
         console.error((e as Error).message);
         process.exit(2);
       }
+    } else if (f.model !== undefined && resolvedWorker === "openrouter") {
+      try {
+        modelId = asOpenRouterModel(f.model);
+      } catch (e) {
+        console.error((e as Error).message);
+        process.exit(2);
+      }
     }
 
     let prompt = "";

package/src/config.ts

@@ -11,7 +11,7 @@ export type WorkerKind = "grok" | "claude-ds" | "openrouter" | "deepseek" | "ope
 export type Lane = "easy" | "mid" | "hard";
 
 /** Public CLI aliases for mid-lane DeepSeek models. */
-export type DsModelAlias = "flash" | "pro";
+export type DsModelAlias = "flash" | "pro" | "vision";
 
 export interface DsModelChoice {
   alias: DsModelAlias;
@@ -21,13 +21,22 @@ export interface DsModelChoice {
 
 export const WORKERS: WorkerKind[] = ["grok", "claude-ds", "openrouter", "deepseek", "opencode"];
 export const LANES: Lane[] = ["easy", "mid", "hard"];
-export const DS_MODELS: DsModelAlias[] = ["flash", "pro"];
+export const DS_MODELS: DsModelAlias[] = ["flash", "pro", "vision"];
 
 export const DS_MODEL_IDS: Record<DsModelAlias, string> = {
   flash: "deepseek-v4-flash",
   pro: "deepseek-v4-pro",
+  vision: "deepseek-v4-flash-vision-exp",
 };
 
+/** Prompt looks like a screenshot / image / ui mock — vision auto-pick. */
+const VISION_PROMPT_RE =
+  /screenshot|\bimage\b|\.png|\.jpe?g|\.webp|ui mock|multimodal|\bvision\b/i;
+
+export function promptLooksLikeVision(prompt: string): boolean {
+  return VISION_PROMPT_RE.test(prompt);
+}
+
 /**
  * Resolve --model / env to alias + concrete model id.
  * Preserves `deepseek-v4-pro[1m]` (does not silently strip the SKU).
@@ -44,10 +53,13 @@ export function resolveDsModel(raw?: string | null): DsModelChoice {
   if (v === "pro" || v === "deepseek-v4-pro") {
     return { alias: "pro", id: DS_MODEL_IDS.pro };
   }
+  if (v === "vision" || v === "deepseek-v4-flash-vision-exp") {
+    return { alias: "vision", id: DS_MODEL_IDS.vision };
+  }
   if (v === "deepseek-v4-pro[1m]") {
     return { alias: "pro", id: "deepseek-v4-pro[1m]" };
   }
-  throw new Error(`Invalid --model ${raw}; expected flash|pro`);
+  throw new Error(`Invalid DeepSeek model ${raw}; expected flash|pro|vision`);
 }
 
 /** Alias-only helper (tests / callers that do not need the concrete id). */
@@ -64,46 +76,24 @@ export function defaultDsModelFromEnv(): DsModelChoice {
   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";
-}
-
 /** OpenRouter API base URL (env OPENROUTER_BASE_URL). */
 export function openRouterBaseUrl(): string {
   return process.env.OPENROUTER_BASE_URL || "https://openrouter.ai/api/v1";
 }
 
-/**
- * Default OpenCode model: OpenCode Zen Big Pickle (free, limited-time).
- * Override: CURSOR_ROUTE_OPENCODE_MODEL or `--model provider/model`.
- * Alias `free` resolves to this default (or the env override).
- */
-export const OPENCODE_DEFAULT_MODEL = "opencode/big-pickle";
-
-/** Whitelist OpenCode `provider/model` ids (no spaces / injection). */
-export function assertOpenCodeModel(id: string): string {
-  if (!/^[a-z0-9][a-z0-9._-]*(?:\/[a-z0-9][a-z0-9._\-:]+)+$/i.test(id)) {
-    throw new Error(
-      `Invalid OpenCode model ${id}; expected provider/model (e.g. opencode/big-pickle) or free`,
-    );
-  }
-  return id;
-}
+export {
+  OPENCODE_DEFAULT_MODEL,
+  assertOpenCodeModel,
+  openCodeModel,
+  cachedZenFreePick,
+} from "./zen-free.ts";
 
-/**
- * Resolve OpenCode `--model` / env to a concrete `provider/model` id.
- * Empty or `free` → CURSOR_ROUTE_OPENCODE_MODEL, else OPENCODE_DEFAULT_MODEL.
- */
-export function openCodeModel(raw?: string | null): string {
-  const v = (raw ?? "").trim();
-  if (!v || v.toLowerCase() === "free") {
-    const env = (process.env.CURSOR_ROUTE_OPENCODE_MODEL ?? "").trim();
-    if (!env || env.toLowerCase() === "free") return OPENCODE_DEFAULT_MODEL;
-    return assertOpenCodeModel(env);
-  }
-  return assertOpenCodeModel(v);
-}
+export {
+  OPENROUTER_FALLBACK_MODEL,
+  assertOpenRouterModel,
+  cachedOrFreePick,
+  openRouterModel,
+} from "./or-free.ts";
 
 function maxConcurrentJobsFromEnv(): number {
   const raw = process.env.CURSOR_ROUTE_MAX_JOBS;
@@ -121,7 +111,7 @@ function maxConcurrentJobsFromEnv(): number {
  */
 export const config = {
   product: "cursor-route",
-  version: "0.1.10",
+  version: "0.1.13",
   get jobsDir(): string {
     return defaultJobsDir();
   },

package/src/jobs.ts

@@ -18,6 +18,8 @@ import {
   defaultDsModelFromEnv,
   DS_MODEL_IDS,
   openCodeModel,
+  openRouterModel,
+  promptLooksLikeVision,
   type Lane,
   type WorkerKind,
   type DsModelAlias,
@@ -38,7 +40,7 @@ export interface Job {
   status: JobStatus;
   worker: WorkerKind;
   lane?: Lane;
-  /** Worker model: flash|pro for claude-ds/deepseek; provider/model for opencode. */
+  /** Worker model: flash|pro|vision for claude-ds/deepseek; provider/model for opencode/openrouter. */
   model?: string;
   prompt: string;
   cwd: string;
@@ -194,13 +196,16 @@ function terminatePid(pid: number): boolean {
     if (!pidAlive(pid)) return true;
     sleepMs(100);
   }
-  trySignal("SIGKILL", true);
-  trySignal("SIGKILL", false);
+  const gKill = trySignal("SIGKILL", true);
+  const pKill = trySignal("SIGKILL", false);
   for (let i = 0; i < 10; i++) {
     if (!pidAlive(pid)) return true;
     sleepMs(100);
   }
-  return !pidAlive(pid);
+  if (!pidAlive(pid)) return true;
+  // Sandboxed `ps` (EPERM) treats unreaped zombies as alive. If SIGKILL was
+  // sent, killJob should succeed — refreshStatus still fail-safes to alive.
+  return gKill || pKill;
 }
 
 /** Refresh running jobs without inventing success from "session gone". */
@@ -281,9 +286,9 @@ export interface StartOptions {
   prompt: string;
   worker?: WorkerKind;
   lane?: Lane;
-  /** Mid-lane DeepSeek: flash (default) | pro (claude-ds + deepseek). Ignored by grok/openrouter. */
+  /** Mid-lane DeepSeek: flash (default) | vision | pro (claude-ds + deepseek). Ignored by grok. */
   model?: DsModelAlias;
-  /** Concrete DeepSeek id (preserves pro[1m]) or OpenCode provider/model. Derived from --model / env when unset. */
+  /** Concrete DeepSeek id (preserves pro[1m]) or OpenCode/OpenRouter provider/model. Derived from --model / env when unset. */
   modelId?: string;
   cwd?: string;
   alwaysApprove?: boolean;
@@ -341,18 +346,32 @@ export function startJob(opts: StartOptions): {
       model = opts.model;
       modelId = opts.modelId ?? DS_MODEL_IDS[opts.model];
     } else {
-      try {
-        const choice = defaultDsModelFromEnv();
-        dsAlias = choice.alias;
-        model = choice.alias;
-        modelId = opts.modelId ?? choice.id;
-      } catch (e) {
+      const envRaw = (process.env.CURSOR_ROUTE_DS_MODEL || process.env.ANTHROPIC_MODEL || "").trim();
+      if (envRaw) {
         try {
-          unlinkSync(paths.prompt);
+          const choice = defaultDsModelFromEnv();
+          dsAlias = choice.alias;
+          model = choice.alias;
+          modelId = opts.modelId ?? choice.id;
         } catch {
-          /* ignore */
+          try {
+            unlinkSync(paths.prompt);
+          } catch {
+            /* ignore */
+          }
+          return {
+            ok: false,
+            error: `Invalid CURSOR_ROUTE_DS_MODEL/ANTHROPIC_MODEL value ${envRaw}; expected flash|pro|vision`,
+          };
         }
-        return { ok: false, error: (e as Error).message };
+      } else if (promptLooksLikeVision(opts.prompt)) {
+        dsAlias = "vision";
+        model = "vision";
+        modelId = opts.modelId ?? DS_MODEL_IDS.vision;
+      } else {
+        dsAlias = "flash";
+        model = "flash";
+        modelId = opts.modelId ?? DS_MODEL_IDS.flash;
       }
     }
   } else if (worker === "opencode") {
@@ -368,6 +387,19 @@ export function startJob(opts: StartOptions): {
       }
       return { ok: false, error: (e as Error).message };
     }
+  } else if (worker === "openrouter") {
+    try {
+      const orModel = openRouterModel(opts.modelId);
+      model = orModel;
+      modelId = orModel;
+    } catch (e) {
+      try {
+        unlinkSync(paths.prompt);
+      } catch {
+        /* ignore */
+      }
+      return { ok: false, error: (e as Error).message };
+    }
   }
 
   let plan;

package/src/openrouter-run.ts

@@ -24,7 +24,7 @@ function parseArgs(argv: string[]): { promptFile?: string } {
     if (a === "-h" || a === "--help") {
       console.log(
         "usage: cursor-route/openrouter-run --prompt-file <path>\n" +
-          "env: OPENROUTER_API_KEY (required), CURSOR_ROUTE_OPENROUTER_MODEL, OPENROUTER_BASE_URL",
+          "env: OPENROUTER_API_KEY (required), CURSOR_ROUTE_OPENROUTER_MODEL (unset/free = live pick), OPENROUTER_BASE_URL",
       );
       process.exit(0);
     }