claude-overnight 0.5.0 → 1.0.0

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { readFileSync, existsSync, mkdirSync, readdirSync, rmSync } from "fs";
+import { readFileSync, existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "fs";
 import { resolve, dirname, join } from "path";
 import { fileURLToPath } from "url";
 import { execSync } from "child_process";
@@ -7,7 +7,7 @@ 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 { planTasks, refinePlan, detectModelTier, steerWave, identifyThemes, buildThinkingTasks, buildReflectionTasks, orchestrate } from "./planner.js";
 import { startRenderLoop, renderSummary } from "./ui.js";
 // ── CLI flag parsing ──
 function parseCliFlags(argv) {
@@ -270,7 +270,7 @@ function showPlan(tasks) {
     }
     console.log(chalk.dim(`  ${"─".repeat(ruleLen)}\n`));
 }
-function readDesignDocs(dir) {
+function readMdDir(dir) {
     try {
         const files = readdirSync(dir).filter(f => f.endsWith(".md")).sort();
         return files.map(f => {
@@ -282,6 +282,191 @@ function readDesignDocs(dir) {
         return "";
     }
 }
+function readRunMemory(runDir, previousRuns) {
+    let goal = "", status = "";
+    try {
+        goal = readFileSync(join(runDir, "goal.md"), "utf-8");
+    }
+    catch { }
+    try {
+        status = readFileSync(join(runDir, "status.md"), "utf-8");
+    }
+    catch { }
+    return {
+        designs: readMdDir(join(runDir, "designs")),
+        reflections: readMdDir(join(runDir, "reflections")),
+        milestones: readMdDir(join(runDir, "milestones")),
+        status,
+        goal,
+        previousRuns,
+    };
+}
+function writeStatus(baseDir, status) {
+    writeFileSync(join(baseDir, "status.md"), status, "utf-8");
+}
+function saveRunState(runDir, state) {
+    mkdirSync(runDir, { recursive: true });
+    writeFileSync(join(runDir, "run.json"), JSON.stringify(state, null, 2), "utf-8");
+}
+function loadRunState(runDir) {
+    try {
+        return JSON.parse(readFileSync(join(runDir, "run.json"), "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** Find the latest incomplete run, or null. */
+function findIncompleteRun(rootDir) {
+    const runsDir = join(rootDir, "runs");
+    try {
+        const dirs = readdirSync(runsDir).sort().reverse(); // newest first
+        for (const d of dirs) {
+            const state = loadRunState(join(runsDir, d));
+            if (state && state.phase !== "done")
+                return { dir: join(runsDir, d), state };
+        }
+    }
+    catch { }
+    return null;
+}
+/** Read final status + goal from all completed previous runs (newest first, max 5). */
+function readPreviousRunKnowledge(rootDir) {
+    const runsDir = join(rootDir, "runs");
+    try {
+        const dirs = readdirSync(runsDir).sort().reverse();
+        const summaries = [];
+        for (const d of dirs) {
+            if (summaries.length >= 5)
+                break;
+            const state = loadRunState(join(runsDir, d));
+            if (!state || state.phase !== "done")
+                continue;
+            let status = "";
+            try {
+                status = readFileSync(join(runsDir, d, "status.md"), "utf-8");
+            }
+            catch { }
+            let goal = "";
+            try {
+                goal = readFileSync(join(runsDir, d, "goal.md"), "utf-8");
+            }
+            catch { }
+            const date = d.replace("T", " ").slice(0, 19);
+            const cost = state.accCost > 0 ? ` · $${state.accCost.toFixed(2)}` : "";
+            summaries.push(`### Run ${date} (${state.accCompleted} tasks${cost})\n${status || "(no status recorded)"}\n${goal ? `Goal: ${goal.slice(0, 500)}` : ""}`);
+        }
+        return summaries.join("\n\n");
+    }
+    catch {
+        return "";
+    }
+}
+function createRunDir(rootDir) {
+    const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const runDir = join(rootDir, "runs", ts);
+    mkdirSync(join(runDir, "designs"), { recursive: true });
+    mkdirSync(join(runDir, "reflections"), { recursive: true });
+    mkdirSync(join(runDir, "milestones"), { recursive: true });
+    mkdirSync(join(runDir, "sessions"), { recursive: true });
+    return runDir;
+}
+function saveWaveSession(baseDir, waveNum, kind, swarm) {
+    const dir = join(baseDir, "sessions");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, `wave-${waveNum}.json`), JSON.stringify({
+        wave: waveNum, kind,
+        agents: swarm.agents.map(a => ({
+            id: a.id,
+            prompt: a.task.prompt,
+            status: a.status,
+            error: a.error,
+            cost: a.costUsd,
+            toolCalls: a.toolCalls,
+            filesChanged: a.filesChanged,
+            duration: a.finishedAt && a.startedAt ? a.finishedAt - a.startedAt : 0,
+            branch: a.branch,
+        })),
+        totalCost: swarm.totalCostUsd,
+    }, null, 2), "utf-8");
+}
+function recordBranches(swarm, branches) {
+    for (const a of swarm.agents) {
+        if (a.branch) {
+            branches.push({
+                branch: a.branch,
+                taskPrompt: a.task.prompt.slice(0, 200),
+                status: a.status === "done" ? "unmerged" : "failed",
+                filesChanged: a.filesChanged ?? 0,
+                costUsd: a.costUsd ?? 0,
+            });
+        }
+    }
+    // Update with merge results
+    for (const mr of swarm.mergeResults) {
+        const br = branches.find(b => b.branch === mr.branch);
+        if (br)
+            br.status = mr.ok ? "merged" : "merge-failed";
+    }
+}
+function autoMergeBranches(cwd, branches, onLog) {
+    const unmerged = branches.filter(b => b.status === "unmerged" && b.filesChanged > 0);
+    if (unmerged.length === 0)
+        return;
+    onLog(`Merging ${unmerged.length} unmerged branches...`);
+    for (const br of unmerged) {
+        try {
+            execSync(`git merge --no-edit "${br.branch}"`, { cwd, encoding: "utf-8", stdio: "pipe" });
+            br.status = "merged";
+            onLog(`  ✓ ${br.branch} (${br.filesChanged} files)`);
+        }
+        catch {
+            try {
+                try {
+                    execSync("git merge --abort", { cwd, encoding: "utf-8", stdio: "pipe" });
+                }
+                catch { }
+                execSync(`git merge --no-edit -X theirs "${br.branch}"`, { cwd, encoding: "utf-8", stdio: "pipe" });
+                br.status = "merged";
+                onLog(`  ✓ ${br.branch} (auto-resolved)`);
+            }
+            catch {
+                try {
+                    execSync("git merge --abort", { cwd, encoding: "utf-8", stdio: "pipe" });
+                }
+                catch { }
+                br.status = "merge-failed";
+                onLog(`  ✗ ${br.branch} (conflict — preserved for manual merge)`);
+            }
+        }
+    }
+}
+function archiveMilestone(baseDir, waveNum) {
+    const statusPath = join(baseDir, "status.md");
+    if (!existsSync(statusPath))
+        return;
+    const content = readFileSync(statusPath, "utf-8");
+    if (!content.trim())
+        return;
+    const milestoneDir = join(baseDir, "milestones");
+    mkdirSync(milestoneDir, { recursive: true });
+    const ts = new Date().toISOString().slice(0, 19).replace("T", " ");
+    writeFileSync(join(milestoneDir, `wave-${waveNum}.md`), `# Milestone — Wave ${waveNum} (${ts})\n\n${content}`, "utf-8");
+}
+function writeGoalUpdate(baseDir, update) {
+    const goalPath = join(baseDir, "goal.md");
+    let existing = "";
+    try {
+        existing = readFileSync(goalPath, "utf-8");
+    }
+    catch { }
+    const ts = new Date().toISOString().slice(0, 19).replace("T", " ");
+    const entry = `\n\n## Update — ${ts}\n${update}`;
+    const full = existing + entry;
+    // Keep it bounded: original + last ~3000 chars of updates
+    const trimmed = full.length > 4000 ? full.slice(0, 1000) + "\n\n...\n\n" + full.slice(-3000) : full;
+    writeFileSync(goalPath, trimmed, "utf-8");
+}
 const BRAILLE = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 function makeProgressLog() {
     let frame = 0;
@@ -386,6 +571,77 @@ async function main() {
     }
     if (noTTY)
         console.log(chalk.dim("  Non-interactive mode — using defaults\n"));
+    // ── Show run history ──
+    const rootDir = join(cwd, ".claude-overnight");
+    const runsDir = join(rootDir, "runs");
+    let completedRuns = [];
+    try {
+        const dirs = readdirSync(runsDir).sort().reverse();
+        for (const d of dirs) {
+            const s = loadRunState(join(runsDir, d));
+            if (s && s.phase === "done")
+                completedRuns.push({ dir: join(runsDir, d), state: s });
+        }
+    }
+    catch { }
+    if (completedRuns.length > 0 && !noTTY) {
+        console.log(chalk.dim(`\n  ${completedRuns.length} previous run${completedRuns.length > 1 ? "s" : ""}`));
+        for (const r of completedRuns.slice(0, 3)) {
+            const date = r.state.startedAt?.slice(0, 10) || "unknown";
+            const obj = r.state.objective?.slice(0, 40) || "";
+            const cost = r.state.accCost > 0 ? ` · $${r.state.accCost.toFixed(0)}` : "";
+            console.log(chalk.dim(`     ${date} · ${r.state.accCompleted} tasks${cost}${obj ? ` · ${obj}` : ""}${obj.length >= 40 ? "…" : ""}`));
+        }
+    }
+    // ── Resume detection ──
+    let resuming = false;
+    let resumeState = null;
+    let resumeRunDir;
+    const incomplete = findIncompleteRun(rootDir);
+    if (incomplete && incomplete.state.cwd === cwd && !noTTY && tasks.length === 0) {
+        const prev = incomplete.state;
+        const merged = prev.branches.filter(b => b.status === "merged").length;
+        const unmerged = prev.branches.filter(b => b.status === "unmerged").length;
+        const failed = prev.branches.filter(b => b.status === "failed" || b.status === "merge-failed").length;
+        const obj = prev.objective?.slice(0, 50) || "";
+        // Read last status for context
+        let lastStatus = "";
+        try {
+            lastStatus = readFileSync(join(incomplete.dir, "status.md"), "utf-8").trim().slice(0, 120);
+        }
+        catch { }
+        console.log(chalk.yellow(`\n  ⚠ Interrupted run`));
+        const boxLines = [
+            `${obj}${obj.length >= 50 ? "…" : ""}`,
+            `${prev.accCompleted}/${prev.budget} sessions · ${prev.waveNum + 1} waves · $${prev.accCost.toFixed(2)}`,
+        ];
+        if (lastStatus)
+            boxLines.push(lastStatus);
+        if (merged + unmerged + failed > 0)
+            boxLines.push(`${merged} merged · ${unmerged} unmerged · ${failed} failed branches`);
+        const boxW = Math.max(...boxLines.map(l => l.length)) + 4;
+        console.log(chalk.dim(`  ╭${"─".repeat(boxW)}╮`));
+        for (const line of boxLines)
+            console.log(chalk.dim("  │") + `  ${line.padEnd(boxW - 2)}` + chalk.dim("│"));
+        console.log(chalk.dim(`  ╰${"─".repeat(boxW)}╯`));
+        const action = await selectKey("", [
+            { key: "r", desc: "esume" },
+            { key: "f", desc: "resh" },
+            { key: "q", desc: "uit" },
+        ]);
+        if (action === "q") {
+            process.exit(0);
+        }
+        if (action === "r") {
+            resuming = true;
+            resumeState = prev;
+            resumeRunDir = incomplete.dir;
+            if (unmerged > 0) {
+                console.log("");
+                autoMergeBranches(cwd, prev.branches, (msg) => console.log(chalk.dim(`  ${msg}`)));
+            }
+        }
+    }
     // ── Interactive flow: Objective → Budget → Model → Usage cap → Plan → Review ──
     let workerModel;
     let plannerModel;
@@ -463,6 +719,8 @@ async function main() {
             parts.push("flex");
         if (usageCap != null)
             parts.push(`cap ${Math.round(usageCap * 100)}%`);
+        if (completedRuns.length > 0)
+            parts.push(`${completedRuns.length} prior`);
         const inner = parts.join(chalk.dim(" · "));
         const innerLen = parts.join(" · ").length;
         console.log(chalk.dim(`\n  ╭${"─".repeat(innerLen + 4)}╮`));
@@ -506,13 +764,17 @@ async function main() {
         console.log(chalk.dim(`  ${workerModel}  concurrency=${concurrency}  worktrees=${useWorktrees}  merge=${mergeStrategy}  perms=${permissionMode}${capStr}`));
     }
     // ── Flex mode: adaptive multi-wave planning ──
-    const flex = !argv.includes("--no-flex") && (fileCfg?.flexiblePlan ?? objective != null) && objective != null && (budget ?? 10) > 2;
+    let flex = !argv.includes("--no-flex") && (fileCfg?.flexiblePlan ?? objective != null) && objective != null && (budget ?? 10) > 2;
     const agentTimeoutMs = cliFlags.timeout ? parseFloat(cliFlags.timeout) * 1000 : undefined;
     let thinkingUsed = 0;
     let thinkingCost = 0, thinkingIn = 0, thinkingOut = 0, thinkingTools = 0;
-    let designContext;
+    let thinkingHistory;
+    // Create run directory early so thinking wave can use it
+    const runDir = resuming && resumeRunDir ? resumeRunDir : createRunDir(rootDir);
+    const previousKnowledge = readPreviousRunKnowledge(rootDir);
     // ── Plan phase (interactive: review loop, non-interactive: auto-plan or skip) ──
     const needsPlan = tasks.length === 0;
+    const designDir = join(runDir, "designs");
     if (needsPlan) {
         if (noTTY) {
             console.error(chalk.red("  No tasks provided and stdin is not a TTY. Provide tasks via args or a .json file."));
@@ -521,10 +783,10 @@ async function main() {
         process.stdout.write("\x1B[?25l");
         const planRestore = () => process.stdout.write("\x1B[?25h");
         const useThinking = flex && (budget ?? 10) > concurrency * 3;
-        const designDir = join(cwd, ".claude-overnight", "designs");
+        const thinkingCount = useThinking ? Math.min(Math.max(concurrency, Math.ceil((budget ?? 10) * 0.005)), 10) : 0;
         try {
             if (useThinking) {
-                // Phase 1: Quick theme identification
+                // Phase 1: Quick theme identification → review → then autonomous
                 let themeFrame = 0;
                 const themeSpinner = setInterval(() => {
                     const spin = chalk.cyan(BRAILLE[themeFrame++ % BRAILLE.length]);
@@ -532,15 +794,54 @@ async function main() {
                 }, 120);
                 let themes;
                 try {
-                    themes = await identifyThemes(objective, concurrency, plannerModel, permissionMode);
+                    themes = await identifyThemes(objective, thinkingCount, plannerModel, permissionMode);
                 }
                 finally {
                     clearInterval(themeSpinner);
                 }
-                process.stdout.write(`\x1B[2K\r  ${chalk.green(`\u2713 ${themes.length} themes`)}\n`);
-                // Phase 2: Thinking wave — agents explore codebase
+                process.stdout.write(`\x1B[2K\r  ${chalk.green(`\u2713 ${themes.length} themes`)}\n\n`);
+                // Show themes for review — this is the LAST user interaction
+                planRestore();
+                let reviewing = true;
+                while (reviewing) {
+                    for (let i = 0; i < themes.length; i++) {
+                        console.log(chalk.dim(`  ${String(i + 1).padStart(3)}.`) + ` ${themes[i]}`);
+                    }
+                    console.log(chalk.dim(`\n  ${thinkingCount} thinking agents → orchestrate → ${(budget ?? 10) - thinkingCount} execution sessions\n`));
+                    const action = await selectKey(`${chalk.white(`${themes.length} themes`)} ${chalk.dim(`· ${thinkingCount} thinking · ${concurrency} concurrent`)}`, [
+                        { key: "r", desc: "un" },
+                        { key: "e", desc: "dit" },
+                        { key: "q", desc: "uit" },
+                    ]);
+                    switch (action) {
+                        case "r":
+                            reviewing = false;
+                            break;
+                        case "e": {
+                            const feedback = await ask(`\n  ${chalk.bold("What should change?")}\n  ${chalk.cyan(">")} `);
+                            if (!feedback)
+                                break;
+                            process.stdout.write("\x1B[?25l");
+                            try {
+                                themes = await identifyThemes(`${objective}\n\nUser feedback: ${feedback}`, thinkingCount, plannerModel, permissionMode);
+                                process.stdout.write(`\x1B[2K\r  ${chalk.green(`\u2713 ${themes.length} themes`)}\n\n`);
+                            }
+                            catch (err) {
+                                console.error(chalk.red(`\n  Re-planning failed: ${err.message}\n`));
+                            }
+                            planRestore();
+                            break;
+                        }
+                        case "q":
+                            console.log(chalk.dim("\n  Aborted.\n"));
+                            process.exit(0);
+                    }
+                }
+                // ── From here, fully autonomous — no more user interaction ──
+                process.stdout.write("\x1B[?25l");
+                // Phase 2: Thinking wave
                 mkdirSync(designDir, { recursive: true });
-                const thinkingTasks = buildThinkingTasks(objective, themes, designDir, plannerModel);
+                const thinkingTasks = buildThinkingTasks(objective, themes, designDir, plannerModel, previousKnowledge || undefined);
                 console.log(chalk.cyan(`\n  ◆ Thinking: ${thinkingTasks.length} agents exploring...\n`));
                 const thinkingSwarm = new Swarm({
                     tasks: thinkingTasks, concurrency, cwd,
@@ -564,34 +865,102 @@ async function main() {
                 thinkingIn = thinkingSwarm.totalInputTokens;
                 thinkingOut = thinkingSwarm.totalOutputTokens;
                 thinkingTools = thinkingSwarm.agents.reduce((sum, a) => sum + a.toolCalls, 0);
+                // Record thinking wave so steering knows what happened
+                thinkingHistory = {
+                    wave: -1,
+                    kind: "think",
+                    tasks: thinkingSwarm.agents.map(a => ({
+                        prompt: a.task.prompt.slice(0, 200),
+                        status: a.status,
+                        filesChanged: a.filesChanged,
+                        error: a.error,
+                    })),
+                };
                 // Phase 3: Orchestrate from design docs
-                designContext = readDesignDocs(designDir);
-                if (designContext) {
+                const designs = readMdDir(designDir);
+                if (designs) {
                     const orchBudget = Math.min(50, Math.max(concurrency, Math.ceil(((budget ?? 10) - thinkingUsed) * 0.5)));
                     const flexNote = `This is wave 1 of an adaptive multi-wave run (total budget: ${(budget ?? 10) - thinkingUsed}). Plan the highest-impact foundational work first. Future waves will iterate based on what's learned.`;
                     console.log(chalk.cyan(`\n  ◆ Orchestrating plan...\n`));
-                    tasks = await orchestrate(objective, designContext, cwd, plannerModel, workerModel, permissionMode, orchBudget, concurrency, makeProgressLog(), flexNote);
-                    const remaining = (budget ?? 10) - thinkingUsed - tasks.length;
-                    process.stdout.write(`\x1B[2K\r  ${chalk.green(`\u2713 ${tasks.length} tasks`)}${chalk.dim(` · ${remaining} remaining`)}\n\n`);
+                    tasks = await orchestrate(objective, designs, cwd, plannerModel, workerModel, permissionMode, orchBudget, concurrency, makeProgressLog(), flexNote);
+                    process.stdout.write(`\x1B[2K\r  ${chalk.green(`\u2713 ${tasks.length} tasks`)}\n\n`);
                 }
                 else {
-                    // Fallback: no design docs produced, use direct planner
-                    console.log(chalk.yellow(`\n  No design docs produced — falling back to direct planning\n`));
+                    console.log(chalk.yellow(`\n  No design docs — falling back to direct planning\n`));
                     const waveBudget = Math.min(50, Math.max(concurrency, Math.ceil(((budget ?? 10) - thinkingUsed) * 0.5)));
                     tasks = await planTasks(objective, cwd, plannerModel, workerModel, permissionMode, waveBudget, concurrency, makeProgressLog());
                     process.stdout.write(`\x1B[2K\r  ${chalk.green(`\u2713 ${tasks.length} tasks`)}\n\n`);
                 }
             }
             else {
-                // Small budget: direct planning (no thinking wave)
+                // Small budget: direct planning → review → run
                 const waveBudget = flex ? Math.min(50, Math.max(concurrency, Math.ceil((budget ?? 10) * 0.5))) : budget;
                 const flexNote = flex
                     ? `This is wave 1 of an adaptive multi-wave run (total budget: ${budget}). Plan the highest-impact foundational work first. Future waves will iterate, polish, and expand based on what's learned.`
                     : undefined;
                 console.log(chalk.cyan(`\n  ◆ Planning${flex ? " wave 1" : ""}...\n`));
                 tasks = await planTasks(objective, cwd, plannerModel, workerModel, permissionMode, waveBudget, concurrency, makeProgressLog(), flexNote);
-                const flexHint = flex ? chalk.dim(` (wave 1, ${(budget ?? 10) - tasks.length} remaining)`) : "";
+                const flexHint = flex ? chalk.dim(` · wave 1`) : "";
                 process.stdout.write(`\x1B[2K\r  ${chalk.green(`\u2713 ${tasks.length} tasks`)}${flexHint}\n\n`);
+                // Review loop for small-budget path
+                planRestore();
+                let reviewing = true;
+                while (reviewing) {
+                    showPlan(tasks);
+                    const action = await selectKey(`${chalk.white(`${tasks.length} tasks`)} ${chalk.dim(`· ${concurrency} concurrent`)}`, [
+                        { key: "r", desc: "un" },
+                        { key: "e", desc: "dit" },
+                        { key: "c", desc: "hat" },
+                        { key: "q", desc: "uit" },
+                    ]);
+                    switch (action) {
+                        case "r":
+                            reviewing = false;
+                            break;
+                        case "e": {
+                            const feedback = await ask(`\n  ${chalk.bold("What should change?")}\n  ${chalk.cyan(">")} `);
+                            if (!feedback)
+                                break;
+                            console.log(chalk.cyan("\n  ◆ Re-planning...\n"));
+                            process.stdout.write("\x1B[?25l");
+                            try {
+                                tasks = await refinePlan(objective, tasks, feedback, cwd, plannerModel, workerModel, permissionMode, budget, concurrency, makeProgressLog());
+                                process.stdout.write(`\x1B[2K\r  ${chalk.green(`\u2713 ${tasks.length} tasks`)}\n\n`);
+                            }
+                            catch (err) {
+                                console.error(chalk.red(`\n  Re-planning failed: ${err.message}\n`));
+                            }
+                            planRestore();
+                            break;
+                        }
+                        case "c": {
+                            const question = await ask(`\n  ${chalk.bold("Ask about the plan:")}\n  ${chalk.cyan(">")} `);
+                            if (!question)
+                                break;
+                            process.stdout.write("\x1B[?25l");
+                            try {
+                                let answer = "";
+                                for await (const msg of query({
+                                    prompt: `You planned these tasks for the objective "${objective}":\n${tasks.map((t, i) => `${i + 1}. ${t.prompt}`).join("\n")}\n\nUser question: ${question}`,
+                                    options: { cwd, model: plannerModel, permissionMode, persistSession: false },
+                                })) {
+                                    if (msg.type === "result" && msg.subtype === "success")
+                                        answer = msg.result || "";
+                                }
+                                planRestore();
+                                if (answer)
+                                    console.log(chalk.dim(`\n  ${answer.slice(0, 500)}\n`));
+                            }
+                            catch {
+                                planRestore();
+                            }
+                            break;
+                        }
+                        case "q":
+                            console.log(chalk.dim("\n  Aborted.\n"));
+                            process.exit(0);
+                    }
+                }
             }
         }
         catch (err) {
@@ -602,65 +971,6 @@ async function main() {
                 console.error(chalk.red(`\n  Planning failed: ${err.message}\n`));
             process.exit(1);
         }
-        // ── Review loop ──
-        planRestore();
-        let reviewing = true;
-        while (reviewing) {
-            showPlan(tasks);
-            const action = await selectKey(`${chalk.white(`${tasks.length} tasks`)} ${chalk.dim(`· ${concurrency} concurrent`)}`, [
-                { key: "r", desc: "un" },
-                { key: "e", desc: "dit" },
-                { key: "c", desc: "hat" },
-                { key: "q", desc: "uit" },
-            ]);
-            switch (action) {
-                case "r":
-                    reviewing = false;
-                    break;
-                case "e": {
-                    const feedback = await ask(`\n  ${chalk.bold("What should change?")}\n  ${chalk.cyan(">")} `);
-                    if (!feedback)
-                        break;
-                    console.log(chalk.cyan("\n  ◆ Re-planning...\n"));
-                    process.stdout.write("\x1B[?25l");
-                    try {
-                        tasks = await refinePlan(objective, tasks, feedback, cwd, plannerModel, workerModel, permissionMode, budget, concurrency, makeProgressLog());
-                        process.stdout.write(`\x1B[2K\r  ${chalk.green(`\u2713 ${tasks.length} tasks`)}\n\n`);
-                    }
-                    catch (err) {
-                        console.error(chalk.red(`\n  Re-planning failed: ${err.message}\n`));
-                    }
-                    planRestore();
-                    break;
-                }
-                case "c": {
-                    const question = await ask(`\n  ${chalk.bold("Ask about the plan:")}\n  ${chalk.cyan(">")} `);
-                    if (!question)
-                        break;
-                    process.stdout.write("\x1B[?25l");
-                    try {
-                        let answer = "";
-                        for await (const msg of query({
-                            prompt: `You planned these tasks for the objective "${objective}":\n${tasks.map((t, i) => `${i + 1}. ${t.prompt}`).join("\n")}\n\nUser question: ${question}`,
-                            options: { cwd, model: plannerModel, permissionMode, persistSession: false },
-                        })) {
-                            if (msg.type === "result" && msg.subtype === "success")
-                                answer = msg.result || "";
-                        }
-                        planRestore();
-                        if (answer)
-                            console.log(chalk.dim(`\n  ${answer.slice(0, 500)}\n`));
-                    }
-                    catch {
-                        planRestore();
-                    }
-                    break;
-                }
-                case "q":
-                    console.log(chalk.dim("\n  Aborted.\n"));
-                    process.exit(0);
-            }
-        }
     }
     if (tasks.length === 0) {
         console.error("No tasks provided.");
@@ -675,14 +985,62 @@ async function main() {
     process.stdout.write("\x1B[?25l");
     const restore = () => process.stdout.write("\x1B[?25h\n");
     const runStartedAt = Date.now();
-    // Wave-loop state
+    // Wave-loop state — either fresh or resumed
+    mkdirSync(join(runDir, "reflections"), { recursive: true });
+    mkdirSync(join(runDir, "milestones"), { recursive: true });
+    mkdirSync(join(runDir, "sessions"), { recursive: true });
     let currentSwarm;
-    let remaining = (budget ?? tasks.length) - thinkingUsed;
-    let currentTasks = tasks;
-    let waveNum = 0;
+    let remaining;
+    let currentTasks;
+    let waveNum;
     const waveHistory = [];
-    let accCost = thinkingCost, accIn = thinkingIn, accOut = thinkingOut, accCompleted = 0, accFailed = 0, accTools = thinkingTools;
+    let accCost, accCompleted, accFailed, accTools;
+    let accIn = 0, accOut = 0;
     let lastCapped = false, lastAborted = false;
+    let lastWaveKind;
+    let reflectionBudgetUsed;
+    const branches = [];
+    if (resuming && resumeState) {
+        // Restore ALL config from saved state
+        remaining = resumeState.remaining;
+        currentTasks = resumeState.currentTasks;
+        waveNum = resumeState.waveNum;
+        accCost = resumeState.accCost;
+        accCompleted = resumeState.accCompleted;
+        accFailed = resumeState.accFailed;
+        accTools = 0;
+        lastWaveKind = resumeState.lastWaveKind;
+        reflectionBudgetUsed = resumeState.reflectionBudgetUsed;
+        branches.push(...resumeState.branches);
+        objective = resumeState.objective;
+        workerModel = resumeState.workerModel;
+        plannerModel = resumeState.plannerModel;
+        budget = resumeState.budget;
+        concurrency = resumeState.concurrency;
+        flex = resumeState.flex;
+        usageCap = resumeState.usageCap;
+        console.log(chalk.green(`\n  ✓ Resumed`) + chalk.dim(` · wave ${waveNum + 1} · ${remaining} remaining · $${accCost.toFixed(2)} spent\n`));
+    }
+    else {
+        // Fresh run
+        if (objective && !existsSync(join(runDir, "goal.md"))) {
+            writeFileSync(join(runDir, "goal.md"), `## Original Objective\n${objective}`, "utf-8");
+        }
+        remaining = (budget ?? tasks.length) - thinkingUsed;
+        currentTasks = tasks;
+        waveNum = 0;
+        if (thinkingHistory)
+            waveHistory.push(thinkingHistory);
+        accCost = thinkingCost;
+        accCompleted = 0;
+        accFailed = 0;
+        accTools = thinkingTools;
+        accIn = thinkingIn;
+        accOut = thinkingOut;
+        lastWaveKind = "execute";
+        reflectionBudgetUsed = 0;
+    }
+    const maxReflectionBudget = Math.max(2, Math.ceil((budget ?? 10) * 0.05));
     // For flex + branch strategy: create one target branch, waves merge via yolo into it
     let runBranch;
     let originalRef;
@@ -753,8 +1111,18 @@ async function main() {
         remaining -= swarm.completed + swarm.failed;
         lastCapped = swarm.cappedOut;
         lastAborted = swarm.aborted;
+        recordBranches(swarm, branches);
+        saveWaveSession(runDir, waveNum, lastWaveKind, swarm);
+        saveRunState(runDir, {
+            id: `run-${new Date().toISOString().slice(0, 19)}`, objective: objective, budget: budget ?? tasks.length,
+            remaining, workerModel, plannerModel, concurrency, permissionMode,
+            usageCap, flex, useWorktrees, mergeStrategy, waveNum, currentTasks,
+            lastWaveKind, reflectionBudgetUsed, accCost, accCompleted, accFailed,
+            branches, phase: "steering", startedAt: new Date(runStartedAt).toISOString(), cwd,
+        });
         waveHistory.push({
             wave: waveNum,
+            kind: lastWaveKind,
             tasks: swarm.agents.map(a => ({
                 prompt: a.task.prompt,
                 status: a.status,
@@ -764,30 +1132,116 @@ async function main() {
         });
         if (!flex || remaining <= 0 || swarm.aborted || swarm.cappedOut)
             break;
-        // ── Steer next wave ──
-        console.log(chalk.cyan("\n  ◆ Steering...\n"));
-        process.stdout.write("\x1B[?25l");
-        try {
-            const steer = await steerWave(objective, waveHistory, remaining, cwd, plannerModel, workerModel, permissionMode, concurrency, makeProgressLog(), designContext);
-            process.stdout.write(`\x1B[2K\r`);
-            process.stdout.write("\x1B[?25h");
-            if (steer.done) {
-                console.log(chalk.green(`  \u2713 ${steer.reasoning}\n`));
+        // ── Steer: assess quality and decide next action ──
+        // May loop through reflect→re-steer cycles before producing execution tasks
+        let steerDone = false;
+        let steerAttempts = 0;
+        while (!steerDone && remaining > 0 && !stopping && steerAttempts < 4) {
+            steerAttempts++;
+            console.log(chalk.cyan(`\n  ◆ Assessing...\n`));
+            process.stdout.write("\x1B[?25l");
+            try {
+                const memory = readRunMemory(runDir, previousKnowledge || undefined);
+                const steer = await steerWave(objective, waveHistory, remaining, cwd, plannerModel, workerModel, permissionMode, concurrency, makeProgressLog(), memory);
+                process.stdout.write(`\x1B[2K\r`);
+                process.stdout.write("\x1B[?25h");
+                // Persist context layers
+                if (steer.statusUpdate)
+                    writeStatus(runDir, steer.statusUpdate);
+                if (steer.goalUpdate) {
+                    writeGoalUpdate(runDir, steer.goalUpdate);
+                    console.log(chalk.dim(`  Goal refined: ${steer.goalUpdate.slice(0, 100)}\n`));
+                }
+                // Archive milestone every ~5 execution waves
+                const execWaves = waveHistory.filter(w => w.kind === "execute").length;
+                if (execWaves > 0 && execWaves % 5 === 0)
+                    archiveMilestone(runDir, waveNum);
+                if (steer.done || steer.action === "done") {
+                    console.log(chalk.green(`  \u2713 ${steer.reasoning}\n`));
+                    steerDone = true;
+                    remaining = 0; // exit outer loop too
+                    break;
+                }
+                if (steer.action === "reflect") {
+                    // Safety: no consecutive reflections, budget cap
+                    const canReflect = lastWaveKind !== "reflect" && reflectionBudgetUsed + 2 <= maxReflectionBudget;
+                    if (!canReflect) {
+                        console.log(chalk.dim(`  ${steer.reasoning}`));
+                        console.log(chalk.yellow(`  Reflection skipped (${lastWaveKind === "reflect" ? "consecutive" : "budget cap"}) — re-assessing\n`));
+                        lastWaveKind = "execute"; // allow next steer to see non-reflect
+                        continue; // re-steer in this inner loop
+                    }
+                    // Run reflection wave
+                    console.log(chalk.dim(`  ${steer.reasoning}`));
+                    console.log(chalk.cyan(`\n  ◆ Reflection: 2 agents reviewing...\n`));
+                    const reflectionDir = join(runDir, "reflections");
+                    waveNum++;
+                    const reflTasks = buildReflectionTasks(objective, memory.goal, reflectionDir, waveNum, plannerModel);
+                    const reflSwarm = new Swarm({
+                        tasks: reflTasks, concurrency: 2, cwd,
+                        model: plannerModel, permissionMode,
+                        useWorktrees: false, mergeStrategy: "yolo",
+                        agentTimeoutMs, usageCap,
+                    });
+                    currentSwarm = reflSwarm;
+                    const stopReflRender = startRenderLoop(reflSwarm);
+                    try {
+                        await reflSwarm.run();
+                    }
+                    finally {
+                        stopReflRender();
+                    }
+                    console.log(renderSummary(reflSwarm));
+                    accCost += reflSwarm.totalCostUsd;
+                    accIn += reflSwarm.totalInputTokens;
+                    accOut += reflSwarm.totalOutputTokens;
+                    accCompleted += reflSwarm.completed;
+                    accFailed += reflSwarm.failed;
+                    accTools += reflSwarm.agents.reduce((sum, a) => sum + a.toolCalls, 0);
+                    remaining -= reflSwarm.completed + reflSwarm.failed;
+                    reflectionBudgetUsed += reflSwarm.completed + reflSwarm.failed;
+                    waveHistory.push({
+                        wave: waveNum,
+                        kind: "reflect",
+                        tasks: reflSwarm.agents.map(a => ({ prompt: a.task.prompt, status: a.status, filesChanged: a.filesChanged, error: a.error })),
+                    });
+                    lastWaveKind = "reflect";
+                    continue; // re-steer with reflection artifacts
+                }
+                // action === "execute"
+                if (steer.tasks.length === 0) {
+                    console.log(chalk.green(`  \u2713 ${steer.reasoning}\n`));
+                    remaining = 0;
+                    break;
+                }
+                console.log(chalk.dim(`  ${steer.reasoning}\n`));
+                currentTasks = steer.tasks;
+                lastWaveKind = "execute";
+                steerDone = true; // exit inner loop, outer loop runs the tasks
+            }
+            catch (err) {
+                process.stdout.write("\x1B[?25h");
+                console.log(chalk.yellow(`  Steering failed: ${err.message?.slice(0, 80)} \u2014 stopping\n`));
+                remaining = 0;
                 break;
             }
-            console.log(chalk.dim(`  ${steer.reasoning}\n`));
-            currentTasks = steer.tasks;
-            waveNum++;
-        }
-        catch (err) {
-            process.stdout.write("\x1B[?25h");
-            console.log(chalk.yellow(`  Steering failed: ${err.message?.slice(0, 80)} \u2014 stopping\n`));
-            break;
         }
+        waveNum++;
     }
-    // Clean up design docs
+    // Mark run as done — keep sessions/milestones/status/goal, clean transient files
+    saveRunState(runDir, {
+        id: `run-${new Date().toISOString().slice(0, 19)}`, objective: objective ?? "", budget: budget ?? tasks.length,
+        remaining, workerModel, plannerModel, concurrency, permissionMode,
+        usageCap, flex, useWorktrees, mergeStrategy, waveNum, currentTasks: [],
+        lastWaveKind, reflectionBudgetUsed, accCost, accCompleted, accFailed,
+        branches, phase: "done", startedAt: new Date(runStartedAt).toISOString(), cwd,
+    });
     try {
-        rmSync(join(cwd, ".claude-overnight", "designs"), { recursive: true, force: true });
+        rmSync(join(runDir, "designs"), { recursive: true, force: true });
+    }
+    catch { }
+    try {
+        rmSync(join(runDir, "reflections"), { recursive: true, force: true });
     }
     catch { }
     // Switch back if we created a run branch
@@ -799,48 +1253,40 @@ async function main() {
     }
     // ── Final summary ──
     const waves = waveNum + 1;
-    const cappedNote = lastCapped ? chalk.yellow(` (capped at ${usageCap != null ? Math.round(usageCap * 100) : 100}%)`) : "";
-    const summaryText = accFailed > 0
-        ? chalk.yellow(`${accCompleted} done, ${accFailed} failed`) + cappedNote
-        : chalk.green(`${accCompleted} done`) + cappedNote;
-    const costText = accCost > 0 ? chalk.dim(` · $${accCost.toFixed(3)}`) : "";
-    const wavePart = waves > 1 ? chalk.dim(`${waves} waves · `) : "";
+    const elapsed = Math.round((Date.now() - runStartedAt) / 1000);
+    const elapsedStr = elapsed < 60 ? `${elapsed}s` : elapsed < 3600 ? `${Math.floor(elapsed / 60)}m ${elapsed % 60}s` : `${Math.floor(elapsed / 3600)}h ${Math.floor((elapsed % 3600) / 60)}m`;
+    const totalMerged = branches.filter(b => b.status === "merged").length;
+    const totalConflicts = branches.filter(b => b.status === "merge-failed").length;
     console.log(chalk.dim(`\n  ${"─".repeat(36)}`));
-    console.log(`  ${chalk.green("✓")} ${chalk.bold("Complete")}  ${wavePart}${summaryText}${costText}`);
-    if (accFailed > 0 && waves === 1) {
-        const failedAgents = currentSwarm?.agents.filter((a) => a.status === "error") ?? [];
-        if (failedAgents.length > 0) {
-            console.log(chalk.red(`\n  Failed agents:`));
-            for (const a of failedAgents) {
-                console.log(chalk.red(`    \u2717 Agent ${a.id + 1}: ${a.task.prompt.slice(0, 60)}${a.task.prompt.length > 60 ? "\u2026" : ""}`));
-                console.log(chalk.dim(`      ${a.error || "unknown error"}`));
-            }
-        }
+    console.log(`  ${accFailed === 0 ? chalk.green("✓") : chalk.yellow("⚠")} ${chalk.bold("Complete")}\n`);
+    const boxLines = [];
+    const statusLine = accFailed > 0 ? `${accCompleted} done · ${accFailed} failed` : `${accCompleted} done`;
+    boxLines.push(`${waves} wave${waves > 1 ? "s" : ""} · ${statusLine} · $${accCost.toFixed(2)}`);
+    boxLines.push(`${elapsedStr} · ${fmtTokens(accIn)} in / ${fmtTokens(accOut)} out · ${accTools} tools`);
+    if (totalMerged > 0 || totalConflicts > 0)
+        boxLines.push(`${totalMerged} merged${totalConflicts > 0 ? ` · ${totalConflicts} conflicts` : ""}`);
+    if (reflectionBudgetUsed > 0)
+        boxLines.push(`${reflectionBudgetUsed} reflection agents`);
+    if (lastCapped)
+        boxLines.push(chalk.yellow(`Capped at ${usageCap != null ? Math.round(usageCap * 100) : 100}%`));
+    const boxW = Math.max(...boxLines.map(l => l.replace(/\x1B\[[0-9;]*m/g, "").length)) + 4;
+    console.log(chalk.dim(`  ╭${"─".repeat(boxW)}╮`));
+    for (const line of boxLines) {
+        const plainLen = line.replace(/\x1B\[[0-9;]*m/g, "").length;
+        console.log(chalk.dim("  │") + `  ${line}${" ".repeat(Math.max(0, boxW - 2 - plainLen))}` + chalk.dim("│"));
+    }
+    console.log(chalk.dim(`  ╰${"─".repeat(boxW)}╯`));
+    if (totalConflicts > 0) {
+        const conflictBranches = branches.filter(b => b.status === "merge-failed");
+        console.log(chalk.red(`\n  Unresolved conflicts:`));
+        for (const c of conflictBranches)
+            console.log(chalk.red(`    ${c.branch}`));
+        console.log(chalk.dim("  git merge <branch> to resolve"));
     }
-    const elapsed = Math.round((Date.now() - runStartedAt) / 1000);
-    const elapsedStr = elapsed < 60 ? `${elapsed}s` : `${Math.floor(elapsed / 60)}m ${elapsed % 60}s`;
-    console.log(chalk.dim(`  ${elapsedStr}  ${fmtTokens(accIn)} in / ${fmtTokens(accOut)} out  ${accTools} tool calls`));
     if (runBranch) {
-        console.log(chalk.dim(`  Branch: ${runBranch} \u2014 create a PR or: git merge ${runBranch}`));
-    }
-    else if (currentSwarm?.mergeResults && currentSwarm.mergeResults.length > 0) {
-        const merged = currentSwarm.mergeResults.filter((r) => r.ok);
-        const autoResolved = merged.filter((r) => r.autoResolved).length;
-        const conflicts = currentSwarm.mergeResults.filter((r) => !r.ok);
-        const target = currentSwarm.mergeBranch || "HEAD";
-        if (merged.length > 0) {
-            const extra = autoResolved > 0 ? chalk.yellow(` (${autoResolved} auto-resolved)`) : "";
-            console.log(chalk.green(`  Merged ${merged.length} branch(es) into ${target}`) + extra);
-        }
-        if (currentSwarm.mergeBranch)
-            console.log(chalk.dim(`  Branch: ${currentSwarm.mergeBranch} \u2014 create a PR or: git merge ${currentSwarm.mergeBranch}`));
-        if (conflicts.length > 0) {
-            console.log(chalk.red(`  ${conflicts.length} unresolved conflict(s):`));
-            for (const c of conflicts)
-                console.log(chalk.red(`    ${c.branch}`));
-            console.log(chalk.dim("  Merge manually: git merge <branch>"));
-        }
+        console.log(chalk.dim(`\n  Branch: ${runBranch} — git merge ${runBranch}`));
     }
+    console.log(chalk.dim(`  Run: ${runDir}`));
     if (currentSwarm?.logFile)
         console.log(chalk.dim(`  Log: ${currentSwarm.logFile}`));
     console.log("");