claude-overnight 1.25.42 → 1.25.45

package/dist/bin.js

@@ -30,7 +30,7 @@ if (process.stdout.isTTY && !quiet && !process.env.CLAUDE_OVERNIGHT_UPDATED) {
             writeFileSync(tsFile, String(Date.now())); // stamp first so failures don't re-trigger
             const { execFileSync, spawnSync } = await import("node:child_process");
             const latest = execFileSync("npm", ["show", "claude-overnight", "version"], { encoding: "utf-8", timeout: 6000 }).trim();
-            const { VERSION } = await import("./_version.js");
+            const { VERSION } = await import("./core/_version.js");
             if (latest !== VERSION) {
                 process.stdout.write(`\r\x1b[2K  🌙  claude-overnight \x1b[33m${VERSION} → ${latest}\x1b[0m  updating…\n`);
                 execFileSync("npm", ["i", "-g", `claude-overnight@${latest}`], { stdio: "inherit", timeout: 60000 });

package/dist/{cli.d.ts → cli/cli.d.ts}

@@ -1,10 +1,10 @@
 import type { ModelInfo } from "@anthropic-ai/claude-agent-sdk";
-import type { Task, PermMode, MergeStrategy } from "./types.js";
+import type { Task, MergeStrategy } from "../core/types.js";
 export declare function parseCliFlags(argv: string[]): {
     flags: Record<string, string>;
     positional: string[];
 };
-import { isJWTAuthError } from "./auth.js";
+import { isJWTAuthError } from "../core/auth.js";
 /** @deprecated Use isJWTAuthError from auth.ts instead. */
 export declare const isAuthError: typeof isJWTAuthError;
 export { isJWTAuthError };
@@ -51,7 +51,6 @@ export interface FileArgs {
     objective?: string;
     concurrency?: number;
     model?: string;
-    permissionMode?: PermMode;
     cwd?: string;
     allowedTools?: string[];
     beforeWave?: string | string[];
@@ -68,4 +67,15 @@ export declare function isGitRepo(cwd: string): boolean;
 export declare function validateGitRepo(cwd: string): void;
 export declare function showPlan(tasks: Task[]): void;
 export declare const BRAILLE: readonly ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-export declare function makeProgressLog(): (text: string) => void;
+/** Dual-mode progress renderer.
+ *
+ *  - `status` (default): transient single-line ticker — clears itself each frame.
+ *    Use for elapsed-time / cost / rolling tail of model text.
+ *  - `event`: permanent log line — scrolls up, ticker redraws underneath.
+ *    Use for tool calls and notable state changes.
+ *
+ *  The two modes cooperate: an event clears the current ticker, writes the
+ *  event on its own line, and the next status tick redraws the ticker below.
+ *  That gives the user a visible history of what the planner did, with a live
+ *  "now" indicator that always stays pinned at the bottom. */
+export declare function makeProgressLog(): (text: string, kind?: "status" | "event") => void;

package/dist/{cli.js → cli/cli.js}

@@ -6,7 +6,7 @@ import chalk from "chalk";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 // ── CLI flag parsing ──
 export function parseCliFlags(argv) {
-    const known = new Set(["concurrency", "model", "timeout", "budget", "usage-cap", "extra-usage-budget", "merge", "perm"]);
+    const known = new Set(["concurrency", "model", "timeout", "budget", "usage-cap", "extra-usage-budget", "merge"]);
     const booleans = new Set(["--dry-run", "-h", "--help", "-v", "--version", "--no-flex", "--allow-extra-usage", "--worktrees", "--no-worktrees", "--yolo"]);
     const flags = {};
     const positional = [];
@@ -30,7 +30,7 @@ export function parseCliFlags(argv) {
     return { flags, positional };
 }
 // ── Auth error detection (re-exported from auth module for backward compatibility) ──
-import { isJWTAuthError } from "./auth.js";
+import { isJWTAuthError } from "../core/auth.js";
 /** @deprecated Use isJWTAuthError from auth.ts instead. */
 export const isAuthError = isJWTAuthError;
 export { isJWTAuthError };
@@ -332,7 +332,7 @@ export async function selectKey(label, options) {
     });
 }
 const KNOWN_TASK_FILE_KEYS = new Set([
-    "tasks", "objective", "concurrency", "cwd", "model", "permissionMode", "allowedTools", "beforeWave", "afterWave", "afterRun", "worktrees", "mergeStrategy", "usageCap", "flexiblePlan",
+    "tasks", "objective", "concurrency", "cwd", "model", "allowedTools", "beforeWave", "afterWave", "afterRun", "worktrees", "mergeStrategy", "usageCap", "flexiblePlan",
 ]);
 export function loadTaskFile(file) {
     const path = resolve(file);
@@ -392,7 +392,6 @@ export function loadTaskFile(file) {
         concurrency: parsed.concurrency,
         model: parsed.model,
         cwd: parsed.cwd ? resolve(parsed.cwd) : undefined,
-        permissionMode: parsed.permissionMode,
         allowedTools: parsed.allowedTools,
         beforeWave: parsed.beforeWave,
         afterWave: parsed.afterWave,
@@ -437,13 +436,28 @@ export function showPlan(tasks) {
     console.log(chalk.dim(`  ${"─".repeat(ruleLen)}\n`));
 }
 export const BRAILLE = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/** Dual-mode progress renderer.
+ *
+ *  - `status` (default): transient single-line ticker — clears itself each frame.
+ *    Use for elapsed-time / cost / rolling tail of model text.
+ *  - `event`: permanent log line — scrolls up, ticker redraws underneath.
+ *    Use for tool calls and notable state changes.
+ *
+ *  The two modes cooperate: an event clears the current ticker, writes the
+ *  event on its own line, and the next status tick redraws the ticker below.
+ *  That gives the user a visible history of what the planner did, with a live
+ *  "now" indicator that always stays pinned at the bottom. */
 export function makeProgressLog() {
     let frame = 0;
-    return (text) => {
-        const spin = chalk.cyan(BRAILLE[frame++ % BRAILLE.length]);
+    return (text, kind = "status") => {
         const maxW = (process.stdout.columns ?? 80) - 6;
         const clean = text.replace(/\n/g, " ");
         const line = clean.length > maxW ? clean.slice(0, maxW - 1) + "\u2026" : clean;
+        if (kind === "event") {
+            process.stdout.write(`\x1B[2K\r  ${chalk.cyan("›")} ${chalk.dim(line)}\n`);
+            return;
+        }
+        const spin = chalk.cyan(BRAILLE[frame++ % BRAILLE.length]);
         process.stdout.write(`\x1B[2K\r  ${spin} ${chalk.dim(line)}`);
     };
 }

package/dist/cli/help.d.ts

@@ -0,0 +1,2 @@
+export declare function printVersion(): void;
+export declare function printHelp(): void;

package/dist/cli/help.js

@@ -0,0 +1,44 @@
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+import { VERSION } from "../core/_version.js";
+export function printVersion() {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(readFileSync(join(__dirname, "..", "..", "package.json"), "utf-8"));
+    console.log(`claude-overnight v${pkg.version}`);
+}
+export function printHelp() {
+    console.log(`
+  ${chalk.bold("🌙  claude-overnight")} ${chalk.dim("v" + VERSION + "  -- background lane for your Claude Max plan")}
+  ${chalk.dim("─".repeat(60))}
+
+  ${chalk.cyan("Usage")}
+    claude-overnight                          ${chalk.dim("interactive mode")}
+    claude-overnight tasks.json               ${chalk.dim("task file mode")}
+    claude-overnight "fix auth" "add tests"   ${chalk.dim("inline tasks")}
+
+  ${chalk.cyan("Flags")}
+    -h, --help             Show this help
+    -v, --version          Print version
+    --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("(interactive mode picks planner + worker separately  -- supports 'Other…' for Qwen / OpenRouter / etc.)")}
+    --fast-model=NAME      Fast worker model for quick tasks ${chalk.dim("(optional  -- checked by next wave's workers)")}
+    --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)")}
+    --timeout=SECONDS      Agent inactivity timeout ${chalk.dim("(default: 900s, nudges at timeout, kills at 2×)")}
+    --no-flex              Disable adaptive multi-wave planning ${chalk.dim("(run all tasks in one shot)")}
+    --worktrees            Force worktree isolation on ${chalk.dim("(default: auto-detect git repo)")}
+    --no-worktrees         Disable worktree isolation ${chalk.dim("(all agents work in real cwd)")}
+    --merge=MODE           Merge strategy: yolo or branch ${chalk.dim("(default: yolo)")}
+    --yolo                 Shorthand for --no-worktrees
+    --no-coach             Skip the setup coach ${chalk.dim("(raw objective, no preflight rewrite)")}
+    --coach-model          Re-pick coach model ${chalk.dim("(overrides saved choice)")}
+
+  ${chalk.cyan("Defaults")} ${chalk.dim("(non-interactive)")}
+    model: first available    concurrency: 5    worktrees: auto    merge: yolo
+    `);
+}

package/dist/cli/plan-phase.d.ts

@@ -0,0 +1,38 @@
+import type { ProviderConfig, EnvResolver } from "../providers/index.js";
+import type { Task, MergeStrategy, WaveSummary } from "../core/types.js";
+export interface PlanPhaseInput {
+    objective: string | undefined;
+    noTTY: boolean;
+    flex: boolean;
+    budget: number | undefined;
+    concurrency: number;
+    cwd: string;
+    plannerModel: string;
+    workerModel: string;
+    fastModel: string | undefined;
+    plannerProvider: ProviderConfig | undefined;
+    workerProvider: ProviderConfig | undefined;
+    fastProvider: ProviderConfig | undefined;
+    usageCap: number | undefined;
+    allowExtraUsage: boolean;
+    extraUsageBudget: number | undefined;
+    useWorktrees: boolean;
+    mergeStrategy: MergeStrategy;
+    agentTimeoutMs: number | undefined;
+    runDir: string;
+    designDir: string;
+    previousKnowledge: string;
+    envForModel: EnvResolver;
+    coachedOriginal: string | undefined;
+    coachedAt: number | undefined;
+}
+export interface PlanPhaseResult {
+    tasks: Task[];
+    thinkingHistory?: WaveSummary;
+    thinkingUsed: number;
+    thinkingCost: number;
+    thinkingIn: number;
+    thinkingOut: number;
+    thinkingTools: number;
+}
+export declare function runPlanPhase(input: PlanPhaseInput): Promise<PlanPhaseResult>;

package/dist/cli/plan-phase.js

@@ -0,0 +1,290 @@
+import { readFileSync, readdirSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import chalk from "chalk";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { Swarm } from "../swarm/swarm.js";
+import { identifyThemes, buildThinkingTasks, orchestrate, planTasks, refinePlan } from "../planner/planner.js";
+import { RunDisplay } from "../ui/ui.js";
+import { renderSummary } from "../ui/summary.js";
+import { isCursorProxyProvider } from "../providers/index.js";
+import { readMdDir, saveRunState } from "../state/state.js";
+import { selectKey, ask, showPlan, makeProgressLog, isJWTAuthError } from "./cli.js";
+export async function runPlanPhase(input) {
+    const { objective, noTTY, flex, budget, concurrency, cwd, plannerModel, workerModel, fastModel, plannerProvider, workerProvider, fastProvider, usageCap, allowExtraUsage, extraUsageBudget, useWorktrees, mergeStrategy, agentTimeoutMs, runDir, designDir, previousKnowledge, envForModel, coachedOriginal, coachedAt, } = input;
+    let tasks = [];
+    let thinkingHistory;
+    let thinkingUsed = 0, thinkingCost = 0, thinkingIn = 0, thinkingOut = 0, thinkingTools = 0;
+    // Persist an early planning-phase state so the run is visible to the resume
+    // picker even if orchestrate dies before executeRun gets a chance to run.
+    // Without this, a crashed plan phase leaves no run.json and the run vanishes
+    // from findIncompleteRuns  -- you pay for orchestration and can't see it.
+    if (objective) {
+        try {
+            saveRunState(runDir, {
+                id: runDir.split(/[/\\]/).pop() ?? "",
+                objective, budget: budget ?? 10, remaining: budget ?? 10,
+                workerModel, plannerModel, fastModel,
+                workerProviderId: workerProvider?.id, plannerProviderId: plannerProvider?.id,
+                fastProviderId: fastProvider?.id,
+                concurrency,
+                usageCap, allowExtraUsage, extraUsageBudget,
+                flex, useWorktrees, mergeStrategy,
+                waveNum: 0, currentTasks: [],
+                accCost: 0, accCompleted: 0, accFailed: 0,
+                accIn: 0, accOut: 0, accTools: 0,
+                branches: [],
+                phase: "planning",
+                startedAt: new Date().toISOString(),
+                cwd,
+            });
+        }
+        catch { }
+    }
+    if (noTTY) {
+        console.error(chalk.red("  No tasks provided and stdin is not a TTY."));
+        process.exit(1);
+    }
+    process.stdout.write("\x1B[?25l");
+    const planRestore = () => process.stdout.write("\x1B[?25h");
+    const useThinking = flex && (budget ?? 10) > concurrency * 3;
+    const thinkingCount = useThinking ? Math.min(Math.max(concurrency, Math.ceil((budget ?? 10) * 0.005)), 10) : 0;
+    try {
+        if (useThinking) {
+            // Persist themes as a Markdown doc so a planning-phase crash leaves a
+            // readable record (and a future resume can skip identifyThemes).
+            const saveThemesMd = (list) => {
+                try {
+                    writeFileSync(join(runDir, "themes.md"), `# Themes\n\n**Objective:** ${objective}\n\n${list.map((t, i) => `${i + 1}. ${t}`).join("\n")}\n`, "utf-8");
+                }
+                catch { }
+            };
+            let themes = await identifyThemes(objective, thinkingCount, cwd, plannerModel, makeProgressLog(), "themes");
+            saveThemesMd(themes);
+            process.stdout.write(`\x1B[2K\r  ${chalk.green(`✓ ${themes.length} themes`)}\n\n`);
+            planRestore();
+            let reviewing = true;
+            while (reviewing) {
+                for (let i = 0; i < themes.length; i++)
+                    console.log(chalk.dim(`  ${String(i + 1).padStart(3)}.`) + ` ${themes[i]}`);
+                console.log(chalk.dim(`\n  ${thinkingCount} thinking agents → orchestrate → ${(budget ?? 10) - thinkingCount} execution sessions\n`));
+                const action = await selectKey(`${chalk.white(`${themes.length} themes`)} ${chalk.dim(`· ${thinkingCount} thinking · ${concurrency} concurrent`)}`, [{ key: "r", desc: "un" }, { key: "e", desc: "dit" }, { key: "c", desc: "hat" }, { key: "q", desc: "uit" }]);
+                if (action === "r") {
+                    reviewing = false;
+                    break;
+                }
+                if (action === "e") {
+                    const feedback = await ask(`\n  ${chalk.bold("What should change?")}\n  ${chalk.cyan(">")} `);
+                    if (!feedback)
+                        continue;
+                    process.stdout.write("\x1B[?25l");
+                    try {
+                        themes = await identifyThemes(`${objective}\n\nUser feedback: ${feedback}`, thinkingCount, cwd, plannerModel, makeProgressLog(), "themes-refine");
+                        saveThemesMd(themes);
+                        process.stdout.write(`\x1B[2K\r  ${chalk.green(`✓ ${themes.length} themes`)}\n\n`);
+                    }
+                    catch (err) {
+                        console.error(chalk.red(`\n  Re-planning failed: ${err.message}\n`));
+                    }
+                    planRestore();
+                }
+                else if (action === "c") {
+                    const question = await ask(`\n  ${chalk.bold("Ask about the themes:")}\n  ${chalk.cyan(">")} `);
+                    if (!question)
+                        continue;
+                    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: "bypassPermissions", allowDangerouslySkipPermissions: true, persistSession: false, ...(plannerEnv && { env: plannerEnv }) },
+                        })) {
+                            if (msg.type === "result" && msg.subtype === "success")
+                                answer = msg.result || "";
+                        }
+                        planRestore();
+                        if (answer)
+                            console.log(chalk.dim(`\n  ${answer.slice(0, 500)}\n`));
+                    }
+                    catch {
+                        planRestore();
+                    }
+                }
+                else {
+                    console.log(chalk.dim("\n  Aborted.\n"));
+                    process.exit(0);
+                }
+            }
+            process.stdout.write("\x1B[?25l");
+            mkdirSync(designDir, { recursive: true });
+            const existingDesigns = readMdDir(designDir);
+            if (existingDesigns) {
+                const designFiles = readdirSync(designDir).filter(f => f.endsWith(".md")).sort();
+                console.log(chalk.green(`\n  ✓ Reusing ${designFiles.length} design docs`) + chalk.dim(` (from prior attempt)`));
+                for (const f of designFiles) {
+                    try {
+                        const firstLine = readFileSync(join(designDir, f), "utf-8").split("\n")[0].replace(/^#+\s*/, "").trim();
+                        if (firstLine)
+                            console.log(chalk.dim(`    ${firstLine.slice(0, 80)}`));
+                    }
+                    catch { }
+                }
+                console.log("");
+            }
+            else {
+                const researchModel = fastModel ? workerModel : plannerModel;
+                const thinkingTasks = buildThinkingTasks(objective, themes, designDir, researchModel, previousKnowledge || undefined);
+                console.log(chalk.cyan(`\n  ◆ Thinking: ${thinkingTasks.length} agents exploring...\n`));
+                const thinkingSwarm = new Swarm({
+                    tasks: thinkingTasks, concurrency, cwd, model: researchModel,
+                    useWorktrees: false, mergeStrategy: "yolo", agentTimeoutMs, usageCap, allowExtraUsage, extraUsageBudget,
+                    envForModel,
+                    cursorProxy: [plannerProvider, workerProvider, fastProvider].some(p => p && isCursorProxyProvider(p)),
+                });
+                const thinkRunInfo = { accIn: 0, accOut: 0, accCost: 0, accCompleted: 0, accFailed: 0, sessionsBudget: budget ?? 10, waveNum: -1, remaining: budget ?? 10, model: researchModel, startedAt: Date.now() };
+                const thinkDisplay = new RunDisplay(thinkRunInfo, { remaining: 0, usageCap, concurrency, paused: false, dirty: false });
+                thinkDisplay.setWave(thinkingSwarm);
+                thinkDisplay.start();
+                // Save thinking-wave state on every exit path (normal, abort, double-q).
+                const saveThinkingState = () => {
+                    thinkingUsed = thinkingSwarm.completed + thinkingSwarm.failed;
+                    thinkingCost = thinkingSwarm.totalCostUsd;
+                    thinkingIn = thinkingSwarm.totalInputTokens;
+                    thinkingOut = thinkingSwarm.totalOutputTokens;
+                    thinkingTools = thinkingSwarm.agents.reduce((sum, a) => sum + a.toolCalls, 0);
+                    try {
+                        saveRunState(runDir, {
+                            id: runDir.split(/[/\\]/).pop() ?? "",
+                            objective: objective, budget: budget ?? 10, remaining: (budget ?? 10) - thinkingUsed,
+                            workerModel, plannerModel, fastModel,
+                            workerProviderId: workerProvider?.id, plannerProviderId: plannerProvider?.id,
+                            fastProviderId: fastProvider?.id,
+                            concurrency,
+                            usageCap, allowExtraUsage, extraUsageBudget,
+                            flex, useWorktrees, mergeStrategy,
+                            waveNum: 0, currentTasks: [],
+                            accCost: thinkingCost, accCompleted: thinkingUsed, accFailed: 0,
+                            accIn: thinkingIn, accOut: thinkingOut, accTools: thinkingTools,
+                            branches: [],
+                            phase: "planning",
+                            startedAt: new Date().toISOString(),
+                            cwd,
+                            coachedObjective: coachedOriginal,
+                            coachedAt,
+                        });
+                    }
+                    catch { }
+                };
+                // Catch double-q / hard exit during thinking wave
+                const exitHandler = () => { try {
+                    saveThinkingState();
+                }
+                catch { } };
+                process.on("exit", exitHandler);
+                try {
+                    await thinkingSwarm.run();
+                }
+                finally {
+                    thinkDisplay.pause();
+                    console.log(renderSummary(thinkingSwarm));
+                    thinkDisplay.stop();
+                    saveThinkingState();
+                    process.removeListener("exit", exitHandler);
+                }
+                thinkingHistory = { wave: -1, tasks: thinkingSwarm.agents.map(a => ({ prompt: a.task.prompt.slice(0, 200), status: a.status, filesChanged: a.filesChanged, error: a.error })) };
+                if (thinkingSwarm.rateLimitResetsAt) {
+                    const waitMs = thinkingSwarm.rateLimitResetsAt - Date.now();
+                    if (waitMs > 0) {
+                        console.log(chalk.dim(`  Waiting ${Math.ceil(waitMs / 1000)}s for rate limit reset...`));
+                        await new Promise(r => setTimeout(r, waitMs + 2000));
+                    }
+                }
+            }
+            const designs = readMdDir(designDir);
+            const taskFile = join(runDir, "tasks.json");
+            if (designs) {
+                const orchBudget = Math.min(50, Math.max(concurrency, Math.ceil(((budget ?? 10) - thinkingUsed) * 0.5)));
+                const flexNote = `This is wave 1 of an adaptive multi-wave run (total budget: ${(budget ?? 10) - thinkingUsed}). Plan the highest-impact foundational work first. Future waves will iterate based on what's learned.`;
+                console.log(chalk.cyan(`\n  ◆ Orchestrating plan...\n`));
+                tasks = await orchestrate(objective, designs, cwd, plannerModel, workerModel, orchBudget, concurrency, makeProgressLog(), flexNote, taskFile);
+                process.stdout.write(`\x1B[2K\r  ${chalk.green(`✓ ${tasks.length} tasks`)}\n\n`);
+            }
+            else {
+                console.log(chalk.yellow(`\n  No design docs  -- falling back to direct planning\n`));
+                const waveBudget = Math.min(50, Math.max(concurrency, Math.ceil(((budget ?? 10) - thinkingUsed) * 0.5)));
+                tasks = await planTasks(objective, cwd, plannerModel, workerModel, waveBudget, concurrency, makeProgressLog(), undefined, taskFile);
+                process.stdout.write(`\x1B[2K\r  ${chalk.green(`✓ ${tasks.length} tasks`)}\n\n`);
+            }
+        }
+        else {
+            const waveBudget = flex ? Math.min(50, Math.max(concurrency, Math.ceil((budget ?? 10) * 0.5))) : budget;
+            const flexNote = flex ? `This is wave 1 of an adaptive multi-wave run (total budget: ${budget}). Plan the highest-impact foundational work first. Future waves will iterate, polish, and expand based on what's learned.` : undefined;
+            console.log(chalk.cyan(`\n  ◆ Planning${flex ? " wave 1" : ""}...\n`));
+            tasks = await planTasks(objective, cwd, plannerModel, workerModel, waveBudget, concurrency, makeProgressLog(), flexNote);
+            process.stdout.write(`\x1B[2K\r  ${chalk.green(`✓ ${tasks.length} tasks`)}${flex ? chalk.dim(` · wave 1`) : ""}\n\n`);
+            planRestore();
+            let reviewing = true;
+            while (reviewing) {
+                showPlan(tasks);
+                const action = await selectKey(`${chalk.white(`${tasks.length} tasks`)} ${chalk.dim(`· ${concurrency} concurrent`)}`, [{ key: "r", desc: "un" }, { key: "e", desc: "dit" }, { key: "c", desc: "hat" }, { key: "q", desc: "uit" }]);
+                switch (action) {
+                    case "r":
+                        reviewing = false;
+                        break;
+                    case "e": {
+                        const feedback = await ask(`\n  ${chalk.bold("What should change?")}\n  ${chalk.cyan(">")} `);
+                        if (!feedback)
+                            break;
+                        console.log(chalk.cyan("\n  ◆ Re-planning...\n"));
+                        process.stdout.write("\x1B[?25l");
+                        try {
+                            tasks = await refinePlan(objective, tasks, feedback, cwd, plannerModel, workerModel, budget, concurrency, makeProgressLog());
+                            process.stdout.write(`\x1B[2K\r  ${chalk.green(`✓ ${tasks.length} tasks`)}\n\n`);
+                        }
+                        catch (err) {
+                            console.error(chalk.red(`\n  Re-planning failed: ${err.message}\n`));
+                        }
+                        planRestore();
+                        break;
+                    }
+                    case "c": {
+                        const question = await ask(`\n  ${chalk.bold("Ask about the plan:")}\n  ${chalk.cyan(">")} `);
+                        if (!question)
+                            break;
+                        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: "bypassPermissions", allowDangerouslySkipPermissions: true, persistSession: false, ...(plannerEnv && { env: plannerEnv }) },
+                            })) {
+                                if (msg.type === "result" && msg.subtype === "success")
+                                    answer = msg.result || "";
+                            }
+                            planRestore();
+                            if (answer)
+                                console.log(chalk.dim(`\n  ${answer.slice(0, 500)}\n`));
+                        }
+                        catch {
+                            planRestore();
+                        }
+                        break;
+                    }
+                    case "q":
+                        console.log(chalk.dim("\n  Aborted.\n"));
+                        process.exit(0);
+                }
+            }
+        }
+    }
+    catch (err) {
+        planRestore();
+        if (isJWTAuthError(err))
+            console.error(chalk.red(`\n  Authentication failed  -- check your API key or run: claude auth\n`));
+        else
+            console.error(chalk.red(`\n  Planning failed: ${err.message}\n`));
+        process.exit(1);
+    }
+    return { tasks, thinkingHistory, thinkingUsed, thinkingCost, thinkingIn, thinkingOut, thinkingTools };
+}

