claude-overnight 1.11.6 → 1.11.9

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";
+import { loadRunState, findIncompleteRuns, findOrphanedDesigns, backfillOrphanedPlans, 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")) {
@@ -114,6 +123,12 @@ async function main() {
     // ── Run history ──
     const rootDir = join(cwd, ".claude-overnight");
     const runsDir = join(rootDir, "runs");
+    // Backfill run.json for pre-1.11.7 orphaned plans so they become visible
+    // to the resume picker. One-shot, idempotent, silent if there's nothing.
+    const backfilled = backfillOrphanedPlans(rootDir, cwd);
+    if (backfilled > 0 && !noTTY) {
+        console.log(chalk.dim(`\n  ↻ Recovered ${backfilled} orphaned plan${backfilled > 1 ? "s" : ""} from disk`));
+    }
     const allRuns = [];
     try {
         for (const d of readdirSync(runsDir).sort().reverse()) {
@@ -162,8 +177,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 +227,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 +262,23 @@ async function main() {
             }
         }
         if (resuming && resumeState && resumeRunDir) {
+            // If currentTasks is empty but tasks.json exists on disk, reload it.
+            // Covers two cases:
+            //   1. Planning-phase resumes (the prior run died before executeRun).
+            //   2. Stopped/capped runs whose state was saved with currentTasks: []
+            //      (saveRunState always stores [] — the plan is on disk in tasks.json).
+            if (resumeState.currentTasks.length === 0) {
+                const loaded = salvageFromFile(join(resumeRunDir, "tasks.json"), resumeState.budget, () => { }, "resume");
+                if (!loaded && resumeState.phase === "planning") {
+                    console.error(chalk.red(`\n  Planning-phase run has no usable tasks.json — start Fresh instead.\n`));
+                    process.exit(1);
+                }
+                if (loaded) {
+                    resumeState.currentTasks = loaded;
+                    const label = resumeState.phase === "planning" ? "Resuming plan" : `Resuming ${resumeState.phase} run`;
+                    console.log(chalk.green(`\n  ✓ ${label} · ${loaded.length} tasks loaded from tasks.json`));
+                }
+            }
             const unmerged = resumeState.branches.filter(b => b.status === "unmerged").length;
             if (unmerged > 0) {
                 console.log("");
@@ -479,6 +522,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/merge.js

@@ -162,11 +162,16 @@ export function cleanStaleWorktrees(cwd, log) {
     try {
         const list = gitExec("git worktree list --porcelain", cwd);
         const stale = [];
-        const tmp = tmpdir();
+        // Match any worktree whose path contains our mkdtemp prefix. We used to
+        // gate on `startsWith(tmpdir())` too, but on macOS `os.tmpdir()` returns
+        // `/var/folders/...` while git reports worktrees as `/private/var/...`
+        // (realpath-resolved), so the prefix never matched and stale worktrees
+        // silently accumulated. The `claude-overnight-` substring is unambiguous
+        // enough on its own — nothing else in the repo uses that prefix.
         for (const line of list.split("\n")) {
             if (line.startsWith("worktree ")) {
                 const wpath = line.slice("worktree ".length);
-                if (wpath.startsWith(tmp) && wpath.includes("claude-overnight-"))
+                if (wpath.includes("/claude-overnight-"))
                     stale.push(wpath);
             }
         }

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.d.ts

@@ -36,6 +36,19 @@ export declare function findIncompleteRuns(rootDir: string, filterCwd: string):
     state: RunState;
 }[];
 export declare function findOrphanedDesigns(rootDir: string): string | null;
+/**
+ * Backfill run.json for pre-1.11.7 orphaned plans: runs where orchestrate's
+ * agent wrote tasks.json via its Write tool but the process died before
+ * executeRun ever got to saveRunState. Without this, those runs are invisible
+ * to findIncompleteRuns forever.
+ *
+ * Idempotent: runs with an existing run.json are skipped. Synthesizes a
+ * minimal "planning" state from what can be read off disk — dir name for
+ * timestamp, task count for budget, sane defaults for everything else.
+ * The cwd field is set to filterCwd so findIncompleteRuns picks it up on the
+ * current project (which is safe — rootDir is already scoped to `cwd`).
+ */
+export declare function backfillOrphanedPlans(rootDir: string, filterCwd: string): number;
 export declare function formatTimeAgo(isoStr: string): string;
 export declare function showRunHistory(allRuns: {
     dir: string;

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;
     }
@@ -214,6 +219,70 @@ export function findOrphanedDesigns(rootDir) {
     catch { }
     return null;
 }
+/**
+ * Backfill run.json for pre-1.11.7 orphaned plans: runs where orchestrate's
+ * agent wrote tasks.json via its Write tool but the process died before
+ * executeRun ever got to saveRunState. Without this, those runs are invisible
+ * to findIncompleteRuns forever.
+ *
+ * Idempotent: runs with an existing run.json are skipped. Synthesizes a
+ * minimal "planning" state from what can be read off disk — dir name for
+ * timestamp, task count for budget, sane defaults for everything else.
+ * The cwd field is set to filterCwd so findIncompleteRuns picks it up on the
+ * current project (which is safe — rootDir is already scoped to `cwd`).
+ */
+export function backfillOrphanedPlans(rootDir, filterCwd) {
+    const runsDir = join(rootDir, "runs");
+    let count = 0;
+    try {
+        const dirs = readdirSync(runsDir);
+        for (const d of dirs) {
+            const runDir = join(runsDir, d);
+            if (existsSync(join(runDir, "run.json")))
+                continue;
+            const tasksFile = join(runDir, "tasks.json");
+            if (!existsSync(tasksFile))
+                continue;
+            let taskCount = 0;
+            try {
+                const parsed = JSON.parse(readFileSync(tasksFile, "utf-8"));
+                if (!Array.isArray(parsed?.tasks))
+                    continue;
+                taskCount = parsed.tasks.length;
+            }
+            catch {
+                continue;
+            }
+            if (taskCount === 0)
+                continue;
+            // Dir name format: 2026-04-12T13-03-57 (UTC). Convert to ISO.
+            const m = d.match(/^(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})$/);
+            const startedAt = m ? `${m[1]}T${m[2]}:${m[3]}:${m[4]}.000Z` : new Date(0).toISOString();
+            try {
+                saveRunState(runDir, {
+                    id: d,
+                    objective: `(recovered pre-1.11.7 plan · ${taskCount} tasks)`,
+                    budget: taskCount, remaining: taskCount,
+                    workerModel: "claude-opus-4-6", plannerModel: "claude-opus-4-6",
+                    concurrency: 5, permissionMode: "bypassPermissions",
+                    flex: false, useWorktrees: true, mergeStrategy: "yolo",
+                    allowExtraUsage: false,
+                    waveNum: 0, currentTasks: [],
+                    accCost: 0, accCompleted: 0, accFailed: 0,
+                    accIn: 0, accOut: 0, accTools: 0,
+                    branches: [],
+                    phase: "planning",
+                    startedAt,
+                    cwd: filterCwd,
+                });
+                count++;
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return count;
+}
 // ── History display ──
 export function formatTimeAgo(isoStr) {
     const ms = Date.now() - new Date(isoStr).getTime();

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.9",
   "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": {