claude-overnight 1.17.3 → 1.18.0

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.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; }
@@ -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 [
@@ -490,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)));
@@ -522,29 +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);
+    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.3",
-  "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 + Cursor API Proxy + 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"

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

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.17.3",
+  "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"