claude-overnight 1.11.6 → 1.11.7

package/dist/index.js

@@ -5,13 +5,22 @@ import { fileURLToPath } from "url";
 import chalk from "chalk";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { Swarm } from "./swarm.js";
-import { planTasks, refinePlan, identifyThemes, buildThinkingTasks, orchestrate } from "./planner.js";
+import { planTasks, refinePlan, identifyThemes, buildThinkingTasks, orchestrate, salvageFromFile } from "./planner.js";
 import { detectModelTier } from "./planner-query.js";
 import { RunDisplay } from "./ui.js";
 import { renderSummary } from "./render.js";
 import { executeRun } from "./run.js";
 import { parseCliFlags, isAuthError, fetchModels, ask, select, selectKey, loadTaskFile, validateConcurrency, isGitRepo, validateGitRepo, showPlan, BRAILLE, makeProgressLog, } from "./cli.js";
 import { loadRunState, findIncompleteRuns, findOrphanedDesigns, formatTimeAgo, showRunHistory, readPreviousRunKnowledge, createRunDir, updateLatestSymlink, readMdDir, saveRunState, autoMergeBranches, } from "./state.js";
+function countTasksInFile(path) {
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        return Array.isArray(parsed?.tasks) ? parsed.tasks.length : 0;
+    }
+    catch {
+        return 0;
+    }
+}
 async function main() {
     const argv = process.argv.slice(2);
     if (argv.includes("-v") || argv.includes("--version")) {
@@ -162,8 +171,13 @@ async function main() {
                     lastStatus = readFileSync(join(run.dir, "status.md"), "utf-8").trim().slice(0, 120);
                 }
                 catch { }
+                const planTaskCount = prev.phase === "planning" ? countTasksInFile(join(run.dir, "tasks.json")) : 0;
                 console.log(chalk.yellow(`\n  ⚠ Unfinished run`) + chalk.dim(` · ${ago}`));
-                const boxLines = [
+                const boxLines = prev.phase === "planning" ? [
+                    `${obj}${obj.length >= 50 ? "…" : ""}`,
+                    `Plan ready · ${planTaskCount} tasks · budget ${prev.budget} · ${prev.concurrency}× concurrent`,
+                    `Plan phase · not yet executing`,
+                ] : [
                     `${obj}${obj.length >= 50 ? "…" : ""}`,
                     `${prev.accCompleted}/${prev.budget} sessions · ${Math.max(1, (prev.budget ?? 0) - prev.accCompleted)} remaining · $${prev.accCost.toFixed(2)}`,
                     `Wave ${prev.waveNum + 1} · ${prev.phase}`,
@@ -207,7 +221,13 @@ async function main() {
                     }
                     catch { }
                     console.log(chalk.cyan(`  ${i + 1}`) + `  ${obj}${obj.length >= 50 ? "…" : ""}`);
-                    console.log(chalk.dim(`     ${s.accCompleted}/${s.budget} · $${s.accCost.toFixed(2)} · ${ago} · ${s.phase} at wave ${s.waveNum + 1}${merged ? ` · ${merged} merged` : ""}`));
+                    if (s.phase === "planning") {
+                        const n = countTasksInFile(join(shown[i].dir, "tasks.json"));
+                        console.log(chalk.dim(`     plan ready · ${n} tasks · budget ${s.budget} · ${ago} · not yet executing`));
+                    }
+                    else {
+                        console.log(chalk.dim(`     ${s.accCompleted}/${s.budget} · $${s.accCost.toFixed(2)} · ${ago} · ${s.phase} at wave ${s.waveNum + 1}${merged ? ` · ${merged} merged` : ""}`));
+                    }
                     if (lastStatus)
                         console.log(chalk.dim(`     ${lastStatus}`));
                     console.log("");
@@ -236,6 +256,18 @@ async function main() {
             }
         }
         if (resuming && resumeState && resumeRunDir) {
+            // Planning-phase resume: the prior run died before executeRun ran any
+            // wave, but the orchestrate agent wrote tasks.json to disk. Load those
+            // tasks into currentTasks so executeRun can pick them up as wave 0.
+            if (resumeState.phase === "planning") {
+                const loaded = salvageFromFile(join(resumeRunDir, "tasks.json"), resumeState.budget, () => { }, "resume");
+                if (!loaded) {
+                    console.error(chalk.red(`\n  Planning-phase run has no usable tasks.json — start Fresh instead.\n`));
+                    process.exit(1);
+                }
+                resumeState.currentTasks = loaded;
+                console.log(chalk.green(`\n  ✓ Resuming plan · ${loaded.length} tasks loaded from tasks.json`));
+            }
             const unmerged = resumeState.branches.filter(b => b.status === "unmerged").length;
             if (unmerged > 0) {
                 console.log("");
@@ -479,6 +511,29 @@ async function main() {
     const previousKnowledge = readPreviousRunKnowledge(rootDir);
     const needsPlan = tasks.length === 0 && !resuming;
     const designDir = join(runDir, "designs");
+    // Persist an early planning-phase state so the run is visible to the resume
+    // picker even if orchestrate dies before executeRun gets a chance to run.
+    // Without this, a crashed plan phase leaves no run.json and the run vanishes
+    // from findIncompleteRuns — you pay for orchestration and can't see it.
+    if (needsPlan && objective) {
+        try {
+            saveRunState(runDir, {
+                id: runDir.split(/[/\\]/).pop() ?? "",
+                objective, budget: budget ?? 10, remaining: budget ?? 10,
+                workerModel, plannerModel, concurrency, permissionMode,
+                usageCap, allowExtraUsage, extraUsageBudget,
+                flex, useWorktrees, mergeStrategy,
+                waveNum: 0, currentTasks: [],
+                accCost: 0, accCompleted: 0, accFailed: 0,
+                accIn: 0, accOut: 0, accTools: 0,
+                branches: [],
+                phase: "planning",
+                startedAt: new Date().toISOString(),
+                cwd,
+            });
+        }
+        catch { }
+    }
     if (needsPlan) {
         if (noTTY) {
             console.error(chalk.red("  No tasks provided and stdin is not a TTY."));

package/dist/planner.d.ts

@@ -1,4 +1,5 @@
 import type { Task, PermMode } from "./types.js";
+export declare function salvageFromFile(outFile: string | undefined, budget: number | undefined, onLog: (text: string, kind?: "status" | "event") => void, why: string): Task[] | null;
 export declare const DESIGN_THINKING = "\nHOW TO THINK ABOUT EVERY TASK:\n\nStart from the user's job. What is someone hiring this product to do? \"I need to send money abroad cheaply\" \u2014 not \"I need a currency conversion API.\" Every decision \u2014 what to build, how fast it responds, what happens on error \u2014 flows from the job.\n\nThe experience IS the product. A 200ms server response is not a \"performance metric\" \u2014 it's the difference between an app that feels alive and one that feels broken. A loading state is not \"polish\" \u2014 it's the user knowing the app heard them. An error message is not \"error handling\" \u2014 it's the app being honest. There is no line between backend and UX. The server, the API, the database query, the render \u2014 they're all one experience the user either trusts or doesn't.\n\nBuild the core, verify it works, learn, iterate. Don't plan 20 features and build them all. Build the ONE thing that matters most, run it, see if it actually works from a user's chair. What you learn from seeing it run will change what you build next. Each wave should make what exists better before adding what doesn't exist yet.\n\nConsistency is what makes complex things feel simple. One design system, rigid rules, no exceptions. This is how Revolut ships a super-app with 30+ features that doesn't feel like chaos.\n";
 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, cwd: string, model: string, permissionMode: PermMode, onLog?: (text: string) => void): Promise<string[]>;

package/dist/planner.js

@@ -1,4 +1,29 @@
+import { readFileSync } from "fs";
 import { runPlannerQuery, extractTaskJson, attemptJsonParse, postProcess, detectModelTier, modelCapabilityBlock } from "./planner-query.js";
+// Resilience: if the planner query throws but the agent already wrote valid
+// tasks to `outFile` (via its Write tool), salvage them instead of discarding
+// expensive work. Returns salvaged tasks on success, null if nothing usable on
+// disk — caller should then re-throw the original error.
+export function salvageFromFile(outFile, budget, onLog, why) {
+    if (!outFile)
+        return null;
+    try {
+        const parsed = attemptJsonParse(readFileSync(outFile, "utf-8"));
+        if (!parsed?.tasks?.length)
+            return null;
+        let tasks = parsed.tasks.map((t, i) => ({
+            id: String(i), prompt: typeof t === "string" ? t : t.prompt,
+        }));
+        tasks = postProcess(tasks, budget, onLog);
+        if (tasks.length === 0)
+            return null;
+        onLog(`Planner errored (${why}) — salvaged ${tasks.length} tasks from ${outFile}`, "event");
+        return tasks;
+    }
+    catch {
+        return null;
+    }
+}
 // The core framing for all planning. Not a checklist — a way of thinking.
 export const DESIGN_THINKING = `
 HOW TO THINK ABOUT EVERY TASK:
@@ -152,7 +177,16 @@ export async function planTasks(objective, cwd, plannerModel, workerModel, permi
     onLog("Analyzing codebase...");
     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, outputFormat: TASKS_SCHEMA }, onLog);
+    let resultText;
+    try {
+        resultText = await runPlannerQuery(prompt + fileInstruction, { cwd, model: plannerModel, permissionMode, outputFormat: TASKS_SCHEMA }, onLog);
+    }
+    catch (err) {
+        const salvaged = salvageFromFile(outFile, budget, onLog, err?.message ?? String(err));
+        if (salvaged)
+            return salvaged;
+        throw err;
+    }
     const parsed = await extractTaskJson(resultText, async () => {
         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, outputFormat: TASKS_SCHEMA }, onLog);
@@ -234,7 +268,16 @@ Requirements:
 Respond with ONLY a JSON object (no markdown fences):
 {"tasks": [{"prompt": "..."}]}${fileInstruction}`;
     onLog("Synthesizing...");
-    const resultText = await runPlannerQuery(prompt, { cwd, model: plannerModel, permissionMode, outputFormat: TASKS_SCHEMA }, onLog);
+    let resultText;
+    try {
+        resultText = await runPlannerQuery(prompt, { cwd, model: plannerModel, permissionMode, outputFormat: TASKS_SCHEMA }, onLog);
+    }
+    catch (err) {
+        const salvaged = salvageFromFile(outFile, budget, onLog, err?.message ?? String(err));
+        if (salvaged)
+            return salvaged;
+        throw err;
+    }
     const parsed = await extractTaskJson(resultText, async () => {
         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, outputFormat: TASKS_SCHEMA }, onLog);

package/dist/run.js

@@ -46,8 +46,16 @@ export async function executeRun(cfg) {
         branches.push(...rs.branches);
         flex = rs.flex;
         waveHistory.push(...loadWaveHistory(runDir));
-        console.log(chalk.green(`\n  ✓ Resumed`) + chalk.dim(` · wave ${waveNum + 1} · ${remaining} remaining · $${accCost.toFixed(2)} spent · ${waveHistory.length} prior waves\n`));
-        waveNum++;
+        // Planning-phase resume starts at wave 0 (nothing ran before); all other
+        // resumes bump to the next wave since rs.waveNum is the last completed one.
+        const fromPlanning = rs.phase === "planning";
+        if (fromPlanning && !existsSync(join(runDir, "goal.md")) && objective) {
+            writeFileSync(join(runDir, "goal.md"), `## Original Objective\n${objective}`, "utf-8");
+        }
+        const detail = fromPlanning ? `${currentTasks.length} tasks from plan` : `${waveHistory.length} prior waves`;
+        console.log(chalk.green(`\n  ✓ Resumed`) + chalk.dim(` · wave ${waveNum + 1} · ${remaining} remaining · $${accCost.toFixed(2)} spent · ${detail}\n`));
+        if (!fromPlanning)
+            waveNum++;
     }
     else {
         if (objective && !existsSync(join(runDir, "goal.md"))) {

package/dist/state.js

@@ -187,10 +187,15 @@ export function findIncompleteRuns(rootDir, filterCwd) {
         const dirs = readdirSync(runsDir).sort().reverse();
         const results = [];
         for (const d of dirs) {
-            const state = loadRunState(join(runsDir, d));
-            if (state && state.phase !== "done" && state.cwd === filterCwd) {
-                results.push({ dir: join(runsDir, d), state });
-            }
+            const runDir = join(runsDir, d);
+            const state = loadRunState(runDir);
+            if (!state || state.phase === "done" || state.cwd !== filterCwd)
+                continue;
+            // Planning-phase runs are only resumable if tasks.json was actually
+            // written — resuming without tasks is nothing to resume.
+            if (state.phase === "planning" && !existsSync(join(runDir, "tasks.json")))
+                continue;
+            results.push({ dir: runDir, state });
         }
         return results;
     }

package/dist/types.d.ts

@@ -172,7 +172,7 @@ export interface RunState {
     accOut?: number;
     accTools?: number;
     branches: BranchRecord[];
-    phase: "steering" | "capped" | "done" | "stopped";
+    phase: "planning" | "steering" | "capped" | "done" | "stopped";
     startedAt: string;
     cwd: string;
 }

package/package.json

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