claude-overnight 1.11.4 → 1.11.6

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

@@ -80,10 +80,9 @@ function renderUsageBars(out, w, swarm) {
         }
         let label = `${Math.round(pct * 100)}% used`;
         if (swarm.cappedOut) {
-            if (swarm.isUsingOverage && !swarm.allowExtraUsage)
-                label = chalk.red("Extra usage blocked \u2014 stopping");
-            else
-                label = chalk.yellow(`Capped at ${capFrac != null ? Math.round(capFrac * 100) : 100}% \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) {
             label = chalk.yellow(`Cooling down \u2014 ${swarm.rateLimitPaused} worker(s) waiting`);
@@ -94,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");
@@ -160,6 +160,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 +383,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 +415,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 — RATE LIMITED`));
+        console.log(chalk.bold.yellow(`  CLAUDE OVERNIGHT — BUDGET EXHAUSTED`));
     else if (stopping || lastAborted)
         console.log(chalk.bold.yellow(`  CLAUDE OVERNIGHT — INTERRUPTED`));
     else
@@ -406,7 +431,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(`Capped at ${usageCap != null ? Math.round(usageCap * 100) : 100}%`)}`);
+        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 });

package/dist/swarm.d.ts

@@ -40,7 +40,6 @@ export declare class Swarm {
     rateLimitWindows: Map<string, RateLimitWindow>;
     rateLimitPaused: number;
     isUsingOverage: boolean;
-    overageDisabledReason?: string;
     overageCostUsd: number;
     private queue;
     private config;

package/dist/swarm.js

@@ -33,7 +33,6 @@ export class Swarm {
     rateLimitWindows = new Map();
     rateLimitPaused = 0;
     isUsingOverage = false;
-    overageDisabledReason;
     overageCostUsd = 0;
     queue;
     config;
@@ -180,43 +179,43 @@ export class Swarm {
     async throttle() {
         if (this.cappedOut)
             return;
-        if (this.isUsingOverage && !this.allowExtraUsage) {
-            this.capForOverage(`Extra usage detected but not allowed — stopping dispatch`);
-            return;
-        }
+        // Hard stop: overage budget exhausted (only legitimate cap)
         if (this.isUsingOverage && this.extraUsageBudget != null && this.overageCostUsd >= this.extraUsageBudget) {
             this.capForOverage(`Extra usage budget $${this.extraUsageBudget} reached ($${this.overageCostUsd.toFixed(2)} spent) — stopping dispatch`);
             return;
         }
-        const cap = this.usageCap;
-        if (cap != null && cap < 1 && this.rateLimitUtilization >= cap) {
-            const waitMs = this.rateLimitResetsAt
+        // 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 capExceeded = cap != null && cap < 1 && this.rateLimitUtilization >= cap;
+            const rejected = this.rateLimitResetsAt && this.rateLimitResetsAt > Date.now();
+            if (!capExceeded && !rejected)
+                break;
+            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())
-                : 60_000;
-            this.log(-1, `Usage at ${Math.round(this.rateLimitUtilization * 100)}% (cap ${Math.round(cap * 100)}%), waiting ${Math.ceil(waitMs / 1000)}s for cooldown`);
+                : fallbackMs;
+            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--;
             this.rateLimitUtilization = 0;
             this.rateLimitResetsAt = undefined;
-            return;
-        }
-        if (this.rateLimitResetsAt) {
-            const resetTarget = this.rateLimitResetsAt;
-            const waitMs = resetTarget - Date.now();
-            if (waitMs > 0) {
-                this.log(-1, `Rate limited, pausing ${Math.ceil(waitMs / 1000)}s`);
-                this.rateLimitPaused++;
-                await sleep(waitMs);
-                this.rateLimitPaused--;
-            }
-            if (this.rateLimitResetsAt === resetTarget)
-                this.rateLimitResetsAt = undefined;
+            consecutiveWaits++;
         }
-        else if (this.rateLimitUtilization > 0.75) {
+        // Soft delay: high utilization, pace requests
+        if (this.rateLimitUtilization > 0.75) {
             const delay = Math.floor((this.rateLimitUtilization - 0.75) * 60000);
-            this.log(-1, `Soft throttle: ${Math.round(this.rateLimitUtilization * 100)}% utilization, pausing ${(delay / 1000).toFixed(1)}s`);
-            await sleep(delay);
+            if (delay > 0)
+                await sleep(delay);
         }
     }
     // ── Agent execution ──
@@ -370,6 +369,21 @@ export class Swarm {
             catch (err) {
                 if (agent.status !== "running")
                     break;
+                // Rate-limit errors: wait and retry WITHOUT burning the retry budget
+                if (!this.aborted && isRateLimitError(err)) {
+                    const waitMs = this.rateLimitResetsAt && this.rateLimitResetsAt > Date.now()
+                        ? Math.max(5000, this.rateLimitResetsAt - Date.now())
+                        : 120_000;
+                    this.log(id, `Rate limited — waiting ${Math.ceil(waitMs / 1000)}s (attempt not counted)`);
+                    this.rateLimitPaused++;
+                    await sleep(waitMs);
+                    this.rateLimitPaused--;
+                    this.isUsingOverage = false;
+                    this.rateLimitUtilization = 0;
+                    this.rateLimitResetsAt = undefined;
+                    attempt--; // don't count this against retries
+                    continue;
+                }
                 const canRetry = attempt < maxRetries && !this.aborted && isTransientError(err);
                 if (canRetry) {
                     this.log(id, `Transient error: ${String(err.message || err).slice(0, 80)}`);
@@ -460,26 +474,21 @@ export class Swarm {
                 const rl = msg;
                 const info = rl.rate_limit_info;
                 this.rateLimitUtilization = info.utilization ?? 0;
-                if (info.status === "rejected" && info.resetsAt && !this.allowExtraUsage)
+                if (info.resetsAt)
                     this.rateLimitResetsAt = info.resetsAt;
                 else if (info.status !== "rejected")
                     this.rateLimitResetsAt = undefined;
+                if (info.isUsingOverage)
+                    this.isUsingOverage = true;
                 const windowType = info.rateLimitType;
                 if (windowType) {
                     this.rateLimitWindows.set(windowType, {
                         type: windowType, utilization: info.utilization ?? 0, status: info.status, resetsAt: info.resetsAt,
                     });
                 }
-                if (info.isUsingOverage)
-                    this.isUsingOverage = true;
-                if (info.overageDisabledReason)
-                    this.overageDisabledReason = info.overageDisabledReason;
-                if (this.isUsingOverage && !this.allowExtraUsage)
-                    this.capForOverage(`Extra usage detected but not allowed — stopping dispatch`);
                 const pct = info.utilization != null ? `${Math.round(info.utilization * 100)}%` : "";
                 const overageTag = this.isUsingOverage ? " [EXTRA]" : "";
-                const statusLabel = info.status === "rejected" && this.allowExtraUsage ? "switching to extra usage" : info.status;
-                this.log(agent.id, `Rate: ${statusLabel} ${pct}${overageTag}${windowType ? ` (${windowType})` : ""}`);
+                this.log(agent.id, `Rate: ${info.status} ${pct}${overageTag}${windowType ? ` (${windowType})` : ""}`);
                 break;
             }
         }
@@ -491,6 +500,18 @@ class AgentTimeoutError extends Error {
         this.name = "AgentTimeoutError";
     }
 }
+function isRateLimitError(err) {
+    const status = err?.status ?? err?.statusCode;
+    if (status === 429)
+        return true;
+    const msg = String(err?.message || err).toLowerCase();
+    if (msg.includes("rate limit") || msg.includes("rate_limit") || msg.includes("too many requests"))
+        return true;
+    const cause = err?.cause;
+    if (cause && cause !== err)
+        return isRateLimitError(cause);
+    return false;
+}
 function isTransientError(err) {
     if (err instanceof AgentTimeoutError)
         return false;

package/package.json

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