claude-overnight 1.6.1 → 1.8.0

package/dist/index.js

@@ -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"]);
@@ -1091,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;
@@ -1231,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 });
@@ -1294,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;
@@ -1315,29 +1336,33 @@ 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) {
         let steerAttempts = 0;
+        display.setSteering(rlGetter);
+        display.start();
         while (currentTasks.length === 0 && remaining > 0 && !objectiveComplete && 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)
@@ -1345,24 +1370,20 @@ async function main() {
                 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;
                     }
-                    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`));
+                        display.updateText(`Overhead budget exhausted (${overheadBudgetUsed}/${maxOverheadBudget}) \u2014 re-assessing`);
                         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
@@ -1374,42 +1395,45 @@ async function main() {
                 }
             }
             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`));
                 break;
             }
         }
     }
+    // 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;
@@ -1418,11 +1442,9 @@ async function main() {
         accFailed += swarm.failed;
         accTools += swarm.agents.reduce((sum, a) => sum + a.toolCalls, 0);
         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;
             usageCap = liveConfig.usageCap;
@@ -1453,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
@@ -1506,16 +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; // steering failed — stop, don't re-run old tasks
+            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";

package/dist/planner.d.ts

@@ -37,6 +37,7 @@ export interface RunMemory {
 }
 export type ModelTier = "opus" | "sonnet" | "haiku" | "unknown";
 export declare function detectModelTier(model: string): ModelTier;
+export declare function getTotalPlannerCost(): number;
 export declare function getPlannerRateLimitInfo(): PlannerRateLimitInfo;
 export declare function planTasks(objective: string, cwd: string, plannerModel: string, workerModel: string, permissionMode: PermMode, budget: number | undefined, concurrency: number, onLog: (text: string) => void, flexNote?: string, outFile?: string): Promise<Task[]>;
 export declare function identifyThemes(objective: string, count: number, model: string, permissionMode: PermMode, onLog?: (text: string) => void): Promise<string[]>;

package/dist/planner.js

@@ -200,6 +200,9 @@ async function runPlannerQuery(prompt, opts, onLog) {
     }
     throw new Error("Planner query failed after retries");
 }
