claude-overnight 1.0.0 → 1.0.1

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");
@@ -769,8 +787,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 +858,71 @@ 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) {
+                    console.log(chalk.green(`\n  ✓ Reusing ${readdirSync(designDir).filter(f => f.endsWith(".md")).length} existing design docs`) + chalk.dim(` (from prior attempt)\n`));
                 }
-                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`);
                 }
             }

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Run 10, 100, or 1000 Claude agents overnight. Parallel autonomous AI coding with thinking waves, iterative quality steering, crash recovery, and rate limit handling. Built on the Claude Agent SDK.",
   "type": "module",
   "bin": {