claude-overnight 1.6.0 → 1.6.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";
@@ -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;
@@ -1129,32 +1251,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
@@ -1212,35 +1328,57 @@ async function main() {
     process.on("unhandledRejection", (reason) => { currentSwarm?.abort(); currentSwarm?.cleanup(); restore(); console.error(chalk.red(`\n  Unhandled: ${reason instanceof Error ? reason.message : reason}`)); process.exit(1); });
     // 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;
+        while (currentTasks.length === 0 && remaining > 0 && !objectiveComplete && steerAttempts < 3) {
+            steerAttempts++;
+            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) {
+                    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`));
+                        lastWaveKind = "done-blocked";
+                        continue;
+                    }
+                    console.log(chalk.green(`  \u2713 ${steer.reasoning}\n`));
+                    objectiveComplete = true;
+                    remaining = 0;
+                }
+                else {
+                    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`));
+                        lastWaveKind = "overhead-capped";
+                        continue;
+                    }
+                    console.log(chalk.dim(`  ${steer.reasoning}\n`));
+                    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) {
+                process.stdout.write("\x1B[?25h");
+                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`));
-        }
     }
     while (remaining > 0 && currentTasks.length > 0 && !stopping) {
         if (currentTasks.length > remaining)
@@ -1279,7 +1417,11 @@ async function main() {
         accCompleted += swarm.completed;
         accFailed += swarm.failed;
         accTools += swarm.agents.reduce((sum, a) => sum + a.toolCalls, 0);
-        remaining -= swarm.completed + swarm.failed;
+        remaining = Math.max(0, remaining - swarm.completed - swarm.failed);
+        // Sanity check: remaining should never drop below budget - total consumed
+        const expectedFloor = Math.max(0, (budget ?? 0) - accCompleted - accFailed);
+        if (remaining < expectedFloor)
+            remaining = expectedFloor;
         // Apply live config changes if user adjusted budget/threshold mid-wave
         if (liveConfig.dirty) {
             remaining = liveConfig.remaining;
@@ -1295,7 +1437,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({
@@ -1370,6 +1512,8 @@ async function main() {
                 break;
             }
         }
+        if (!steered)
+            break; // steering failed — stop, don't re-run old tasks
         waveNum++;
     }
     // Only truly "done" if steering explicitly completed the objective (or non-flex single wave with budget exhausted)
@@ -1379,7 +1523,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 +1535,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) {

package/dist/planner.js

@@ -643,7 +643,8 @@ export async function steerWave(objective, history, remainingBudget, cwd, planne
         return `Wave ${w.wave + 1} (${w.kind}):\n${lines}`;
     }).join("\n\n") : "(first wave)";
     const lastKind = history.length > 0 ? history[history.length - 1].kind : "";
-    const repeatHint = lastKind && lastKind !== "execute"
+    const isSyntheticKind = lastKind.includes("blocked") || lastKind.includes("capped");
+    const repeatHint = lastKind && lastKind !== "execute" && !isSyntheticKind
         ? `\nThe previous wave was "${lastKind}". Don't repeat the same wave kind unless you have a strong reason.\n`
         : "";
     const cap = (s, max) => s.length > max ? s.slice(0, max) + "\n...(truncated)" : s;

package/dist/types.d.ts

@@ -138,8 +138,11 @@ export interface RunState {
     accCost: number;
     accCompleted: number;
     accFailed: number;
+    accIn?: number;
+    accOut?: number;
+    accTools?: number;
     branches: BranchRecord[];
-    phase: "executing" | "steering" | "reflecting" | "verifying" | "capped" | "done";
+    phase: "steering" | "capped" | "done";
     startedAt: string;
     cwd: string;
 }

package/package.json

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