+/** Cumulative cost of all planner queries (steering, orchestration, etc.) across the session. */
+let _totalPlannerCostUsd = 0;
+export function getTotalPlannerCost() { return _totalPlannerCostUsd; }
 /** Shared mutable rate limit state that planner queries write to for UI display. Reset per query. */
 let _plannerRateLimitInfo = {
     utilization: 0, status: "", isUsingOverage: false, windows: new Map(), costUsd: 0,
@@ -310,6 +313,7 @@ async function runPlannerQueryOnce(prompt, opts, onLog) {
                 if (typeof r.total_cost_usd === "number") {
                     costUsd = r.total_cost_usd;
                     _plannerRateLimitInfo.costUsd += costUsd;
+                    _totalPlannerCostUsd += costUsd;
                 }
                 if (msg.subtype === "success")
                     resultText = r.result || "";

package/dist/ui.d.ts

@@ -1,11 +1,64 @@
 import type { Swarm } from "./swarm.js";
-export declare function renderFrame(swarm: Swarm, showHotkeys?: boolean): string;
+import type { RateLimitWindow } from "./types.js";
+/** Cumulative run-level stats — mutable, updated between phases. */
+export interface RunInfo {
+    accIn: number;
+    accOut: number;
+    accCost: number;
+    accCompleted: number;
+    accFailed: number;
+    sessionsBudget: number;
+    waveNum: number;
+    remaining: number;
+    model?: string;
+    startedAt: number;
+}
 /** Mutable config that can be changed live during execution. */
 export interface LiveConfig {
     remaining: number;
     usageCap: number | undefined;
-    /** Set by hotkey handler when user changes a value. Cleared after main loop reads it. */
     dirty: boolean;
 }
-export declare function startRenderLoop(swarm: Swarm, liveConfig?: LiveConfig): () => void;
+type RLGetter = () => {
+    utilization: number;
+    isUsingOverage: boolean;
+    windows: Map<string, RateLimitWindow>;
+    resetsAt?: number;
+};
+export declare class RunDisplay {
+    readonly runInfo: RunInfo;
+    private liveConfig?;
+    private swarm?;
+    private steeringText?;
+    private rlGetter?;
+    private interval?;
+    private keyHandler?;
+    private inputMode;
+    private inputBuf;
+    private started;
+    private readonly isTTY;
+    private lastSeq;
+    private lastCompleted;
+    constructor(runInfo: RunInfo, liveConfig?: LiveConfig);
+    /** Start the persistent render loop. Call once at the beginning of the run. */
+    start(): void;
+    /** Switch to wave mode — show agent table + events. */
+    setWave(swarm: Swarm): void;
+    /** Switch to steering mode — show assessment text. */
+    setSteering(rlGetter?: RLGetter): void;
+    /** Update the steering text. */
+    updateText(text: string): void;
+    /** Pause rendering (e.g. to print a summary). */
+    pause(): void;
+    /** Resume rendering after a pause. */
+    resume(): void;
+    /** Stop and clean up. */
+    stop(): void;
+    private resumeInterval;
+    private render;
+    private hasHotkeys;
+    private setupHotkeys;
+    private plainTick;
+}
 export declare function renderSummary(swarm: Swarm): string;
+export {};

package/dist/ui.js

@@ -4,6 +4,226 @@ const WINDOW_SHORT_NAMES = {
     five_hour: "5h", seven_day: "7d", seven_day_opus: "7d op",
     seven_day_sonnet: "7d sn", overage: "extra",
 };
+// ── Unified display ──
+export class RunDisplay {
+    runInfo;
+    liveConfig;
+    swarm;
+    steeringText;
+    rlGetter;
+    interval;
+    keyHandler;
+    inputMode = "none";
+    inputBuf = "";
+    started = false;
+    isTTY;
+    // Plain-log state
+    lastSeq = 0;
+    lastCompleted = -1;
+    constructor(runInfo, liveConfig) {
+        this.runInfo = runInfo;
+        this.liveConfig = liveConfig;
+        this.isTTY = !!process.stdout.isTTY;
+    }
+    /** Start the persistent render loop. Call once at the beginning of the run. */
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.setupHotkeys();
+        this.resumeInterval();
+    }
+    /** Switch to wave mode — show agent table + events. */
+    setWave(swarm) {
+        this.swarm = swarm;
+        this.steeringText = undefined;
+        this.rlGetter = undefined;
+        this.lastSeq = 0;
+        this.lastCompleted = -1;
+    }
+    /** Switch to steering mode — show assessment text. */
+    setSteering(rlGetter) {
+        this.swarm = undefined;
+        this.steeringText = "Assessing...";
+        this.rlGetter = rlGetter;
+    }
+    /** Update the steering text. */
+    updateText(text) { this.steeringText = text; }
+    /** Pause rendering (e.g. to print a summary). */
+    pause() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = undefined;
+        }
+    }
+    /** Resume rendering after a pause. */
+    resume() {
+        if (!this.started || this.interval)
+            return;
+        if (this.isTTY)
+            try {
+                process.stdout.write("\x1B[?25l");
+            }
+            catch { }
+        this.resumeInterval();
+    }
+    /** Stop and clean up. */
+    stop() {
+        this.pause();
+        if (this.keyHandler) {
+            process.stdin.removeListener("data", this.keyHandler);
+            this.keyHandler = undefined;
+            try {
+                process.stdin.setRawMode(false);
+                process.stdin.pause();
+            }
+            catch { }
+        }
+        try {
+            process.stdout.write("\x1B[?25h");
+        }
+        catch { }
+        this.started = false;
+    }
+    // ── Internals ──
+    resumeInterval() {
+        if (this.interval)
+            return;
+        if (!this.isTTY) {
+            this.interval = setInterval(() => this.plainTick(), 500);
+            return;
+        }
+        try {
+            process.stdout.write("\x1B[?25l\x1B[H\x1B[J");
+        }
+        catch {
+            return;
+        }
+        this.interval = setInterval(() => {
+            try {
+                process.stdout.write("\x1B[H\x1B[J");
+                process.stdout.write(this.render());
+            }
+            catch {
+                this.pause();
+            }
+        }, 250);
+    }
+    render() {
+        if (this.swarm) {
+            let frame = renderFrame(this.swarm, this.hasHotkeys(), this.runInfo);
+            if (this.inputMode !== "none") {
+                const label = this.inputMode === "budget" ? "New budget (remaining sessions)" : "New usage cap (0-100%)";
+                frame += `\n  ${chalk.cyan(">")} ${label}: ${this.inputBuf}\u2588`;
+            }
+            return frame;
+        }
+        if (this.steeringText != null) {
+            let frame = renderSteeringFrame(this.runInfo, this.steeringText, this.hasHotkeys(), this.rlGetter);
+            if (this.inputMode === "budget") {
+                frame += `\n  ${chalk.cyan(">")} New budget (remaining sessions): ${this.inputBuf}\u2588`;
+            }
+            return frame;
+        }
+        return "";
+    }
+    hasHotkeys() {
+        return !!this.liveConfig && !!process.stdin.isTTY;
+    }
+    setupHotkeys() {
+        if (!this.liveConfig || !process.stdin.isTTY)
+            return;
+        try {
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+        }
+        catch {
+            return;
+        }
+        const lc = this.liveConfig;
+        this.keyHandler = (buf) => {
+            const s = buf.toString();
+            if (this.inputMode !== "none") {
+                if (s === "\r" || s === "\n") {
+                    const val = parseFloat(this.inputBuf);
+                    if (this.inputMode === "budget" && !isNaN(val) && val > 0) {
+                        lc.remaining = Math.round(val);
+                        lc.dirty = true;
+                        this.swarm?.log(-1, `Budget changed to ${lc.remaining} remaining`);
+                    }
+                    else if (this.inputMode === "threshold" && !isNaN(val) && val >= 0 && val <= 100) {
+                        const frac = val / 100;
+                        lc.usageCap = frac > 0 ? frac : undefined;
+                        lc.dirty = true;
+                        if (this.swarm)
+                            this.swarm.usageCap = lc.usageCap;
+                        this.swarm?.log(-1, `Usage cap changed to ${val > 0 ? val + "%" : "unlimited"}`);
+                    }
+                    this.inputMode = "none";
+                    this.inputBuf = "";
+                }
+                else if (s === "\x1B" || s === "\x03") {
+                    this.inputMode = "none";
+                    this.inputBuf = "";
+                }
+                else if (s === "\x7F") {
+                    this.inputBuf = this.inputBuf.slice(0, -1);
+                }
+                else if (/^[0-9.]$/.test(s)) {
+                    this.inputBuf += s;
+                }
+                return;
+            }
+            if (s === "b" || s === "B") {
+                this.inputMode = "budget";
+                this.inputBuf = "";
+            }
+            else if (s === "t" || s === "T") {
+                if (this.swarm) {
+                    this.inputMode = "threshold";
+                    this.inputBuf = "";
+                }
+            }
+            else if (s === "q" || s === "Q" || s === "\x03") {
+                if (this.swarm) {
+                    if (this.swarm.aborted)
+                        process.exit(0);
+                    this.swarm.abort();
+                }
+                else {
+                    process.exit(0);
+                }
+            }
+        };
+        process.stdin.on("data", this.keyHandler);
+    }
+    plainTick() {
+        if (!this.swarm)
+            return;
+        const swarm = this.swarm;
+        const write = (line) => { try {
+            process.stdout.write(line + "\n");
+        }
+        catch { } };
+        const currentSeq = swarm.logSequence;
+        if (currentSeq > this.lastSeq) {
+            const newCount = currentSeq - this.lastSeq;
+            const available = swarm.logs.length;
+            const toShow = Math.min(newCount, available);
+            for (const entry of swarm.logs.slice(available - toShow)) {
+                const t = new Date(entry.time).toLocaleTimeString("en", { hour12: false });
+                const tag = entry.agentId < 0 ? "[sys]" : `[${entry.agentId}]`;
+                write(`${t} ${tag} ${entry.text}`);
+            }
+            this.lastSeq = currentSeq;
+        }
+        if (swarm.completed !== this.lastCompleted) {
+            this.lastCompleted = swarm.completed;
+            write(`progress: ${swarm.completed}/${swarm.total} done, ${swarm.active} active, ${swarm.pending} queued`);
+        }
+    }
+}
+// ── Pure render functions ──
 function colorEvent(text) {
     if (text === "Done" || text.startsWith("Merged ") || text.startsWith("Committed "))
         return chalk.green(text);
@@ -15,51 +235,66 @@ function colorEvent(text) {
         return chalk.yellow(text);
     return text;
 }
-export function renderFrame(swarm, showHotkeys = false) {
+/** Render the shared header block (title + stats + usage bars). */
+function renderHeader(out, w, p) {
+    const barW = Math.min(30, w - 50);
+    const filled = Math.round(p.barPct * barW);
+    const bar = chalk.green("\u2588".repeat(filled)) + chalk.gray("\u2591".repeat(barW - filled));
+    const modelTag = p.model ? chalk.dim(` [${p.model}]`) : "";
+    const phaseTag = p.phase ? " " + p.phase : "";
+    out.push("");
+    out.push(`  ${chalk.bold.white("CLAUDE OVERNIGHT")}${modelTag}${phaseTag}  ${bar}  ` +
+        `${p.barLabel}  ` +
+        (p.active > 0 ? chalk.cyan(`${p.active} active`) + "  " : "") +
+        (p.queued > 0 ? chalk.gray(`${p.queued} queued`) + "  " : "") +
+        chalk.gray(`\u23F1 ${fmtDur(Date.now() - p.startedAt)}`));
+    // Stats line
+    const tokIn = fmtTokens(p.totalIn);
+    const tokOut = fmtTokens(p.totalOut);
+    const costStr = p.totalCost > 0 ? chalk.yellow(`$${p.totalCost.toFixed(2)}`) : "";
+    const waveLabel = p.waveNum >= 0 ? `wave ${p.waveNum + 1} \u00b7 ` : "";
+    const sessionStr = chalk.dim(`  ${waveLabel}`) +
+        chalk.white(`${p.sessionsUsed}/${p.sessionsBudget}`) +
+        chalk.dim(` sessions \u00b7 ${p.remaining} left`);
+    out.push(chalk.gray(`  \u2191 ${tokIn} in  \u2193 ${tokOut} out`) +
+        (costStr ? `  ${costStr}` : "") +
+        sessionStr);
+}
+function renderFrame(swarm, showHotkeys, runInfo) {
     const w = Math.max((process.stdout.columns ?? 80) || 80, 60);
     const out = [];
     // ── Header ──
-    const barW = Math.min(30, w - 50);
-    const pct = swarm.total > 0 ? swarm.completed / swarm.total : 0;
-    const filled = Math.round(pct * barW);
-    const bar = chalk.green("\u2588".repeat(filled)) +
-        chalk.gray("\u2591".repeat(barW - filled));
-    const stoppingTag = swarm.aborted ? chalk.yellow(" STOPPING") : "";
-    const phaseLabel = (swarm.phase === "planning"
-        ? chalk.magenta(" PLANNING")
+    const stoppingTag = swarm.aborted ? chalk.yellow("STOPPING") : "";
+    const phaseLabel = swarm.phase === "planning"
+        ? chalk.magenta("PLANNING")
         : swarm.phase === "merging"
-            ? chalk.yellow(" MERGING")
-            : "") + stoppingTag;
-    const modelTag = swarm.model ? chalk.dim(` [${swarm.model}]`) : "";
-    out.push("");
-    out.push(`  ${chalk.bold.white("CLAUDE OVERNIGHT")}${modelTag}${phaseLabel}  ${bar}  ` +
-        `${swarm.completed}/${swarm.total}  ` +
-        chalk.cyan(`${swarm.active} active`) +
-        "  " +
-        chalk.gray(`${swarm.pending} queued`) +
-        "  " +
-        chalk.gray(`\u23F1 ${fmtDur(Date.now() - swarm.startedAt)}`));
-    // Stats line — show wave cost + overall if there's a base
-    const tokIn = fmtTokens(swarm.totalInputTokens);
-    const tokOut = fmtTokens(swarm.totalOutputTokens);
-    const waveCost = swarm.totalCostUsd;
-    const totalCost = swarm.baseCostUsd + waveCost;
-    let costStr = "";
-    if (totalCost > 0) {
-        costStr = swarm.baseCostUsd > 0
-            ? chalk.yellow(`$${waveCost.toFixed(3)}`) + chalk.dim(` / $${totalCost.toFixed(2)} total`)
-            : chalk.yellow(`$${waveCost.toFixed(3)}`);
-    }
-    out.push(chalk.gray(`  \u2191 ${tokIn} in  \u2193 ${tokOut} out`) +
-        (costStr ? `  ${costStr}` : ""));
-    // ── Usage bar(s) — cycle through windows every 3s ──
+            ? chalk.yellow("MERGING")
+            : "";
+    const phase = [phaseLabel, stoppingTag].filter(Boolean).join(" ");
+    const waveUsed = swarm.completed + swarm.failed;
+    renderHeader(out, w, {
+        model: runInfo?.model ?? swarm.model,
+        phase,
+        barPct: swarm.total > 0 ? swarm.completed / swarm.total : 0,
+        barLabel: `${swarm.completed}/${swarm.total}`,
+        active: swarm.active,
+        queued: swarm.pending,
+        startedAt: runInfo?.startedAt ?? swarm.startedAt,
+        totalIn: (runInfo?.accIn ?? 0) + swarm.totalInputTokens,
+        totalOut: (runInfo?.accOut ?? 0) + swarm.totalOutputTokens,
+        totalCost: (runInfo?.accCost ?? swarm.baseCostUsd) + swarm.totalCostUsd,
+        waveNum: runInfo?.waveNum ?? -1,
+        sessionsUsed: (runInfo ? runInfo.accCompleted + runInfo.accFailed : 0) + waveUsed,
+        sessionsBudget: runInfo?.sessionsBudget ?? swarm.total,
+        remaining: Math.max(0, (runInfo?.remaining ?? swarm.total) - waveUsed),
+    });
+    // ── Usage bar(s) ──
     const windows = Array.from(swarm.rateLimitWindows.values());
     const rlPct = swarm.rateLimitUtilization;
     if (rlPct > 0 || swarm.rateLimitResetsAt || swarm.cappedOut || windows.length > 0) {
         const barW = Math.min(30, w - 40);
         const capFrac = swarm.usageCap;
         const capMark = capFrac != null && capFrac < 1 ? Math.round(capFrac * barW) : -1;
-        // Show primary usage bar
         const renderBar = (pct, windowLabel) => {
             const filled = Math.round(pct * barW);
             let barStr = "";
@@ -74,10 +309,10 @@ export function renderFrame(swarm, showHotkeys = false) {
             let label = `${Math.round(pct * 100)}% used`;
             if (swarm.cappedOut) {
                 if (swarm.isUsingOverage && !swarm.allowExtraUsage) {
-                    label = chalk.red("Extra usage blocked — stopping");
+                    label = chalk.red("Extra usage blocked \u2014 stopping");
                 }
                 else {
-                    label = chalk.yellow(`Capped at ${capFrac != null ? Math.round(capFrac * 100) : 100}% — finishing active`);
+                    label = chalk.yellow(`Capped at ${capFrac != null ? Math.round(capFrac * 100) : 100}% \u2014 finishing active`);
                 }
             }
             else if (swarm.rateLimitResetsAt && swarm.rateLimitResetsAt > Date.now()) {
@@ -93,13 +328,11 @@ export function renderFrame(swarm, showHotkeys = false) {
             out.push(`  ${prefix}${barStr}  ${label}`);
         };
         if (windows.length > 1) {
-            // Cycle through windows every 3 seconds
             const cycleIdx = Math.floor(Date.now() / 3000) % windows.length;
             const win = windows[cycleIdx];
             const shortName = WINDOW_SHORT_NAMES[win.type] ?? win.type.replace(/_/g, " ");
             renderBar(win.utilization, shortName);
-            // Show dots indicator for which window we're viewing
-            const dots = windows.map((_, i) => i === cycleIdx ? "●" : "○").join("");
+            const dots = windows.map((_, i) => i === cycleIdx ? "\u25CF" : "\u25CB").join("");
             out[out.length - 1] += chalk.dim(`  ${dots}`);
         }
         else {
@@ -119,7 +352,7 @@ export function renderFrame(swarm, showHotkeys = false) {
                 barStr += chalk.gray("\u2591");
         }
         const label = swarm.cappedOut
-            ? chalk.red(`$${swarm.overageCostUsd.toFixed(2)}/$${swarm.extraUsageBudget} — budget hit`)
+            ? chalk.red(`$${swarm.overageCostUsd.toFixed(2)}/$${swarm.extraUsageBudget} \u2014 budget hit`)
             : `$${swarm.overageCostUsd.toFixed(2)}/$${swarm.extraUsageBudget}`;
         out.push(`  ${chalk.dim("Extra ")}${barStr}  ${label}`);
     }
@@ -134,12 +367,10 @@ export function renderFrame(swarm, showHotkeys = false) {
             " ".repeat(Math.max(1, w - 56)) +
             "Action"));
         out.push(chalk.gray("  " + "\u2500".repeat(Math.min(w - 4, 100))));
-        for (const a of show) {
+        for (const a of show)
             out.push(fmtRow(a, w));
-        }
-        if (swarm.pending > 0) {
+        if (swarm.pending > 0)
             out.push(chalk.gray(`  ... + ${swarm.pending} queued`));
-        }
     }
     // ── Merge results ──
     if (swarm.mergeResults.length > 0) {
@@ -155,16 +386,11 @@ export function renderFrame(swarm, showHotkeys = false) {
     }
     // ── Event log ──
     out.push("");
-    out.push(chalk.gray("  \u2500\u2500\u2500 Events " +
-        "\u2500".repeat(Math.min(w - 16, 90))));
+    out.push(chalk.gray("  \u2500\u2500\u2500 Events " + "\u2500".repeat(Math.min(w - 16, 90))));
     const logN = Math.min(10, swarm.logs.length);
     for (const entry of swarm.logs.slice(-logN)) {
-        const t = new Date(entry.time).toLocaleTimeString("en", {
-            hour12: false,
-        });
-        const tag = entry.agentId < 0
-            ? chalk.magenta("[sys]")
-            : chalk.cyan(`[${entry.agentId}]`);
+        const t = new Date(entry.time).toLocaleTimeString("en", { hour12: false });
+        const tag = entry.agentId < 0 ? chalk.magenta("[sys]") : chalk.cyan(`[${entry.agentId}]`);
         out.push(chalk.gray(`  ${t} `) + tag + ` ${colorEvent(truncate(entry.text, w - 22))}`);
     }
     if (showHotkeys)
@@ -172,184 +398,78 @@ export function renderFrame(swarm, showHotkeys = false) {
     out.push("");
     return out.join("\n");
 }
-function fmtRow(a, w) {
-    const id = String(a.id).padStart(3);
-    const elapsed = a.status === "running" && a.startedAt
-        ? " " + chalk.dim(fmtDur(Date.now() - a.startedAt))
-        : "";
-    const spin = SPINNER[Math.floor(Date.now() / 250) % SPINNER.length];
-    const icon = a.status === "running"
-        ? chalk.blue(`${spin} run`) + elapsed
-        : a.status === "done"
-            ? chalk.green("\u2713 done")
-            : chalk.red("\u2717 err ");
-    const taskW = Math.max(20, Math.min(36, w - 50));
-    const task = truncate(a.task.prompt, taskW).padEnd(taskW);
-    let action;
-    if (a.currentTool) {
-        action = chalk.yellow(a.currentTool);
-    }
-    else if (a.status === "running") {
-        action = chalk.dim(truncate(a.lastText || "...", 24));
-    }
-    else if (a.status === "done") {
-        const dur = fmtDur((a.finishedAt || Date.now()) - (a.startedAt || Date.now()));
-        const cost = a.costUsd != null ? ` $${a.costUsd.toFixed(3)}` : "";
-        const files = a.filesChanged != null && a.filesChanged > 0
-            ? chalk.dim(` ${a.filesChanged}f`)
-            : "";
-        action = chalk.dim(`${dur}${cost}${files}`);
-    }
-    else {
-        action = chalk.red(truncate(a.error || "error", 24));
-    }
-    return `  ${id}  ${icon}  ${task}  ${action}`;
-}
-function truncate(s, max) {
-    return s.length <= max ? s : s.slice(0, max - 1) + "\u2026";
-}
-function fmtTokens(n) {
-    if (n >= 1_000_000)
-        return `${(n / 1_000_000).toFixed(1)}M`;
-    if (n >= 1_000)
-        return `${(n / 1_000).toFixed(1)}K`;
-    return String(n);
-}
-function fmtDur(ms) {
-    const s = Math.floor(ms / 1000);
-    if (s < 60)
-        return `${s}s`;
-    const m = Math.floor(s / 60);
-    if (m < 60)
-        return `${m}m ${s % 60}s`;
-    return `${Math.floor(m / 60)}h ${m % 60}m`;
-}
-export function startRenderLoop(swarm, liveConfig) {
-    if (!process.stdout.isTTY) {
-        return startPlainLog(swarm);
-    }
-    try {
-        process.stdout.write("\x1B[?25l\x1B[2J\x1B[H");
-    }
-    catch {
-        return () => { };
-    }
-    // Live hotkey input state
-    let inputMode = "none";
-    let inputBuf = "";
-    const hasHotkeys = !!liveConfig && !!process.stdin.isTTY;
-    const render = () => {
-        let frame = renderFrame(swarm, hasHotkeys);
-        if (inputMode !== "none") {
-            const label = inputMode === "budget" ? "New budget (remaining sessions)" : "New usage cap (0-100%)";
-            frame += `\n  ${chalk.cyan(">")} ${label}: ${inputBuf}█`;
-        }
-        return frame;
-    };
-    const interval = setInterval(() => {
-        try {
-            process.stdout.write("\x1B[H\x1B[J");
-            process.stdout.write(render());
-        }
-        catch {
-            clearInterval(interval);
-        }
-    }, 250);
-    // Keyboard listener for live controls
-    let keyHandler;
-    if (liveConfig && process.stdin.isTTY) {
-        try {
-            process.stdin.setRawMode(true);
-            process.stdin.resume();
-        }
-        catch { }
-        keyHandler = (buf) => {
-            const s = buf.toString();
-            if (inputMode !== "none") {
-                if (s === "\r" || s === "\n") {
-                    const val = parseFloat(inputBuf);
-                    if (inputMode === "budget" && !isNaN(val) && val > 0) {
-                        liveConfig.remaining = Math.round(val);
-                        liveConfig.dirty = true;
-                        swarm.log(-1, `Budget changed to ${liveConfig.remaining} remaining`);
-                    }
-                    else if (inputMode === "threshold" && !isNaN(val) && val >= 0 && val <= 100) {
-                        const frac = val / 100;
-                        liveConfig.usageCap = frac > 0 ? frac : undefined;
-                        liveConfig.dirty = true;
-                        swarm.usageCap = liveConfig.usageCap;
-                        swarm.log(-1, `Usage cap changed to ${val > 0 ? val + "%" : "unlimited"}`);
-                    }
-                    inputMode = "none";
-                    inputBuf = "";
-                }
-                else if (s === "\x1B" || s === "\x03") {
-                    inputMode = "none";
-                    inputBuf = "";
-                }
-                else if (s === "\x7F") {
-                    inputBuf = inputBuf.slice(0, -1);
-                }
-                else if (/^[0-9.]$/.test(s)) {
-                    inputBuf += s;
-                }
-                return;
-            }
-            if (s === "b" || s === "B") {
-                inputMode = "budget";
-                inputBuf = "";
-            }
-            else if (s === "t" || s === "T") {
-                inputMode = "threshold";
-                inputBuf = "";
+function renderSteeringFrame(runInfo, steeringText, showHotkeys, rlGetter) {
+    const w = Math.max((process.stdout.columns ?? 80) || 80, 60);
+    const out = [];
+    const totalUsed = runInfo.accCompleted + runInfo.accFailed;
+    renderHeader(out, w, {
+        model: runInfo.model,
+        phase: chalk.magenta("STEERING"),
+        barPct: runInfo.sessionsBudget > 0 ? totalUsed / runInfo.sessionsBudget : 0,
+        barLabel: `${totalUsed}/${runInfo.sessionsBudget}`,
+        active: 0,
+        queued: 0,
+        startedAt: runInfo.startedAt,
+        totalIn: runInfo.accIn,
+        totalOut: runInfo.accOut,
+        totalCost: runInfo.accCost,
+        waveNum: runInfo.waveNum,
+        sessionsUsed: totalUsed,
+        sessionsBudget: runInfo.sessionsBudget,
+        remaining: runInfo.remaining,
+    });
+    // Usage bar from planner rate limit
+    const rl = rlGetter?.();
+    if (rl && (rl.utilization > 0 || rl.windows.size > 0)) {
+        const rlBarW = Math.min(30, w - 40);
+        const renderBar = (pct, label) => {
+            const f = Math.round(pct * rlBarW);
+            let barStr = "";
+            for (let i = 0; i < rlBarW; i++) {
+                if (i < f)
+                    barStr += pct > 0.9 ? chalk.red("\u2588") : pct > 0.75 ? chalk.yellow("\u2588") : chalk.blue("\u2588");
+                else
+                    barStr += chalk.gray("\u2591");
             }
-            else if (s === "q" || s === "Q" || s === "\x03") {
-                if (swarm.aborted)
-                    process.exit(0); // second press = force quit
-                swarm.abort();
+            let lbl = `${Math.round(pct * 100)}% used`;
+            if (rl.isUsingOverage)
+                lbl += chalk.red(" [EXTRA USAGE]");
+            if (rl.resetsAt && rl.resetsAt > Date.now()) {
+                const waitSec = Math.ceil((rl.resetsAt - Date.now()) / 1000);
+                const mm = Math.floor(waitSec / 60), ss = waitSec % 60;
+                lbl = chalk.red(`Waiting for reset ${mm > 0 ? `${mm}m ${ss}s` : `${ss}s`}`);
             }
+            const prefix = label ? chalk.dim(label.padEnd(6)) : chalk.dim("Usage ");
+            out.push(`  ${prefix}${barStr}  ${lbl}`);
         };
-        process.stdin.on("data", keyHandler);
-    }
-    return () => {
-        clearInterval(interval);
-        if (keyHandler) {
-            process.stdin.removeListener("data", keyHandler);
-            try {
-                process.stdin.setRawMode(false);
-                process.stdin.pause();
-            }
-            catch { }
+        if (rl.windows.size > 1) {
+            const wins = Array.from(rl.windows.values());
+            const idx = Math.floor(Date.now() / 3000) % wins.length;
+            const shortName = wins[idx].type.replace(/_/g, " ").slice(0, 5);
+            renderBar(wins[idx].utilization, shortName);
         }
-        try {
-            process.stdout.write("\x1B[H\x1B[J");
-            process.stdout.write(renderFrame(swarm));
-            process.stdout.write("\x1B[?25h");
+        else {
+            renderBar(rl.utilization);
         }
-        catch { }
-    };
+    }
+    out.push("");
+    out.push(chalk.gray("  " + "\u2500".repeat(Math.min(w - 4, 60))));
+    const clean = steeringText.replace(/\n/g, " ");
+    const maxTextW = w - 8;
+    out.push(`  ${chalk.cyan("\u25C6")} ${clean.length > maxTextW ? clean.slice(0, maxTextW - 1) + "\u2026" : clean}`);
+    out.push("");
+    if (showHotkeys)
+        out.push(chalk.dim("  [b] budget  [q] stop"));
+    out.push("");
+    return out.join("\n");
 }
 export function renderSummary(swarm) {
     const w = Math.max((process.stdout.columns ?? 80) || 80, 60);
     const out = [];
-    // Fixed column widths: #(3) + Status(6) + Duration(8) + Files(5) + Tools(5) + Cost(8)
-    // gaps: 6×2 = 12, indent = 2 → task gets the rest
     const fixedW = 3 + 6 + 8 + 5 + 5 + 8 + 12 + 2;
     const taskW = Math.max(10, w - fixedW);
-    const hdr = chalk.gray("  " +
-        "#".padStart(3) +
-        "  " +
-        "Status".padEnd(6) +
-        "  " +
-        "Task".padEnd(taskW) +
-        "  " +
-        "Duration".padStart(8) +
-        "  " +
-        "Files".padStart(5) +
-        "  " +
-        "Tools".padStart(5) +
-        "  " +
-        "Cost".padStart(8));
+    const hdr = chalk.gray("  " + "#".padStart(3) + "  " + "Status".padEnd(6) + "  " + "Task".padEnd(taskW) +
+        "  " + "Duration".padStart(8) + "  " + "Files".padStart(5) + "  " + "Tools".padStart(5) + "  " + "Cost".padStart(8));
     const sep = chalk.gray("  " + "\u2500".repeat(Math.min(w - 4, fixedW + taskW)));
     out.push("");
     out.push(hdr);
@@ -360,25 +480,16 @@ export function renderSummary(swarm) {
         swarm.agents.filter(a => a.status === "error"),
     ].filter(g => g.length > 0);
     const thinSep = chalk.gray("  " + "\u254C".repeat(Math.min(w - 4, fixedW + taskW)));
-    let totalDurMs = 0;
-    let totalFiles = 0;
-    let totalTools = 0;
-    let totalCost = 0;
+    let totalDurMs = 0, totalFiles = 0, totalTools = 0, totalCost = 0;
     for (let gi = 0; gi < groups.length; gi++) {
         if (gi > 0)
             out.push(thinSep);
         for (const a of groups[gi]) {
             const id = String(a.id).padStart(3);
             const ok = a.status === "done";
-            const status = ok
-                ? chalk.green("\u2713 done")
-                : a.status === "running"
-                    ? chalk.blue("~ run ")
-                    : chalk.red("\u2717 err ");
+            const status = ok ? chalk.green("\u2713 done") : a.status === "running" ? chalk.blue("~ run ") : chalk.red("\u2717 err ");
             const task = truncate(a.task.prompt, taskW).padEnd(taskW);
-            const durMs = a.startedAt != null
-                ? (a.finishedAt ?? Date.now()) - a.startedAt
-                : 0;
+            const durMs = a.startedAt != null ? (a.finishedAt ?? Date.now()) - a.startedAt : 0;
             const dur = fmtDur(durMs).padStart(8);
             const files = String(a.filesChanged ?? 0).padStart(5);
             const tools = String(a.toolCalls).padStart(5);
@@ -392,44 +503,55 @@ export function renderSummary(swarm) {
         }
     }
     out.push(sep);
-    // Totals row
     const label = `${swarm.agents.length} tasks`.padEnd(taskW);
     out.push(chalk.bold(`  ${"".padStart(3)}  ${"Total ".padEnd(6)}  ${label}  ${fmtDur(totalDurMs).padStart(8)}  ${String(totalFiles).padStart(5)}  ${String(totalTools).padStart(5)}  ${`$${totalCost.toFixed(3)}`.padStart(8)}`));
     out.push("");
     return out.join("\n");
 }
-function startPlainLog(swarm) {
-    let lastSeq = swarm.logSequence;
-    let lastCompleted = -1;
-    const write = (line) => {
-        try {
-            process.stdout.write(line + "\n");
-        }
-        catch {
-            clearInterval(interval);
-        }
-    };
-    const interval = setInterval(() => {
-        const currentSeq = swarm.logSequence;
-        if (currentSeq > lastSeq) {
-            // Read the most recent (currentSeq - lastSeq) entries from the tail of the log
-            const newCount = currentSeq - lastSeq;
-            const available = swarm.logs.length;
-            const toShow = Math.min(newCount, available);
-            for (const entry of swarm.logs.slice(available - toShow)) {
-                const t = new Date(entry.time).toLocaleTimeString("en", { hour12: false });
-                const tag = entry.agentId < 0 ? "[sys]" : `[${entry.agentId}]`;
-                write(`${t} ${tag} ${entry.text}`);
-            }
-            lastSeq = currentSeq;
-        }
-        if (swarm.completed !== lastCompleted) {
-            lastCompleted = swarm.completed;
-            write(`progress: ${swarm.completed}/${swarm.total} done, ${swarm.active} active, ${swarm.pending} queued`);
-        }
-    }, 500);
-    return () => {
-        clearInterval(interval);
-        write(`done: ${swarm.completed}/${swarm.total} tasks, ${fmtDur(Date.now() - swarm.startedAt)}`);
-    };
+// ── Formatting helpers ──
+function fmtRow(a, w) {
+    const id = String(a.id).padStart(3);
+    const elapsed = a.status === "running" && a.startedAt ? " " + chalk.dim(fmtDur(Date.now() - a.startedAt)) : "";
+    const spin = SPINNER[Math.floor(Date.now() / 250) % SPINNER.length];
+    const icon = a.status === "running"
+        ? chalk.blue(`${spin} run`) + elapsed
+        : a.status === "done" ? chalk.green("\u2713 done") : chalk.red("\u2717 err ");
+    const taskW = Math.max(20, Math.min(36, w - 50));
+    const task = truncate(a.task.prompt, taskW).padEnd(taskW);
+    let action;
+    if (a.currentTool) {
+        action = chalk.yellow(a.currentTool);
+    }
+    else if (a.status === "running") {
+        action = chalk.dim(truncate(a.lastText || "...", 24));
+    }
+    else if (a.status === "done") {
+        const dur = fmtDur((a.finishedAt || Date.now()) - (a.startedAt || Date.now()));
+        const cost = a.costUsd != null ? ` $${a.costUsd.toFixed(3)}` : "";
+        const files = a.filesChanged != null && a.filesChanged > 0 ? chalk.dim(` ${a.filesChanged}f`) : "";
+        action = chalk.dim(`${dur}${cost}${files}`);
+    }
+    else {
+        action = chalk.red(truncate(a.error || "error", 24));
+    }
+    return `  ${id}  ${icon}  ${task}  ${action}`;
+}
+function truncate(s, max) {
+    return s.length <= max ? s : s.slice(0, max - 1) + "\u2026";
+}
+function fmtTokens(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(1)}K`;
+    return String(n);
+}
+function fmtDur(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m ${s % 60}s`;
+    return `${Math.floor(m / 60)}h ${m % 60}m`;
 }

package/package.json

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