claude-overnight 1.11.5 → 1.11.7

package/README.md

@@ -14,6 +14,15 @@ npm install -g claude-overnight
 
 Requires Node.js >= 20 and Claude authentication (`claude auth login`, or set `ANTHROPIC_API_KEY`).
 
+### Claude Code plugin
+
+This repo also ships a Claude Code plugin so any Claude instance (inside this repo or any other) knows how to use, inspect, and resume `claude-overnight` runs:
+
+```
+/plugin marketplace add Fornace/claude-overnight
+/plugin install claude-overnight
+```
+
 ## Quick start
 
 ```bash
@@ -131,7 +140,9 @@ If the thinking phase succeeds but orchestration crashes, the next run detects t
 
 **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.
 
-Add `.claude-overnight` to your `.gitignore`.
+Add `.claude-overnight/` to your `.gitignore` (with the trailing slash — see below).
+
+A separate, tiny `claude-overnight.log.md` is also written at the repo root on every run. It's human-readable, append-only, one block per run (objective, start/finish, cost, outcome, branch), and is designed to be **committed** — so even after `.claude-overnight/` is cleaned up you can still recover which prompt produced which commits. Use `.claude-overnight/` (with trailing slash) in your gitignore so this file isn't matched by accident.
 
 ## Other usage modes
 

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/render.js

@@ -80,8 +80,8 @@ function renderUsageBars(out, w, swarm) {
         }
         let label = `${Math.round(pct * 100)}% used`;
         if (swarm.cappedOut) {
-            label = swarm.isUsingOverage
-                ? chalk.red(`Extra usage budget exhausted \u2014 finishing active`)
+            label = swarm.extraUsageBudget != null
+                ? chalk.red(`Budget $${swarm.extraUsageBudget} exhausted \u2014 finishing active`)
                 : chalk.yellow(`Capped at ${capFrac != null ? Math.round(capFrac * 100) : 100}% \u2014 finishing active`);
         }
         else if (swarm.rateLimitPaused > 0) {
@@ -93,7 +93,7 @@ function renderUsageBars(out, w, swarm) {
             label = chalk.red(`Waiting for reset ${mm > 0 ? `${mm}m ${ss}s` : `${ss}s`}`);
         }
         if (swarm.isUsingOverage && !swarm.cappedOut)
-            label += chalk.red(" [EXTRA USAGE]");
+            label += chalk.red(" [OVERAGE]");
         const prefix = windowLabel ? chalk.dim(windowLabel.padEnd(6)) : chalk.dim("Usage ");
         out.push(`  ${prefix}${barStr}  ${label}`);
     };

package/dist/run.js

@@ -9,7 +9,7 @@ import { RunDisplay } from "./ui.js";
 import { renderSummary } from "./render.js";
 import { fmtTokens } from "./render.js";
 import { isAuthError } from "./cli.js";
-import { readRunMemory, writeStatus, writeGoalUpdate, saveRunState, saveWaveSession, loadWaveHistory, recordBranches, archiveMilestone, writeSteerInbox, consumeSteerInbox, countSteerInbox, } from "./state.js";
+import { readRunMemory, writeStatus, writeGoalUpdate, saveRunState, saveWaveSession, loadWaveHistory, recordBranches, archiveMilestone, writeSteerInbox, consumeSteerInbox, countSteerInbox, appendOvernightLogStart, updateOvernightLogEnd, } from "./state.js";
 export async function executeRun(cfg) {
     const restore = () => { try {
         process.stdout.write("\x1B[?25h\n");
@@ -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"))) {
@@ -160,6 +168,20 @@ export async function executeRun(cfg) {
         catch { }
     }
     const waveMerge = (flex && runBranch) ? "yolo" : mergeStrategy;
+    const runId = runDir.split(/[/\\]/).pop() ?? "";
+    if (!cfg.resuming) {
+        try {
+            appendOvernightLogStart(cwd, runId, {
+                objective: objective || "",
+                model: workerModel,
+                budget: cfg.budget,
+                flex,
+                usageCap,
+                branch: runBranch,
+            });
+        }
+        catch { }
+    }
     let stopping = false;
     const gracefulStop = () => {
         if (stopping) {
@@ -369,6 +391,17 @@ export async function executeRun(cfg) {
         }
         catch { }
     }
+    try {
+        updateOvernightLogEnd(cwd, runId, {
+            cost: accCost,
+            completed: accCompleted,
+            failed: accFailed,
+            waves: waveNum + 1,
+            phase: finalPhase,
+            elapsedSec: Math.round((Date.now() - cfg.runStartedAt) / 1000),
+        });
+    }
+    catch { }
     if (runBranch && originalRef) {
         try {
             execSync(`git checkout "${originalRef}"`, { cwd, encoding: "utf-8", stdio: "pipe" });
@@ -390,7 +423,7 @@ export async function executeRun(cfg) {
     else if (remaining <= 0)
         console.log(chalk.bold.yellow(`  CLAUDE OVERNIGHT — BUDGET EXHAUSTED`));
     else if (lastCapped)
-        console.log(chalk.bold.yellow(`  CLAUDE OVERNIGHT — EXTRA USAGE BUDGET HIT`));
+        console.log(chalk.bold.yellow(`  CLAUDE OVERNIGHT — BUDGET EXHAUSTED`));
     else if (stopping || lastAborted)
         console.log(chalk.bold.yellow(`  CLAUDE OVERNIGHT — INTERRUPTED`));
     else
@@ -406,7 +439,7 @@ export async function executeRun(cfg) {
     for (const [k1, v1, k2, v2] of statRows)
         console.log(`  ${k1}  ${v1.padEnd(20)}  ${k2}  ${v2}`);
     if (lastCapped)
-        console.log(`  ${chalk.yellow(`Extra usage budget exhausted`)}`);
+        console.log(`  ${chalk.yellow(`Overage budget exhausted`)}`);
     console.log("");
     const statusFile = join(runDir, "status.md");
     if (existsSync(statusFile)) {

package/dist/state.d.ts

@@ -11,6 +11,24 @@ export declare function writeSteerInbox(runDir: string, text: string): string;
 export declare function consumeSteerInbox(runDir: string, waveNum: number): number;
 export declare function writeStatus(baseDir: string, status: string): void;
 export declare function writeGoalUpdate(baseDir: string, update: string): void;
+export interface OvernightLogStart {
+    objective: string;
+    model: string;
+    budget: number;
+    flex: boolean;
+    usageCap?: number;
+    branch?: string;
+}
+export interface OvernightLogEnd {
+    cost: number;
+    completed: number;
+    failed: number;
+    waves: number;
+    phase: string;
+    elapsedSec: number;
+}
+export declare function appendOvernightLogStart(cwd: string, runId: string, meta: OvernightLogStart): void;
+export declare function updateOvernightLogEnd(cwd: string, runId: string, meta: OvernightLogEnd): void;
 export declare function saveRunState(runDir: string, state: RunState): void;
 export declare function loadRunState(runDir: string): RunState | null;
 export declare function findIncompleteRuns(rootDir: string, filterCwd: string): {

package/dist/state.js

@@ -109,6 +109,65 @@ export function writeGoalUpdate(baseDir, update) {
     const trimmed = full.length > 4000 ? full.slice(0, 1000) + "\n\n...\n\n" + full.slice(-3000) : full;
     writeFileSync(goalPath, trimmed, "utf-8");
 }
+// ── Durable run log (claude-overnight.log.md, committed) ──
+// Tiny human-readable record per run so the objective survives even after
+// .claude-overnight/ is cleaned up. Append-only friendly: each run's block
+// is keyed by runId (the run dir basename) so concurrent runs on different
+// machines don't collide.
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function appendOvernightLogStart(cwd, runId, meta) {
+    const path = join(cwd, "claude-overnight.log.md");
+    const startedAt = new Date().toISOString().replace("T", " ").slice(0, 19) + " UTC";
+    const capStr = meta.usageCap != null ? ` · **Cap:** ${meta.usageCap}%` : "";
+    const branchLine = meta.branch ? `\n- **Branch:** ${meta.branch}` : "";
+    const block = [
+        `## ${runId}`,
+        `- **Objective:** ${meta.objective || "(none)"}`,
+        `- **Started:** ${startedAt}`,
+        `- **Model:** ${meta.model} · **Budget:** ${meta.budget} · **Flex:** ${meta.flex ? "yes" : "no"}${capStr}${branchLine}`,
+        `- **Status:** running`,
+        "",
+        "",
+    ].join("\n");
+    let existing = "";
+    try {
+        existing = readFileSync(path, "utf-8");
+    }
+    catch { }
+    const header = existing ? "" : "# claude-overnight — run history\n\n";
+    writeFileSync(path, header + existing + block, "utf-8");
+}
+export function updateOvernightLogEnd(cwd, runId, meta) {
+    const path = join(cwd, "claude-overnight.log.md");
+    let existing = "";
+    try {
+        existing = readFileSync(path, "utf-8");
+    }
+    catch {
+        return;
+    }
+    const finishedAt = new Date().toISOString().replace("T", " ").slice(0, 19) + " UTC";
+    const sec = meta.elapsedSec;
+    const elapsed = sec < 60 ? `${sec}s` : sec < 3600 ? `${Math.floor(sec / 60)}m ${sec % 60}s` : `${Math.floor(sec / 3600)}h ${Math.floor((sec % 3600) / 60)}m`;
+    const outcome = meta.phase === "done" ? "✓ done" : meta.phase === "capped" ? "⊘ capped" : "⊘ stopped";
+    const endLines = [
+        `- **Finished:** ${finishedAt} (${elapsed})`,
+        `- **Cost:** $${meta.cost.toFixed(2)}`,
+        `- **Tasks:** ${meta.completed} done${meta.failed > 0 ? ` / ${meta.failed} failed` : ""} · **Waves:** ${meta.waves}`,
+        `- **Status:** ${outcome}`,
+    ].join("\n");
+    const re = new RegExp(`(## ${escapeRegExp(runId)}\\n(?:(?!\\n## )[\\s\\S])*?)- \\*\\*Status:\\*\\* running`);
+    if (re.test(existing)) {
+        writeFileSync(path, existing.replace(re, `$1${endLines}`), "utf-8");
+    }
+    else {
+        const header = existing ? "" : "# claude-overnight — run history\n\n";
+        const block = `## ${runId}\n${endLines}\n\n`;
+        writeFileSync(path, header + existing + block, "utf-8");
+    }
+}
 // ── Run state persistence ──
 export function saveRunState(runDir, state) {
     mkdirSync(runDir, { recursive: true });
@@ -128,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/swarm.js

@@ -185,30 +185,28 @@ export class Swarm {
             return;
         }
         // Wait loop: keep waiting until the blocking condition clears
+        // isUsingOverage is purely informational — the API enforces overage via 429s
+        // which the retry loop handles. Throttle only gates on actual rejections and user cap.
         let consecutiveWaits = 0;
         for (;;) {
             if (this.aborted || this.cappedOut)
                 return;
             const cap = this.usageCap;
-            const overageBlocked = this.isUsingOverage && !this.allowExtraUsage;
             const capExceeded = cap != null && cap < 1 && this.rateLimitUtilization >= cap;
             const rejected = this.rateLimitResetsAt && this.rateLimitResetsAt > Date.now();
-            if (!overageBlocked && !capExceeded && !rejected)
+            if (!capExceeded && !rejected)
                 break;
-            // Use SDK reset time if available, otherwise escalate: 1m → 3m → 5m (max)
             const fallbackMs = Math.min(300_000, 60_000 * (1 + consecutiveWaits * 2));
             const waitMs = this.rateLimitResetsAt && this.rateLimitResetsAt > Date.now()
                 ? Math.max(5000, this.rateLimitResetsAt - Date.now())
                 : fallbackMs;
-            const reason = overageBlocked ? "Extra usage blocked (plan limit)"
-                : capExceeded ? `Usage at ${Math.round(this.rateLimitUtilization * 100)}% (cap ${Math.round(cap * 100)}%)`
-                    : "Rate limited";
+            const reason = capExceeded
+                ? `Usage at ${Math.round(this.rateLimitUtilization * 100)}% (cap ${Math.round(cap * 100)}%)`
+                : "Rate limited";
             this.log(-1, `${reason} — waiting ${Math.ceil(waitMs / 1000)}s then retrying`);
             this.rateLimitPaused++;
             await sleep(waitMs);
             this.rateLimitPaused--;
-            // Reset stale flags — fresh state will come from the next SDK event
-            this.isUsingOverage = false;
             this.rateLimitUtilization = 0;
             this.rateLimitResetsAt = undefined;
             consecutiveWaits++;

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.5",
+  "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": {
@@ -9,7 +9,8 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "start": "node dist/index.js"
+    "start": "node dist/index.js",
+    "prepublishOnly": "node scripts/sync-plugin-version.js"
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.92",