claude-overnight 1.17.2 → 1.18.0

package/README.md

@@ -4,6 +4,8 @@
 
 Your Max plan rate limits eat interactive coding time. One deep refactor and the 5-hour window is gone before lunch. `claude-overnight` runs background agent sessions up to the percentage cap you pick (90% is typical), leaving the rest free for your own Claude Code session. Hand it an objective and a session budget, walk away, review the diff when the run ends.
 
+Cursor API Proxy supported -- route through Cursor's model gateway for Composer-powered execution on `auto`, `composer`, or `composer-2` models. See **Run via Cursor API Proxy** below.
+
 Isolated by default. Every agent runs in its own git worktree on its own branch, so a misbehaving agent can't trash your working tree. You choose what agents can do before the run starts  -- no surprise escalation mid-flight. Unmerged branches are preserved for manual review, never discarded. Built on the [Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk)  -- not a Claude Code replacement, but a background lane that runs alongside it.
 
 Different shape from hosted agent harnesses like [Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview): instead of one agent in one cloud container billed separately, you get many parallel sessions on your own machine, in your real repo, against your own Max plan (or API key). Works with Claude Opus, Sonnet, and Haiku  -- or pair an Anthropic planner with a cheaper executor on Qwen, OpenRouter, or any Anthropic-compatible endpoint.
@@ -33,6 +35,39 @@ export ANTHROPIC_MODEL="qwen3.6-plus"
 claude-overnight
 ```
 
+## Run via Cursor API Proxy
+
+Use Cursor's model gateway as an executor -- `auto` (delegates to best available), `composer`, or `composer-2` models. Runs locally through a proxy that speaks the Anthropic Messages API, so it's a drop-in replacement for any other provider.
+
+1. **Install the Cursor CLI and proxy:**
+
+   ```bash
+   curl https://cursor.com/install -fsS | bash
+   npm install -g cursor-api-proxy
+   ```
+
+2. **Get an API key.** Visit [cursor.com/dashboard/integrations](https://cursor.com/dashboard/integrations) and scroll to the "API Keys" section.
+
+3. **Set up.** Run `claude-overnight` and when prompted to pick a model, choose **Cursor…**. It walks you through a one-time setup: CLI check, API key entry (persisted to `providers.json`), and proxy health check.
+
+4. **Start the proxy** (in a separate terminal):
+
+   ```bash
+   npx cursor-api-proxy
+   ```
+
+5. Pick your model (`auto`, `composer`, `composer-2`, etc.). The provider is saved and reappears in every future run.
+
+Or configure the key manually:
+
+```bash
+export CURSOR_BRIDGE_API_KEY="sk-..."
+npx cursor-api-proxy &
+claude-overnight
+```
+
+**Tip:** run `claude-overnight` with the `--model=cursor-auto` flag in non-interactive mode to skip the picker. If the proxy isn't running at startup, a warning is shown but Anthropic providers remain available.
+
 ## Install
 
 ```bash

package/dist/cursor-models.d.ts

@@ -0,0 +1,14 @@
+export declare const CURSOR_PRIORITY_MODELS: Array<{
+    id: string;
+    label: string;
+    hint: string;
+}>;
+export declare const CURSOR_KNOWN_MODELS: Array<{
+    id: string;
+    label: string;
+    hint: string;
+}>;
+/** All known model IDs as a Set for quick membership checks. */
+export declare const KNOWN_CURSOR_MODEL_IDS: Set<string>;
+/** Display hint for a model ID — known ones get a hint, unknowns get a generic label. */
+export declare function cursorModelHint(modelId: string): string;

package/dist/cursor-models.js

