claude-overnight 1.6.0 → 1.7.1

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { readFileSync, existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "fs";
+import { readFileSync, existsSync, mkdirSync, readdirSync, rmSync, writeFileSync, symlinkSync, unlinkSync } from "fs";
 import { resolve, dirname, join } from "path";
 import { fileURLToPath } from "url";
 import { execSync } from "child_process";
@@ -7,8 +7,8 @@ import { createInterface } from "readline";
 import chalk from "chalk";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { Swarm } from "./swarm.js";
-import { planTasks, refinePlan, detectModelTier, steerWave, identifyThemes, buildThinkingTasks, orchestrate } from "./planner.js";
-import { startRenderLoop, renderSummary } from "./ui.js";
+import { planTasks, refinePlan, detectModelTier, steerWave, identifyThemes, buildThinkingTasks, orchestrate, getTotalPlannerCost, getPlannerRateLimitInfo } from "./planner.js";
+import { RunDisplay, renderSummary } from "./ui.js";
 // ── CLI flag parsing ──
 function parseCliFlags(argv) {
     const known = new Set(["concurrency", "model", "timeout", "budget", "usage-cap", "extra-usage-budget"]);
@@ -317,19 +317,23 @@ function loadRunState(runDir) {
         return null;
     }
 }
-/** Find the latest incomplete run, or null. */
-function findIncompleteRun(rootDir) {
+/** Find all incomplete runs for a given working directory, newest first. */
+function findIncompleteRuns(rootDir, filterCwd) {
     const runsDir = join(rootDir, "runs");
     try {
-        const dirs = readdirSync(runsDir).sort().reverse(); // newest first
+        const dirs = readdirSync(runsDir).sort().reverse();
+        const results = [];
         for (const d of dirs) {
             const state = loadRunState(join(runsDir, d));
-            if (state && state.phase !== "done")
-                return { dir: join(runsDir, d), state };
+            if (state && state.phase !== "done" && state.cwd === filterCwd) {
+                results.push({ dir: join(runsDir, d), state });
+            }
         }
+        return results;
+    }
+    catch {
+        return [];
     }
-    catch { }
-    return null;
 }
 /** Find orphaned designs: a run where thinking succeeded but orchestration crashed (has designs, no run.json). */
 function findOrphanedDesigns(rootDir) {
@@ -349,6 +353,49 @@ function findOrphanedDesigns(rootDir) {
     catch { }
     return null;
 }
+function formatTimeAgo(isoStr) {
+    const ms = Date.now() - new Date(isoStr).getTime();
+    const mins = Math.floor(ms / 60000);
+    if (mins < 1)
+        return "just now";
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}
+function showRunHistory(allRuns, filterCwd) {
+    const runs = allRuns.filter(r => r.state.cwd === filterCwd);
+    if (runs.length === 0) {
+        console.log(chalk.dim("\n  No run history.\n"));
+        return;
+    }
+    const w = Math.min((process.stdout.columns ?? 80) - 6, 50);
+    console.log(chalk.dim(`\n  ── Run History ${"─".repeat(Math.max(0, w - 16))}\n`));
+    let resumeIdx = 0;
+    for (const run of runs) {
+        const s = run.state;
+        const done = s.phase === "done";
+        const icon = done ? chalk.green("✓") : chalk.yellow("⚠");
+        const date = s.startedAt?.slice(0, 16).replace("T", " ") || "unknown";
+        const cost = s.accCost > 0 ? ` · $${s.accCost.toFixed(2)}` : "";
+        const obj = s.objective?.slice(0, 50) || "";
+        const num = done ? " " : chalk.cyan(String(++resumeIdx));
+        const merged = s.branches.filter(b => b.status === "merged").length;
+        console.log(`  ${icon} ${num} ${chalk.dim(date)} · ${s.phase} · ${s.accCompleted}/${s.budget}${cost}${merged ? ` · ${merged} merged` : ""}`);
+        console.log(`      ${obj}${obj.length >= 50 ? "…" : ""}`);
+        let status = "";
+        try {
+            status = readFileSync(join(run.dir, "status.md"), "utf-8").trim().split("\n")[0].slice(0, 70);
+        }
+        catch { }
+        if (status)
+            console.log(chalk.dim(`      ${status}`));
+        console.log("");
+    }
+}
 /** Read final status + goal from all completed previous runs (newest first, max 5). */
 function readPreviousRunKnowledge(rootDir) {
     const runsDir = join(rootDir, "runs");
@@ -389,8 +436,20 @@ function createRunDir(rootDir) {
     mkdirSync(join(runDir, "verifications"), { recursive: true });
     mkdirSync(join(runDir, "milestones"), { recursive: true });
     mkdirSync(join(runDir, "sessions"), { recursive: true });
+    updateLatestSymlink(rootDir, runDir);
     return runDir;
 }
+function updateLatestSymlink(rootDir, runDir) {
+    const link = join(rootDir, "latest");
+    try {
+        unlinkSync(link);
+    }
+    catch { }
+    try {
+        symlinkSync(runDir, link);
+    }
+    catch { }
+}
 function saveWaveSession(baseDir, waveNum, kind, swarm) {
     const dir = join(baseDir, "sessions");
     mkdirSync(dir, { recursive: true });
@@ -625,16 +684,17 @@ async function main() {
     // ── Show run history ──
     const rootDir = join(cwd, ".claude-overnight");
     const runsDir = join(rootDir, "runs");
-    let completedRuns = [];
+    const allRuns = [];
     try {
         const dirs = readdirSync(runsDir).sort().reverse();
         for (const d of dirs) {
             const s = loadRunState(join(runsDir, d));
-            if (s && s.phase === "done")
-                completedRuns.push({ dir: join(runsDir, d), state: s });
+            if (s)
+                allRuns.push({ dir: join(runsDir, d), state: s });
         }
     }
     catch { }
+    const completedRuns = allRuns.filter(r => r.state.phase === "done" && r.state.cwd === cwd);
     if (completedRuns.length > 0 && !noTTY) {
         console.log(chalk.dim(`\n  ${completedRuns.length} previous run${completedRuns.length > 1 ? "s" : ""}`));
         for (const r of completedRuns.slice(0, 3)) {
@@ -643,7 +703,6 @@ async function main() {
             const cost = r.state.accCost > 0 ? ` · $${r.state.accCost.toFixed(0)}` : "";
             const merged = r.state.branches.filter(b => b.status === "merged").length;
             console.log(chalk.dim(`     ${date} · ${r.state.accCompleted} done · ${merged} merged${cost}${obj ? ` · ${obj}` : ""}${obj.length >= 50 ? "…" : ""}`));
-            // Show status if available
             let status = "";
             try {
                 status = readFileSync(join(r.dir, "status.md"), "utf-8").trim().split("\n")[0].slice(0, 80);
@@ -657,52 +716,113 @@ async function main() {
     let resuming = false;
     let resumeState = null;
     let resumeRunDir;
-    const incomplete = findIncompleteRun(rootDir);
-    if (incomplete && incomplete.state.cwd === cwd && !noTTY && tasks.length === 0) {
-        const prev = incomplete.state;
-        const merged = prev.branches.filter(b => b.status === "merged").length;
-        const unmerged = prev.branches.filter(b => b.status === "unmerged").length;
-        const failed = prev.branches.filter(b => b.status === "failed" || b.status === "merge-failed").length;
-        const obj = prev.objective?.slice(0, 50) || "";
-        // Read last status for context
-        let lastStatus = "";
-        try {
-            lastStatus = readFileSync(join(incomplete.dir, "status.md"), "utf-8").trim().slice(0, 120);
-        }
-        catch { }
-        const label = "Unfinished run";
-        console.log(chalk.yellow(`\n  ⚠ ${label}`));
-        const boxLines = [
-            `${obj}${obj.length >= 50 ? "…" : ""}`,
-            `${prev.accCompleted}/${prev.budget} sessions · ${prev.remaining} remaining · $${prev.accCost.toFixed(2)}`,
-        ];
-        if (lastStatus)
-            boxLines.push(lastStatus);
-        if (merged + unmerged + failed > 0)
-            boxLines.push(`${merged} merged · ${unmerged} unmerged · ${failed} failed branches`);
-        const boxW = Math.max(...boxLines.map(l => l.length)) + 4;
-        console.log(chalk.dim(`  ╭${"─".repeat(boxW)}╮`));
-        for (const line of boxLines)
-            console.log(chalk.dim("  │") + `  ${line.padEnd(boxW - 2)}` + chalk.dim("│"));
-        console.log(chalk.dim(`  ╰${"─".repeat(boxW)}╯`));
-        const action = await selectKey("", [
-            { key: "r", desc: "esume" },
-            { key: "f", desc: "resh" },
-            { key: "q", desc: "uit" },
-        ]);
-        if (action === "q") {
-            process.exit(0);
+    const incompleteRuns = findIncompleteRuns(rootDir, cwd);
+    if (incompleteRuns.length > 0 && !noTTY && tasks.length === 0) {
+        let decided = false;
+        while (!decided) {
+            if (incompleteRuns.length === 1) {
+                // Single incomplete run — show detailed box
+                const run = incompleteRuns[0];
+                const prev = run.state;
+                const merged = prev.branches.filter(b => b.status === "merged").length;
+                const unmerged = prev.branches.filter(b => b.status === "unmerged").length;
+                const failed = prev.branches.filter(b => b.status === "failed" || b.status === "merge-failed").length;
+                const obj = prev.objective?.slice(0, 50) || "";
+                const ago = formatTimeAgo(prev.startedAt);
+                let lastStatus = "";
+                try {
+                    lastStatus = readFileSync(join(run.dir, "status.md"), "utf-8").trim().slice(0, 120);
+                }
+                catch { }
+                console.log(chalk.yellow(`\n  ⚠ Unfinished run`) + chalk.dim(` · ${ago}`));
+                const boxLines = [
+                    `${obj}${obj.length >= 50 ? "…" : ""}`,
+                    `${prev.accCompleted}/${prev.budget} sessions · ${Math.max(1, (prev.budget ?? 0) - prev.accCompleted)} remaining · $${prev.accCost.toFixed(2)}`,
+                    `Wave ${prev.waveNum + 1} · ${prev.phase}`,
+                ];
+                if (lastStatus)
+                    boxLines.push(lastStatus);
+                if (merged + unmerged + failed > 0)
+                    boxLines.push(`${merged} merged · ${unmerged} unmerged · ${failed} failed`);
+                const boxW = Math.max(...boxLines.map(l => l.length)) + 4;
+                console.log(chalk.dim(`  ╭${"─".repeat(boxW)}╮`));
+                for (const line of boxLines)
+                    console.log(chalk.dim("  │") + `  ${line.padEnd(boxW - 2)}` + chalk.dim("│"));
+                console.log(chalk.dim(`  ╰${"─".repeat(boxW)}╯`));
+                const action = await selectKey("", [
+                    { key: "r", desc: "esume" },
+                    { key: "h", desc: "istory" },
+                    { key: "f", desc: "resh" },
+                    { key: "q", desc: "uit" },
+                ]);
+                if (action === "q")
+                    process.exit(0);
+                if (action === "f") {
+                    decided = true;
+                    break;
+                }
+                if (action === "h") {
+                    showRunHistory(allRuns, cwd);
+                    continue;
+                }
+                resuming = true;
+                resumeState = prev;
+                resumeRunDir = run.dir;
+                decided = true;
+            }
+            else {
+                // Multiple incomplete runs — show numbered list (cap at 9 for single-keystroke selection)
+                const shown = incompleteRuns.slice(0, 9);
+                console.log(chalk.yellow(`\n  ⚠ ${incompleteRuns.length} unfinished runs${incompleteRuns.length > 9 ? ` (showing newest 9)` : ""}\n`));
+                for (let i = 0; i < shown.length; i++) {
+                    const run = shown[i];
+                    const s = run.state;
+                    const ago = formatTimeAgo(s.startedAt);
+                    const obj = s.objective?.slice(0, 50) || "";
+                    const merged = s.branches.filter(b => b.status === "merged").length;
+                    let lastStatus = "";
+                    try {
+                        lastStatus = readFileSync(join(run.dir, "status.md"), "utf-8").trim().split("\n")[0].slice(0, 70);
+                    }
+                    catch { }
+                    console.log(chalk.cyan(`  ${i + 1}`) + `  ${obj}${obj.length >= 50 ? "…" : ""}`);
+                    console.log(chalk.dim(`     ${s.accCompleted}/${s.budget} · $${s.accCost.toFixed(2)} · ${ago} · ${s.phase} at wave ${s.waveNum + 1}${merged ? ` · ${merged} merged` : ""}`));
+                    if (lastStatus)
+                        console.log(chalk.dim(`     ${lastStatus}`));
+                    console.log("");
+                }
+                const action = await selectKey(`  ${chalk.dim(`[1-${shown.length}] resume`)}`, [
+                    ...shown.map((_, i) => ({ key: String(i + 1), desc: "" })),
+                    { key: "h", desc: "istory" },
+                    { key: "f", desc: "resh" },
+                    { key: "q", desc: "uit" },
+                ]);
+                if (action === "q")
+                    process.exit(0);
+                if (action === "f") {
+                    decided = true;
+                    break;
+                }
+                if (action === "h") {
+                    showRunHistory(allRuns, cwd);
+                    continue;
+                }
+                const idx = parseInt(action) - 1;
+                if (idx >= 0 && idx < shown.length) {
+                    resuming = true;
+                    resumeState = shown[idx].state;
+                    resumeRunDir = shown[idx].dir;
+                    decided = true;
+                }
+            }
         }
-        if (action === "r") {
-            resuming = true;
-            resumeState = prev;
-            resumeRunDir = incomplete.dir;
+        if (resuming && resumeState && resumeRunDir) {
+            const unmerged = resumeState.branches.filter(b => b.status === "unmerged").length;
             if (unmerged > 0) {
                 console.log("");
-                autoMergeBranches(cwd, prev.branches, (msg) => console.log(chalk.dim(`  ${msg}`)));
-                // Persist merged branch statuses immediately so they survive a crash before next saveRunState
+                autoMergeBranches(cwd, resumeState.branches, (msg) => console.log(chalk.dim(`  ${msg}`)));
                 try {
-                    saveRunState(incomplete.dir, prev);
+                    saveRunState(resumeRunDir, resumeState);
                 }
                 catch { }
             }
@@ -883,6 +1003,8 @@ async function main() {
     // Create run directory — reuse orphaned run (thinking succeeded, orchestration crashed) if available
     const orphanedDir = !resuming ? findOrphanedDesigns(rootDir) : null;
     const runDir = resuming && resumeRunDir ? resumeRunDir : (orphanedDir ?? createRunDir(rootDir));
+    if (resuming && resumeRunDir)
+        updateLatestSymlink(rootDir, resumeRunDir);
     const previousKnowledge = readPreviousRunKnowledge(rootDir);
     // ── Plan phase (interactive: review loop, non-interactive: auto-plan or skip) ──
     const needsPlan = tasks.length === 0 && !resuming;
@@ -969,14 +1091,22 @@ async function main() {
                         agentTimeoutMs,
                         usageCap, allowExtraUsage, extraUsageBudget,
                     });
-                    const stopThinkRender = startRenderLoop(thinkingSwarm, { remaining: 0, usageCap, dirty: false });
+                    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, dirty: false });
+                    thinkDisplay.setWave(thinkingSwarm);
+                    thinkDisplay.start();
                     try {
                         await thinkingSwarm.run();
                     }
                     finally {
-                        stopThinkRender();
+                        thinkDisplay.pause();
+                        console.log(renderSummary(thinkingSwarm));
+                        thinkDisplay.stop();
                     }
-                    console.log(renderSummary(thinkingSwarm));
                     thinkingUsed = thinkingSwarm.completed + thinkingSwarm.failed;
                     thinkingCost = thinkingSwarm.totalCostUsd;
                     thinkingIn = thinkingSwarm.totalInputTokens;
@@ -1109,8 +1239,10 @@ async function main() {
         process.exit(0);
     }
     // ── Run (wave loop) ──
-    process.stdout.write("\x1B[?25l");
-    const restore = () => process.stdout.write("\x1B[?25h\n");
+    const restore = () => { try {
+        process.stdout.write("\x1B[?25h\n");
+    }
+    catch { } };
     const runStartedAt = resuming && resumeState?.startedAt ? new Date(resumeState.startedAt).getTime() : Date.now();
     // Wave-loop state — either fresh or resumed
     mkdirSync(join(runDir, "reflections"), { recursive: true });
@@ -1129,32 +1261,26 @@ async function main() {
     let overheadBudgetUsed;
     const branches = [];
     if (resuming && resumeState) {
-        // Restore ALL config from saved state
-        remaining = resumeState.remaining;
+        // Restore wave-loop state (config already restored in the early resume block + ternaries above)
+        // Recalculate remaining from budget — don't trust saved value which counts failures
+        // and may have been zeroed by a premature "done" signal from the steerer.
+        // The user explicitly chose Resume, so give back budget not yet successfully used.
+        remaining = Math.max(1, (resumeState.budget ?? 0) - resumeState.accCompleted);
         currentTasks = resumeState.currentTasks;
         waveNum = resumeState.waveNum;
         accCost = resumeState.accCost;
         accCompleted = resumeState.accCompleted;
         accFailed = resumeState.accFailed;
-        accTools = 0;
+        accTools = resumeState.accTools ?? 0;
+        accIn = resumeState.accIn ?? 0;
+        accOut = resumeState.accOut ?? 0;
         lastWaveKind = resumeState.lastWaveKind;
         overheadBudgetUsed = resumeState.overheadBudgetUsed ?? (resumeState.reflectionBudgetUsed ?? 0) + (resumeState.verificationBudgetUsed ?? 0);
         branches.push(...resumeState.branches);
-        objective = resumeState.objective;
-        workerModel = resumeState.workerModel;
-        plannerModel = resumeState.plannerModel;
-        budget = resumeState.budget;
-        concurrency = resumeState.concurrency;
-        flex = resumeState.flex;
-        usageCap = resumeState.usageCap;
-        allowExtraUsage = resumeState.allowExtraUsage ?? false;
-        extraUsageBudget = resumeState.extraUsageBudget;
-        permissionMode = resumeState.permissionMode;
-        useWorktrees = resumeState.useWorktrees;
-        mergeStrategy = resumeState.mergeStrategy;
-        // Restore wave history from saved session files so steerer has full context
+        flex = resumeState.flex; // override computed flex with saved value
         waveHistory.push(...loadWaveHistory(runDir));
         console.log(chalk.green(`\n  ✓ Resumed`) + chalk.dim(` · wave ${waveNum + 1} · ${remaining} remaining · $${accCost.toFixed(2)} spent · ${waveHistory.length} prior waves\n`));
+        waveNum++; // advance past last completed wave so next session file doesn't overwrite
     }
     else {
         // Fresh run
@@ -1178,6 +1304,17 @@ async function main() {
     liveConfig.remaining = remaining;
     liveConfig.usageCap = usageCap;
     const maxOverheadBudget = Math.max(4, Math.ceil((budget ?? 10) * 0.15));
+    // Unified display — one instance for the entire run
+    const runInfoRef = {
+        accIn, accOut, accCost, accCompleted, accFailed,
+        sessionsBudget: budget ?? tasks.length, waveNum, remaining,
+        model: workerModel, startedAt: runStartedAt,
+    };
+    const display = new RunDisplay(runInfoRef, liveConfig);
+    const rlGetter = () => {
+        const rl = getPlannerRateLimitInfo();
+        return { utilization: rl.utilization, isUsingOverage: rl.isUsingOverage, windows: rl.windows, resetsAt: rl.resetsAt };
+    };
     // For flex + branch strategy: create one target branch, waves merge via yolo into it
     let runBranch;
     let originalRef;
@@ -1199,79 +1336,104 @@ async function main() {
     const gracefulStop = (signal) => {
         if (stopping) {
             currentSwarm?.cleanup();
+            display.stop();
             restore();
             process.exit(0);
         }
         stopping = true;
-        process.stdout.write(`\n  ${chalk.yellow(`${signal}: stopping... (send again to force)`)}\n`);
         currentSwarm?.abort();
     };
     process.on("SIGINT", () => gracefulStop("SIGINT"));
     process.on("SIGTERM", () => gracefulStop("SIGTERM"));
-    process.on("uncaughtException", (err) => { currentSwarm?.abort(); currentSwarm?.cleanup(); restore(); console.error(chalk.red(`\n  Uncaught: ${err.message}`)); process.exit(1); });
-    process.on("unhandledRejection", (reason) => { currentSwarm?.abort(); currentSwarm?.cleanup(); restore(); console.error(chalk.red(`\n  Unhandled: ${reason instanceof Error ? reason.message : reason}`)); process.exit(1); });
+    process.on("uncaughtException", (err) => { currentSwarm?.abort(); currentSwarm?.cleanup(); display.stop(); restore(); console.error(chalk.red(`\n  Uncaught: ${err.message}`)); process.exit(1); });
+    process.on("unhandledRejection", (reason) => { currentSwarm?.abort(); currentSwarm?.cleanup(); display.stop(); restore(); console.error(chalk.red(`\n  Unhandled: ${reason instanceof Error ? reason.message : reason}`)); process.exit(1); });
+    // Helper: sync mutable runInfo with accumulated state
+    const syncRunInfo = () => Object.assign(runInfoRef, { accIn, accOut, accCost, accCompleted, accFailed, waveNum, remaining });
     // When resuming a flex run with no queued tasks, steer immediately to get the next wave
     if (resuming && flex && currentTasks.length === 0 && remaining > 0) {
-        console.log(chalk.cyan(`\n  ◆ Assessing...\n`));
-        process.stdout.write("\x1B[?25l");
-        try {
-            const memory = readRunMemory(runDir, previousKnowledge || undefined);
-            const steer = await steerWave(objective, waveHistory, remaining, cwd, plannerModel, workerModel, permissionMode, concurrency, makeProgressLog(), memory);
-            process.stdout.write(`\x1B[2K\r`);
-            process.stdout.write("\x1B[?25h");
-            if (steer.statusUpdate)
-                writeStatus(runDir, steer.statusUpdate);
-            if (steer.goalUpdate)
-                writeGoalUpdate(runDir, steer.goalUpdate);
-            if (!steer.done && steer.tasks.length > 0) {
-                console.log(chalk.dim(`  ${steer.reasoning}\n`));
-                currentTasks = steer.tasks.map(t => ({
-                    ...t,
-                    model: t.model === "planner" ? plannerModel : t.model === "worker" ? workerModel : t.model,
-                }));
-                lastWaveKind = steer.waveKind;
+        let steerAttempts = 0;
+        display.setSteering(rlGetter);
+        display.start();
+        while (currentTasks.length === 0 && remaining > 0 && !objectiveComplete && steerAttempts < 3) {
+            steerAttempts++;
+            const plannerCostBefore = getTotalPlannerCost();
+            try {
+                const memory = readRunMemory(runDir, previousKnowledge || undefined);
+                const steer = await steerWave(objective, waveHistory, remaining, cwd, plannerModel, workerModel, permissionMode, concurrency, (text) => display.updateText(text), memory);
+                const steerCost = getTotalPlannerCost() - plannerCostBefore;
+                accCost += steerCost;
+                syncRunInfo();
+                if (steer.statusUpdate)
+                    writeStatus(runDir, steer.statusUpdate);
+                if (steer.goalUpdate)
+                    writeGoalUpdate(runDir, steer.goalUpdate);
+                if (steer.done || steer.tasks.length === 0) {
+                    const hasVerification = waveHistory.some(w => w.kind.includes("verif"));
+                    if (!hasVerification && remaining >= 1) {
+                        display.updateText(`Done blocked \u2014 verification required`);
+                        lastWaveKind = "done-blocked";
+                        continue;
+                    }
+                    objectiveComplete = true;
+                    remaining = 0;
+                }
+                else {
+                    const isOverhead = steer.waveKind !== "execute";
+                    if (isOverhead && overheadBudgetUsed + steer.tasks.length > maxOverheadBudget) {
+                        display.updateText(`Overhead budget exhausted (${overheadBudgetUsed}/${maxOverheadBudget}) \u2014 re-assessing`);
+                        lastWaveKind = "overhead-capped";
+                        continue;
+                    }
+                    currentTasks = steer.tasks.map(t => ({
+                        ...t,
+                        model: t.model === "planner" ? plannerModel : t.model === "worker" ? workerModel
+                            : isOverhead && !t.model ? plannerModel : t.model,
+                    }));
+                    lastWaveKind = steer.waveKind;
+                    if (isOverhead)
+                        overheadBudgetUsed += currentTasks.length;
+                }
             }
-            else if (steer.done) {
-                console.log(chalk.green(`  \u2713 ${steer.reasoning}\n`));
-                objectiveComplete = true;
-                remaining = 0;
+            catch (err) {
+                const steerCost = getTotalPlannerCost() - plannerCostBefore;
+                accCost += steerCost;
+                display.stop();
+                console.log(chalk.yellow(`  Steering failed: ${err.message?.slice(0, 80)} \u2014 stopping\n`));
+                break;
             }
         }
-        catch (err) {
-            process.stdout.write("\x1B[?25h");
-            console.log(chalk.yellow(`  Steering failed: ${err.message?.slice(0, 80)} \u2014 stopping\n`));
-        }
     }
+    // Start unified display (first call — idempotent)
+    if (!display.runInfo.startedAt)
+        display.runInfo.startedAt = runStartedAt;
+    display.start();
     while (remaining > 0 && currentTasks.length > 0 && !stopping) {
         if (currentTasks.length > remaining)
             currentTasks = currentTasks.slice(0, remaining);
-        if (flex) {
-            const costSoFar = accCost > 0 ? ` · $${accCost.toFixed(2)} spent` : "";
-            console.log(chalk.cyan(`\n  ◆ Wave ${waveNum + 1}`) + chalk.dim(` · ${currentTasks.length} tasks · ${remaining} remaining${costSoFar}\n`));
-        }
+        syncRunInfo();
         const swarm = new Swarm({
             tasks: currentTasks, concurrency, cwd, model: workerModel, permissionMode, allowedTools,
             useWorktrees, mergeStrategy: waveMerge, agentTimeoutMs, usageCap, allowExtraUsage, extraUsageBudget,
             baseCostUsd: accCost,
         });
         currentSwarm = swarm;
-        const stopRender = startRenderLoop(swarm, liveConfig);
+        display.setWave(swarm);
+        display.resume();
         try {
             await swarm.run();
         }
         catch (err) {
             if (isAuthError(err)) {
-                stopRender();
+                display.stop();
                 restore();
                 console.error(chalk.red(`\n  Authentication failed — check your API key or run: claude auth\n`));
                 process.exit(1);
             }
             throw err;
         }
-        finally {
-            stopRender();
-            console.log(renderSummary(swarm));
-        }
+        // Show wave summary (pauses render, prints, then we switch to steering)
+        display.pause();
+        console.log(renderSummary(swarm));
         // Accumulate
         accCost += swarm.totalCostUsd;
         accIn += swarm.totalInputTokens;
@@ -1279,8 +1441,10 @@ async function main() {
         accCompleted += swarm.completed;
         accFailed += swarm.failed;
         accTools += swarm.agents.reduce((sum, a) => sum + a.toolCalls, 0);
-        remaining -= swarm.completed + swarm.failed;
-        // Apply live config changes if user adjusted budget/threshold mid-wave
+        remaining = Math.max(0, remaining - swarm.completed - swarm.failed);
+        const expectedFloor = Math.max(0, (budget ?? 0) - accCompleted - accFailed);
+        if (remaining < expectedFloor)
+            remaining = expectedFloor;
         if (liveConfig.dirty) {
             remaining = liveConfig.remaining;
             usageCap = liveConfig.usageCap;
@@ -1295,7 +1459,7 @@ async function main() {
             id: `run-${new Date().toISOString().slice(0, 19)}`, objective: objective, budget: budget ?? tasks.length,
             remaining, workerModel, plannerModel, concurrency, permissionMode,
             usageCap, allowExtraUsage, extraUsageBudget, flex, useWorktrees, mergeStrategy, waveNum, currentTasks: [],
-            lastWaveKind, overheadBudgetUsed, accCost, accCompleted, accFailed,
+            lastWaveKind, overheadBudgetUsed, accCost, accCompleted, accFailed, accIn, accOut, accTools,
             branches, phase: "steering", startedAt: new Date(runStartedAt).toISOString(), cwd,
         });
         waveHistory.push({
@@ -1311,48 +1475,44 @@ async function main() {
         if (!flex || remaining <= 0 || swarm.aborted || swarm.cappedOut)
             break;
         // ── Steer: assess and compose the next wave ──
+        syncRunInfo();
+        display.setSteering(rlGetter);
+        display.resume();
         let steered = false;
         let steerAttempts = 0;
         while (!steered && remaining > 0 && !stopping && steerAttempts < 3) {
             steerAttempts++;
-            console.log(chalk.cyan(`\n  ◆ Assessing...\n`));
-            process.stdout.write("\x1B[?25l");
+            const plannerCostBefore = getTotalPlannerCost();
             try {
                 const memory = readRunMemory(runDir, previousKnowledge || undefined);
-                const steer = await steerWave(objective, waveHistory, remaining, cwd, plannerModel, workerModel, permissionMode, concurrency, makeProgressLog(), memory);
-                process.stdout.write(`\x1B[2K\r`);
-                process.stdout.write("\x1B[?25h");
+                const steer = await steerWave(objective, waveHistory, remaining, cwd, plannerModel, workerModel, permissionMode, concurrency, (text) => display.updateText(text), memory);
+                const steerCost = getTotalPlannerCost() - plannerCostBefore;
+                accCost += steerCost;
+                syncRunInfo();
                 if (steer.statusUpdate)
                     writeStatus(runDir, steer.statusUpdate);
-                if (steer.goalUpdate) {
+                if (steer.goalUpdate)
                     writeGoalUpdate(runDir, steer.goalUpdate);
-                    console.log(chalk.dim(`  Goal refined: ${steer.goalUpdate.slice(0, 100)}\n`));
-                }
                 const execWaves = waveHistory.filter(w => w.kind === "execute").length;
                 if (execWaves > 0 && execWaves % 5 === 0)
                     archiveMilestone(runDir, waveNum);
                 if (steer.done || steer.tasks.length === 0) {
                     const hasVerification = waveHistory.some(w => w.kind.includes("verif"));
                     if (!hasVerification && remaining >= 1) {
-                        console.log(chalk.dim(`  ${steer.reasoning}`));
-                        console.log(chalk.yellow(`  Done blocked — verification required before completion\n`));
+                        display.updateText(`Done blocked \u2014 verification required`);
                         lastWaveKind = "done-blocked";
-                        continue; // re-steer — steerer will see the hint
+                        continue;
                     }
-                    console.log(chalk.green(`  \u2713 ${steer.reasoning}\n`));
                     objectiveComplete = true;
                     remaining = 0;
                     break;
                 }
                 const isOverhead = steer.waveKind !== "execute";
                 if (isOverhead && overheadBudgetUsed + steer.tasks.length > maxOverheadBudget) {
-                    console.log(chalk.dim(`  ${steer.reasoning}`));
-                    console.log(chalk.yellow(`  Overhead budget exhausted (${overheadBudgetUsed}/${maxOverheadBudget}) — re-assessing\n`));
+                    display.updateText(`Overhead budget exhausted (${overheadBudgetUsed}/${maxOverheadBudget}) \u2014 re-assessing`);
                     lastWaveKind = "overhead-capped";
-                    continue; // re-steer
+                    continue;
                 }
-                console.log(chalk.dim(`  ${steer.reasoning}\n`));
-                // Resolve model aliases: "planner" → plannerModel, "worker" → workerModel
                 currentTasks = steer.tasks.map(t => ({
                     ...t,
                     model: t.model === "planner" ? plannerModel : t.model === "worker" ? workerModel
@@ -1364,14 +1524,18 @@ async function main() {
                 steered = true;
             }
             catch (err) {
-                process.stdout.write("\x1B[?25h");
+                const steerCost = getTotalPlannerCost() - plannerCostBefore;
+                accCost += steerCost;
+                display.stop();
                 console.log(chalk.yellow(`  Steering failed: ${err.message?.slice(0, 80)} \u2014 stopping\n`));
-                // Don't zero out remaining — preserve unspent budget so resume works
                 break;
             }
         }
+        if (!steered)
+            break;
         waveNum++;
     }
+    display.stop();
     // Only truly "done" if steering explicitly completed the objective (or non-flex single wave with budget exhausted)
     const trulyDone = objectiveComplete || (!flex && remaining <= 0);
     const finalPhase = trulyDone ? "done" : "capped";
@@ -1379,7 +1543,7 @@ async function main() {
         id: `run-${new Date().toISOString().slice(0, 19)}`, objective: objective ?? "", budget: budget ?? tasks.length,
         remaining, workerModel, plannerModel, concurrency, permissionMode,
         usageCap, allowExtraUsage, extraUsageBudget, flex, useWorktrees, mergeStrategy, waveNum, currentTasks: [],
-        lastWaveKind, overheadBudgetUsed, accCost, accCompleted, accFailed,
+        lastWaveKind, overheadBudgetUsed, accCost, accCompleted, accFailed, accIn, accOut, accTools,
         branches, phase: finalPhase, startedAt: new Date(runStartedAt).toISOString(), cwd,
     });
     if (trulyDone) {
@@ -1391,6 +1555,10 @@ async function main() {
             rmSync(join(runDir, "reflections"), { recursive: true, force: true });
         }
         catch { }
+        try {
+            rmSync(join(runDir, "verifications"), { recursive: true, force: true });
+        }
+        catch { }
     }
     // Switch back if we created a run branch
     if (runBranch && originalRef) {