claude-overnight 1.13.1 → 1.16.0

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";
@@ -21,6 +22,140 @@ function countTasksInFile(path) {
         return 0;
     }
 }
+async function promptResumeOverrides(state, cliFlags, argv, noTTY, runDir) {
+    // ── Apply CLI flag overrides first ──
+    if (cliFlags.model)
+        state.workerModel = cliFlags.model;
+    if (cliFlags.concurrency) {
+        const n = parseInt(cliFlags.concurrency);
+        if (n >= 1)
+            state.concurrency = n;
+    }
+    if (cliFlags.budget) {
+        const n = parseInt(cliFlags.budget);
+        if (n > 0) {
+            state.remaining = n;
+            state.budget = state.accCompleted + state.accFailed + n;
+        }
+    }
+    if (cliFlags["usage-cap"] != null) {
+        const v = parseFloat(cliFlags["usage-cap"]);
+        if (!isNaN(v) && v >= 0 && v <= 100)
+            state.usageCap = v > 0 ? v / 100 : undefined;
+    }
+    if (cliFlags["extra-usage-budget"] != null) {
+        const v = parseFloat(cliFlags["extra-usage-budget"]);
+        if (!isNaN(v) && v > 0) {
+            state.extraUsageBudget = v;
+            state.allowExtraUsage = true;
+        }
+    }
+    if (argv.includes("--allow-extra-usage"))
+        state.allowExtraUsage = true;
+    if (cliFlags.perm)
+        state.permissionMode = cliFlags.perm;
+    if (noTTY) {
+        try {
+            saveRunState(runDir, state);
+        }
+        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);
+        const remaining = Math.max(1, state.remaining);
+        const capStr = state.usageCap != null ? `${Math.round(state.usageCap * 100)}%` : "unlimited";
+        const extraStr = state.allowExtraUsage
+            ? (state.extraUsageBudget ? `$${state.extraUsageBudget}` : "unlimited")
+            : "off";
+        console.log();
+        console.log(`  ${chalk.dim("Resume settings")}`);
+        console.log(`  ${chalk.dim("─".repeat(40))}`);
+        console.log(`  ${chalk.dim("model      ")}${chalk.white(state.workerModel)} ${chalk.dim(`(${tier})`)}`);
+        console.log(`  ${chalk.dim("remaining  ")}${chalk.white(String(remaining))} ${chalk.dim("sessions")}`);
+        console.log(`  ${chalk.dim("concur     ")}${chalk.white(String(state.concurrency))}`);
+        console.log(`  ${chalk.dim("usage cap  ")}${chalk.white(capStr)}`);
+        console.log(`  ${chalk.dim("extra      ")}${chalk.white(extraStr)}`);
+    };
+    fmtSummary();
+    const action = await selectKey("", [
+        { key: "r", desc: "esume" },
+        { key: "e", desc: "dit" },
+        { key: "q", desc: "uit" },
+    ]);
+    if (action === "q")
+        process.exit(0);
+    if (action === "r")
+        return;
+    // ── Edit walk ──
+    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;
+    }
+    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) {
+        state.remaining = parsedRem;
+        state.budget = state.accCompleted + state.accFailed + parsedRem;
+    }
+    const concAns = await ask(`\n  ${chalk.cyan("③")} Concurrency ${chalk.dim(`[${state.concurrency}]:`)} `);
+    const parsedConc = parseInt(concAns);
+    if (!isNaN(parsedConc) && parsedConc >= 1)
+        state.concurrency = parsedConc;
+    const currentCap = state.usageCap != null ? String(Math.round(state.usageCap * 100)) : "off";
+    const capAns = await ask(`\n  ${chalk.cyan("④")} Usage cap % ${chalk.dim(`[${currentCap}]`)} ${chalk.dim("(0 = off):")} `);
+    if (capAns.trim()) {
+        const v = parseFloat(capAns);
+        if (!isNaN(v) && v >= 0 && v <= 100)
+            state.usageCap = v > 0 ? v / 100 : undefined;
+    }
+    const currentExtra = state.allowExtraUsage
+        ? (state.extraUsageBudget ? `$${state.extraUsageBudget}` : "unlimited")
+        : "off";
+    const extraChoice = await select(`${chalk.cyan("⑤")} Extra usage ${chalk.dim(`[current: ${currentExtra}]`)}:`, [
+        { name: "Keep current", value: "keep" },
+        { name: "Off", value: "off", hint: "stop at plan limit" },
+        { name: "With $ cap", value: "budget", hint: "set a spending cap" },
+        { name: "Unlimited", value: "unlimited", hint: "no cap, billed as overage" },
+    ]);
+    if (extraChoice === "off") {
+        state.allowExtraUsage = false;
+        state.extraUsageBudget = undefined;
+    }
+    else if (extraChoice === "budget") {
+        const bAns = await ask(`  ${chalk.dim("Max extra $:")} `);
+        const bVal = parseFloat(bAns);
+        if (!isNaN(bVal) && bVal > 0) {
+            state.extraUsageBudget = bVal;
+            state.allowExtraUsage = true;
+        }
+    }
+    else if (extraChoice === "unlimited") {
+        state.allowExtraUsage = true;
+        state.extraUsageBudget = undefined;
+    }
+    try {
+        saveRunState(runDir, state);
+    }
+    catch { }
+    console.log(chalk.green("\n  ✓ Settings updated"));
+    fmtSummary();
+    console.log();
+}
 async function main() {
     const argv = process.argv.slice(2);
     if (argv.includes("-v") || argv.includes("--version")) {
@@ -45,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)")}
@@ -108,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;
@@ -310,11 +447,14 @@ async function main() {
                 }
                 catch { }
             }
+            await promptResumeOverrides(resumeState, cliFlags, argv, noTTY, resumeRunDir);
         }
     }
     // ── Config resolution ──
     let workerModel;
     let plannerModel;
+    let workerProvider;
+    let plannerProvider;
     let budget;
     let concurrency;
     let objective = fileCfg?.objective;
@@ -327,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;
@@ -378,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" },
@@ -406,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;
@@ -415,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;
@@ -432,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" },
@@ -475,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)) {
@@ -527,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";
@@ -553,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: [],
@@ -612,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 || "";
@@ -654,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 });
@@ -680,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: [],
@@ -755,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 || "";
@@ -798,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;