claude-overnight 1.0.0 → 1.1.0

package/README.md

@@ -52,7 +52,7 @@ claude-overnight
 ◆ Assessing... ✓ Vision met
 ```
 
-You interact once (objective, budget, model, review themes), then everything runs autonomously — thinking, planning, executing, reflecting, steering. Rate-limited? It waits and retries. Crash? Resume where you left off.
+You interact once (objective, budget, model, review themes), then everything runs autonomously — thinking, planning, executing, reflecting, steering. Rate-limited? It waits and retries. Crash? Resume where you left off. Capped at usage limit? Pick up next time with full context preserved.
 
 ## How it works
 
@@ -62,7 +62,7 @@ For budgets > 15, the tool launches **architect agents** that explore your codeb
 
 ### 2. Orchestration
 
-An orchestrator agent reads all design documents and synthesizes concrete execution tasks — grounded in real files and patterns the architects found. No guesswork.
+An orchestrator agent reads all design documents and synthesizes concrete execution tasks — grounded in real files and patterns the architects found. No guesswork. The task plan is also written to a file for resilience — if orchestration is interrupted, partial results survive.
 
 ### 3. Iterative execution
 
@@ -97,20 +97,30 @@ Every run gets its own folder in `.claude-overnight/runs/`. Nothing is ever over
       run.json, sessions/
 ```
 
-If a run crashes, gets rate-limited, or you Ctrl+C:
+Any run that stops before the steering system declares the objective complete — capped at usage limit, Ctrl+C, crash, rate limit timeout, steering failure — is automatically resumable:
 
 ```
-  ⚠ Interrupted run
+  ⚠ Unfinished run
   ╭──────────────────────────────────────────────────╮
   │  refactor auth, add tests, update docs           │
-  │  50/200 sessions · 3 waves · $69.16              │
+  │  50/200 sessions · 150 remaining · $69.16        │
   │  34 merged · 16 unmerged · 0 failed branches     │
   ╰──────────────────────────────────────────────────╯
 
   Resume  │  Fresh  │  Quit
 ```
 
-On resume: unmerged branches auto-merge, the wave loop continues, all context is preserved.
+On resume: unmerged branches auto-merge, the wave loop continues, all context is preserved. Designs and reflections stay on disk until the objective is truly complete.
+
+If the thinking phase succeeds but orchestration crashes, the next run detects the orphaned design docs and reuses them — no re-running $9 worth of architect agents:
+
+```
+  ✓ Reusing 5 design docs (from prior attempt)
+    Focus 0: Project Wizard UI vs VISION.md Flow
+    Focus 1: Team Load and Rebalancer Surface
+    Focus 2: Code Health After Swarm Wave
+    ...
+```
 
 **Knowledge carries forward** — new runs inherit knowledge from completed previous runs. Thinking agents and steering see what past runs built. Run 2 knows run 1 already built the auth system.
 
@@ -186,9 +196,10 @@ Built for unattended runs lasting hours or days.
 
 - **Hard block**: pauses until the rate limit window resets, then resumes
 - **Soft throttle**: slows dispatch at >75% utilization
+- **Cooldown between phases**: waits for rate limit reset after thinking before starting orchestration
 - **Retry with backoff**: transient errors (429, overloaded) retry automatically
-- **Usage cap**: set a ceiling, active agents finish, no new ones start
-- **Planner retries**: steering and orchestration also retry on rate limits (30s/60s/120s backoff)
+- **Usage cap**: set a ceiling, active agents finish, no new ones start — run is resumable
+- **Planner retries**: steering and orchestration retry on rate limits (30s/60s/120s backoff) with full context
 
 ## Worktrees and merging
 

package/dist/index.js

@@ -330,6 +330,24 @@ function findIncompleteRun(rootDir) {
     catch { }
     return null;
 }
