claude-overnight 1.25.1 → 1.25.6

package/dist/_version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.25.1";
+export declare const VERSION = "1.25.6";

package/dist/_version.js

@@ -1,2 +1,2 @@
 // Auto-generated by build — do not edit manually.
-export const VERSION = "1.25.1";
+export const VERSION = "1.25.6";

package/dist/bin.js

@@ -12,6 +12,37 @@
 process.env.CURSOR_SKIP_KEYCHAIN = "1";
 const argv = process.argv.slice(2);
 const quiet = argv.includes("-h") || argv.includes("--help") || argv.includes("-v") || argv.includes("--version");
+// Auto-update: check npm at most once every 4 hours, install and re-exec if newer.
+// Skipped in non-TTY (CI/pipe) mode, on --help/--version, and if CLAUDE_OVERNIGHT_UPDATED is set.
+if (process.stdout.isTTY && !quiet && !process.env.CLAUDE_OVERNIGHT_UPDATED) {
+    const UPDATE_INTERVAL_MS = 4 * 60 * 60 * 1000;
+    const { homedir } = await import("node:os");
+    const { join } = await import("node:path");
+    const { readFileSync, writeFileSync } = await import("node:fs");
+    const tsFile = join(homedir(), ".claude-overnight-update-ts");
+    let shouldCheck = true;
+    try {
+        shouldCheck = Date.now() - parseInt(readFileSync(tsFile, "utf-8").trim(), 10) > UPDATE_INTERVAL_MS;
+    }
+    catch { }
+    if (shouldCheck) {
+        try {
+            writeFileSync(tsFile, String(Date.now())); // stamp first so failures don't re-trigger
+            const { execFileSync, spawnSync } = await import("node:child_process");
+            const latest = execFileSync("npm", ["show", "claude-overnight", "version"], { encoding: "utf-8", timeout: 6000 }).trim();
+            const { VERSION } = await import("./_version.js");
+            if (latest !== VERSION) {
+                process.stdout.write(`\r\x1b[2K  🌙  claude-overnight \x1b[33m${VERSION} → ${latest}\x1b[0m  updating…\n`);
+                execFileSync("npm", ["i", "-g", `claude-overnight@${latest}`], { stdio: "inherit", timeout: 60000 });
+                const r = spawnSync(process.argv[0], process.argv.slice(1), {
+                    stdio: "inherit", env: { ...process.env, CLAUDE_OVERNIGHT_UPDATED: "1" },
+                });
+                process.exit(r.status ?? 0);
+            }
+        }
+        catch { } // silent — never block startup for a failed update check
+    }
+}
 if (!quiet && process.stdout.isTTY) {
     const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
     let i = 0;

package/dist/cli.d.ts

@@ -54,6 +54,9 @@ export interface FileArgs {
     permissionMode?: PermMode;
     cwd?: string;
     allowedTools?: string[];
+    beforeWave?: string | string[];
+    afterWave?: string | string[];
+    afterRun?: string | string[];
     useWorktrees?: boolean;
     mergeStrategy?: MergeStrategy;
     usageCap?: number;

package/dist/cli.js

@@ -332,7 +332,7 @@ export async function selectKey(label, options) {
     });
 }
 const KNOWN_TASK_FILE_KEYS = new Set([
-    "tasks", "objective", "concurrency", "cwd", "model", "permissionMode", "allowedTools", "worktrees", "mergeStrategy", "usageCap", "flexiblePlan",
+    "tasks", "objective", "concurrency", "cwd", "model", "permissionMode", "allowedTools", "beforeWave", "afterWave", "afterRun", "worktrees", "mergeStrategy", "usageCap", "flexiblePlan",
 ]);
 export function loadTaskFile(file) {
     const path = resolve(file);
@@ -394,6 +394,9 @@ export function loadTaskFile(file) {
         cwd: parsed.cwd ? resolve(parsed.cwd) : undefined,
         permissionMode: parsed.permissionMode,
         allowedTools: parsed.allowedTools,
+        beforeWave: parsed.beforeWave,
+        afterWave: parsed.afterWave,
+        afterRun: parsed.afterRun,
         useWorktrees: parsed.worktrees,
         mergeStrategy: parsed.mergeStrategy,
         usageCap,

package/dist/index.js

@@ -271,6 +271,9 @@ async function main() {
     const nonInteractive = noTTY || fileCfg !== undefined || tasks.length > 0;
     const cwd = fileCfg?.cwd ?? process.cwd();
     const allowedTools = fileCfg?.allowedTools;
+    const beforeWave = fileCfg?.beforeWave;
+    const afterWave = fileCfg?.afterWave;
+    const afterRun = fileCfg?.afterRun;
     if (!existsSync(cwd)) {
         console.error(chalk.red(`  Working directory does not exist: ${cwd}`));
         process.exit(1);
@@ -329,7 +332,7 @@ async function main() {
             if (action === "q")
                 process.exit(0);
             if (action === "h") {
-                showRunHistory(allRuns, cwd);
+                await showRunHistory(allRuns, cwd);
                 continue;
             }
             if (action === "c") {
@@ -382,7 +385,7 @@ async function main() {
                     break;
                 }
                 if (action === "h") {
-                    showRunHistory(allRuns, cwd);
+                    await showRunHistory(allRuns, cwd);
                     continue;
                 }
                 resuming = true;
@@ -426,7 +429,7 @@ async function main() {
                     break;
                 }
                 if (action === "h") {
-                    showRunHistory(allRuns, cwd);
+                    await showRunHistory(allRuns, cwd);
                     continue;
                 }
                 const idx = parseInt(action) - 1;
@@ -979,6 +982,39 @@ async function main() {
                     const thinkDisplay = new RunDisplay(thinkRunInfo, { remaining: 0, usageCap, concurrency, paused: false, dirty: false });
                     thinkDisplay.setWave(thinkingSwarm);
                     thinkDisplay.start();
+                    // Save thinking-wave state on every exit path (normal, abort, double-q).
+                    const saveThinkingState = () => {
+                        thinkingUsed = thinkingSwarm.completed + thinkingSwarm.failed;
+                        thinkingCost = thinkingSwarm.totalCostUsd;
+                        thinkingIn = thinkingSwarm.totalInputTokens;
+                        thinkingOut = thinkingSwarm.totalOutputTokens;
+                        thinkingTools = thinkingSwarm.agents.reduce((sum, a) => sum + a.toolCalls, 0);
+                        try {
+                            saveRunState(runDir, {
+                                id: runDir.split(/[/\\]/).pop() ?? "",
+                                objective: objective, budget: budget ?? 10, remaining: (budget ?? 10) - thinkingUsed,
+                                workerModel, plannerModel,
+                                workerProviderId: workerProvider?.id, plannerProviderId: plannerProvider?.id,
+                                concurrency, permissionMode,
+                                usageCap, allowExtraUsage, extraUsageBudget,
+                                flex, useWorktrees, mergeStrategy,
+                                waveNum: 0, currentTasks: [],
+                                accCost: thinkingCost, accCompleted: thinkingUsed, accFailed: 0,
+                                accIn: thinkingIn, accOut: thinkingOut, accTools: thinkingTools,
+                                branches: [],
+                                phase: "planning",
+                                startedAt: new Date().toISOString(),
+                                cwd,
+                            });
+                        }
+                        catch { }
+                    };
+                    // Catch double-q / hard exit during thinking wave
+                    const exitHandler = () => { try {
+                        saveThinkingState();
+                    }
+                    catch { } };
+                    process.on("exit", exitHandler);
                     try {
                         await thinkingSwarm.run();
                     }
@@ -986,35 +1022,10 @@ async function main() {
                         thinkDisplay.pause();
                         console.log(renderSummary(thinkingSwarm));
                         thinkDisplay.stop();
+                        saveThinkingState();
+                        process.removeListener("exit", exitHandler);
                     }
-                    thinkingUsed = thinkingSwarm.completed + thinkingSwarm.failed;
-                    thinkingCost = thinkingSwarm.totalCostUsd;
-                    thinkingIn = thinkingSwarm.totalInputTokens;
-                    thinkingOut = thinkingSwarm.totalOutputTokens;
-                    thinkingTools = thinkingSwarm.agents.reduce((sum, a) => sum + a.toolCalls, 0);
                     thinkingHistory = { wave: -1, tasks: thinkingSwarm.agents.map(a => ({ prompt: a.task.prompt.slice(0, 200), status: a.status, filesChanged: a.filesChanged, error: a.error })) };
-                    // Persist thinking cost/count into run.json so if the user quits
-                    // between thinking and orchestrate, resume still sees the real spend
-                    // and the run stays visible in the picker (designs on disk = resumable).
-                    try {
-                        saveRunState(runDir, {
-                            id: runDir.split(/[/\\]/).pop() ?? "",
-                            objective: objective, budget: budget ?? 10, remaining: (budget ?? 10) - thinkingUsed,
-                            workerModel, plannerModel,
-                            workerProviderId: workerProvider?.id, plannerProviderId: plannerProvider?.id,
-                            concurrency, permissionMode,
-                            usageCap, allowExtraUsage, extraUsageBudget,
-                            flex, useWorktrees, mergeStrategy,
-                            waveNum: 0, currentTasks: [],
-                            accCost: thinkingCost, accCompleted: thinkingUsed, accFailed: 0,
-                            accIn: thinkingIn, accOut: thinkingOut, accTools: thinkingTools,
-                            branches: [],
-                            phase: "planning",
-                            startedAt: new Date().toISOString(),
-                            cwd,
-                        });
-                    }
-                    catch { }
                     if (thinkingSwarm.rateLimitResetsAt) {
                         const waitMs = thinkingSwarm.rateLimitResetsAt - Date.now();
                         if (waitMs > 0) {
@@ -1124,7 +1135,7 @@ async function main() {
         tasks, objective, budget: budget ?? tasks.length, workerModel, plannerModel, fastModel,
         workerProvider, plannerProvider, fastProvider, concurrency,
         permissionMode, useWorktrees, mergeStrategy, usageCap, allowExtraUsage, extraUsageBudget,
-        flex, agentTimeoutMs, cwd, allowedTools, runDir, previousKnowledge,
+        flex, agentTimeoutMs, cwd, allowedTools, beforeWave, afterWave, afterRun, runDir, previousKnowledge,
         resuming, resumeState: resumeState ?? undefined,
         thinkingUsed, thinkingCost, thinkingIn, thinkingOut, thinkingTools, thinkingHistory,
         runStartedAt: resuming && resumeState?.startedAt ? new Date(resumeState.startedAt).getTime() : Date.now(),

package/dist/planner-query.js

@@ -115,8 +115,8 @@ async function runPlannerQueryOnce(prompt, opts, onLog) {
         options: {
             cwd: opts.cwd,
             model: opts.model,
-            tools: ["Read", "Glob", "Grep", "Write"],
-            allowedTools: ["Read", "Glob", "Grep", "Write"],
+            tools: ["Read", "Glob", "Grep", "Write", "Bash", "WebFetch", "WebSearch", "TodoWrite", "Agent"],
+            allowedTools: ["Read", "Glob", "Grep", "Write", "Bash", "WebFetch", "WebSearch", "TodoWrite", "Agent"],
             permissionMode: opts.permissionMode,
             ...(opts.permissionMode === "bypassPermissions" && { allowDangerouslySkipPermissions: true }),
             persistSession: true,

package/dist/render.d.ts

@@ -34,6 +34,7 @@ export declare function renderUnifiedFrame(params: {
     content: ContentRenderer;
     hotkeyRow?: string;
     extraFooterRows?: string[];
+    maxRows?: number;
 }): string;
 type RLGetter = () => {
     utilization: number;
@@ -41,7 +42,7 @@ type RLGetter = () => {
     windows: Map<string, RateLimitWindow>;
     resetsAt?: number;
 };
-export declare function renderFrame(swarm: Swarm, showHotkeys: boolean, runInfo?: RunInfo, selectedAgentId?: number): string;
+export declare function renderFrame(swarm: Swarm, showHotkeys: boolean, runInfo?: RunInfo, selectedAgentId?: number, maxRows?: number, debrief?: string): string;
 export interface SteeringViewData {
     /** The ephemeral ticker heartbeat  -- elapsed, tool count, cost, current reasoning snippet. */
     statusLine: string;
@@ -50,6 +51,6 @@ export interface SteeringViewData {
     /** Optional context read from disk at setSteering() time. */
     context?: SteeringContext;
 }
-export declare function renderSteeringFrame(runInfo: RunInfo, data: SteeringViewData, showHotkeys: boolean, rlGetter?: RLGetter): string;
+export declare function renderSteeringFrame(runInfo: RunInfo, data: SteeringViewData, showHotkeys: boolean, rlGetter?: RLGetter, maxRows?: number, debrief?: string): string;
 export declare function renderSummary(swarm: Swarm): string;
 export {};

package/dist/render.js

@@ -141,9 +141,9 @@ function renderUsageBars(out, w, swarm) {
 // ── Unified frame renderer ──
 export function renderUnifiedFrame(params) {
     const w = Math.max((process.stdout.columns ?? 80) || 80, 60);
-    const out = [];
-    // Header
-    renderHeader(out, w, {
+    // ── Header (fixed) ──
+    const header = [];
+    renderHeader(header, w, {
         model: params.model,
         phase: params.phase,
         barPct: params.barPct,
@@ -160,42 +160,46 @@ export function renderUnifiedFrame(params) {
         sessionsBudget: params.sessionsBudget,
         remaining: params.remaining,
     });
-    // Usage bar
-    if (params.usageBarRender) {
-        params.usageBarRender(out, w);
-    }
-    out.push("");
-    // Content sections
+    if (params.usageBarRender)
+        params.usageBarRender(header, w);
+    header.push("");
+    // ── Footer (fixed) ──
+    const footer = [""];
+    if (params.hotkeyRow)
+        footer.push(params.hotkeyRow);
+    if (params.extraFooterRows)
+        for (const row of params.extraFooterRows)
+            footer.push(row);
+    footer.push("");
+    // ── Content (elastic — shrinks to fit) ──
+    const contentBudget = params.maxRows != null
+        ? Math.max(0, params.maxRows - header.length - footer.length)
+        : Infinity;
+    const content = [];
     const sections = params.content.sections();
     for (const sec of sections) {
-        if (sec.title) {
-            section(out, w, sec.title);
-        }
+        if (content.length >= contentBudget)
+            break;
+        if (sec.title)
+            section(content, w, sec.title);
         for (const row of sec.rows) {
-            out.push(row);
+            if (content.length >= contentBudget)
+                break;
+            content.push(row);
         }
     }
-    // Footer
-    out.push("");
-    if (params.hotkeyRow) {
-        out.push(params.hotkeyRow);
-    }
-    if (params.extraFooterRows) {
-        for (const row of params.extraFooterRows) {
-            out.push(row);
-        }
-    }
-    out.push("");
-    return out.join("\n");
+    return [...header, ...content, ...footer].join("\n");
 }
-export function renderFrame(swarm, showHotkeys, runInfo, selectedAgentId) {
+export function renderFrame(swarm, showHotkeys, runInfo, selectedAgentId, maxRows, debrief) {
+    const allDone = swarm.agents.length > 0 && swarm.agents.every(a => a.status !== "running");
+    const doneTag = allDone && !swarm.aborted ? chalk.green("COMPLETE") : "";
     const stoppingTag = swarm.aborted ? chalk.yellow("STOPPING") : "";
     const pausedTag = swarm.paused ? chalk.yellow("PAUSED") : "";
     const stallTag = swarm.stallLevel >= 3 ? chalk.red("STALL") : swarm.stallLevel > 0 ? chalk.yellow(`STALL L${swarm.stallLevel}`) : "";
     const phaseLabel = swarm.phase === "planning" ? chalk.magenta("PLANNING")
         : swarm.phase === "merging" ? chalk.yellow("MERGING")
             : swarm.rateLimitPaused > 0 ? chalk.yellow("COOLING") : "";
-    const phase = [phaseLabel, pausedTag, stallTag, stoppingTag].filter(Boolean).join(" ");
+    const phase = [phaseLabel, doneTag, pausedTag, stallTag, stoppingTag].filter(Boolean).join(" ");
     const waveUsed = swarm.completed + swarm.failed;
     const running = swarm.agents.filter(a => a.status === "running");
     const finished = swarm.agents.filter(a => a.status !== "running");
@@ -259,6 +263,11 @@ export function renderFrame(swarm, showHotkeys, runInfo, selectedAgentId) {
             // Event log (undecorated)
             const ww = Math.max((process.stdout.columns ?? 80) || 80, 60);
             const eventRows = [chalk.gray("  \u2500\u2500\u2500 Events " + "\u2500".repeat(Math.min(ww - 16, 90)))];
+            // All-done indicator: visible immediately when swarm finishes, before summary / steering
+            if (allDone && swarm.phase !== "done") {
+                eventRows.push(chalk.dim("  (all tasks done \u2014 processing)"));
+                eventRows.push("");
+            }
             const logN = Math.min(12, swarm.logs.length);
             for (const entry of swarm.logs.slice(-logN)) {
                 const t = new Date(entry.time).toLocaleTimeString("en", { hour12: false });
@@ -281,6 +290,8 @@ export function renderFrame(swarm, showHotkeys, runInfo, selectedAgentId) {
     // Build footer
     let hotkeyRow;
     const extraFooterRows = [];
+    if (debrief)
+        extraFooterRows.push(chalk.dim(`  ${debrief}`));
     if (showHotkeys) {
         const pending = runInfo?.pendingSteer ?? 0;
         const chip = pending > 0 ? chalk.cyan(`  \u270E ${pending} steer queued`) : "";
@@ -314,6 +325,7 @@ export function renderFrame(swarm, showHotkeys, runInfo, selectedAgentId) {
         content,
         hotkeyRow,
         extraFooterRows,
+        maxRows,
     });
 }
 function section(out, w, title) {
@@ -387,7 +399,7 @@ function renderStatusBlock(out, w, status) {
     for (const ln of lines)
         out.push(`  ${chalk.dim(truncate(ln.trim(), w - 4))}`);
 }
-export function renderSteeringFrame(runInfo, data, showHotkeys, rlGetter) {
+export function renderSteeringFrame(runInfo, data, showHotkeys, rlGetter, maxRows, debrief) {
     const totalUsed = runInfo.accCompleted + runInfo.accFailed;
     const ctx = data.context;
     const content = {
@@ -457,6 +469,9 @@ export function renderSteeringFrame(runInfo, data, showHotkeys, rlGetter) {
         : undefined;
     // Footer
     let hotkeyRow;
+    const extraFooterRows = [];
+    if (debrief)
+        extraFooterRows.push(chalk.dim(`  ${debrief}`));
     if (showHotkeys) {
         const pending = runInfo?.pendingSteer ?? 0;
         const chip = pending > 0 ? chalk.cyan(`  \u270E ${pending} steer queued`) : "";
@@ -480,6 +495,8 @@ export function renderSteeringFrame(runInfo, data, showHotkeys, rlGetter) {
         usageBarRender,
         content,
         hotkeyRow,
+        extraFooterRows,
+        maxRows,
     });
 }
 export function renderSummary(swarm) {

package/dist/run.d.ts

@@ -17,6 +17,12 @@ export interface RunConfig extends RunConfigBase {
     cwd: string;
     /** Allowlist of SDK tool names agents are permitted to use. */
     allowedTools?: string[];
+    /** Shell command(s) to run in cwd before each wave starts (e.g. "pnpm run generate"). */
+    beforeWave?: string | string[];
+    /** Shell command(s) to run in cwd after each wave completes (e.g. "supabase db push"). */
+    afterWave?: string | string[];
+    /** Shell command(s) to run in cwd once after the entire run finishes (e.g. "vercel deploy"). */
+    afterRun?: string | string[];
     /** Persisted run directory path. */
     runDir: string;
     /** Knowledge about the codebase from a pre-run thinking wave. */

package/dist/run.js

@@ -17,7 +17,7 @@ export async function executeRun(cfg) {
         process.stdout.write("\x1B[?25h\n");
     }
     catch { } };
-    const { objective, cwd, workerModel, plannerModel, fastModel, concurrency, permissionMode, allowedTools, runDir, previousKnowledge, } = cfg;
+    const { objective, cwd, workerModel, plannerModel, fastModel, concurrency, permissionMode, allowedTools, beforeWave: beforeWaveCmds, afterWave: afterWaveCmds, afterRun: afterRunCmds, runDir, previousKnowledge, } = cfg;
     const envForModel = buildEnvResolver({
         plannerModel, plannerProvider: cfg.plannerProvider,
         workerModel, workerProvider: cfg.workerProvider,
@@ -170,6 +170,21 @@ export async function executeRun(cfg) {
         else
             display.updateSteeringStatus(text);
     };
+    const runDebrief = (label) => {
+        const debriefModel = fastModel || workerModel;
+        const memory = readRunMemory(runDir, previousKnowledge || undefined);
+        const cap = (s, n) => s && s.length > n ? s.slice(0, n) + "…" : (s || "");
+        const ctx = [
+            objective ? `Objective: ${objective}` : "",
+            memory.status ? `Status:\n${cap(memory.status, 800)}` : "",
+            waveHistory.length ? `Waves done: ${waveHistory.length}` : "",
+            memory.reflections ? `Reflections:\n${cap(memory.reflections, 600)}` : "",
+        ].filter(Boolean).join("\n\n");
+        const prompt = `${label}\n\n${ctx}\n\nWrite one short sentence (max 120 chars) summarising progress and what's next. No preamble.`;
+        void runPlannerQuery(prompt, { cwd, model: debriefModel, permissionMode }, () => { })
+            .then(text => { display.setDebrief(text.trim().slice(0, 140)); })
+            .catch(() => { });
+    };
     // For flex + branch strategy: create one target branch
     let runBranch;
     let originalRef;
@@ -359,6 +374,22 @@ export async function executeRun(cfg) {
             await throttleBeforeWave(() => getPlannerRateLimitInfo(), (text) => display.appendSteeringEvent(text), () => stopping);
             if (stopping)
                 break;
+            // Before-wave commands: run in cwd before each wave starts (e.g. generate types from schema).
+            if (beforeWaveCmds) {
+                const cmds = Array.isArray(beforeWaveCmds) ? beforeWaveCmds : [beforeWaveCmds];
+                for (const cmd of cmds) {
+                    display.appendSteeringEvent(`Before-wave: ${cmd}`);
+                    try {
+                        const out = execSync(cmd, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+                        if (out.trim())
+                            display.appendSteeringEvent(`  → ${out.trim().slice(0, 200)}`);
+                    }
+                    catch (err) {
+                        const msg = (err.stderr || err.stdout || err.message || "").trim().slice(0, 300);
+                        display.appendSteeringEvent(`  ✗ ${cmd}: ${msg}`);
+                    }
+                }
+            }
             const swarm = new Swarm({
                 tasks: currentTasks, concurrency, cwd, model: workerModel, permissionMode, allowedTools,
                 useWorktrees, mergeStrategy: waveMerge, agentTimeoutMs: cfg.agentTimeoutMs,
@@ -424,6 +455,25 @@ export async function executeRun(cfg) {
                 wave: waveNum,
                 tasks: swarm.agents.map(a => ({ prompt: a.task.prompt, status: a.status, filesChanged: a.filesChanged, error: a.error })),
             });
+            // Fire-and-forget debrief after each wave.
+            runDebrief(`Wave ${waveNum + 1} just finished.`);
+            // After-wave commands: run shell commands in cwd after each wave (e.g. "supabase db push").
+            // Runs regardless of flex mode so migrations are applied before review/steering.
+            if (afterWaveCmds && !swarm.aborted && !swarm.cappedOut) {
+                const cmds = Array.isArray(afterWaveCmds) ? afterWaveCmds : [afterWaveCmds];
+                for (const cmd of cmds) {
+                    display.appendSteeringEvent(`After-wave: ${cmd}`);
+                    try {
+                        const out = execSync(cmd, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+                        if (out.trim())
+                            display.appendSteeringEvent(`  → ${out.trim().slice(0, 200)}`);
+                    }
+                    catch (err) {
+                        const msg = (err.stderr || err.stdout || err.message || "").trim().slice(0, 300);
+                        display.appendSteeringEvent(`  ✗ ${cmd}: ${msg}`);
+                    }
+                }
+            }
             // Post-wave review: a single review agent against the consolidated diff.
             // Runs only when there was real work (not first wave, not abort/cap).
             if (flex && remaining > 0 && !swarm.aborted && !swarm.cappedOut && waveNum > 0) {
@@ -530,6 +580,23 @@ export async function executeRun(cfg) {
         }
         catch { }
     }
+    // After-run commands: run once after the entire run finishes (e.g. deploy).
+    if (afterRunCmds) {
+        const cmds = Array.isArray(afterRunCmds) ? afterRunCmds : [afterRunCmds];
+        for (const cmd of cmds) {
+            console.log(chalk.dim(`  After-run: ${cmd}`));
+            try {
+                const out = execSync(cmd, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+                if (out.trim())
+                    console.log(chalk.dim(`  → ${out.trim().slice(0, 300)}`));
+            }
+            catch (err) {
+                const msg = (err.stderr || err.stdout || err.message || "").trim().slice(0, 400);
+                console.log(chalk.red(`  ✗ ${cmd}: ${msg}`));
+            }
+        }
+        console.log("");
+    }
     // ── Final summary ──
     const waves = waveNum + 1;
     const elapsed = Math.round((Date.now() - cfg.runStartedAt) / 1000);

package/dist/state.d.ts

@@ -53,7 +53,7 @@ export declare function formatTimeAgo(isoStr: string): string;
 export declare function showRunHistory(allRuns: {
     dir: string;
     state: RunState;
-}[], filterCwd: string): void;
+}[], filterCwd: string): Promise<void>;
 export declare function readPreviousRunKnowledge(rootDir: string): string;
 export declare function createRunDir(rootDir: string): string;
 export declare function updateLatestSymlink(rootDir: string, runDir: string): void;

package/dist/state.js

@@ -4,6 +4,7 @@ import { join } from "path";
 import chalk from "chalk";
 import { forceMergeOverlay } from "./merge.js";
 import { FALLBACK_MODEL } from "./models.js";
+import { selectKey } from "./cli.js";
 // ── File I/O helpers ──
 export function readMdDir(dir) {
     try {
@@ -193,12 +194,13 @@ export function findIncompleteRuns(rootDir, filterCwd) {
             const state = loadRunState(runDir);
             if (!state || state.phase === "done" || state.cwd !== filterCwd)
                 continue;
-            // Planning-phase runs are resumable if either tasks.json was written
-            // (orchestrate completed) OR design docs exist on disk (thinking wave
-            // got killed mid-way  -- we can re-orchestrate from the designs on resume).
+            // Planning-phase runs are resumable if: tasks.json exists (orchestrate
+            // completed), design docs exist (thinking wave produced output), or the
+            // run already consumed tokens (thinking wave started but was killed).
             if (state.phase === "planning"
                 && !existsSync(join(runDir, "tasks.json"))
-                && !readMdDir(join(runDir, "designs")))
+                && !readMdDir(join(runDir, "designs"))
+                && state.accCompleted === 0 && state.accCost === 0)
                 continue;
             results.push({ dir: runDir, state });
         }
@@ -303,34 +305,54 @@ export function formatTimeAgo(isoStr) {
         return `${hours}h ago`;
     return `${Math.floor(hours / 24)}d ago`;
 }
-export function showRunHistory(allRuns, filterCwd) {
-    const runs = allRuns.filter(r => r.state.cwd === filterCwd);
+export async function showRunHistory(allRuns, filterCwd) {
+    const runs = allRuns.filter(r => r.state.cwd === filterCwd && r.state.phase === "done");
     if (runs.length === 0) {
-        console.log(chalk.dim("\n  No run history.\n"));
+        console.log(chalk.dim("\n  No completed runs.\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);
+    const PAGE = 5;
+    const pages = Math.ceil(runs.length / PAGE);
+    let page = 0;
+    while (true) {
+        const w = Math.min((process.stdout.columns ?? 80) - 6, 50);
+        const pageLabel = pages > 1 ? ` (${page + 1}/${pages})` : "";
+        console.log(chalk.dim(`\n  ── Run History${pageLabel} ${"─".repeat(Math.max(0, w - 16 - pageLabel.length))}\n`));
+        for (const run of runs.slice(page * PAGE, (page + 1) * PAGE)) {
+            const s = run.state;
+            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 merged = s.branches.filter(b => b.status === "merged").length;
+            console.log(`  ${chalk.green("✓")} ${chalk.dim(date)} · ${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("");
+        }
+        if (pages === 1)
+            break;
+        const opts = [];
+        if (page < pages - 1)
+            opts.push({ key: "n", desc: "ext" });
+        if (page > 0)
+            opts.push({ key: "p", desc: "rev" });
+        opts.push({ key: "b", desc: "ack" });
+        const action = await selectKey("", opts);
+        if (action === "n") {
+            page++;
+            continue;
+        }
+        if (action === "p") {
+            page--;
+            continue;
         }
-        catch { }
-        if (status)
-            console.log(chalk.dim(`      ${status}`));
-        console.log("");
+        break;
     }
 }
 export function readPreviousRunKnowledge(rootDir) {

package/dist/types.d.ts

@@ -25,6 +25,12 @@ export interface TaskFile {
     permissionMode?: PermMode;
     /** Allowlist of SDK tool names agents are permitted to use. */
     allowedTools?: string[];
+    /** Shell command(s) to run in cwd before each wave starts (e.g. "pnpm run generate"). */
+    beforeWave?: string | string[];
+    /** Shell command(s) to run in cwd after each wave completes (e.g. "supabase db push"). */
+    afterWave?: string | string[];
+    /** Shell command(s) to run in cwd once after the entire run finishes (e.g. "vercel deploy"). */
+    afterRun?: string | string[];
     /** Merge strategy: "yolo" merges into current branch, "branch" creates a new branch. */
     mergeStrategy?: MergeStrategy;
     /** Stop dispatching new tasks when rate-limit utilization reaches this percentage (0-100). */
@@ -183,6 +189,12 @@ export interface RunConfigBase {
     flex: boolean;
     /** Use git worktree isolation for agents. */
     useWorktrees: boolean;
+    /** Shell command(s) to run in cwd before each wave starts (e.g. "pnpm run generate"). */
+    beforeWave?: string | string[];
+    /** Shell command(s) to run in cwd after each wave completes (e.g. "supabase db push"). */
+    afterWave?: string | string[];
+    /** Shell command(s) to run in cwd once after the entire run finishes (e.g. "vercel deploy"). */
+    afterRun?: string | string[];
     /** How worktree branches are merged. */
     mergeStrategy: MergeStrategy;
 }

package/dist/ui.d.ts

@@ -74,6 +74,11 @@ export declare class RunDisplay {
     private navState;
     private onSteer?;
     private onAsk?;
+    private debriefText?;
+    /** Get the latest debrief line for footer rendering. */
+    getDebrief(): string | undefined;
+    /** Set or clear the debrief text shown in the footer. */
+    setDebrief(text: string | undefined): void;
     constructor(runInfo: RunInfo, liveConfig?: LiveConfig, callbacks?: {
         onSteer?: (text: string) => void;
         onAsk?: (text: string) => void;
@@ -113,7 +118,9 @@ export declare class RunDisplay {
     resume(): void;
     stop(): void;
     private resumeInterval;
-    /** Write the full frame to stdout, clamped to terminal height. */
+    /** Write the full frame to stdout, clamped to terminal height.
+     *  Layout: header + content (elastic) + footer + input/ask (fixed).
+     *  The content area shrinks so input prompts are never clipped. */
     private flush;
     private render;
     private renderInputPrompt;
@@ -124,16 +131,16 @@ export declare class RunDisplay {
     private handlePaste;
     /** Handle a typed (non-pasted) chunk. Returns true if the frame needs a redraw.
      *
-     * Demux pipeline  -- routes arrow keys and ESC BEFORE hotkey matching:
+     * Demux pipeline  -- routes escape sequences and modifiers BEFORE hotkey matching:
      *   Raw stdin chunk → splitPaste
-     *     ├─ paste → handlePaste (existing, fine)
+     *     ├─ paste → handlePaste
      *     └─ typed → demux
-     *          ├─ ESC + [A/B/C/D  → this.navigate("up"/"down"/"right"/"left")
-     *          ├─ ESC             → cancel input / close detail / dismiss panel
-     *          ├─ Enter           → submit / reveal / select
-     *          ├─ Ctrl+C          → abort
-     *          ├─ Backspace       → delete
-     *          └─ printable       → hotkey matching (b, t, c, e, p, s, q, ?, d, 0-9)
+     *          1. ESC + [A/B/C/D  → navigate; other CSI → swallow
+     *          2. ESC + non-[     → Alt/Option+key → swallow
+     *          3. ESC alone       → cancel input / close detail / dismiss panel
+     *          4. numeric input   → digits, Enter, Backspace
+     *          5. text input      → printable chars, Enter, Backspace, ESC (with lookahead)
+     *          6. hotkey mode     → b, t, c, e, p, s, q, ?, d, 0-9
      */
     private handleTyped;
     private plainTick;

package/dist/ui.js

@@ -34,6 +34,11 @@ export class RunDisplay {
     navState = { focusSection: 0, focusRow: 0, scrollOffset: 0 };
     onSteer;
     onAsk;
+    debriefText;
+    /** Get the latest debrief line for footer rendering. */
+    getDebrief() { return this.debriefText; }
+    /** Set or clear the debrief text shown in the footer. */
+    setDebrief(text) { this.debriefText = text; }
     constructor(runInfo, liveConfig, callbacks) {
         this.runInfo = runInfo;
         this.liveConfig = liveConfig;
@@ -345,37 +350,42 @@ export class RunDisplay {
         }
         this.interval = setInterval(() => this.flush(), 250);
     }
-    /** Write the full frame to stdout, clamped to terminal height. */
+    /** Write the full frame to stdout, clamped to terminal height.
+     *  Layout: header + content (elastic) + footer + input/ask (fixed).
+     *  The content area shrinks so input prompts are never clipped. */
     flush() {
         try {
             const maxRows = (process.stdout.rows || 40) - 1;
-            const frame = this.render();
-            const lines = frame.split("\n");
-            process.stdout.write("\x1B[H\x1B[J");
-            process.stdout.write(lines.length > maxRows ? lines.slice(0, maxRows).join("\n") : frame);
+            const frame = this.render(maxRows);
+            process.stdout.write("\x1B[H\x1B[J" + frame);
         }
         catch {
             this.pause();
         }
     }
-    render() {
+    render(maxRows) {
+        // Compute how many rows the input prompt + ask panel need so the
+        // main frame can shrink its content area to leave room.
+        const inputPrompt = this.renderInputPrompt();
+        const askPanel = this.renderAskPanel();
+        const bottom = inputPrompt + askPanel;
+        const bottomRows = bottom ? (bottom.match(/\n/g) || []).length : 0;
+        const frameBudget = maxRows != null ? maxRows - bottomRows : undefined;
         let frame = "";
         if (this.swarm) {
-            frame = renderFrame(this.swarm, this.hasHotkeys(), this.runInfo, this.selectedAgentId);
+            frame = renderFrame(this.swarm, this.hasHotkeys(), this.runInfo, this.selectedAgentId, frameBudget, this.debriefText);
         }
         else if (this.steeringActive) {
             frame = renderSteeringFrame(this.runInfo, {
                 statusLine: this.steeringStatusLine,
                 events: this.steeringEvents,
                 context: this.steeringContext,
-            }, this.hasHotkeys(), this.rlGetter);
+            }, this.hasHotkeys(), this.rlGetter, frameBudget, this.debriefText);
         }
         else {
             return "";
         }
-        frame += this.renderInputPrompt();
-        frame += this.renderAskPanel();
-        return frame;
+        return frame + bottom;
     }
     renderInputPrompt() {
         if (this.inputMode === "none")
@@ -482,16 +492,16 @@ export class RunDisplay {
     }
     /** Handle a typed (non-pasted) chunk. Returns true if the frame needs a redraw.
      *
-     * Demux pipeline  -- routes arrow keys and ESC BEFORE hotkey matching:
+     * Demux pipeline  -- routes escape sequences and modifiers BEFORE hotkey matching:
      *   Raw stdin chunk → splitPaste
-     *     ├─ paste → handlePaste (existing, fine)
+     *     ├─ paste → handlePaste
      *     └─ typed → demux
-     *          ├─ ESC + [A/B/C/D  → this.navigate("up"/"down"/"right"/"left")
-     *          ├─ ESC             → cancel input / close detail / dismiss panel
-     *          ├─ Enter           → submit / reveal / select
-     *          ├─ Ctrl+C          → abort
-     *          ├─ Backspace       → delete
-     *          └─ printable       → hotkey matching (b, t, c, e, p, s, q, ?, d, 0-9)
+     *          1. ESC + [A/B/C/D  → navigate; other CSI → swallow
+     *          2. ESC + non-[     → Alt/Option+key → swallow
+     *          3. ESC alone       → cancel input / close detail / dismiss panel
+     *          4. numeric input   → digits, Enter, Backspace
+     *          5. text input      → printable chars, Enter, Backspace, ESC (with lookahead)
+     *          6. hotkey mode     → b, t, c, e, p, s, q, ?, d, 0-9
      */
     handleTyped(s) {
         const lc = this.liveConfig;
@@ -517,7 +527,11 @@ export class RunDisplay {
             // Other ANSI sequences  -- swallow silently
             return true;
         }
-        // ── 2. Standalone ESC ──
+        // ── 2. Alt/Option+key: \x1B followed by a non-bracket byte (e.g. \x1Bb, \x1Bf) ──
+        if (s.length >= 2 && s[0] === "\x1B" && s[1] !== "[") {
+            return false; // swallow — don't cancel input, don't trigger hotkeys
+        }
+        // ── 3. Standalone ESC ──
         if (s === "\x1B") {
             if (this.inputMode !== "none") {
                 this.inputMode = "none";
@@ -535,7 +549,7 @@ export class RunDisplay {
             }
             return false;
         }
-        // ── 3. Input mode: budget / threshold / concurrency / extra ──
+        // ── 4. Input mode: budget / threshold / concurrency / extra ──
         if (this.inputMode === "budget" || this.inputMode === "threshold" || this.inputMode === "concurrency" || this.inputMode === "extra") {
             let dirty = false;
             for (const ch of s) {
@@ -586,7 +600,7 @@ export class RunDisplay {
             }
             return dirty;
         }
-        // ── 4. Input mode: steer / ask ──
+        // ── 5. Input mode: steer / ask ──
         if (this.inputMode === "steer" || this.inputMode === "ask") {
             let dirty = false;
             for (let ci = 0; ci < s.length; ci++) {
@@ -609,9 +623,13 @@ export class RunDisplay {
                     this.inputSegs = [];
                     return true;
                 }
-                // ESC cancels input mode (no ANSI-byte consumption loop  -- arrows arrive
-                // as "\x1B[A" in a single call and are caught by step 1 above)
+                // ESC: if next byte exists it's part of an Alt+key sequence — skip both.
+                // Standalone ESC (no following byte) cancels input mode.
                 if (ch === "\x1B") {
+                    if (ci + 1 < s.length) {
+                        ci++;
+                        continue;
+                    }
                     this.inputMode = "none";
                     this.inputSegs = [];
                     return true;
@@ -633,7 +651,7 @@ export class RunDisplay {
             }
             return dirty;
         }
-        // ── 5. Hotkey mode ──
+        // ── 6. Hotkey mode ──
         // Enter
         if (s === "\r" || s === "\n") {
             if (this.askTempFile) {
@@ -717,7 +735,7 @@ export class RunDisplay {
             if (this.askState && !this.askState.streaming) {
                 this.askState = undefined;
                 this.clearAskTempFile();
-                return false;
+                return true;
             }
             this.inputMode = "ask";
             this.inputSegs = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.25.1",
+  "version": "1.25.6",
   "description": "Parallel Claude agents in git worktrees with a usage cap that reserves headroom for your interactive Claude Code. Crash-safe resume. Provider-agnostic model catalog (Anthropic, Cursor, OpenAI, Gemini, DeepSeek, Llama, Qwen) with capability-based task scoping.",
   "type": "module",
   "bin": {

package/plugins/claude-overnight/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.25.1",
+  "version": "1.25.6",
   "description": "Claude Code skill for understanding, installing, and inspecting claude-overnight runs  -- parallel Claude agents in git worktrees with thinking waves, multi-wave steering, and crash-safe resume. Supports Cursor API Proxy, Qwen, OpenRouter.",
   "author": {
     "name": "Francesco Fornace"

package/plugins/claude-overnight/skills/claude-overnight/SKILL.md

@@ -31,6 +31,20 @@ claude-overnight "task a" "task b"    # inline
 
 Common flags: `--budget=N`, `--concurrency=N`, `--model=<name>`, `--usage-cap=N`, `--allow-extra-usage`, `--extra-usage-budget=N`, `--timeout=SECONDS`, `--no-flex`, `--dry-run`.
 
+Task file supports lifecycle hooks — shell commands run in `cwd` at key points:
+
+```json
+{
+  "objective": "...",
+  "beforeWave": "pnpm run db:generate",
+  "afterWave":  "supabase db push",
+  "afterRun":   "vercel deploy --prod",
+  "tasks": []
+}
+```
+
+`beforeWave` runs before each wave starts · `afterWave` runs after workers merge (before review/steering) · `afterRun` runs once after the entire run. All accept a string or `string[]`. Failures are surfaced but never abort the run.
+
 Live keys while running: `b` change budget · `t` change usage cap · `q` graceful stop (twice = force).
 
 Exit codes: `0` all ok · `1` some failed · `2` all/none.