claude-overnight 1.14.0 → 1.16.1

package/README.md

@@ -4,7 +4,7 @@ Run 10, 100, or 1000 Claude agents overnight. Come back to shipped work.
 
 Describe what to build. Set a budget. The tool plans, explores your codebase, breaks the objective into tasks, launches parallel agents in isolated git worktrees, iterates toward quality, and handles rate limits automatically. You press Run once, then go to sleep.
 
-Built on the [Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk). Works with Claude Opus, Sonnet, and Haiku.
+Built on the [Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk). Works with Claude Opus, Sonnet, and Haiku — or route executors to Qwen / OpenRouter / any Anthropic-compatible endpoint via the `Other…` picker.
 
 ## Install
 
@@ -38,14 +38,19 @@ claude-overnight
 
 ② Budget [10]: 200
 
-③ Worker model:
+④ Planner model (thinking, steering — use your strongest):
+  ● Opus — Opus 4.6 · Most capable
+  ○ Sonnet — Sonnet 4.6 · Best for everyday tasks
+
+⑤ Executor model (what runs the tasks — Qwen/OpenRouter/etc via Other…):
   ● Sonnet — Sonnet 4.6 · Best for everyday tasks
   ○ Opus — Opus 4.6 · Most capable
+  ○ Other… · custom OpenAI/Anthropic-compatible endpoint
 
-④ Usage cap:
+⑥ Usage cap:
   ● 90% · leave 10% for other work
 
-⑤ Allow extra usage (billed separately):
+⑦ Allow extra usage (billed separately):
   ● No · stop when plan limits are reached
 
 ╭──────────────────────────────────────────────────╮
@@ -188,7 +193,7 @@ claude-overnight "fix auth bug in src/auth.ts" "add tests for user model"
 |---|---|---|
 | `--budget=N` | `10` | Total agent sessions |
 | `--concurrency=N` | `5` | Parallel agents |
-| `--model=NAME` | prompted | Worker model (planner uses best available) |
+| `--model=NAME` | prompted | Worker model — interactive picks planner + executor separately; `Other…` adds Qwen / OpenRouter / any Anthropic-compat endpoint. In non-interactive mode, a saved provider's model id is auto-resolved to the provider. |
 | `--usage-cap=N` | unlimited | Stop at N% utilization |
 | `--allow-extra-usage` | off | Allow extra/overage usage (billed separately) |
 | `--extra-usage-budget=N` | — | Max $ for extra usage (implies --allow-extra-usage) |
@@ -210,6 +215,36 @@ claude-overnight "fix auth bug in src/auth.ts" "add tests for user model"
 | `mergeStrategy` | `"yolo" \| "branch"` | `"yolo"` | Merge into HEAD or new branch |
 | `usageCap` | `number (0-100)` | unlimited | Stop at N% utilization |
 
+## Custom providers (Qwen, OpenRouter, anything Anthropic-compatible)
+
+Planner and executor are picked separately — pair Opus-on-Anthropic for the planner/thinker with a cheaper model on another provider for the bulk of execution.
+
+From the interactive picker, choose `Other…` on the planner or executor step:
+
+```
+⑤ Executor model (what runs the tasks — Qwen/OpenRouter/etc via Other…):
+  ○ Sonnet
+  ○ Opus
+  ● Other…
+
+  Name: Qwen Coder
+  Base URL: https://dashscope-intl.aliyuncs.com/api/v2/apps/claude-code-proxy
+  Model id: qwen3-coder-plus
+  API key source:
+    ● Paste key now        · stored plaintext in ~/.claude/claude-overnight/providers.json (0600)
+    ○ Read from env var    · nothing written to disk
+```
+
+Saved providers live user-level at `~/.claude/claude-overnight/providers.json` (mode 0600) and show up automatically in every repo. No per-project config.
+
+**How routing works.** Each `query()` gets its own env override (`ANTHROPIC_BASE_URL` + `ANTHROPIC_AUTH_TOKEN`) — planner queries use the planner provider, executor queries use the executor provider. No global shell env, no proxy daemon, no `process.env` pollution between calls.
+
+**Pre-flight.** Before the swarm starts, each custom provider is pinged with a 1-turn auth check. Bad keys fail fast with `✗ executor preflight failed: ...` instead of N scattered mid-run errors.
+
+**Resume.** Provider ids are persisted in `run.json` and rehydrated on resume. If you deleted a provider between runs, resume refuses to start and tells you exactly which id is missing.
+
+**Non-interactive / CI.** `claude-overnight --model=qwen3-coder-plus` auto-resolves the model id to a saved provider — no separate `--provider` flag.
+
 ## Usage controls
 
 ### Extra usage protection

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// Tiny launcher: prints a splash the instant node is ready, then dynamically
+// imports the real entrypoint. Loading `@anthropic-ai/claude-agent-sdk` and the
+// rest of the module graph takes several seconds on a cold cache — without
+// this, the terminal sits black that whole time. index.ts stops the splash
+// via `globalThis.__coStopSplash` as soon as its header is about to print.
+const argv = process.argv.slice(2);
+const quiet = argv.includes("-h") || argv.includes("--help") || argv.includes("-v") || argv.includes("--version");
+if (!quiet && process.stdout.isTTY) {
+    const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    let i = 0;
+    const render = () => process.stdout.write(`\r\x1b[2K  🌙  \x1b[1mclaude-overnight\x1b[0m  \x1b[2m${frames[i++ % frames.length]} starting…\x1b[0m`);
+    render();
+    const timer = setInterval(render, 120);
+    let stopped = false;
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        clearInterval(timer);
+        process.stdout.write("\r\x1b[2K");
+    };
+    globalThis.__coStopSplash = stop;
+    process.once("exit", stop);
+}
+await import("./index.js");
+export {};

package/dist/cli.js