@@ -0,0 +1,50 @@
+// ── Cursor model constants ──
+//
+// Hardcoded model IDs returned by the Cursor API Proxy. These serve as a
+// fallback when `agent --list-models` crashes (the bundled Node.js binary
+// segfaults on some setups — the proxy inherits this bug).
+//
+// Update this list when Cursor adds/removes models. Run:
+//   node ~/.local/share/cursor-agent/versions/*/index.js --list-models
+// to get the current list.
+//
+// The `priority` models always appear at the top of the picker in this order.
+// `known` models appear after them. Anything the proxy returns dynamically
+// that isn't in this list goes into a "more..." sub-menu.
+import { CURSOR_MODEL_HINTS } from "./models.js";
+export const CURSOR_PRIORITY_MODELS = [
+    { id: "composer-2", label: "composer-2", hint: "Cursor Composer 2 — latest, strongest Cursor model" },
+    { id: "composer-2-fast", label: "composer-2-fast", hint: "Cursor Composer 2 Fast — faster, cheaper variant" },
+    { id: "auto", label: "auto", hint: "auto-delegates to the best available model" },
+];
+export const CURSOR_KNOWN_MODELS = [
+    { id: "composer", label: "composer", hint: "Cursor Composer — previous generation" },
+];
+/** All known model IDs as a Set for quick membership checks. */
+export const KNOWN_CURSOR_MODEL_IDS = new Set([
+    ...CURSOR_PRIORITY_MODELS.map(m => m.id),
+    ...CURSOR_KNOWN_MODELS.map(m => m.id),
+]);
+/** Display hint for a model ID — known ones get a hint, unknowns get a generic label. */
+export function cursorModelHint(modelId) {
+    const m = modelId.toLowerCase();
+    for (const entry of [...CURSOR_PRIORITY_MODELS, ...CURSOR_KNOWN_MODELS]) {
+        if (entry.id === m)
+            return entry.hint;
+    }
+    if (m.startsWith("composer"))
+        return "Cursor Composer model";
+    if (m.includes("opus"))
+        return CURSOR_MODEL_HINTS.opus;
+    if (m.includes("sonnet"))
+        return CURSOR_MODEL_HINTS.sonnet;
+    if (m.includes("haiku"))
+        return CURSOR_MODEL_HINTS.haiku;
+    if (m.startsWith("gpt-5"))
+        return "GPT model via Cursor";
+    if (m.startsWith("gemini"))
+        return "Gemini model via Cursor";
+    if (m.startsWith("grok"))
+        return "Grok model via Cursor";
+    return "Cursor model";
+}

package/dist/index.js

@@ -10,6 +10,7 @@ import { query } from "@anthropic-ai/claude-agent-sdk";
 import { Swarm } from "./swarm.js";
 import { planTasks, refinePlan, identifyThemes, buildThinkingTasks, orchestrate, salvageFromFile } from "./planner.js";
 import { detectModelTier, setPlannerEnvResolver } from "./planner-query.js";
+import { DEFAULT_MODEL } from "./models.js";
 import { pickModel, loadProviders, preflightProvider, buildEnvResolver, healthCheckCursorProxy, PROXY_DEFAULT_URL, isCursorProxyProvider } from "./providers.js";
 import { RunDisplay } from "./ui.js";
 import { renderSummary } from "./render.js";