package/dist/cli/preflight.d.ts

@@ -0,0 +1,15 @@
+import type { ProviderConfig } from "../providers/index.js";
+export interface PreflightInput {
+    plannerModel: string;
+    plannerProvider?: ProviderConfig | undefined;
+    workerModel: string;
+    workerProvider?: ProviderConfig | undefined;
+    fastModel?: string | undefined;
+    fastProvider?: ProviderConfig | undefined;
+    cwd: string;
+}
+export interface PreflightResult {
+    /** true when the fast provider failed preflight and the caller should drop it */
+    fastDegraded: boolean;
+}
+export declare function runProviderPreflight(input: PreflightInput): Promise<PreflightResult>;

package/dist/cli/preflight.js

@@ -0,0 +1,139 @@
+import chalk from "chalk";
+import { getProxyPort, buildProxyUrl } from "../core/proxy-port.js";
+import { setPlannerEnvResolver } from "../planner/query.js";
+import { preflightProvider, isCursorProxyProvider, readCursorProxyLogTail, ensureCursorProxyRunning, bundledComposerProxyShellCommand, hasCursorAgentToken, PROXY_DEFAULT_URL, buildEnvResolver, } from "../providers/index.js";
+export async function runProviderPreflight(input) {
+    const { plannerModel, plannerProvider, workerModel, workerProvider, fastProvider, cwd } = input;
+    const seen = new Set();
+    const all = [
+        ["planner", plannerProvider],
+        ["worker", workerProvider],
+        ["fast", fastProvider],
+    ];
+    const pending = [];
+    const cursorProxies = [];
+    for (const [role, p] of all) {
+        if (p && !seen.has(p.id)) {
+            seen.add(p.id);
+            pending.push([role, p]);
+            if (isCursorProxyProvider(p))
+                cursorProxies.push(p);
+        }
+    }
+    // Auto-start cursor proxy before pinging (restarts when a token exists so stale listeners get CURSOR_API_KEY).
+    if (cursorProxies.length > 0) {
+        const resolvedPort = getProxyPort(cwd);
+        const resolvedUrl = buildProxyUrl(resolvedPort);
+        await ensureCursorProxyRunning(resolvedUrl);
+        // Sync providers to the resolved port (may differ from default if per-project port was picked)
+        for (const p of cursorProxies) {
+            if (!p.baseURL || p.baseURL === PROXY_DEFAULT_URL) {
+                p.baseURL = resolvedUrl;
+            }
+        }
+        if (resolvedUrl !== PROXY_DEFAULT_URL) {
+            console.log(chalk.dim(`  Proxy port: ${resolvedPort}`));
+        }
+        if (!hasCursorAgentToken()) {
+            console.error(chalk.red(`  ✗ Cursor models require a User API key — add it via ${chalk.bold("Cursor…")} setup, or set ` +
+                `${chalk.bold("CURSOR_API_KEY")} / ${chalk.bold("CURSOR_BRIDGE_API_KEY")}, or ${chalk.bold("cursorApiKey")} in providers.json.`));
+            console.error(chalk.dim(`    Without it the Cursor CLI falls back to macOS Keychain (\`cursor-user\`).`));
+            process.exit(1);
+        }
+    }
+    process.stdout.write(`  ${chalk.dim(`◆ Pinging ${pending.map(([r, p]) => `${r} (${p.displayName})`).join(", ")}…`)}\n`);
+    // Preflight strategy: all providers run fully in parallel. Cursor proxy
+    // providers used to race on the shared `~/.cursor/cli-config.json`, but the
+    // proxy now uses an account pool (`CURSOR_CONFIG_DIRS`) — each parallel
+    // cursor-agent subprocess gets its own config dir, eliminating the race.
+    // See ensureCursorAccountPool() in providers.ts.
+    //
+    // Single in-place status line collapses N parallel progress streams (one
+    // per provider) into one tty line updated via `\r` + ANSI clear. Keeps the
+    // "window head" calm instead of appending 3 lines per 3s tick.
+    const statuses = new Map();
+    const isTTY = process.stdout.isTTY;
+    let statusLineActive = false;
+    const renderStatus = () => {
+        if (!isTTY)
+            return;
+        const parts = [...statuses.entries()].map(([r, s]) => `${r} ${chalk.dim(s)}`);
+        process.stdout.write(`\x1B[2K\r`);
+        if (parts.length === 0) {
+            statusLineActive = false;
+            return;
+        }
+        process.stdout.write(chalk.dim("    " + parts.join("  ·  ")));
+        statusLineActive = true;
+    };
+    const clearStatusLine = () => {
+        if (isTTY && statusLineActive) {
+            process.stdout.write(`\x1B[2K\r`);
+            statusLineActive = false;
+        }
+    };
+    /** Cursor agent cold start + thinking-variant model latency can exceed 20s, and the cursor
+     *  preflight now also runs a write-capability probe (see probeCursorWriteCapability) that
+     *  asks cursor to Bash a marker file — so the total budget must cover auth ping + write turn. */
+    const preflightMs = (p) => isCursorProxyProvider(p) ? 90_000 : 20_000;
+    // Cursor's composer-2 pipeline intermittently stalls for 100s+ on a write-tool turn
+    // even though the tool succeeded (proxy logs it as "SLOW response"). A single retry
+    // almost always clears it — so we retry once on timeout-style failures for cursor
+    // proxy providers before giving up.
+    const isTimeoutError = (err) => /^timeout after /.test(err) || /: timeout after /.test(err);
+    const runPreflight = async (role, p) => {
+        statuses.set(role, "connecting…");
+        renderStatus();
+        let result = await preflightProvider(p, cwd, preflightMs(p), {
+            onProgress: (msg) => { statuses.set(role, msg); renderStatus(); },
+        });
+        if (!result.ok && isCursorProxyProvider(p) && isTimeoutError(result.error)) {
+            statuses.set(role, "retrying after timeout…");
+            renderStatus();
+            result = await preflightProvider(p, cwd, preflightMs(p), {
+                onProgress: (msg) => { statuses.set(role, `retry: ${msg}`); renderStatus(); },
+            });
+        }
+        statuses.delete(role);
+        renderStatus();
+        return { role, provider: p, result };
+    };
+    const results = await Promise.all(pending.map(([role, p]) => runPreflight(role, p)));
+    clearStatusLine();
+    let fastDegraded = false;
+    for (const { role, provider, result } of results) {
+        if (!result.ok) {
+            const degradable = role === "fast";
+            const prefix = degradable ? chalk.yellow(`  ⚠ ${role} preflight failed`) : chalk.red(`  ✗ ${role} preflight failed`);
+            console.error(`${prefix}: ${chalk.dim(result.error)}`);
+            if (isCursorProxyProvider(provider)) {
+                const tail = readCursorProxyLogTail(25);
+                if (tail) {
+                    console.error(chalk.yellow(`  ── proxy log tail (agent stderr + sessions) ──`));
+                    for (const line of tail.split("\n"))
+                        console.error(chalk.dim(`    ${line}`));
+                }
+                const cmd = bundledComposerProxyShellCommand();
+                const proxyUrl = provider.baseURL || PROXY_DEFAULT_URL;
+                console.error(chalk.yellow(`  The proxy at ${proxyUrl} may have crashed or timed out (e.g. keychain/UI). Retry, or start the bundled proxy: ${cmd ?? "npm install in the claude-overnight package, then re-run"}`));
+            }
+            else if (!degradable) {
+                console.error(chalk.red(`  Fix the provider at ~/.claude/claude-overnight/providers.json and retry.`));
+            }
+            if (degradable) {
+                console.error(chalk.yellow(`  Continuing without the fast worker — fast-eligible tasks will run on the main worker model instead.`));
+                console.error("");
+                fastDegraded = true;
+                continue;
+            }
+            console.error("");
+            process.exit(1);
+        }
+        console.log(`  ${chalk.green(`✓ ${role} ready`)} ${chalk.dim(`· ${provider.displayName} · ${provider.model}`)}`);
+    }
+    if (fastDegraded) {
+        const rebuilt = buildEnvResolver({ plannerModel, plannerProvider, workerModel, workerProvider, fastModel: undefined, fastProvider: undefined });
+        setPlannerEnvResolver(rebuilt);
+    }
+    return { fastDegraded };
+}