+/** Find orphaned designs: a run where thinking succeeded but orchestration crashed (has designs, no run.json). */
+function findOrphanedDesigns(rootDir) {
+    const runsDir = join(rootDir, "runs");
+    try {
+        const dirs = readdirSync(runsDir).sort().reverse();
+        for (const d of dirs) {
+            const runDir = join(runsDir, d);
+            const hasState = existsSync(join(runDir, "run.json"));
+            if (hasState)
+                continue; // has state — either complete or properly resumable
+            const designs = readMdDir(join(runDir, "designs"));
+            if (designs)
+                return runDir;
+        }
+    }
+    catch { }
+    return null;
+}
 /** Read final status + goal from all completed previous runs (newest first, max 5). */
 function readPreviousRunKnowledge(rootDir) {
     const runsDir = join(rootDir, "runs");
@@ -588,9 +606,18 @@ async function main() {
         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 obj = r.state.objective?.slice(0, 50) || "";
             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 ? "…" : ""}`));
+            const merged = r.state.branches.filter(b => b.status === "merged").length;
+            console.log(chalk.dim(`     ${date} · ${r.state.accCompleted} done · ${merged} merged${cost}${obj ? ` · ${obj}` : ""}${obj.length >= 50 ? "…" : ""}`));
+            // Show status if available
+            let status = "";
+            try {
+                status = readFileSync(join(r.dir, "status.md"), "utf-8").trim().split("\n")[0].slice(0, 80);
+            }
+            catch { }
+            if (status)
+                console.log(chalk.dim(`       ${status}`));
         }
     }
     // ── Resume detection ──
@@ -610,10 +637,11 @@ async function main() {
             lastStatus = readFileSync(join(incomplete.dir, "status.md"), "utf-8").trim().slice(0, 120);
         }
         catch { }
-        console.log(chalk.yellow(`\n  ⚠ Interrupted run`));
+        const label = "Unfinished run";
+        console.log(chalk.yellow(`\n  ⚠ ${label}`));
         const boxLines = [
             `${obj}${obj.length >= 50 ? "…" : ""}`,
-            `${prev.accCompleted}/${prev.budget} sessions · ${prev.waveNum + 1} waves · $${prev.accCost.toFixed(2)}`,
+            `${prev.accCompleted}/${prev.budget} sessions · ${prev.remaining} remaining · $${prev.accCost.toFixed(2)}`,
         ];
         if (lastStatus)
             boxLines.push(lastStatus);
@@ -769,8 +797,9 @@ async function main() {
     let thinkingUsed = 0;
     let thinkingCost = 0, thinkingIn = 0, thinkingOut = 0, thinkingTools = 0;
     let thinkingHistory;
-    // Create run directory early so thinking wave can use it
-    const runDir = resuming && resumeRunDir ? resumeRunDir : createRunDir(rootDir);
+    // Create run directory — reuse orphaned run (thinking succeeded, orchestration crashed) if available
+    const orphanedDir = !resuming ? findOrphanedDesigns(rootDir) : null;
+    const runDir = resuming && resumeRunDir ? resumeRunDir : (orphanedDir ?? createRunDir(rootDir));
     const previousKnowledge = readPreviousRunKnowledge(rootDir);
     // ── Plan phase (interactive: review loop, non-interactive: auto-plan or skip) ──
     const needsPlan = tasks.length === 0;
@@ -839,56 +868,81 @@ async function main() {
                 }
                 // ── From here, fully autonomous — no more user interaction ──
                 process.stdout.write("\x1B[?25l");
-                // Phase 2: Thinking wave
+                // Phase 2: Thinking wave — skip if design docs already exist (e.g. previous orchestration failed)
                 mkdirSync(designDir, { recursive: true });
-                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,
-                    model: plannerModel,
-                    permissionMode,
-                    useWorktrees: false,
-                    mergeStrategy: "yolo",
-                    agentTimeoutMs,
-                    usageCap,
-                });
-                const stopThinkRender = startRenderLoop(thinkingSwarm);
-                try {
-                    await thinkingSwarm.run();
+                const existingDesigns = readMdDir(designDir);
+                if (existingDesigns) {
+                    const designFiles = readdirSync(designDir).filter(f => f.endsWith(".md")).sort();
+                    console.log(chalk.green(`\n  ✓ Reusing ${designFiles.length} design docs`) + chalk.dim(` (from prior attempt)`));
+                    for (const f of designFiles) {
+                        try {
+                            const firstLine = readFileSync(join(designDir, f), "utf-8").split("\n")[0].replace(/^#+\s*/, "").trim();
+                            if (firstLine)
+                                console.log(chalk.dim(`    ${firstLine.slice(0, 80)}`));
+                        }
+                        catch { }
+                    }
+                    console.log("");
                 }
-                finally {
-                    stopThinkRender();
+                else {
+                    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,
+                        model: plannerModel,
+                        permissionMode,
+                        useWorktrees: false,
+                        mergeStrategy: "yolo",
+                        agentTimeoutMs,
+                        usageCap,
+                    });
+                    const stopThinkRender = startRenderLoop(thinkingSwarm);
+                    try {
+                        await thinkingSwarm.run();
+                    }
+                    finally {
+                        stopThinkRender();
+                    }
+                    console.log(renderSummary(thinkingSwarm));
+                    thinkingUsed = thinkingSwarm.completed + thinkingSwarm.failed;
+                    thinkingCost = thinkingSwarm.totalCostUsd;
+                    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,
+                        })),
+                    };
+                    // Wait for rate limit reset before orchestration
+                    if (thinkingSwarm.rateLimitResetsAt) {
+                        const waitMs = thinkingSwarm.rateLimitResetsAt - Date.now();
+                        if (waitMs > 0) {
+                            console.log(chalk.dim(`  Waiting ${Math.ceil(waitMs / 1000)}s for rate limit reset...`));
+                            await new Promise(r => setTimeout(r, waitMs + 2000));
+                        }
+                    }
                 }
-                console.log(renderSummary(thinkingSwarm));
-                thinkingUsed = thinkingSwarm.completed + thinkingSwarm.failed;
-                thinkingCost = thinkingSwarm.totalCostUsd;
-                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
                 const designs = readMdDir(designDir);
+                const taskFile = join(runDir, "tasks.json");
                 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, designs, cwd, plannerModel, workerModel, permissionMode, orchBudget, concurrency, makeProgressLog(), flexNote);
+                    tasks = await orchestrate(objective, designs, cwd, plannerModel, workerModel, permissionMode, orchBudget, concurrency, makeProgressLog(), flexNote, taskFile);
                     process.stdout.write(`\x1B[2K\r  ${chalk.green(`\u2713 ${tasks.length} tasks`)}\n\n`);
                 }
                 else {
                     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());
+                    tasks = await planTasks(objective, cwd, plannerModel, workerModel, permissionMode, waveBudget, concurrency, makeProgressLog(), undefined, taskFile);
                     process.stdout.write(`\x1B[2K\r  ${chalk.green(`\u2713 ${tasks.length} tasks`)}\n\n`);
                 }
             }
@@ -996,7 +1050,7 @@ async function main() {
     const waveHistory = [];
     let accCost, accCompleted, accFailed, accTools;
     let accIn = 0, accOut = 0;
-    let lastCapped = false, lastAborted = false;
+    let lastCapped = false, lastAborted = false, objectiveComplete = false;
     let lastWaveKind;
     let reflectionBudgetUsed;
     const branches = [];
@@ -1159,6 +1213,7 @@ async function main() {
                 if (steer.done || steer.action === "done") {
                     console.log(chalk.green(`  \u2713 ${steer.reasoning}\n`));
                     steerDone = true;
+                    objectiveComplete = true;
                     remaining = 0; // exit outer loop too
                     break;
                 }
@@ -1211,6 +1266,7 @@ async function main() {
                 // action === "execute"
                 if (steer.tasks.length === 0) {
                     console.log(chalk.green(`  \u2713 ${steer.reasoning}\n`));
+                    objectiveComplete = true;
                     remaining = 0;
                     break;
                 }
@@ -1228,22 +1284,26 @@ async function main() {
         }
         waveNum++;
     }
-    // Mark run as done — keep sessions/milestones/status/goal, clean transient files
+    // 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";
     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,
+        branches, phase: finalPhase, startedAt: new Date(runStartedAt).toISOString(), cwd,
     });
-    try {
-        rmSync(join(runDir, "designs"), { recursive: true, force: true });
-    }
-    catch { }
-    try {
-        rmSync(join(runDir, "reflections"), { recursive: true, force: true });
+    if (trulyDone) {
+        try {
+            rmSync(join(runDir, "designs"), { recursive: true, force: true });
+        }
+        catch { }
+        try {
+            rmSync(join(runDir, "reflections"), { recursive: true, force: true });
+        }
+        catch { }
     }
-    catch { }
     // Switch back if we created a run branch
     if (runBranch && originalRef) {
         try {

package/dist/planner.d.ts

@@ -27,10 +27,10 @@ export interface RunMemory {
 }
 export type ModelTier = "opus" | "sonnet" | "haiku" | "unknown";
 export declare function detectModelTier(model: string): ModelTier;
-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): Promise<Task[]>;
+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): Promise<string[]>;
 export declare function buildThinkingTasks(objective: string, themes: string[], designDir: string, plannerModel: string, previousKnowledge?: string): Task[];
 export declare function buildReflectionTasks(objective: string, goal: string, reflectionDir: string, waveNum: number, plannerModel: string): Task[];
-export declare function orchestrate(objective: string, designDocs: string, cwd: string, plannerModel: string, workerModel: string, permissionMode: PermMode, budget: number, concurrency: number, onLog: (text: string) => void, flexNote?: string): Promise<Task[]>;
+export declare function orchestrate(objective: string, designDocs: string, cwd: string, plannerModel: string, workerModel: string, permissionMode: PermMode, budget: number, concurrency: number, onLog: (text: string) => void, flexNote?: string, outFile?: string): Promise<Task[]>;
 export declare function refinePlan(objective: string, previousTasks: Task[], feedback: string, cwd: string, plannerModel: string, workerModel: string, permissionMode: PermMode, budget: number | undefined, concurrency: number, onLog: (text: string) => void): Promise<Task[]>;
 export declare function steerWave(objective: string, history: WaveSummary[], remainingBudget: number, cwd: string, plannerModel: string, workerModel: string, permissionMode: PermMode, concurrency: number, onLog: (text: string) => void, runMemory?: RunMemory): Promise<SteerResult>;

package/dist/planner.js

@@ -1,4 +1,5 @@
 import { query } from "@anthropic-ai/claude-agent-sdk";
+import { readFileSync } from "fs";
 const INACTIVITY_MS = 5 * 60 * 1000;
 export function detectModelTier(model) {
     const m = model.toLowerCase();
@@ -179,8 +180,8 @@ async function runPlannerQueryOnce(prompt, opts, onLog) {
         options: {
             cwd: opts.cwd,
             model: opts.model,
-            tools: ["Read", "Glob", "Grep"],
-            allowedTools: ["Read", "Glob", "Grep"],
+            tools: ["Read", "Glob", "Grep", "Write"],
+            allowedTools: ["Read", "Glob", "Grep", "Write"],
             permissionMode: opts.permissionMode,
             ...(opts.permissionMode === "bypassPermissions" && { allowDangerouslySkipPermissions: true }),
             persistSession: false,
@@ -311,21 +312,15 @@ function postProcess(raw, budget, onLog) {
     tasks = tasks.map((t, i) => ({ ...t, id: String(i) }));
     return tasks;
 }
-export async function planTasks(objective, cwd, plannerModel, workerModel, permissionMode, budget, concurrency, onLog, flexNote) {
+export async function planTasks(objective, cwd, plannerModel, workerModel, permissionMode, budget, concurrency, onLog, flexNote, outFile) {
     onLog("Analyzing codebase...");
-    const resultText = await runPlannerQuery(plannerPrompt(objective, workerModel, budget, concurrency, flexNote), { cwd, model: plannerModel, permissionMode }, onLog);
+    const prompt = plannerPrompt(objective, workerModel, budget, concurrency, flexNote);
+    const fileInstruction = outFile ? `\n\nAFTER generating the JSON, also write it to ${outFile} using the Write tool.` : "";
+    const resultText = await runPlannerQuery(prompt + fileInstruction, { cwd, model: plannerModel, permissionMode }, onLog);
     const parsed = await extractTaskJson(resultText, async () => {
-        onLog("Retrying for valid JSON...");
-        let retryText = "";
-        for await (const msg of query({
-            prompt: `Your previous response did not contain valid JSON. Output ONLY a JSON object:\n{"tasks":[{"prompt":"..."}]}`,
-            options: { cwd, model: plannerModel, permissionMode, ...(permissionMode === "bypassPermissions" && { allowDangerouslySkipPermissions: true }), persistSession: false },
-        })) {
-            if (msg.type === "result" && msg.subtype === "success")
-                retryText = msg.result || "";
-        }
-        return retryText;
-    });
+        onLog("Retrying...");
+        return runPlannerQuery(`Your previous response was not valid JSON. Respond with ONLY a JSON object {"tasks":[{"prompt":"..."}]}.\n\n${prompt}`, { cwd, model: plannerModel, permissionMode }, onLog);
+    }, onLog, outFile);
     let tasks = (parsed.tasks || []).map((t, i) => ({
         id: String(i),
         prompt: typeof t === "string" ? t : t.prompt,
@@ -428,9 +423,10 @@ End with ## Priorities: rank the top 3 things that would most improve the result
         },
     ];
 }
-export async function orchestrate(objective, designDocs, cwd, plannerModel, workerModel, permissionMode, budget, concurrency, onLog, flexNote) {
+export async function orchestrate(objective, designDocs, cwd, plannerModel, workerModel, permissionMode, budget, concurrency, onLog, flexNote, outFile) {
     const capability = modelCapabilityBlock(workerModel);
     const flexLine = flexNote ? `\n\n${flexNote}` : "";
+    const fileInstruction = outFile ? `\n\nAFTER generating the JSON, also write it to ${outFile} using the Write tool.` : "";
     const prompt = `You are a tech lead planning a sprint based on your team's codebase research.
 
 Objective: ${objective}
@@ -452,21 +448,13 @@ Requirements:
 - Priority order: foundational first, polish last${flexLine}
 
 Respond with ONLY a JSON object (no markdown fences):
-{"tasks": [{"prompt": "..."}]}`;
+{"tasks": [{"prompt": "..."}]}${fileInstruction}`;
     onLog("Synthesizing...");
     const resultText = await runPlannerQuery(prompt, { cwd, model: plannerModel, permissionMode }, onLog);
     const parsed = await extractTaskJson(resultText, async () => {
         onLog("Retrying...");
-        let retryText = "";
-        for await (const msg of query({
-            prompt: `Output ONLY a JSON object:\n{"tasks":[{"prompt":"..."}]}`,
-            options: { cwd, model: plannerModel, permissionMode, ...(permissionMode === "bypassPermissions" && { allowDangerouslySkipPermissions: true }), persistSession: false },
-        })) {
-            if (msg.type === "result" && msg.subtype === "success")
-                retryText = msg.result || "";
-        }
-        return retryText;
-    });
+        return runPlannerQuery(`Your previous response was not valid JSON. Respond with ONLY a JSON object {"tasks":[{"prompt":"..."}]}.\n\n${prompt}`, { cwd, model: plannerModel, permissionMode }, onLog);
+    }, onLog, outFile);
     let tasks = (parsed.tasks || []).map((t, i) => ({
         id: String(i),
         prompt: typeof t === "string" ? t : t.prompt,
@@ -505,16 +493,8 @@ Respond with ONLY a JSON object (no markdown):
     const resultText = await runPlannerQuery(prompt, { cwd, model: plannerModel, permissionMode }, onLog);
     const parsed = await extractTaskJson(resultText, async () => {
         onLog("Retrying...");
-        let retryText = "";
-        for await (const msg of query({
-            prompt: `Output ONLY a JSON object:\n{"tasks":[{"prompt":"..."}]}`,
-            options: { cwd, model: plannerModel, permissionMode, ...(permissionMode === "bypassPermissions" && { allowDangerouslySkipPermissions: true }), persistSession: false },
-        })) {
-            if (msg.type === "result" && msg.subtype === "success")
-                retryText = msg.result || "";
-        }
-        return retryText;
-    });
+        return runPlannerQuery(`Your previous response was not valid JSON. Respond with ONLY a JSON object {"tasks":[{"prompt":"..."}]}.\n\n${prompt}`, { cwd, model: plannerModel, permissionMode }, onLog);
+    }, onLog);
     let tasks = (parsed.tasks || []).map((t, i) => ({
         id: String(i),
         prompt: typeof t === "string" ? t : t.prompt,
@@ -574,17 +554,55 @@ function attemptJsonParse(text) {
             catch { }
         }
     }
+    // Salvage truncated task JSON — find last complete task object and close
+    const tasksMatch = text.match(/\{\s*"tasks"\s*:\s*\[/);
+    if (tasksMatch) {
+        const lastBrace = text.lastIndexOf("}");
+        if (lastBrace > tasksMatch.index) {
+            const salvaged = text.slice(tasksMatch.index, lastBrace + 1) + "]}";
+            try {
+                const obj = JSON.parse(salvaged);
+                if (obj?.tasks?.length > 0)
+                    return obj;
+            }
+            catch { }
+        }
+    }
     return null;
 }
-/** Extract task JSON with validation and one retry. */
-async function extractTaskJson(raw, retry) {
+/** Extract task JSON: try file first, then in-memory parse, then retry with context. */
+async function extractTaskJson(raw, retry, onLog, outFile) {
+    // 1. Try reading from file (most resilient — survives truncated output)
+    if (outFile) {
+        try {
+            const fileContent = readFileSync(outFile, "utf-8");
+            const fromFile = attemptJsonParse(fileContent);
+            if (fromFile?.tasks)
+                return fromFile;
+        }
+        catch { }
+    }
+    // 2. Try parsing result text
     const first = attemptJsonParse(raw);
     if (first?.tasks)
         return first;
+    onLog?.(`Parse failed (${raw.length} chars): ${raw.slice(0, 300)}`);
+    // 3. Retry with full context
     const retryText = await retry();
+    // Re-check file in case retry wrote it
+    if (outFile) {
+        try {
+            const fileContent = readFileSync(outFile, "utf-8");
+            const fromFile = attemptJsonParse(fileContent);
+            if (fromFile?.tasks)
+                return fromFile;
+        }
+        catch { }
+    }
     const second = attemptJsonParse(retryText);
     if (second?.tasks)
         return second;
+    onLog?.(`Retry failed (${retryText.length} chars): ${retryText.slice(0, 300)}`);
     throw new Error("Planner did not return valid task JSON after retry");
 }
 // ── Wave steering ──
@@ -655,14 +673,7 @@ Respond with ONLY a JSON object (no markdown fences):
         if (first)
             return first;
         onLog("Retrying...");
-        let retryText = "";
-        for await (const msg of query({
-            prompt: `Output ONLY a JSON object: {"action":"execute"|"reflect"|"done","done":true/false,"reasoning":"...","tasks":[{"prompt":"..."}]}`,
-            options: { cwd, model: plannerModel, permissionMode, ...(permissionMode === "bypassPermissions" && { allowDangerouslySkipPermissions: true }), persistSession: false },
-        })) {
-            if (msg.type === "result" && msg.subtype === "success")
-                retryText = msg.result || "";
-        }
+        const retryText = await runPlannerQuery(`Your previous response was not valid JSON. Respond with ONLY a JSON object {"action":"execute"|"reflect"|"done","done":true/false,"reasoning":"...","tasks":[{"prompt":"..."}]}.\n\n${prompt}`, { cwd, model: plannerModel, permissionMode }, onLog);
         return attemptJsonParse(retryText) ?? { action: "done", done: true, reasoning: "Could not parse steering response" };
     })();
     const action = parsed.action || (parsed.done ? "done" : "execute");

package/dist/types.d.ts

@@ -125,7 +125,7 @@ export interface RunState {
     accCompleted: number;
     accFailed: number;
     branches: BranchRecord[];
-    phase: "executing" | "steering" | "reflecting" | "done";
+    phase: "executing" | "steering" | "reflecting" | "capped" | "done";
     startedAt: string;
     cwd: string;
 }

package/package.json

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