@@ -665,7 +666,7 @@ async function main() {
         const defaultModel = activeProvider?.model
             ?? models[0]?.value
             ?? savedForCLI.find(p => p !== activeProvider)?.model
-            ?? "claude-sonnet-4-6";
+            ?? DEFAULT_MODEL;
         workerModel = cliFlags.model ?? fileCfg?.model ?? defaultModel;
         plannerModel = activeProvider?.model ?? models[0]?.value ?? workerModel;
         // Auto-resolve a saved custom provider if --model matches its id or model id.

package/dist/models.d.ts

@@ -0,0 +1,27 @@
+export declare const MODEL_TIER_OPUS = "opus";
+export declare const MODEL_TIER_SONNET = "sonnet";
+export declare const MODEL_TIER_HAIKU = "haiku";
+export declare const MODEL_TIER_UNKNOWN = "unknown";
+export type ModelTier = typeof MODEL_TIER_OPUS | typeof MODEL_TIER_SONNET | typeof MODEL_TIER_HAIKU | typeof MODEL_TIER_UNKNOWN;
+export interface TierDetectionRule {
+    match: (model: string) => boolean;
+    tier: ModelTier;
+}
+export declare const TIER_DETECTION_RULES: TierDetectionRule[];
+export declare function detectModelTier(model: string): ModelTier;
+export declare const MODEL_CAPABILITY_DESCRIPTIONS: Record<ModelTier, string>;
+export declare const UNKNOWN_MODEL_CAPABILITIES: Record<string, string>;
+export declare function modelCapabilityBlock(model: string): string;
+export declare const DEFAULT_MODEL = "claude-sonnet-4-6";
+export declare const FALLBACK_MODEL = "claude-opus-4-6";
+export declare const PLANNER_THRESHOLDS: {
+    opus: {
+        small: number;
+        medium: number;
+    };
+    default: {
+        small: number;
+        medium: number;
+    };
+};
+export declare const CURSOR_MODEL_HINTS: Record<string, string>;

package/dist/models.js

@@ -0,0 +1,60 @@
+// ── Model tier constants ──
+export const MODEL_TIER_OPUS = "opus";
+export const MODEL_TIER_SONNET = "sonnet";
+export const MODEL_TIER_HAIKU = "haiku";
+export const MODEL_TIER_UNKNOWN = "unknown";
+export const TIER_DETECTION_RULES = [
+    { match: m => m === "default" || m.includes("opus"), tier: MODEL_TIER_OPUS },
+    { match: m => m.includes("sonnet"), tier: MODEL_TIER_SONNET },
+    { match: m => m.includes("haiku"), tier: MODEL_TIER_HAIKU },
+    { match: m => m === "auto", tier: MODEL_TIER_UNKNOWN },
+    { match: m => m.startsWith("composer"), tier: MODEL_TIER_SONNET },
+    { match: m => m.startsWith("gpt-5") || m.startsWith("gemini") || m.startsWith("grok"), tier: MODEL_TIER_SONNET },
+];
+export function detectModelTier(model) {
+    const m = model.toLowerCase();
+    for (const rule of TIER_DETECTION_RULES) {
+        if (rule.match(m))
+            return rule.tier;
+    }
+    return MODEL_TIER_UNKNOWN;
+}
+// ── Capability descriptions ──
+export const MODEL_CAPABILITY_DESCRIPTIONS = {
+    opus: "Each agent runs Claude Opus with 1M context  -- a powerhouse. It can own entire epics, do deep codebase research, make architectural decisions, implement complex multi-file systems end-to-end, use browser tools for analysis, and deliver expert-level work. These agents can work for 30+ minutes on the most complex tasks. Do NOT waste them on trivial edits  -- give them ownership and autonomy.",
+    sonnet: "Each agent runs Claude Sonnet  -- capable of substantial implementation, refactoring, testing, and design work. Can work autonomously for 10-20 minutes on complex tasks. Give agents meaningful scope  -- not just single-line edits.",
+    haiku: "Each agent runs Claude Haiku  -- fast and efficient, best for focused, well-specified tasks. Be explicit about files, functions, and expected changes. Keep tasks scoped to a clear, concrete deliverable.",
+    unknown: "", // handled by UNKNOWN_MODEL_CAPABILITIES below
+};
+export const UNKNOWN_MODEL_CAPABILITIES = {
+    composer: "Each agent runs a Cursor Composer model with full codebase access. Capable of focused implementation work. Be explicit about files, functions, and expected changes.",
+    "gpt-5": "Each agent runs a GPT model via Cursor with full codebase access. Capable of focused implementation work. Be explicit about files, functions, and expected changes.",
+    gemini: "Each agent runs a Gemini model via Cursor with full codebase access. Be explicit about files, functions, and expected changes.",
+    grok: "Each agent runs a Grok model via Cursor with full codebase access. Be explicit about files, functions, and expected changes.",
+};
+export function modelCapabilityBlock(model) {
+    const tier = detectModelTier(model);
+    const cap = MODEL_CAPABILITY_DESCRIPTIONS[tier];
+    if (cap)
+        return cap;
+    const m = model.toLowerCase();
+    for (const [prefix, desc] of Object.entries(UNKNOWN_MODEL_CAPABILITIES)) {
+        if (m.startsWith(prefix))
+            return desc;
+    }
+    return `Each agent has full codebase access and can work autonomously.`;
+}
+// ── Default / fallback models ──
+export const DEFAULT_MODEL = "claude-sonnet-4-6";
+export const FALLBACK_MODEL = "claude-opus-4-6"; // used for planner + worker recovery
+// ── Planner thresholds (opus-tuned vs default) ──
+export const PLANNER_THRESHOLDS = {
+    opus: { small: 5, medium: 30 },
+    default: { small: 15, medium: 50 },
+};
+// ── Cursor model hints ──
+export const CURSOR_MODEL_HINTS = {
+    opus: "Opus-tier model via Cursor",
+    sonnet: "Sonnet-tier model via Cursor",
+    haiku: "Haiku-tier model via Cursor (fast)",
+};

package/dist/planner-query.d.ts

@@ -1,4 +1,6 @@
 import type { Task, PermMode, RateLimitWindow } from "./types.js";
+import { detectModelTier, modelCapabilityBlock } from "./models.js";
+export { detectModelTier, modelCapabilityBlock };
 /**
  * Logging callback used by planner/steering queries.
  * `kind` distinguishes ephemeral status updates (heartbeat ticker) from
@@ -25,9 +27,6 @@ export interface PlannerOpts {
     };
 }
 export declare function setPlannerEnvResolver(fn: ((model?: string) => Record<string, string> | undefined) | undefined): void;
-export type ModelTier = "opus" | "sonnet" | "haiku" | "unknown";
-export declare function detectModelTier(model: string): ModelTier;
-export declare function modelCapabilityBlock(model: string): string;
 export declare function getTotalPlannerCost(): number;
 export declare function getPlannerRateLimitInfo(): PlannerRateLimitInfo;
 export declare function runPlannerQuery(prompt: string, opts: PlannerOpts, onLog: PlannerLog): Promise<string>;

package/dist/planner-query.js

@@ -1,6 +1,9 @@
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { readFileSync } from "fs";
 import { NudgeError } from "./types.js";
+import { detectModelTier, modelCapabilityBlock } from "./models.js";
+// Re-export for consumers that import from planner-query (steering.ts, index.ts).
+export { detectModelTier, modelCapabilityBlock };
 // ── Shared env resolver (set once at run start, used by every planner query) ──
 //
 // Swarm and planner calls share a model→env map so a custom provider configured
@@ -10,37 +13,6 @@ let _envResolver;
 export function setPlannerEnvResolver(fn) {
     _envResolver = fn;
 }
-export function detectModelTier(model) {
-    const m = model.toLowerCase();
-    if (m === "default" || m.includes("opus"))
-        return "opus";
-    if (m.includes("sonnet"))
-        return "sonnet";
-    if (m.includes("haiku"))
-        return "haiku";
-    // Cursor API Proxy models
-    if (m === "auto")
-        return "unknown";
-    if (m.startsWith("composer"))
-        return "sonnet";
-    return "unknown";
-}
-export function modelCapabilityBlock(model) {
-    switch (detectModelTier(model)) {
-        case "opus":
-            return `Each agent runs Claude Opus with 1M context  -- a powerhouse. It can own entire epics, do deep codebase research, make architectural decisions, implement complex multi-file systems end-to-end, use browser tools for analysis, and deliver expert-level work. These agents can work for 30+ minutes on the most complex tasks. Do NOT waste them on trivial edits  -- give them ownership and autonomy.`;
-        case "sonnet":
-            return `Each agent runs Claude Sonnet  -- capable of substantial implementation, refactoring, testing, and design work. Can work autonomously for 10-20 minutes on complex tasks. Give agents meaningful scope  -- not just single-line edits.`;
-        case "haiku":
-            return `Each agent runs Claude Haiku  -- fast and efficient, best for focused, well-specified tasks. Be explicit about files, functions, and expected changes. Keep each task scoped to a clear, concrete deliverable.`;
-        default:
-            // Cursor API Proxy or unknown model — generic but mention Cursor context
-            if (model.toLowerCase().startsWith("composer") || model.toLowerCase() === "auto") {
-                return `Each agent runs a Cursor model with full codebase access. Capable of focused implementation work. Be explicit about files, functions, and expected changes.`;
-            }
-            return `Each agent has full codebase access and can work autonomously.`;
-    }
-}
 // ── Rate limit tracking ──
 const RATE_LIMIT_PATTERNS = ["rate", "limit", "overloaded", "429", "hit your limit", "too many"];
 function isRateLimitError(err) {

package/dist/planner.js

@@ -1,5 +1,6 @@
 import { readFileSync } from "fs";
-import { runPlannerQuery, extractTaskJson, attemptJsonParse, postProcess, detectModelTier, modelCapabilityBlock } from "./planner-query.js";
+import { runPlannerQuery, extractTaskJson, attemptJsonParse, postProcess } from "./planner-query.js";
+import { detectModelTier, modelCapabilityBlock, MODEL_TIER_HAIKU, MODEL_TIER_OPUS, PLANNER_THRESHOLDS } from "./models.js";
 // Resilience: if the planner query throws but the agent already wrote valid
 // tasks to `outFile` (via its Write tool), salvage them instead of discarding
 // expensive work. Returns salvaged tasks on success, null if nothing usable on
@@ -62,7 +63,7 @@ function plannerPrompt(objective, workerModel, budget, concurrency, flexNote) {
         ? `\n- ${concurrency} agents run in parallel  -- tasks that run concurrently must touch DIFFERENT files to avoid merge conflicts`
         : "";
     const flexLine = flexNote ? `\n\n${flexNote}` : "";
-    if (tier === "haiku") {
+    if (tier === MODEL_TIER_HAIKU) {
         return `You are a task coordinator for a parallel agent system. Analyze this codebase and break the following objective into independent tasks.
 
 Objective: ${objective}
@@ -84,8 +85,9 @@ Respond with ONLY a JSON object (no markdown fences):
   ]
 }`;
     }
-    const smallThreshold = tier === "opus" ? 5 : 15;
-    const mediumThreshold = tier === "opus" ? 30 : 50;
+    const thresholds = tier === MODEL_TIER_OPUS ? PLANNER_THRESHOLDS.opus : PLANNER_THRESHOLDS.default;
+    const smallThreshold = thresholds.small;
+    const mediumThreshold = thresholds.medium;
     if (b <= smallThreshold) {
         return `You are a task coordinator for a parallel agent system. Analyze this codebase and break the following objective into independent tasks.
 

package/dist/providers.d.ts

@@ -17,6 +17,8 @@ export interface ProviderConfig {
     useJWT?: boolean;
     /** When true, this provider routes through cursor-api-proxy (special env/health-check handling). */
     cursorProxy?: boolean;
+    /** API key for cursor-api-proxy. Stored in providers.json (0600), used as fallback when CURSOR_BRIDGE_API_KEY env is not set. */
+    cursorApiKey?: string;
 }
 export declare function getStorePath(): string;
 export declare function loadProviders(): ProviderConfig[];