@@ -55,7 +55,7 @@ export async function fetchModels(timeoutMs = 10_000) {
         clearTimeout(timer);
         q?.close();
         if (err.message === "model_fetch_timeout") {
-            console.warn(chalk.yellow("\n  Model fetch timed out — continuing with defaults"));
+            // Silent: callers fall back to a text prompt with the current value as default.
         }
         else if (isAuthError(err)) {
             console.error(chalk.red("\n  Authentication failed — check your API key or run: claude auth\n"));

package/dist/index.js

@@ -6,7 +6,8 @@ import chalk from "chalk";
 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 } from "./planner-query.js";
+import { detectModelTier, setPlannerEnvResolver } from "./planner-query.js";
+import { pickModel, loadProviders, preflightProvider, buildEnvResolver } from "./providers.js";
 import { RunDisplay } from "./ui.js";
 import { renderSummary } from "./render.js";
 import { executeRun } from "./run.js";
@@ -60,6 +61,8 @@ async function promptResumeOverrides(state, cliFlags, argv, noTTY, runDir) {
         catch { }
         return;
     }
+    // Kick off model fetch in the background so it's ready if the user picks Edit.
+    const modelsPromise = fetchModels(20_000).catch(() => []);
     // ── Interactive review ──
     const fmtSummary = () => {
         const tier = detectModelTier(state.workerModel);
@@ -88,16 +91,21 @@ async function promptResumeOverrides(state, cliFlags, argv, noTTY, runDir) {
     if (action === "r")
         return;
     // ── Edit walk ──
-    const models = await fetchModels(5_000);
-    if (models.length > 0) {
-        const currentIdx = Math.max(0, models.findIndex(m => m.value === state.workerModel));
-        state.workerModel = await select(`${chalk.cyan("①")} Worker model:`, models.map(m => ({ name: m.displayName, value: m.value, hint: m.description })), currentIdx);
+    let modelFrame = 0;
+    const modelSpinner = setInterval(() => {
+        process.stdout.write(`\x1B[2K\r  ${chalk.cyan(BRAILLE[modelFrame++ % BRAILLE.length])} ${chalk.dim("loading models...")}`);
+    }, 120);
+    let models;
+    try {
+        models = await modelsPromise;
     }
-    else {
-        const ans = await ask(`\n  ${chalk.cyan("①")} Worker model ${chalk.dim(`[${state.workerModel}]:`)} `);
-        if (ans.trim())
-            state.workerModel = ans.trim();
+    finally {
+        clearInterval(modelSpinner);
+        process.stdout.write(`\x1B[2K\r`);
     }
+    const pick = await pickModel(`${chalk.cyan("①")} Worker model:`, models, state.workerProviderId ?? state.workerModel);
+    state.workerModel = pick.model;
+    state.workerProviderId = pick.providerId;
     const remAns = await ask(`\n  ${chalk.cyan("②")} Remaining sessions ${chalk.dim(`[${state.remaining}]:`)} `);
     const parsedRem = parseInt(remAns);
     if (!isNaN(parsedRem) && parsedRem > 0) {
@@ -172,7 +180,7 @@ async function main() {
     --dry-run              Show planned tasks without running them
     --budget=N             Target number of agent runs ${chalk.dim("(default: 10)")}
     --concurrency=N        Max parallel agents ${chalk.dim("(default: 5)")}
-    --model=NAME           Worker model override ${chalk.dim("(planner always uses best available)")}
+    --model=NAME           Worker model override ${chalk.dim("(interactive mode picks planner + executor separately — supports 'Other…' for Qwen / OpenRouter / etc.)")}
     --usage-cap=N          Stop at N% utilization ${chalk.dim("(e.g. 90 to save 10% for other work)")}
     --allow-extra-usage    Allow extra/overage usage ${chalk.dim("(default: stop when plan limits hit)")}
     --extra-usage-budget=N Max $ for extra usage ${chalk.dim("(implies --allow-extra-usage)")}
@@ -235,7 +243,9 @@ async function main() {
         }
     }
     // ── Mode detection ──
-    console.log(`\n  ${chalk.bold("🌙  claude-overnight")}`);
+    // Stop the bin.ts startup splash (if any) before printing our header.
+    globalThis.__coStopSplash?.();
+    console.log(`  ${chalk.bold("🌙  claude-overnight")}`);
     console.log(chalk.dim(`  ${"─".repeat(36)}`));
     const noTTY = !process.stdin.isTTY;
     const nonInteractive = noTTY || fileCfg !== undefined || tasks.length > 0;
@@ -443,6 +453,8 @@ async function main() {
     // ── Config resolution ──
     let workerModel;
     let plannerModel;
+    let workerProvider;
+    let plannerProvider;
     let budget;
     let concurrency;
     let objective = fileCfg?.objective;
@@ -455,6 +467,23 @@ async function main() {
     if (resuming) {
         workerModel = resumeState.workerModel;
         plannerModel = resumeState.plannerModel;
+        const saved = loadProviders();
+        if (resumeState.workerProviderId) {
+            workerProvider = saved.find(p => p.id === resumeState.workerProviderId);
+            if (!workerProvider) {
+                console.error(chalk.red(`\n  Resume aborted: worker provider "${resumeState.workerProviderId}" is no longer in ~/.claude/claude-overnight/providers.json`));
+                console.error(chalk.dim(`  Re-add it via a fresh run's "Other…" flow, or start Fresh instead.\n`));
+                process.exit(1);
+            }
+        }
+        if (resumeState.plannerProviderId) {
+            plannerProvider = saved.find(p => p.id === resumeState.plannerProviderId);
+            if (!plannerProvider) {
+                console.error(chalk.red(`\n  Resume aborted: planner provider "${resumeState.plannerProviderId}" is no longer in ~/.claude/claude-overnight/providers.json`));
+                console.error(chalk.dim(`  Re-add it via a fresh run's "Other…" flow, or start Fresh instead.\n`));
+                process.exit(1);
+            }
+        }
         budget = resumeState.budget;
         concurrency = resumeState.concurrency;
         objective = resumeState.objective;
@@ -506,21 +535,19 @@ async function main() {
             clearInterval(modelSpinner);
             process.stdout.write(`\x1B[2K\r`);
         }
-        plannerModel = models[0]?.value || "claude-sonnet-4-6";
-        if (models.length > 0) {
-            workerModel = await select(`${chalk.cyan("④")} Worker model:`, models.map(m => ({ name: m.displayName, value: m.value, hint: m.description })));
-        }
-        else {
-            const ans = await ask(`  ${chalk.cyan("④")} ${chalk.dim("Worker model [claude-sonnet-4-6]:")} `);
-            workerModel = ans || "claude-sonnet-4-6";
-        }
-        usageCap = await select(`${chalk.cyan("⑤")} Usage cap:`, [
+        const plannerPick = await pickModel(`${chalk.cyan("④")} Planner model ${chalk.dim("(thinking, steering — use your strongest)")}:`, models);
+        plannerModel = plannerPick.model;
+        plannerProvider = plannerPick.provider;
+        const workerPick = await pickModel(`${chalk.cyan("⑤")} Executor model ${chalk.dim("(what runs the tasks — Qwen/OpenRouter/etc via Other…)")}:`, models);
+        workerModel = workerPick.model;
+        workerProvider = workerPick.provider;
+        usageCap = await select(`${chalk.cyan("⑥")} Usage cap:`, [
             { name: "Unlimited", value: undefined, hint: "full capacity, wait through rate limits" },
             { name: "90%", value: 0.9, hint: "leave 10% for other work" },
             { name: "75%", value: 0.75, hint: "conservative, plenty of headroom" },
             { name: "50%", value: 0.5, hint: "use half, keep the rest" },
         ]);
-        const extraChoice = await select(`${chalk.cyan("⑥")} Allow extra usage ${chalk.dim("(billed separately)")}:`, [
+        const extraChoice = await select(`${chalk.cyan("⑦")} Allow extra usage ${chalk.dim("(billed separately)")}:`, [
             { name: "No", value: "no", hint: "stop when plan limits are reached" },
             { name: "Yes, with $ limit", value: "budget", hint: "set a spending cap" },
             { name: "Yes, unlimited", value: "unlimited", hint: "keep going no matter what" },
@@ -534,7 +561,7 @@ async function main() {
         }
         else if (extraChoice === "unlimited")
             allowExtraUsage = true;
-        // ⑦ Permission mode (skip if --yolo or --perm set)
+        // ⑧ Permission mode (skip if --yolo or --perm set)
         const cliYolo = argv.includes("--yolo");
         if (cliFlags.perm) {
             permissionMode = cliFlags.perm;
@@ -543,13 +570,13 @@ async function main() {
             permissionMode = "bypassPermissions";
         }
         else {
-            permissionMode = await select(`${chalk.cyan("⑦")} Permissions:`, [
+            permissionMode = await select(`${chalk.cyan("⑧")} Permissions:`, [
                 { name: "Auto", value: "auto", hint: "accept low-risk, reject high-risk" },
                 { name: "Bypass all", value: "bypassPermissions", hint: "agents can run anything (yolo)" },
                 { name: "Prompt each", value: "default", hint: "ask for every dangerous op" },
             ]);
         }
-        // ⑧ Worktrees + merge (skip if --yolo, --worktrees, --no-worktrees, or --merge set)
+        // ⑨ Worktrees + merge (skip if --yolo, --worktrees, --no-worktrees, or --merge set)
         const gitRepo = isGitRepo(cwd);
         if (cliYolo || argv.includes("--no-worktrees")) {
             useWorktrees = false;
@@ -560,7 +587,7 @@ async function main() {
             mergeStrategy = cliFlags.merge || "yolo";
         }
         else if (gitRepo) {
-            const wtChoice = await select(`${chalk.cyan("⑧")} Git isolation:`, [
+            const wtChoice = await select(`${chalk.cyan("⑨")} Git isolation:`, [
                 { name: "Worktrees + yolo merge", value: "wt-yolo", hint: "isolate agents, merge into current branch" },
                 { name: "Worktrees + new branch", value: "wt-branch", hint: "isolate agents, merge into a new branch" },
                 { name: "No worktrees", value: "no-wt", hint: "all agents share the working directory" },
@@ -603,6 +630,14 @@ async function main() {
             models = await fetchModels(5_000);
         workerModel = cliFlags.model ?? fileCfg?.model ?? (models[0]?.value || "claude-sonnet-4-6");
         plannerModel = models[0]?.value || workerModel;
+        // Auto-resolve a saved custom provider if --model matches its id or model id.
+        // Lets `claude-overnight --model=qwen3-coder-plus` route correctly without a separate flag.
+        const savedForCli = loadProviders();
+        const matched = savedForCli.find(p => p.id === workerModel || p.model === workerModel);
+        if (matched) {
+            workerProvider = matched;
+            workerModel = matched.model;
+        }
         concurrency = cliFlags.concurrency ? parseInt(cliFlags.concurrency) : (fileCfg?.concurrency ?? 5);
         budget = cliFlags.budget ? parseInt(cliFlags.budget) : undefined;
         if (budget != null && (isNaN(budget) || budget < 1)) {
@@ -655,6 +690,29 @@ async function main() {
     }
     if (useWorktrees)
         validateGitRepo(cwd);
+    // Custom-provider routing: build a model→env resolver so planner and worker
+    // queries hit the right endpoint without touching process.env globally.
+    const envForModel = buildEnvResolver({ plannerModel, plannerProvider, workerModel, workerProvider });
+    setPlannerEnvResolver(envForModel);
+    // Fail fast if a custom provider is misconfigured — one bad key would
+    // otherwise surface as N agent failures scattered across the run.
+    if (plannerProvider || workerProvider) {
+        const pending = [];
+        if (plannerProvider)
+            pending.push(["planner", plannerProvider]);
+        if (workerProvider && workerProvider.id !== plannerProvider?.id)
+            pending.push(["executor", workerProvider]);
+        for (const [role, p] of pending) {
+            process.stdout.write(`  ${chalk.dim(`◆ Pinging ${role} (${p.displayName})...`)}`);
+            const r = await preflightProvider(p, cwd);
+            if (!r.ok) {
+                process.stdout.write(`\x1B[2K\r  ${chalk.red(`✗ ${role} preflight failed:`)} ${chalk.dim(r.error)}\n`);
+                console.error(chalk.red(`\n  Fix the provider at ~/.claude/claude-overnight/providers.json and retry.\n`));
+                process.exit(1);
+            }
+            process.stdout.write(`\x1B[2K\r  ${chalk.green(`✓ ${role} ready`)} ${chalk.dim(`· ${p.displayName} · ${p.model}`)}\n`);
+        }
+    }
     if (nonInteractive) {
         const capStr = usageCap != null ? `  cap=${Math.round(usageCap * 100)}%` : "";
         const extraStr = allowExtraUsage ? (extraUsageBudget ? `  extra=$${extraUsageBudget}` : "  extra=∞") : "  extra=off";
@@ -681,7 +739,9 @@ async function main() {
             saveRunState(runDir, {
                 id: runDir.split(/[/\\]/).pop() ?? "",
                 objective, budget: budget ?? 10, remaining: budget ?? 10,
-                workerModel, plannerModel, concurrency, permissionMode,
+                workerModel, plannerModel,
+                workerProviderId: workerProvider?.id, plannerProviderId: plannerProvider?.id,
+                concurrency, permissionMode,
                 usageCap, allowExtraUsage, extraUsageBudget,
                 flex, useWorktrees, mergeStrategy,
                 waveNum: 0, currentTasks: [],
@@ -740,9 +800,10 @@ async function main() {
                         process.stdout.write("\x1B[?25l");
                         try {
                             let answer = "";
+                            const plannerEnv = envForModel(plannerModel);
                             for await (const msg of query({
                                 prompt: `You're planning work for: "${objective}"\n\nThemes identified:\n${themes.map((t, i) => `${i + 1}. ${t}`).join("\n")}\n\nUser question: ${question}`,
-                                options: { cwd, model: plannerModel, permissionMode, persistSession: false },
+                                options: { cwd, model: plannerModel, permissionMode, persistSession: false, ...(plannerEnv && { env: plannerEnv }) },
                             })) {
                                 if (msg.type === "result" && msg.subtype === "success")
                                     answer = msg.result || "";
@@ -782,6 +843,7 @@ async function main() {
                     const thinkingSwarm = new Swarm({
                         tasks: thinkingTasks, concurrency, cwd, model: plannerModel, permissionMode,
                         useWorktrees: false, mergeStrategy: "yolo", agentTimeoutMs, usageCap, allowExtraUsage, extraUsageBudget,
+                        envForModel,
                     });
                     const thinkRunInfo = { accIn: 0, accOut: 0, accCost: 0, accCompleted: 0, accFailed: 0, sessionsBudget: budget ?? 10, waveNum: -1, remaining: budget ?? 10, model: plannerModel, startedAt: Date.now() };
                     const thinkDisplay = new RunDisplay(thinkRunInfo, { remaining: 0, usageCap, concurrency, paused: false, dirty: false });
@@ -808,7 +870,9 @@ async function main() {
                         saveRunState(runDir, {
                             id: runDir.split(/[/\\]/).pop() ?? "",
                             objective: objective, budget: budget ?? 10, remaining: (budget ?? 10) - thinkingUsed,
-                            workerModel, plannerModel, concurrency, permissionMode,
+                            workerModel, plannerModel,
+                            workerProviderId: workerProvider?.id, plannerProviderId: plannerProvider?.id,
+                            concurrency, permissionMode,
                             usageCap, allowExtraUsage, extraUsageBudget,
                             flex, useWorktrees, mergeStrategy,
                             waveNum: 0, currentTasks: [],
@@ -883,9 +947,10 @@ async function main() {
                             process.stdout.write("\x1B[?25l");
                             try {
                                 let answer = "";
+                                const plannerEnv = envForModel(plannerModel);
                                 for await (const msg of query({
                                     prompt: `You planned these tasks for the objective "${objective}":\n${tasks.map((t, i) => `${i + 1}. ${t.prompt}`).join("\n")}\n\nUser question: ${question}`,
-                                    options: { cwd, model: plannerModel, permissionMode, persistSession: false },
+                                    options: { cwd, model: plannerModel, permissionMode, persistSession: false, ...(plannerEnv && { env: plannerEnv }) },
                                 })) {
                                     if (msg.type === "result" && msg.subtype === "success")
                                         answer = msg.result || "";
@@ -926,7 +991,8 @@ async function main() {
     }
     // ── Execute ──
     await executeRun({
-        tasks, objective, budget: budget ?? tasks.length, workerModel, plannerModel, concurrency,
+        tasks, objective, budget: budget ?? tasks.length, workerModel, plannerModel,
+        workerProvider, plannerProvider, concurrency,
         permissionMode, useWorktrees, mergeStrategy, usageCap, allowExtraUsage, extraUsageBudget,
         flex, agentTimeoutMs, cwd, allowedTools, runDir, previousKnowledge,
         resuming, resumeState: resumeState ?? undefined,

package/dist/planner-query.d.ts

@@ -24,6 +24,7 @@ export interface PlannerOpts {
         schema: Record<string, unknown>;
     };
 }
+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;

package/dist/planner-query.js

@@ -1,6 +1,15 @@
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { readFileSync } from "fs";
 import { NudgeError } from "./types.js";
+// ── 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
+// as planner or worker routes its traffic without threading extra params
+// through every planner.ts / steering.ts function.
+let _envResolver;
+export function setPlannerEnvResolver(fn) {
+    _envResolver = fn;
+}
 export function detectModelTier(model) {
     const m = model.toLowerCase();
     if (m === "default" || m.includes("opus"))
@@ -77,6 +86,7 @@ async function runPlannerQueryOnce(prompt, opts, onLog) {
     let structuredOutput;
     const startedAt = Date.now();
     const isResume = !!opts.resumeSessionId;
+    const envOverride = _envResolver?.(opts.model);
     const pq = query({
         prompt,
         options: {
@@ -90,6 +100,7 @@ async function runPlannerQueryOnce(prompt, opts, onLog) {
             includePartialMessages: true,
             ...(isResume && { resume: opts.resumeSessionId }),
             ...(opts.outputFormat && { outputFormat: opts.outputFormat }),
+            ...(envOverride && { env: envOverride }),
         },
     });
     let lastLogText = "";

package/dist/providers.d.ts

@@ -0,0 +1,61 @@
+import type { ModelInfo } from "@anthropic-ai/claude-agent-sdk";
+/**
+ * A non-Anthropic model provider reachable via an Anthropic-compatible endpoint
+ * (e.g. DashScope for Qwen, OpenRouter, a local proxy). Stored user-level so a
+ * key configured once works across every repo.
+ */
+export interface ProviderConfig {
+    id: string;
+    displayName: string;
+    baseURL: string;
+    model: string;
+    /** Env var name holding the key — preferred over inline `key` (nothing on disk). */
+    keyEnv?: string;
+    /** Inline API key. Stored plaintext in providers.json (mode 0600). */
+    key?: string;
+}
+export declare function getStorePath(): string;
+export declare function loadProviders(): ProviderConfig[];
+export declare function saveProvider(p: ProviderConfig): void;
+export declare function deleteProvider(id: string): void;
+export declare function resolveKey(p: ProviderConfig): string | null;
+/**
+ * Build the env overrides for a custom provider. Returns a full merged env
+ * (including current process.env) because the SDK replaces, not merges, when
+ * you pass `options.env`.
+ */
+export declare function envFor(p: ProviderConfig): Record<string, string>;
+export interface ModelPick {
+    model: string;
+    providerId?: string;
+    provider?: ProviderConfig;
+}
+/**
+ * Show a unified picker: Anthropic models (from SDK), saved custom providers,
+ * and an "Other…" entry that walks the user through adding a new provider.
+ * Returns the selected model string and, if it's a custom provider, the id.
+ */
+export declare function pickModel(label: string, anthropicModels: ModelInfo[], currentModelId?: string): Promise<ModelPick>;
+/**
+ * Cheap auth check: spawn a 1-turn query against the provider and fail fast
+ * if the key is wrong or the endpoint is unreachable. Timeout is aggressive
+ * so misconfig doesn't delay the main run.
+ */
+export declare function preflightProvider(p: ProviderConfig, cwd: string, timeoutMs?: number): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
+export type EnvResolver = (model?: string) => Record<string, string> | undefined;
+/**
+ * Build a single resolver that swarm.ts and planner-query.ts share. Maps a
+ * model string to the env overrides that should be passed to `query()`.
+ * Returns undefined for Anthropic-native models (let the SDK use process.env).
+ */
+export declare function buildEnvResolver(opts: {
+    plannerModel: string;
+    plannerProvider?: ProviderConfig;
+    workerModel: string;
+    workerProvider?: ProviderConfig;
+}): EnvResolver;

package/dist/providers.js

@@ -0,0 +1,243 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import chalk from "chalk";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { ask, select } from "./cli.js";
+// ── Store ──
+const STORE_PATH = join(homedir(), ".claude", "claude-overnight", "providers.json");
+export function getStorePath() { return STORE_PATH; }
+export function loadProviders() {
+    try {
+        const raw = readFileSync(STORE_PATH, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed?.providers))
+            return parsed.providers.filter(isValidProvider);
+    }
+    catch { }
+    return [];
+}
+export function saveProvider(p) {
+    const all = loadProviders().filter(x => x.id !== p.id);
+    all.push(p);
+    mkdirSync(join(homedir(), ".claude", "claude-overnight"), { recursive: true });
+    writeFileSync(STORE_PATH, JSON.stringify({ providers: all }, null, 2), "utf-8");
+    try {
+        chmodSync(STORE_PATH, 0o600);
+    }
+    catch { }
+}
+export function deleteProvider(id) {
+    const all = loadProviders().filter(x => x.id !== id);
+    if (!existsSync(STORE_PATH))
+        return;
+    writeFileSync(STORE_PATH, JSON.stringify({ providers: all }, null, 2), "utf-8");
+    try {
+        chmodSync(STORE_PATH, 0o600);
+    }
+    catch { }
+}
+function isValidProvider(p) {
+    return p && typeof p.id === "string" && typeof p.baseURL === "string"
+        && typeof p.model === "string" && typeof p.displayName === "string";
+}
+// ── Key resolution ──
+export function resolveKey(p) {
+    if (p.keyEnv) {
+        const v = process.env[p.keyEnv];
+        return v && v.trim() ? v : null;
+    }
+    return p.key && p.key.trim() ? p.key : null;
+}
+/**
+ * Build the env overrides for a custom provider. Returns a full merged env
+ * (including current process.env) because the SDK replaces, not merges, when
+ * you pass `options.env`.
+ */
+export function envFor(p) {
+    const key = resolveKey(p);
+    if (!key)
+        throw new Error(`Provider "${p.id}" has no API key (${p.keyEnv ? `env ${p.keyEnv} is empty` : "inline key missing"})`);
+    const base = {};
+    for (const [k, v] of Object.entries(process.env))
+        if (v !== undefined)
+            base[k] = v;
+    base.ANTHROPIC_BASE_URL = p.baseURL;
+    base.ANTHROPIC_AUTH_TOKEN = key;
+    delete base.ANTHROPIC_API_KEY;
+    return base;
+}
+/**
+ * Show a unified picker: Anthropic models (from SDK), saved custom providers,
+ * and an "Other…" entry that walks the user through adding a new provider.
+ * Returns the selected model string and, if it's a custom provider, the id.
+ */
+export async function pickModel(label, anthropicModels, currentModelId) {
+    for (;;) {
+        const saved = loadProviders();
+        const items = [];
+        for (const m of anthropicModels) {
+            items.push({ name: m.displayName, value: { kind: "anthropic", model: m }, hint: m.description });
+        }
+        // Network-failed fallback: ensure the picker always has at least one Anthropic
+        // 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)" } },
+                hint: "default — Anthropic model list unavailable",
+            });
+        }
+        for (const p of saved) {
+            const keySrc = p.keyEnv ? `env ${p.keyEnv}` : "stored key";
+            items.push({ name: `${p.displayName}`, value: { kind: "provider", provider: p }, hint: `${p.model} · ${keySrc}` });
+        }
+        items.push({ name: chalk.cyan("Other…"), value: { kind: "other" }, hint: "custom OpenAI/Anthropic-compatible endpoint" });
+        let defaultIdx = 0;
+        if (currentModelId) {
+            const i = items.findIndex(it => {
+                if (it.value.kind === "anthropic")
+                    return it.value.model.value === currentModelId;
+                if (it.value.kind === "provider")
+                    return it.value.provider.id === currentModelId || it.value.provider.model === currentModelId;
+                return false;
+            });
+            if (i >= 0)
+                defaultIdx = i;
+        }
+        const picked = await select(label, items, defaultIdx);
+        if (picked.kind === "anthropic")
+            return { model: picked.model.value };
+        if (picked.kind === "provider") {
+            return { model: picked.provider.model, providerId: picked.provider.id, provider: picked.provider };
+        }
+        const added = await promptNewProvider();
+        if (added) {
+            saveProvider(added);
+            return { model: added.model, providerId: added.id, provider: added };
+        }
+        // user cancelled "Other…" — loop back to picker
+    }
+}
+async function promptNewProvider() {
+    console.log(chalk.dim("\n  Add a custom provider (Anthropic-compatible endpoint)"));
+    console.log(chalk.dim("  Leave blank to cancel.\n"));
+    const displayName = await ask(`  ${chalk.cyan("Name")} ${chalk.dim("(e.g. 'Qwen Coder'):")} `);
+    if (!displayName)
+        return null;
+    const id = slugify(displayName);
+    const baseURLRaw = await ask(`\n  ${chalk.cyan("Base URL")} ${chalk.dim("(e.g. https://dashscope-intl.aliyuncs.com/api/v2/apps/claude-code-proxy):")} `);
+    if (!baseURLRaw)
+        return null;
+    const baseURL = normalizeBaseURL(baseURLRaw);
+    const model = await ask(`\n  ${chalk.cyan("Model id")} ${chalk.dim("(e.g. qwen3-coder-plus):")} `);
+    if (!model)
+        return null;
+    const keyMode = await select(`  ${chalk.cyan("API key source")}:`, [
+        { name: "Paste key now", value: "inline", hint: "stored plaintext in ~/.claude/claude-overnight/providers.json (0600)" },
+        { name: "Read from env var", value: "env", hint: "nothing written to disk" },
+    ]);
+    if (keyMode === "env") {
+        const envName = await ask(`\n  ${chalk.cyan("Env var name")} ${chalk.dim(`(e.g. CO_KEY_${id.toUpperCase()}):`)} `);
+        if (!envName)
+            return null;
+        if (!process.env[envName]) {
+            console.log(chalk.yellow(`\n  ⚠ ${envName} is not set in the current shell — you'll need to export it before running.`));
+        }
+        return { id, displayName, baseURL, model, keyEnv: envName };
+    }
+    const key = await ask(`\n  ${chalk.cyan("API key")}: `);
+    if (!key)
+        return null;
+    return { id, displayName, baseURL, model, key };
+}
+function slugify(s) {
+    return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 32) || "provider";
+}
+/** Strip trailing slashes and common endpoint suffixes users paste by mistake. */
+function normalizeBaseURL(raw) {
+    let url = raw.trim().replace(/\/+$/, "");
+    url = url.replace(/\/v1\/messages$/i, "").replace(/\/messages$/i, "");
+    return url;
+}
+// ── Pre-flight validation ──
+/**
+ * Cheap auth check: spawn a 1-turn query against the provider and fail fast
+ * if the key is wrong or the endpoint is unreachable. Timeout is aggressive
+ * so misconfig doesn't delay the main run.
+ */
+export async function preflightProvider(p, cwd, timeoutMs = 20_000) {
+    let env;
+    try {
+        env = envFor(p);
+    }
+    catch (err) {
+        return { ok: false, error: err.message };
+    }
+    let pq;
+    try {
+        pq = query({
+            prompt: "Reply with exactly the word ok and nothing else.",
+            options: {
+                cwd,
+                model: p.model,
+                env,
+                permissionMode: "bypassPermissions",
+                allowDangerouslySkipPermissions: true,
+                maxTurns: 1,
+                persistSession: false,
+            },
+        });
+        const stream = pq;
+        const consume = (async () => {
+            for await (const msg of stream) {
+                if (msg.type === "result") {
+                    if (msg.subtype !== "success") {
+                        return { ok: false, error: String(msg.result || msg.subtype || "unknown error").slice(0, 200) };
+                    }
+                    return { ok: true };
+                }
+            }
+            return { ok: false, error: "no result received" };
+        })();
+        const timeout = new Promise((resolve) => {
+            setTimeout(() => {
+                try {
+                    stream.interrupt().catch(() => stream.close());
+                }
+                catch { }
+                resolve({ ok: false, error: `timeout after ${Math.round(timeoutMs / 1000)}s` });
+            }, timeoutMs);
+        });
+        return await Promise.race([consume, timeout]);
+    }
+    catch (err) {
+        return { ok: false, error: String(err?.message || err).slice(0, 200) };
+    }
+    finally {
+        try {
+            pq?.close();
+        }
+        catch { }
+    }
+}
+/**
+ * Build a single resolver that swarm.ts and planner-query.ts share. Maps a
+ * model string to the env overrides that should be passed to `query()`.
+ * Returns undefined for Anthropic-native models (let the SDK use process.env).
+ */
+export function buildEnvResolver(opts) {
+    const byModel = new Map();
+    if (opts.plannerProvider)
+        byModel.set(opts.plannerModel, opts.plannerProvider);
+    if (opts.workerProvider)
+        byModel.set(opts.workerModel, opts.workerProvider);
+    if (byModel.size === 0)
+        return () => undefined;
+    return (model) => {
+        if (!model)
+            return undefined;
+        const p = byModel.get(model);
+        return p ? envFor(p) : undefined;
+    };
+}

package/dist/render.js

@@ -1,9 +1,6 @@
 import chalk from "chalk";
+import { RATE_LIMIT_WINDOW_SHORT } from "./types.js";
 const SPINNER = ["|", "/", "-", "\\"];
-const WINDOW_SHORT_NAMES = {
-    five_hour: "5h", seven_day: "7d", seven_day_opus: "7d op",
-    seven_day_sonnet: "7d sn", overage: "extra",
-};
 // ── Shared helpers ──
 export function truncate(s, max) {
     return s.length <= max ? s : s.slice(0, max - 1) + "\u2026";
@@ -90,13 +87,23 @@ function renderUsageBars(out, w, swarm) {
                 ? chalk.red(`Budget $${swarm.extraUsageBudget} exhausted \u2014 finishing active`)
                 : chalk.yellow(`Capped at ${capFrac != null ? Math.round(capFrac * 100) : 100}% \u2014 finishing active`);
         }
-        else if (swarm.rateLimitPaused > 0) {
-            label = chalk.yellow(`Cooling down \u2014 ${swarm.rateLimitPaused} worker(s) waiting`);
-        }
-        else if (swarm.rateLimitResetsAt && swarm.rateLimitResetsAt > Date.now()) {
-            const waitSec = Math.ceil((swarm.rateLimitResetsAt - Date.now()) / 1000);
-            const mm = Math.floor(waitSec / 60), ss = waitSec % 60;
-            label = chalk.red(`Waiting for reset ${mm > 0 ? `${mm}m ${ss}s` : `${ss}s`}`);
+        else if (swarm.rateLimitPaused > 0 || (swarm.rateLimitResetsAt && swarm.rateLimitResetsAt > Date.now())) {
+            const mcw = swarm.mostConstrainedWindow();
+            const when = (mcw?.resetsAt && mcw.resetsAt > Date.now()) ? mcw.resetsAt
+                : (swarm.rateLimitResetsAt && swarm.rateLimitResetsAt > Date.now()) ? swarm.rateLimitResetsAt
+                    : undefined;
+            const winName = mcw ? (RATE_LIMIT_WINDOW_SHORT[mcw.type] ?? mcw.type.replace(/_/g, " ")) : undefined;
+            let txt = winName
+                ? `Anthropic ${winName} limit hit`
+                : `Rate limited`;
+            if (when) {
+                const waitSec = Math.ceil((when - Date.now()) / 1000);
+                const mm = Math.floor(waitSec / 60), ss = waitSec % 60;
+                txt += ` \u2014 resets in ${mm > 0 ? `${mm}m ${ss}s` : `${ss}s`}`;
+            }
+            if (swarm.rateLimitPaused > 0)
+                txt += ` (${swarm.rateLimitPaused} waiting)`;
+            label = chalk.yellow(txt);
         }
         if (swarm.isUsingOverage && !swarm.cappedOut)
             label += chalk.red(" [OVERAGE]");
@@ -106,7 +113,7 @@ function renderUsageBars(out, w, swarm) {
     if (windows.length > 1) {
         const cycleIdx = Math.floor(Date.now() / 3000) % windows.length;
         const win = windows[cycleIdx];
-        const shortName = WINDOW_SHORT_NAMES[win.type] ?? win.type.replace(/_/g, " ");
+        const shortName = RATE_LIMIT_WINDOW_SHORT[win.type] ?? win.type.replace(/_/g, " ");
         renderBar(win.utilization, shortName);
         const dots = windows.map((_, i) => i === cycleIdx ? "\u25CF" : "\u25CB").join("");
         out[out.length - 1] += chalk.dim(`  ${dots}`);
@@ -195,10 +202,11 @@ export function renderFrame(swarm, showHotkeys, runInfo) {
         const pending = runInfo?.pendingSteer ?? 0;
         const chip = pending > 0 ? chalk.cyan(`  \u270E ${pending} steer queued`) : "";
         const fixChip = swarm.failed > 0 && swarm.active > 0 ? chalk.yellow("  [f] fix") : "";
+        const retryChip = swarm.rateLimitPaused > 0 ? chalk.yellow("  [r] retry-now") : "";
         const pauseLabel = swarm.paused ? "[p] resume" : "[p] pause";
-        out.push(chalk.dim(`  [b] budget  [t] cap  [c] conc  [e] extra  ${pauseLabel}  [s] steer  [?] ask  [q] stop`) + fixChip + chip);
+        out.push(chalk.dim(`  [b] budget  [t] cap  [c] conc  [e] extra  ${pauseLabel}  [s] steer  [?] ask  [q] stop`) + fixChip + retryChip + chip);
         if (swarm.blocked > 0 && swarm.blocked === swarm.active) {
-            out.push(chalk.yellow(`  all workers rate-limited — press [c] to reduce concurrency, [p] to pause, [q] to quit`));
+            out.push(chalk.yellow(`  all workers rate-limited — [r] retry-now, [c] reduce concurrency, [p] pause, [q] quit`));
         }
     }
     out.push("");

package/dist/run.d.ts

@@ -1,10 +1,15 @@
 import type { Task, PermMode, MergeStrategy, RunState, WaveSummary } from "./types.js";
+import type { ProviderConfig } from "./providers.js";
 export interface RunConfig {
     tasks: Task[];
     objective?: string;
     budget: number;
     workerModel: string;
     plannerModel: string;
+    /** Custom provider for worker tasks (optional — Anthropic default when undefined). */
+    workerProvider?: ProviderConfig;
+    /** Custom provider for planner/steering calls (optional). */
+    plannerProvider?: ProviderConfig;
     concurrency: number;
     permissionMode: PermMode;
     useWorktrees: boolean;

package/dist/run.js

@@ -4,7 +4,8 @@ import { execSync } from "child_process";
 import chalk from "chalk";
 import { Swarm } from "./swarm.js";
 import { steerWave } from "./steering.js";
-import { getTotalPlannerCost, getPlannerRateLimitInfo, runPlannerQuery } from "./planner-query.js";
+import { getTotalPlannerCost, getPlannerRateLimitInfo, runPlannerQuery, setPlannerEnvResolver } from "./planner-query.js";
+import { buildEnvResolver } from "./providers.js";
 import { RunDisplay } from "./ui.js";
 import { renderSummary } from "./render.js";
 import { fmtTokens } from "./render.js";
@@ -16,6 +17,11 @@ export async function executeRun(cfg) {
     }
     catch { } };
     const { objective, cwd, workerModel, plannerModel, concurrency, permissionMode, allowedTools, runDir, previousKnowledge, } = cfg;
+    const envForModel = buildEnvResolver({
+        plannerModel, plannerProvider: cfg.plannerProvider,
+        workerModel, workerProvider: cfg.workerProvider,
+    });
+    setPlannerEnvResolver(envForModel);
     let { usageCap, flex } = cfg;
     const useWorktrees = cfg.useWorktrees;
     const mergeStrategy = cfg.mergeStrategy;
@@ -311,7 +317,7 @@ export async function executeRun(cfg) {
                 tasks: currentTasks, concurrency, cwd, model: workerModel, permissionMode, allowedTools,
                 useWorktrees, mergeStrategy: waveMerge, agentTimeoutMs: cfg.agentTimeoutMs,
                 usageCap, allowExtraUsage: cfg.allowExtraUsage, extraUsageBudget: cfg.extraUsageBudget,
-                baseCostUsd: accCost,
+                baseCostUsd: accCost, envForModel,
             });
             currentSwarm = swarm;
             display.setWave(swarm);
@@ -359,7 +365,9 @@ export async function executeRun(cfg) {
             const neverStarted = currentTasks.filter(t => !attemptedPrompts.has(t.prompt));
             saveRunState(runDir, {
                 id: `run-${new Date().toISOString().slice(0, 19)}`, objective: objective ?? "", budget: cfg.budget,
-                remaining, workerModel, plannerModel, concurrency, permissionMode,
+                remaining, workerModel, plannerModel,
+                workerProviderId: cfg.workerProvider?.id, plannerProviderId: cfg.plannerProvider?.id,
+                concurrency, permissionMode,
                 usageCap, allowExtraUsage: cfg.allowExtraUsage, extraUsageBudget: cfg.extraUsageBudget,
                 flex, useWorktrees, mergeStrategy, waveNum, currentTasks: neverStarted,
                 accCost, accCompleted, accFailed, accIn, accOut, accTools,
@@ -417,7 +425,9 @@ export async function executeRun(cfg) {
     const finalPhase = trulyDone ? "done" : wasCapped ? "capped" : remaining <= 0 ? "capped" : "stopped";
     saveRunState(runDir, {
         id: `run-${new Date().toISOString().slice(0, 19)}`, objective: objective ?? "", budget: cfg.budget,
-        remaining, workerModel, plannerModel, concurrency, permissionMode,
+        remaining, workerModel, plannerModel,
+        workerProviderId: cfg.workerProvider?.id, plannerProviderId: cfg.plannerProvider?.id,
+        concurrency, permissionMode,
         usageCap, allowExtraUsage: cfg.allowExtraUsage, extraUsageBudget: cfg.extraUsageBudget,
         flex, useWorktrees, mergeStrategy, waveNum, currentTasks: [],
         accCost, accCompleted, accFailed, accIn, accOut, accTools,

package/dist/swarm.d.ts

@@ -15,6 +15,8 @@ export interface SwarmConfig {
     allowExtraUsage?: boolean;
     extraUsageBudget?: number;
     baseCostUsd?: number;
+    /** Per-task env overrides: given a model id, return the env to pass to `query()` (or undefined for Anthropic default). */
+    envForModel?: (model?: string) => Record<string, string> | undefined;
 }
 export declare class Swarm {
     readonly agents: AgentState[];
@@ -41,6 +43,8 @@ export declare class Swarm {
     rateLimitPaused: number;
     isUsingOverage: boolean;
     overageCostUsd: number;
+    private rateLimitExplained;
+    private rateLimitWakers;
     /** Live-adjustable concurrency target. Workers above this count exit on the next task boundary. */
     targetConcurrency: number;
     /** When true, dispatch is frozen — workers wait without starting new tasks. */
@@ -76,6 +80,13 @@ export declare class Swarm {
     setConcurrency(n: number): void;
     /** Freeze/resume dispatch without killing the run. Paused workers block at the top of their loop. */
     setPaused(b: boolean): void;
+    /** Returns the rate-limit window currently holding the swarm back — rejected first, then highest utilization. */
+    mostConstrainedWindow(): RateLimitWindow | undefined;
+    private windowTag;
+    /** Cancellable sleep used by rate-limit waits. `retryRateLimitNow()` wakes every pending sleeper. */
+    private rateLimitSleep;
+    /** Force-wake every rate-limit sleeper and clear the reset timestamp so the next attempt fires immediately. */
+    retryRateLimitNow(): void;
     /** Live-adjust the overage spend cap. `undefined` = unlimited. If already over the new cap, stop dispatch. */
     setExtraUsageBudget(n: number | undefined): void;
     run(): Promise<void>;

package/dist/swarm.js

@@ -2,7 +2,7 @@ import { mkdtempSync, rmSync } from "fs";
 import { join } from "path";
 import { tmpdir } from "os";
 import { query } from "@anthropic-ai/claude-agent-sdk";
-import { NudgeError } from "./types.js";
+import { NudgeError, RATE_LIMIT_WINDOW_SHORT } from "./types.js";
 import { gitExec, autoCommit, mergeAllBranches, warnDirtyTree, cleanStaleWorktrees, writeSwarmLog } from "./merge.js";
 const SIMPLIFY_PROMPT = `You just finished your task. Now review and simplify your changes.
 
@@ -34,6 +34,8 @@ export class Swarm {
     rateLimitPaused = 0;
     isUsingOverage = false;
     overageCostUsd = 0;
+    rateLimitExplained = false;
+    rateLimitWakers = [];
     /** Live-adjustable concurrency target. Workers above this count exit on the next task boundary. */
     targetConcurrency;
     /** When true, dispatch is frozen — workers wait without starting new tasks. */
@@ -109,6 +111,56 @@ export class Swarm {
         this.paused = b;
         this.log(-1, b ? "Dispatch paused" : "Dispatch resumed");
     }
+    /** Returns the rate-limit window currently holding the swarm back — rejected first, then highest utilization. */
+    mostConstrainedWindow() {
+        const windows = Array.from(this.rateLimitWindows.values());
+        if (windows.length === 0)
+            return undefined;
+        const rejected = windows.find(w => w.status === "rejected" && (!w.resetsAt || w.resetsAt > Date.now()));
+        if (rejected)
+            return rejected;
+        return windows.reduce((a, b) => (a.utilization >= b.utilization ? a : b));
+    }
+    windowTag() {
+        const w = this.mostConstrainedWindow();
+        if (!w)
+            return "";
+        const name = RATE_LIMIT_WINDOW_SHORT[w.type] ?? w.type.replace(/_/g, " ");
+        return ` (${name} window)`;
+    }
+    /** Cancellable sleep used by rate-limit waits. `retryRateLimitNow()` wakes every pending sleeper. */
+    rateLimitSleep(ms) {
+        return new Promise(resolve => {
+            let done = false;
+            const finish = () => {
+                if (done)
+                    return;
+                done = true;
+                clearTimeout(timer);
+                const i = this.rateLimitWakers.indexOf(finish);
+                if (i >= 0)
+                    this.rateLimitWakers.splice(i, 1);
+                resolve();
+            };
+            const timer = setTimeout(finish, ms);
+            this.rateLimitWakers.push(finish);
+        });
+    }
+    /** Force-wake every rate-limit sleeper and clear the reset timestamp so the next attempt fires immediately. */
+    retryRateLimitNow() {
+        const n = this.rateLimitWakers.length;
+        if (n === 0) {
+            this.log(-1, "Retry-now: no workers waiting on rate limit");
+            return;
+        }
+        this.rateLimitResetsAt = undefined;
+        this.rateLimitUtilization = 0;
+        const wakers = this.rateLimitWakers.slice();
+        this.rateLimitWakers.length = 0;
+        for (const w of wakers)
+            w();
+        this.log(-1, `Retry-now: woke ${n} worker(s) — hitting API immediately (may be rejected again)`);
+    }
     /** Live-adjust the overage spend cap. `undefined` = unlimited. If already over the new cap, stop dispatch. */
     setExtraUsageBudget(n) {
         if (this.extraUsageBudget === n)
@@ -319,10 +371,10 @@ export class Swarm {
                 : fallbackMs;
             const reason = capExceeded
                 ? `Usage at ${Math.round(this.rateLimitUtilization * 100)}% (cap ${Math.round(cap * 100)}%)`
-                : "Rate limited";
-            this.log(-1, `${reason} — waiting ${Math.ceil(waitMs / 1000)}s then retrying`);
+                : `Rate limited${this.windowTag()}`;
+            this.log(-1, `${reason} — waiting ${Math.ceil(waitMs / 1000)}s then retrying ([r] to retry now)`);
             this.rateLimitPaused++;
-            await sleep(waitMs);
+            await this.rateLimitSleep(waitMs);
             this.rateLimitPaused--;
             this.rateLimitUtilization = 0;
             this.rateLimitResetsAt = undefined;
@@ -402,13 +454,16 @@ export class Swarm {
                         : this.config.useWorktrees && !task.noWorktree
                             ? `You are working in an isolated git worktree. Focus only on this task. Do NOT commit your changes — the framework handles that.\n\n${preamble}${task.prompt}`
                             : `${preamble}${task.prompt}`;
+                    const effectiveModel = task.model || this.config.model;
+                    const envOverride = this.config.envForModel?.(effectiveModel);
                     const agentQuery = query({
                         prompt: agentPrompt,
                         options: {
-                            cwd: agentCwd, model: task.model || this.config.model, permissionMode: perm,
+                            cwd: agentCwd, model: effectiveModel, permissionMode: perm,
                             ...(perm === "bypassPermissions" && { allowDangerouslySkipPermissions: true }),
                             allowedTools: this.config.allowedTools, includePartialMessages: true, persistSession: true,
                             ...(isResume && resumeSessionId && { resume: resumeSessionId }),
+                            ...(envOverride && { env: envOverride }),
                         },
                     });
                     const timeoutMs = isResume ? inactivityMs * 2 : inactivityMs;
@@ -503,10 +558,10 @@ export class Swarm {
                     // we eventually surrender instead of looping forever.
                     const globallyStalled = Date.now() - this.lastProgressAt > 15 * 60_000;
                     const freebie = !globallyStalled;
-                    this.log(id, `Rate limited — waiting ${Math.ceil(waitMs / 1000)}s${freebie ? " (attempt not counted)" : " (counted — swarm stalled)"}`);
+                    this.log(id, `Rate limited${this.windowTag()} — waiting ${Math.ceil(waitMs / 1000)}s${freebie ? " (attempt not counted)" : " (counted — swarm stalled)"} ([r] to retry now)`);
                     agent.blockedAt = Date.now();
                     this.rateLimitPaused++;
-                    await sleep(waitMs);
+                    await this.rateLimitSleep(waitMs);
                     this.rateLimitPaused--;
                     agent.blockedAt = undefined;
                     this.isUsingOverage = false;
@@ -660,6 +715,12 @@ export class Swarm {
                     if (!this.rateLimitResetsAt || this.rateLimitResetsAt <= Date.now()) {
                         this.rateLimitResetsAt = Date.now() + 60_000;
                     }
+                    if (!this.rateLimitExplained) {
+                        this.rateLimitExplained = true;
+                        const name = windowType ? (RATE_LIMIT_WINDOW_SHORT[windowType] ?? windowType.replace(/_/g, " ")) : "Anthropic";
+                        const overageNote = this.isUsingOverage ? " even on overage" : "";
+                        this.log(-1, `${name} window is full${overageNote} — plan-level Anthropic limit, not a claude-overnight cap. Press [r] to retry now, [c] to lower concurrency, or wait for reset.`);
+                    }
                     throw new Error("rate limit rejected — retrying");
                 }
                 break;

package/dist/types.d.ts

@@ -116,6 +116,7 @@ export interface RateLimitWindow {
     status: string;
     resetsAt?: number;
 }
+export declare const RATE_LIMIT_WINDOW_SHORT: Record<string, string>;
 /** Thrown when a query goes silent — carries session ID for interrupt+resume. */
 export declare class NudgeError extends Error {
     sessionId: string | undefined;
@@ -160,6 +161,10 @@ export interface RunState {
     remaining: number;
     workerModel: string;
     plannerModel: string;
+    /** Optional id of a custom provider (from ~/.claude/claude-overnight/providers.json) used for worker tasks. */
+    workerProviderId?: string;
+    /** Optional id of a custom provider used for planner/steering calls. */
+    plannerProviderId?: string;
     concurrency: number;
     permissionMode: PermMode;
     usageCap?: number;

package/dist/types.js

@@ -1,3 +1,7 @@
+export const RATE_LIMIT_WINDOW_SHORT = {
+    five_hour: "5h", seven_day: "7d", seven_day_opus: "7d opus",
+    seven_day_sonnet: "7d sonnet", overage: "extra",
+};
 /** Thrown when a query goes silent — carries session ID for interrupt+resume. */
 export class NudgeError extends Error {
     sessionId;

package/dist/ui.js

@@ -387,6 +387,10 @@ export class RunDisplay {
             this.swarm.requeueFailed();
             return false;
         }
+        if ((s === "r" || s === "R") && this.swarm && this.swarm.rateLimitPaused > 0) {
+            this.swarm.retryRateLimitNow();
+            return true;
+        }
         if ((s === "s" || s === "S") && this.onSteer) {
             this.inputMode = "steer";
             this.inputSegs = [];

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "claude-overnight",
-  "version": "1.14.0",
+  "version": "1.16.1",
   "description": "Run 10, 100, or 1000 Claude agents overnight. Parallel autonomous AI coding with thinking waves, iterative quality steering, crash recovery, and rate limit handling. Built on the Claude Agent SDK.",
   "type": "module",
   "bin": {
-    "claude-overnight": "dist/index.js"
+    "claude-overnight": "dist/bin.js"
   },
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "start": "node dist/index.js",
+    "start": "node dist/bin.js",
     "prepublishOnly": "node scripts/sync-plugin-version.js"
   },
   "dependencies": {