claude-overnight 1.11.5 → 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,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");
@@ -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 — 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 +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(`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 });

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

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