claude-overnight 1.12.0 → 1.13.1

package/dist/run.js

@@ -8,7 +8,7 @@ import { getTotalPlannerCost, getPlannerRateLimitInfo, runPlannerQuery } from ".
 import { RunDisplay } from "./ui.js";
 import { renderSummary } from "./render.js";
 import { fmtTokens } from "./render.js";
-import { isAuthError } from "./cli.js";
+import { isAuthError, selectKey, ask } from "./cli.js";
 import { readRunMemory, writeStatus, writeGoalUpdate, saveRunState, saveWaveSession, loadWaveHistory, recordBranches, archiveMilestone, writeSteerInbox, consumeSteerInbox, countSteerInbox, appendOvernightLogStart, updateOvernightLogEnd, } from "./state.js";
 export async function executeRun(cfg) {
     const restore = () => { try {
@@ -31,6 +31,7 @@ export async function executeRun(cfg) {
     let accCost, accCompleted, accFailed, accTools;
     let accIn = 0, accOut = 0;
     let lastCapped = false, lastAborted = false, objectiveComplete = false, lastHealed = false;
+    let lastEstimate;
     const branches = [];
     if (cfg.resuming && cfg.resumeState) {
         const rs = cfg.resumeState;
@@ -216,6 +217,8 @@ export async function executeRun(cfg) {
                     writeStatus(runDir, steer.statusUpdate);
                 if (steer.goalUpdate)
                     writeGoalUpdate(runDir, steer.goalUpdate);
+                if (typeof steer.estimatedSessionsRemaining === "number")
+                    lastEstimate = steer.estimatedSessionsRemaining;
                 const steerDir = join(runDir, "steering");
                 mkdirSync(steerDir, { recursive: true });
                 writeFileSync(join(steerDir, `wave-${waveNum}-attempt-${steerAttempts}.json`), JSON.stringify({
@@ -283,93 +286,127 @@ export async function executeRun(cfg) {
     if (!display.runInfo.startedAt)
         display.runInfo.startedAt = cfg.runStartedAt;
     display.start();
-    // ── Main wave loop ──
-    while (remaining > 0 && currentTasks.length > 0 && !stopping) {
-        if (!lastHealed) {
-            const healTask = checkProjectHealth(cwd);
-            if (healTask && remaining > 0) {
-                lastHealed = true;
-                currentTasks = [healTask];
+    // ── Main wave loop (wrapped so exhaustion can prompt for an extension) ──
+    let runAnotherRound = true;
+    while (runAnotherRound) {
+        runAnotherRound = false;
+        while (remaining > 0 && currentTasks.length > 0 && !stopping) {
+            if (!lastHealed) {
+                const healTask = checkProjectHealth(cwd);
+                if (healTask && remaining > 0) {
+                    lastHealed = true;
+                    currentTasks = [healTask];
+                }
             }
+            else {
+                lastHealed = false;
+            }
+            if (currentTasks.length > remaining)
+                currentTasks = currentTasks.slice(0, remaining);
+            syncRunInfo();
+            const swarm = new Swarm({
+                tasks: currentTasks, concurrency, cwd, model: workerModel, permissionMode, allowedTools,
+                useWorktrees, mergeStrategy: waveMerge, agentTimeoutMs: cfg.agentTimeoutMs,
+                usageCap, allowExtraUsage: cfg.allowExtraUsage, extraUsageBudget: cfg.extraUsageBudget,
+                baseCostUsd: accCost,
+            });
+            currentSwarm = swarm;
+            display.setWave(swarm);
+            display.resume();
+            try {
+                await swarm.run();
+            }
+            catch (err) {
+                if (isAuthError(err)) {
+                    display.stop();
+                    restore();
+                    console.error(chalk.red(`\n  Authentication failed — check your API key or run: claude auth\n`));
+                    process.exit(1);
+                }
+                throw err;
+            }
+            display.pause();
+            console.log(renderSummary(swarm));
+            accCost += swarm.totalCostUsd;
+            accIn += swarm.totalInputTokens;
+            accOut += swarm.totalOutputTokens;
+            accCompleted += swarm.completed;
+            accFailed += swarm.failed;
+            accTools += swarm.agents.reduce((sum, a) => sum + a.toolCalls, 0);
+            remaining = Math.max(0, remaining - swarm.completed - swarm.failed);
+            const totalConsumed = accCompleted + accFailed + cfg.thinkingUsed;
+            const expectedFloor = Math.max(0, cfg.budget - totalConsumed);
+            if (remaining < expectedFloor)
+                remaining = expectedFloor;
+            if (liveConfig.dirty) {
+                remaining = liveConfig.remaining;
+                usageCap = liveConfig.usageCap;
+                liveConfig.dirty = false;
+            }
+            liveConfig.remaining = remaining;
+            lastCapped = swarm.cappedOut;
+            lastAborted = swarm.aborted;
+            recordBranches(swarm.agents, swarm.mergeResults, branches);
+            saveWaveSession(runDir, waveNum, swarm.agents, swarm.totalCostUsd);
+            // Tasks that never made it into the swarm (queue cleared on abort/cap)
+            // are preserved as currentTasks so resume picks them up. Budget for these
+            // wasn't decremented (only attempted agents were), so no refund needed.
+            const attemptedPrompts = new Set(swarm.agents.map(a => a.task.prompt));
+            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,
+                usageCap, allowExtraUsage: cfg.allowExtraUsage, extraUsageBudget: cfg.extraUsageBudget,
+                flex, useWorktrees, mergeStrategy, waveNum, currentTasks: neverStarted,
+                accCost, accCompleted, accFailed, accIn, accOut, accTools,
+                branches, phase: "steering", startedAt: new Date(cfg.runStartedAt).toISOString(), cwd,
+            });
+            waveHistory.push({
+                wave: waveNum,
+                tasks: swarm.agents.map(a => ({ prompt: a.task.prompt, status: a.status, filesChanged: a.filesChanged, error: a.error })),
+            });
+            if (!flex || remaining <= 0 || swarm.aborted || swarm.cappedOut)
+                break;
+            syncRunInfo();
+            display.setSteering(rlGetter, buildSteeringContext());
+            display.resume();
+            const steered = await runSteering();
+            if (!steered)
+                break;
+            waveNum++;
         }
-        else {
-            lastHealed = false;
-        }
-        if (currentTasks.length > remaining)
-            currentTasks = currentTasks.slice(0, remaining);
-        syncRunInfo();
-        const swarm = new Swarm({
-            tasks: currentTasks, concurrency, cwd, model: workerModel, permissionMode, allowedTools,
-            useWorktrees, mergeStrategy: waveMerge, agentTimeoutMs: cfg.agentTimeoutMs,
-            usageCap, allowExtraUsage: cfg.allowExtraUsage, extraUsageBudget: cfg.extraUsageBudget,
-            baseCostUsd: accCost,
-        });
-        currentSwarm = swarm;
-        display.setWave(swarm);
-        display.resume();
-        try {
-            await swarm.run();
-        }
-        catch (err) {
-            if (isAuthError(err)) {
+        display.stop();
+        // ── Budget-exhausted: offer to extend with the same settings ──
+        const exhaustedByBudget = !objectiveComplete && !stopping && !lastAborted && !lastCapped &&
+            remaining <= 0 && !!process.stdin.isTTY;
+        if (exhaustedByBudget) {
+            const ext = await promptBudgetExtension({
+                estimate: lastEstimate,
+                spent: accCost,
+                sessionsUsed: accCompleted + accFailed + cfg.thinkingUsed,
+                budget: cfg.budget,
+            });
+            if (ext > 0) {
+                remaining = ext;
+                cfg.budget += ext;
+                lastCapped = false;
+                lastAborted = false;
+                runInfoRef.sessionsBudget = cfg.budget;
+                runInfoRef.remaining = remaining;
+                liveConfig.remaining = remaining;
+                liveConfig.usageCap = usageCap;
+                display.setSteering(rlGetter, buildSteeringContext());
+                display.start();
+                const steered = await runSteering();
+                if (steered) {
+                    waveNum++;
+                    runAnotherRound = true;
+                    continue;
+                }
                 display.stop();
-                restore();
-                console.error(chalk.red(`\n  Authentication failed — check your API key or run: claude auth\n`));
-                process.exit(1);
             }
-            throw err;
         }
-        display.pause();
-        console.log(renderSummary(swarm));
-        accCost += swarm.totalCostUsd;
-        accIn += swarm.totalInputTokens;
-        accOut += swarm.totalOutputTokens;
-        accCompleted += swarm.completed;
-        accFailed += swarm.failed;
-        accTools += swarm.agents.reduce((sum, a) => sum + a.toolCalls, 0);
-        remaining = Math.max(0, remaining - swarm.completed - swarm.failed);
-        const totalConsumed = accCompleted + accFailed + cfg.thinkingUsed;
-        const expectedFloor = Math.max(0, cfg.budget - totalConsumed);
-        if (remaining < expectedFloor)
-            remaining = expectedFloor;
-        if (liveConfig.dirty) {
-            remaining = liveConfig.remaining;
-            usageCap = liveConfig.usageCap;
-            liveConfig.dirty = false;
-        }
-        liveConfig.remaining = remaining;
-        lastCapped = swarm.cappedOut;
-        lastAborted = swarm.aborted;
-        recordBranches(swarm.agents, swarm.mergeResults, branches);
-        saveWaveSession(runDir, waveNum, swarm.agents, swarm.totalCostUsd);
-        // Tasks that never made it into the swarm (queue cleared on abort/cap)
-        // are preserved as currentTasks so resume picks them up. Budget for these
-        // wasn't decremented (only attempted agents were), so no refund needed.
-        const attemptedPrompts = new Set(swarm.agents.map(a => a.task.prompt));
-        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,
-            usageCap, allowExtraUsage: cfg.allowExtraUsage, extraUsageBudget: cfg.extraUsageBudget,
-            flex, useWorktrees, mergeStrategy, waveNum, currentTasks: neverStarted,
-            accCost, accCompleted, accFailed, accIn, accOut, accTools,
-            branches, phase: "steering", startedAt: new Date(cfg.runStartedAt).toISOString(), cwd,
-        });
-        waveHistory.push({
-            wave: waveNum,
-            tasks: swarm.agents.map(a => ({ prompt: a.task.prompt, status: a.status, filesChanged: a.filesChanged, error: a.error })),
-        });
-        if (!flex || remaining <= 0 || swarm.aborted || swarm.cappedOut)
-            break;
-        syncRunInfo();
-        display.setSteering(rlGetter, buildSteeringContext());
-        display.resume();
-        const steered = await runSteering();
-        if (!steered)
-            break;
-        waveNum++;
-    }
-    display.stop();
+    } // end outer extension loop
     // ── Finalize ──
     const trulyDone = objectiveComplete || (!flex && remaining <= 0);
     const wasCapped = lastCapped || lastAborted;
@@ -479,6 +516,37 @@ export async function executeRun(cfg) {
     if (lastAborted || accCompleted === 0)
         process.exit(2);
 }
+async function promptBudgetExtension(ctx) {
+    const avg = ctx.sessionsUsed > 0 ? ctx.spent / ctx.sessionsUsed : 0;
+    const base = ctx.estimate && ctx.estimate > 0
+        ? ctx.estimate
+        : Math.max(10, Math.round(ctx.budget * 0.2));
+    // Wiggle room: 30% buffer, minimum 10, rounded up to a nearest-5.
+    const withBuffer = Math.max(10, Math.ceil(base * 1.3));
+    const suggested = Math.ceil(withBuffer / 5) * 5;
+    const estCost = avg > 0 ? ` · ~$${(suggested * avg).toFixed(2)}` : "";
+    const estLine = ctx.estimate != null
+        ? chalk.dim(`  Planner estimate: ${ctx.estimate} sessions to complete${avg > 0 ? ` (~$${(ctx.estimate * avg).toFixed(2)} at $${avg.toFixed(2)}/session)` : ""}`)
+        : chalk.dim(`  No planner estimate available — using default${avg > 0 ? ` (~$${avg.toFixed(2)}/session)` : ""}`);
+    console.log("");
+    console.log(chalk.yellow(`  Budget exhausted — run not yet complete.`));
+    console.log(estLine);
+    console.log(chalk.dim(`  Continue with ${chalk.bold.white(String(suggested))} more sessions${estCost}? Everything stays the same — just hit enter.`));
+    const action = await selectKey("", [
+        { key: "y", desc: "es (↵)" },
+        { key: "c", desc: "ustom" },
+        { key: "n", desc: "o — stop here" },
+    ]);
+    if (action === "y")
+        return suggested;
+    if (action === "n")
+        return 0;
+    const custom = await ask(`  How many more sessions? ${chalk.dim(`[${suggested}]: `)}`);
+    const n = parseInt(custom);
+    if (isNaN(n) || n <= 0)
+        return suggested;
+    return n;
+}
 function checkProjectHealth(cwd) {
     let pkg;
     try {

package/dist/steering.js

@@ -9,6 +9,7 @@ const STEER_SCHEMA = {
             reasoning: { type: "string" },
             statusUpdate: { type: "string" },
             goalUpdate: { type: "string" },
+            estimatedSessionsRemaining: { type: "number" },
             tasks: {
                 type: "array",
                 items: {
@@ -18,7 +19,7 @@ const STEER_SCHEMA = {
                 },
             },
         },
-        required: ["done", "tasks", "reasoning", "statusUpdate"],
+        required: ["done", "tasks", "reasoning", "statusUpdate", "estimatedSessionsRemaining"],
     },
 };
 export async function steerWave(objective, history, remainingBudget, cwd, plannerModel, workerModel, permissionMode, concurrency, onLog, runMemory) {
@@ -96,6 +97,7 @@ Respond with ONLY a JSON object (no markdown fences):
   "reasoning": "your assessment and why you chose this wave composition",
   "goalUpdate": "optional — refine what 'amazing' means as you learn more",
   "statusUpdate": "REQUIRED — concise project status: what's built, what works, what's rough, quality level, key gaps. This replaces the previous status.",
+  "estimatedSessionsRemaining": 15,
   "tasks": [
     {"prompt": "task instruction...", "model": "worker"},
     {"prompt": "review task...", "model": "planner"},
@@ -103,10 +105,12 @@ Respond with ONLY a JSON object (no markdown fences):
   ]
 }
 
+"estimatedSessionsRemaining" is REQUIRED. Your best honest estimate of how many MORE agent sessions (beyond the wave you just composed above) are needed to reach 'amazing' — include follow-up fixes, polish, verification, and anything else you'd want before shipping. Be realistic, not optimistic. Use 0 only if truly done.
+
 The "model" field on each task: use "worker" (${workerModel}) for implementation tasks, "planner" (${plannerModel}) for review/analysis/verification tasks. Default is "worker".
 Set "noWorktree": true for verify/user-test tasks — they need the real project directory with env files, dependencies, and local config.
 
-If done: {"done": true, "reasoning": "...", "statusUpdate": "...", "tasks": []}`;
+If done: {"done": true, "reasoning": "...", "statusUpdate": "...", "estimatedSessionsRemaining": 0, "tasks": []}`;
     onLog("Assessing...", "status");
     onLog(`Reading codebase — wave ${history.length + 1}`, "event");
     const resultText = await runPlannerQuery(prompt, { cwd, model: plannerModel, permissionMode, outputFormat: STEER_SCHEMA }, onLog);
@@ -124,8 +128,10 @@ If done: {"done": true, "reasoning": "...", "statusUpdate": "...", "tasks": []}`
     })();
     const isDone = parsed.done === true;
     const statusUpdate = parsed.statusUpdate || undefined;
+    const estRaw = parsed.estimatedSessionsRemaining;
+    const estimatedSessionsRemaining = typeof estRaw === "number" && estRaw >= 0 ? Math.round(estRaw) : undefined;
     if (isDone) {
-        return { done: true, tasks: [], reasoning: parsed.reasoning || "Objective complete", goalUpdate: parsed.goalUpdate, statusUpdate };
+        return { done: true, tasks: [], reasoning: parsed.reasoning || "Objective complete", goalUpdate: parsed.goalUpdate, statusUpdate, estimatedSessionsRemaining: estimatedSessionsRemaining ?? 0 };
     }
     let tasks = (parsed.tasks || []).map((t, i) => ({
         id: String(i),
@@ -134,5 +140,5 @@ If done: {"done": true, "reasoning": "...", "statusUpdate": "...", "tasks": []}`
         ...(t.noWorktree && { noWorktree: true }),
     }));
     tasks = postProcess(tasks, remainingBudget, onLog);
-    return { done: tasks.length === 0, tasks, reasoning: parsed.reasoning || "", goalUpdate: parsed.goalUpdate, statusUpdate };
+    return { done: tasks.length === 0, tasks, reasoning: parsed.reasoning || "", goalUpdate: parsed.goalUpdate, statusUpdate, estimatedSessionsRemaining };
 }

package/dist/types.d.ts

@@ -138,6 +138,7 @@ export interface SteerResult {
     reasoning: string;
     goalUpdate?: string;
     statusUpdate?: string;
+    estimatedSessionsRemaining?: number;
 }
 /** Accumulated run memory — designs, verifications, etc. — fed to the steerer. */
 export interface RunMemory {

package/package.json

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