@@ -65,7 +67,7 @@ export declare function healthCheckCursorProxy(baseUrl?: string): Promise<boolea
 export declare function fetchCursorModels(baseUrl?: string): Promise<string[]>;
 /**
  * Interactive setup guide for cursor-api-proxy.
- * Walks through CLI install, login, and proxy start.
+ * Walks through CLI install, API key config, and proxy start.
  * Returns true when proxy is running and healthy.
  */
 export declare function setupCursorProxy(): Promise<boolean>;

package/dist/providers.js

@@ -6,6 +6,8 @@ import chalk from "chalk";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { ask, select, selectKey } from "./cli.js";
 import { getBearerToken, clearTokenCache } from "./auth.js";
+import { DEFAULT_MODEL } from "./models.js";
+import { CURSOR_PRIORITY_MODELS, CURSOR_KNOWN_MODELS, KNOWN_CURSOR_MODEL_IDS, cursorModelHint, } from "./cursor-models.js";
 // ── Store ──
 const STORE_PATH = join(homedir(), ".claude", "claude-overnight", "providers.json");
 export function getStorePath() { return STORE_PATH; }
@@ -64,9 +66,9 @@ export function envFor(p) {
         if (v !== undefined)
             base[k] = v;
     if (p.cursorProxy) {
-        // cursor-api-proxy: routes through local proxy, no real API key needed
         base.ANTHROPIC_BASE_URL = p.baseURL;
-        base.ANTHROPIC_AUTH_TOKEN = process.env.CURSOR_BRIDGE_API_KEY || "unused";
+        const key = process.env.CURSOR_BRIDGE_API_KEY || p.cursorApiKey;
+        base.ANTHROPIC_AUTH_TOKEN = key || "unused";
         delete base.ANTHROPIC_API_KEY;
         return base;
     }
@@ -99,8 +101,8 @@ export async function pickModel(label, anthropicModels, currentModelId) {
         // entry so the user isn't trapped if they cancel the Other… form.
         if (anthropicModels.length === 0) {
             items.push({
-                name: "claude-sonnet-4-6",
-                value: { kind: "anthropic", model: { value: "claude-sonnet-4-6", displayName: "claude-sonnet-4-6", description: "default (model list unavailable)" } },
+                name: DEFAULT_MODEL,
+                value: { kind: "anthropic", model: { value: DEFAULT_MODEL, displayName: DEFAULT_MODEL, description: "default (model list unavailable)" } },
                 hint: "default  -- Anthropic model list unavailable",
             });
         }
@@ -291,24 +293,48 @@ export async function fetchCursorModels(baseUrl = PROXY_DEFAULT_URL) {
     }
 }
 /**
- * Known Cursor model recommendations — short hints to guide users.
+ * Try to fetch live Cursor model IDs. Falls back to an empty array — the
+ * caller merges with known constants, so the picker always has content.
+ *
+ * NOTE: `agent --list-models` segfaults with its bundled Node.js binary
+ * (exit 139). We work around this by running with the system `node` instead.
  */
-const CURSOR_MODEL_HINTS = {
-    "auto": "fast — delegates to best available model",
-    "composer": "Cursor Composer — good for focused tasks",
-    "composer-2": "Cursor Composer 2 — latest, strongest Cursor model",
-};
-function cursorModelHint(modelId) {
-    const m = modelId.toLowerCase();
-    if (CURSOR_MODEL_HINTS[m])
-        return CURSOR_MODEL_HINTS[m];
-    if (m.includes("opus"))
-        return "Opus-tier Cursor model";
-    if (m.includes("sonnet"))
-        return "Sonnet-tier Cursor model";
-    if (m.includes("haiku"))
-        return "Haiku-tier Cursor model (fast)";
-    return "Cursor model";
+async function fetchLiveCursorModels() {
+    // Try the proxy first (works when the bundled node doesn't crash)
+    const proxyModels = await fetchCursorModels();
+    if (proxyModels.length > 0)
+        return proxyModels;
+    // Fallback: run the cursor-agent CLI with system node
+    // Find the agent binary via command -v (alias-safe), then locate its index.js.
+    try {
+        // command -v handles symlinks and doesn't expand shell aliases
+        const agentPath = execSync("command -v agent 2>/dev/null || command -v cursor-agent 2>/dev/null", {
+            timeout: 3_000, encoding: "utf-8", shell: "bash",
+        }).trim();
+        if (!agentPath)
+            return [];
+        // Resolve the directory (realpath handles symlinks like agent → cursor-agent)
+        const dir = execSync(`dirname "$(realpath "${agentPath}")"`, {
+            timeout: 3_000, encoding: "utf-8", shell: "bash",
+        }).trim();
+        // The bundled index.js lives in the same directory as the agent script
+        const indexPath = `${dir}/index.js`;
+        const raw = execSync(`node "${indexPath}" --list-models 2>/dev/null`, {
+            timeout: 10_000, encoding: "utf-8",
+        });
+        // Strip ANSI escape codes (cursor uses \x1B[2K\r etc.)
+        const out = raw.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
+        // Parse lines like "composer-2-fast - Composer 2 Fast"
+        const ids = [];
+        for (const line of out.split("\n")) {
+            const match = line.match(/^([A-Za-z0-9][A-Za-z0-9._:/-]*)\s+-\s+/);
+            if (match)
+                ids.push(match[1]);
+        }
+        return ids;
+    }
+    catch { }
+    return [];
 }
 function setupSteps() {
     return [
@@ -328,19 +354,14 @@ function setupSteps() {
             successMsg: "Cursor CLI found",
         },
         {
-            label: "Cursor authentication",
+            label: "Cursor API key",
             check: () => {
-                try {
-                    const out = execSync("agent --list-models", { stdio: "pipe", timeout: 10_000 });
-                    return out.toString().trim().length > 0;
-                }
-                catch {
-                    return false;
-                }
+                const key = process.env.CURSOR_BRIDGE_API_KEY;
+                return !!key && key.trim().length > 0;
             },
-            autoCmd: "agent login",
-            manualCmd: "agent login",
-            successMsg: "Cursor authenticated",
+            autoCmd: "",
+            manualCmd: "",
+            successMsg: "Cursor API key configured",
         },
         {
             label: "cursor-api-proxy server",
@@ -359,15 +380,51 @@ function setupSteps() {
         },
     ];
 }
+const CURSOR_KEY_PROVIDER_ID = "cursor";
+/** Persist the Cursor API key into providers.json. Updates any existing cursor proxy provider,
+ * or creates a sentinel entry so the key survives across sessions. */
+function saveCursorApiKey(key) {
+    const existing = loadProviders().filter(p => p.cursorProxy);
+    if (existing.length > 0) {
+        const p = existing[0];
+        p.cursorApiKey = key;
+        saveProvider(p);
+    }
+    else {
+        const sentinel = {
+            id: CURSOR_KEY_PROVIDER_ID,
+            displayName: "Cursor (API key)",
+            baseURL: PROXY_DEFAULT_URL,
+            model: "auto",
+            cursorProxy: true,
+            cursorApiKey: key,
+        };
+        saveProvider(sentinel);
+    }
+}
+/** Prompt the user for a Cursor API key and persist it. Returns true if saved. */
+async function promptAndSaveCursorKey() {
+    console.log(chalk.dim(`  Get your API key from https://cursor.com/dashboard/integrations`));
+    console.log(chalk.dim(`  (Scroll to the "API Keys" section at the bottom of the page)\n`));
+    const key = await ask(`  ${chalk.cyan("API key")}: `);
+    if (key && key.trim()) {
+        const trimmed = key.trim();
+        process.env.CURSOR_BRIDGE_API_KEY = trimmed;
+        saveCursorApiKey(trimmed);
+        return true;
+    }
+    console.log(chalk.yellow("  No key provided — skipped"));
+    return false;
+}
 /**
  * Interactive setup guide for cursor-api-proxy.
- * Walks through CLI install, login, and proxy start.
+ * Walks through CLI install, API key config, and proxy start.
  * Returns true when proxy is running and healthy.
  */
 export async function setupCursorProxy() {
     console.log(chalk.dim("\n  Cursor API Proxy Setup"));
     console.log(chalk.dim("  " + "─".repeat(40)));
-    console.log(chalk.dim("  We need three things: Cursor CLI, authentication, and the proxy server.\n"));
+    console.log(chalk.dim("  We need three things: Cursor CLI, an API key, and the proxy server.\n"));
     const steps = setupSteps();
     for (const step of steps) {
         if (step.check()) {
@@ -381,18 +438,10 @@ export async function setupCursorProxy() {
             { key: "s", desc: "kip (I'll handle it)" },
         ]);
         if (choice === "a") {
-            if (step.label === "Cursor authentication") {
-                // agent login needs interactive browser — run it directly
-                console.log(chalk.dim(`  Running: ${step.autoCmd}`));
-                console.log(chalk.dim("  (A browser window will open for login)\n"));
-                try {
-                    execSync(step.autoCmd, { stdio: "inherit", timeout: 120_000 });
+            if (step.label === "Cursor API key") {
+                if (await promptAndSaveCursorKey()) {
                     console.log(chalk.green(`  ✓ ${step.successMsg}`));
                 }
-                catch {
-                    console.log(chalk.yellow("  Login failed — try manual mode"));
-                    // Fall through to manual display
-                }
             }
             else if (step.label === "cursor-api-proxy server") {
                 // Don't auto-start the proxy server here — it blocks. Just verify it's installable.
@@ -428,10 +477,20 @@ export async function setupCursorProxy() {
             }
         }
         else if (choice === "m") {
-            console.log(chalk.cyan(`\n  Run this command:`));
-            console.log(chalk.white(`    ${step.manualCmd}`));
-            if (step.label === "cursor-api-proxy server") {
-                console.log(chalk.yellow(`    Then start the proxy: ${chalk.bold("npx cursor-api-proxy")}`));
+            if (step.label === "Cursor API key") {
+                console.log(chalk.cyan(`\n  1. Open: https://cursor.com/dashboard/integrations`));
+                console.log(chalk.cyan(`  2. Scroll to "API Keys" at the bottom of the page`));
+                console.log(chalk.cyan(`  3. Copy your API key and paste it below\n`));
+                if (await promptAndSaveCursorKey()) {
+                    console.log(chalk.green(`  ✓ ${step.successMsg}`));
+                }
+            }
+            else {
+                console.log(chalk.cyan(`\n  Run this command:`));
+                console.log(chalk.white(`    ${step.manualCmd}`));
+                if (step.label === "cursor-api-proxy server") {
+                    console.log(chalk.yellow(`    Then start the proxy: ${chalk.bold("npx cursor-api-proxy")}`));
+                }
             }
             console.log();
             const done = await selectKey(`  Done?`, [
@@ -457,7 +516,34 @@ export async function setupCursorProxy() {
     console.log(chalk.yellow("\n  Proxy not reachable yet. You can start it later and add it via 'Cursor' in the model picker."));
     return false;
 }
-// ── Cursor model picker sub-flow ──
+/**
+ * Build the full list of cursor model picker items. Priority models go first,
+ * then known models, then any extra live models we fetched. If there are more
+ * than a handful extras, they get a "more..." sub-menu.
+ */
+async function buildCursorPicker() {
+    const liveIds = await fetchLiveCursorModels();
+    const extra = new Set();
+    for (const id of liveIds) {
+        if (!KNOWN_CURSOR_MODEL_IDS.has(id))
+            extra.add(id);
+    }
+    const top = [
+        ...CURSOR_PRIORITY_MODELS.map(m => ({ id: m.id, name: m.label, hint: m.hint })),
+        ...CURSOR_KNOWN_MODELS.map(m => ({ id: m.id, name: m.label, hint: m.hint })),
+    ];
+    // Only a few extras? show them inline. Otherwise defer to "more...".
+    const MORE_THRESHOLD = 6;
+    const more = [...extra].sort().map(id => ({
+        id,
+        name: id,
+        hint: cursorModelHint(id),
+    }));
+    if (more.length <= MORE_THRESHOLD) {
+        return { top: [...top, ...more], more: [] };
+    }
+    return { top, more };
+}
 async function pickCursorModel() {
     console.log(chalk.dim("\n  Cursor API Proxy Models"));
     console.log(chalk.dim("  " + "─".repeat(40)));
@@ -489,28 +575,39 @@ async function pickCursorModel() {
             return null;
         }
     }
-    // Fetch live models
-    const modelIds = await fetchCursorModels();
-    if (modelIds.length === 0) {
-        console.log(chalk.yellow("  No models returned from proxy"));
-        return null;
+    const { top, more } = await buildCursorPicker();
+    // If there are more models available, add a "more…" entry
+    const items = top.map(m => ({
+        name: m.name,
+        value: m.id,
+        hint: m.hint,
+    }));
+    let hasMore = more.length > 0;
+    if (hasMore) {
+        items.push({ name: chalk.gray("more…"), value: "__more__", hint: `${more.length} additional models` });
     }
-    const picked = await select("  Select a Cursor model:", modelIds.map(id => ({
-        name: id,
-        value: id,
-        hint: cursorModelHint(id),
-    })), 0);
-    // Save as a cursor proxy provider
+    const picked = await select("  Select a Cursor model:", items, 0);
+    // Handle "more…" sub-menu
+    if (picked === "__more__") {
+        const moreItems = more.map(m => ({ name: m.name, value: m.id, hint: m.hint }));
+        const morePicked = await select("  More Cursor models:", moreItems, 0);
+        return saveCursorPick(morePicked);
+    }
+    return saveCursorPick(picked);
+}
+function saveCursorPick(modelId) {
+    const existingKey = loadProviders().find(p => p.id === CURSOR_KEY_PROVIDER_ID)?.cursorApiKey;
     const provider = {
-        id: `cursor-${picked}`,
-        displayName: `Cursor: ${picked}`,
+        id: `cursor-${modelId}`,
+        displayName: `Cursor: ${modelId}`,
         baseURL: PROXY_DEFAULT_URL,
-        model: picked,
+        model: modelId,
         cursorProxy: true,
+        ...(existingKey ? { cursorApiKey: existingKey } : {}),
     };
     saveProvider(provider);
     console.log(chalk.green(`  ✓ Saved as provider: ${provider.displayName}`));
-    return { model: picked, providerId: provider.id, provider };
+    return { model: modelId, providerId: provider.id, provider };
 }
 /**
  * Build a single resolver that swarm.ts and planner-query.ts share. Maps a

package/dist/state.js

@@ -3,6 +3,7 @@ import { execSync } from "child_process";
 import { join } from "path";
 import chalk from "chalk";
 import { forceMergeOverlay } from "./merge.js";
+import { FALLBACK_MODEL } from "./models.js";
 // ── File I/O helpers ──
 export function readMdDir(dir) {
     try {
@@ -267,7 +268,7 @@ export function backfillOrphanedPlans(rootDir, filterCwd) {
                     id: d,
                     objective: `(recovered pre-1.11.7 plan · ${taskCount} tasks)`,
                     budget: taskCount, remaining: taskCount,
-                    workerModel: "claude-opus-4-6", plannerModel: "claude-opus-4-6",
+                    workerModel: FALLBACK_MODEL, plannerModel: FALLBACK_MODEL,
                     concurrency: 5, permissionMode: "bypassPermissions",
                     flex: false, useWorktrees: true, mergeStrategy: "yolo",
                     allowExtraUsage: false,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-overnight",
-  "version": "1.17.2",
-  "description": "Background lane for your Claude Max plan. Parallel Claude Agent SDK sessions in git worktrees with a usage cap that reserves headroom for your interactive Claude Code. Crash-safe resume. Opus/Sonnet/Haiku + Qwen/OpenRouter.",
+  "version": "1.18.0",
+  "description": "Background lane for your Claude Max plan. Parallel Claude Agent SDK sessions in git worktrees with a usage cap that reserves headroom for your interactive Claude Code. Crash-safe resume. Provider-agnostic model catalog with capability-based planning.",
   "type": "module",
   "bin": {
     "claude-overnight": "dist/bin.js"
@@ -60,6 +60,7 @@
     "code-automation",
     "refactoring",
     "migration",
+    "cursor",
     "qwen",
     "openrouter",
     "iterative"

package/plugins/claude-overnight/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-overnight",
-  "version": "1.17.2",
-  "description": "Claude Code skill for understanding, installing, and inspecting claude-overnight runs  -- parallel Claude agents in git worktrees with thinking waves, multi-wave steering, and crash-safe resume.",
+  "version": "1.18.0",
+  "description": "Claude Code skill for understanding, installing, and inspecting claude-overnight runs  -- parallel Claude agents in git worktrees with thinking waves, multi-wave steering, and crash-safe resume. Supports Cursor API Proxy, Qwen, OpenRouter.",
   "author": {
     "name": "Francesco Fornace"
   },