claude-overnight 1.0.1 → 1.1.0

package/README.md

@@ -52,7 +52,7 @@ claude-overnight
 ◆ Assessing... ✓ Vision met
 ```
 
-You interact once (objective, budget, model, review themes), then everything runs autonomously — thinking, planning, executing, reflecting, steering. Rate-limited? It waits and retries. Crash? Resume where you left off.
+You interact once (objective, budget, model, review themes), then everything runs autonomously — thinking, planning, executing, reflecting, steering. Rate-limited? It waits and retries. Crash? Resume where you left off. Capped at usage limit? Pick up next time with full context preserved.
 
 ## How it works
 
@@ -62,7 +62,7 @@ For budgets > 15, the tool launches **architect agents** that explore your codeb
 
 ### 2. Orchestration
 
-An orchestrator agent reads all design documents and synthesizes concrete execution tasks — grounded in real files and patterns the architects found. No guesswork.
+An orchestrator agent reads all design documents and synthesizes concrete execution tasks — grounded in real files and patterns the architects found. No guesswork. The task plan is also written to a file for resilience — if orchestration is interrupted, partial results survive.
 
 ### 3. Iterative execution
 
@@ -97,20 +97,30 @@ Every run gets its own folder in `.claude-overnight/runs/`. Nothing is ever over
       run.json, sessions/
 ```
 
-If a run crashes, gets rate-limited, or you Ctrl+C:
+Any run that stops before the steering system declares the objective complete — capped at usage limit, Ctrl+C, crash, rate limit timeout, steering failure — is automatically resumable:
 
 ```
-  ⚠ Interrupted run
+  ⚠ Unfinished run
   ╭──────────────────────────────────────────────────╮
   │  refactor auth, add tests, update docs           │
-  │  50/200 sessions · 3 waves · $69.16              │
+  │  50/200 sessions · 150 remaining · $69.16        │
   │  34 merged · 16 unmerged · 0 failed branches     │
   ╰──────────────────────────────────────────────────╯
 
   Resume  │  Fresh  │  Quit
 ```
 
-On resume: unmerged branches auto-merge, the wave loop continues, all context is preserved.
+On resume: unmerged branches auto-merge, the wave loop continues, all context is preserved. Designs and reflections stay on disk until the objective is truly complete.
+
+If the thinking phase succeeds but orchestration crashes, the next run detects the orphaned design docs and reuses them — no re-running $9 worth of architect agents:
+
+```
+  ✓ Reusing 5 design docs (from prior attempt)
+    Focus 0: Project Wizard UI vs VISION.md Flow
+    Focus 1: Team Load and Rebalancer Surface
+    Focus 2: Code Health After Swarm Wave
+    ...
+```
 
 **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.
 
@@ -186,9 +196,10 @@ Built for unattended runs lasting hours or days.
 
 - **Hard block**: pauses until the rate limit window resets, then resumes
 - **Soft throttle**: slows dispatch at >75% utilization
+- **Cooldown between phases**: waits for rate limit reset after thinking before starting orchestration
 - **Retry with backoff**: transient errors (429, overloaded) retry automatically
-- **Usage cap**: set a ceiling, active agents finish, no new ones start
-- **Planner retries**: steering and orchestration also retry on rate limits (30s/60s/120s backoff)
+- **Usage cap**: set a ceiling, active agents finish, no new ones start — run is resumable
+- **Planner retries**: steering and orchestration retry on rate limits (30s/60s/120s backoff) with full context
 
 ## Worktrees and merging
 

package/dist/index.js

@@ -606,9 +606,18 @@ async function main() {
         console.log(chalk.dim(`\n  ${completedRuns.length} previous run${completedRuns.length > 1 ? "s" : ""}`));
         for (const r of completedRuns.slice(0, 3)) {
             const date = r.state.startedAt?.slice(0, 10) || "unknown";
-            const obj = r.state.objective?.slice(0, 40) || "";
+            const obj = r.state.objective?.slice(0, 50) || "";
             const cost = r.state.accCost > 0 ? ` · $${r.state.accCost.toFixed(0)}` : "";
-            console.log(chalk.dim(`     ${date} · ${r.state.accCompleted} tasks${cost}${obj ? ` · ${obj}` : ""}${obj.length >= 40 ? "…" : ""}`));
+            const merged = r.state.branches.filter(b => b.status === "merged").length;
+            console.log(chalk.dim(`     ${date} · ${r.state.accCompleted} done · ${merged} merged${cost}${obj ? ` · ${obj}` : ""}${obj.length >= 50 ? "…" : ""}`));
+            // Show status if available
+            let status = "";
+            try {
+                status = readFileSync(join(r.dir, "status.md"), "utf-8").trim().split("\n")[0].slice(0, 80);
+            }
+            catch { }
+            if (status)
+                console.log(chalk.dim(`       ${status}`));
         }
     }
     // ── Resume detection ──
@@ -628,10 +637,11 @@ async function main() {
             lastStatus = readFileSync(join(incomplete.dir, "status.md"), "utf-8").trim().slice(0, 120);
         }
         catch { }
-        console.log(chalk.yellow(`\n  ⚠ Interrupted run`));
+        const label = "Unfinished run";
+        console.log(chalk.yellow(`\n  ⚠ ${label}`));
         const boxLines = [
             `${obj}${obj.length >= 50 ? "…" : ""}`,
-            `${prev.accCompleted}/${prev.budget} sessions · ${prev.waveNum + 1} waves · $${prev.accCost.toFixed(2)}`,
+            `${prev.accCompleted}/${prev.budget} sessions · ${prev.remaining} remaining · $${prev.accCost.toFixed(2)}`,
         ];
         if (lastStatus)
             boxLines.push(lastStatus);
@@ -862,7 +872,17 @@ async function main() {
                 mkdirSync(designDir, { recursive: true });
                 const existingDesigns = readMdDir(designDir);
                 if (existingDesigns) {
-                    console.log(chalk.green(`\n  ✓ Reusing ${readdirSync(designDir).filter(f => f.endsWith(".md")).length} existing design docs`) + chalk.dim(` (from prior attempt)\n`));
+                    const designFiles = readdirSync(designDir).filter(f => f.endsWith(".md")).sort();
+                    console.log(chalk.green(`\n  ✓ Reusing ${designFiles.length} design docs`) + chalk.dim(` (from prior attempt)`));
+                    for (const f of designFiles) {
+                        try {
+                            const firstLine = readFileSync(join(designDir, f), "utf-8").split("\n")[0].replace(/^#+\s*/, "").trim();
+                            if (firstLine)
+                                console.log(chalk.dim(`    ${firstLine.slice(0, 80)}`));
+                        }
+                        catch { }
+                    }
+                    console.log("");
                 }
                 else {
                     const thinkingTasks = buildThinkingTasks(objective, themes, designDir, plannerModel, previousKnowledge || undefined);
@@ -1030,7 +1050,7 @@ async function main() {
     const waveHistory = [];
     let accCost, accCompleted, accFailed, accTools;
     let accIn = 0, accOut = 0;
-    let lastCapped = false, lastAborted = false;
+    let lastCapped = false, lastAborted = false, objectiveComplete = false;
     let lastWaveKind;
     let reflectionBudgetUsed;
     const branches = [];
@@ -1193,6 +1213,7 @@ async function main() {
                 if (steer.done || steer.action === "done") {
                     console.log(chalk.green(`  \u2713 ${steer.reasoning}\n`));
                     steerDone = true;
+                    objectiveComplete = true;
                     remaining = 0; // exit outer loop too
                     break;
                 }
@@ -1245,6 +1266,7 @@ async function main() {
                 // action === "execute"
                 if (steer.tasks.length === 0) {
                     console.log(chalk.green(`  \u2713 ${steer.reasoning}\n`));
+                    objectiveComplete = true;
                     remaining = 0;
                     break;
                 }
@@ -1262,22 +1284,26 @@ async function main() {
         }
         waveNum++;
     }
-    // Mark run as done — keep sessions/milestones/status/goal, clean transient files
+    // Only truly "done" if steering explicitly completed the objective (or non-flex single wave with budget exhausted)
+    const trulyDone = objectiveComplete || (!flex && remaining <= 0);
+    const finalPhase = trulyDone ? "done" : "capped";
     saveRunState(runDir, {
         id: `run-${new Date().toISOString().slice(0, 19)}`, objective: objective ?? "", budget: budget ?? tasks.length,
         remaining, workerModel, plannerModel, concurrency, permissionMode,
         usageCap, flex, useWorktrees, mergeStrategy, waveNum, currentTasks: [],
         lastWaveKind, reflectionBudgetUsed, accCost, accCompleted, accFailed,
-        branches, phase: "done", startedAt: new Date(runStartedAt).toISOString(), cwd,
+        branches, phase: finalPhase, startedAt: new Date(runStartedAt).toISOString(), cwd,
     });
-    try {
-        rmSync(join(runDir, "designs"), { recursive: true, force: true });
-    }
-    catch { }
-    try {
-        rmSync(join(runDir, "reflections"), { recursive: true, force: true });
+    if (trulyDone) {
+        try {
+            rmSync(join(runDir, "designs"), { recursive: true, force: true });
+        }
+        catch { }
+        try {
+            rmSync(join(runDir, "reflections"), { recursive: true, force: true });
+        }
+        catch { }
     }
-    catch { }
     // Switch back if we created a run branch
     if (runBranch && originalRef) {
         try {

package/dist/types.d.ts

@@ -125,7 +125,7 @@ export interface RunState {
     accCompleted: number;
     accFailed: number;
     branches: BranchRecord[];
-    phase: "executing" | "steering" | "reflecting" | "done";
+    phase: "executing" | "steering" | "reflecting" | "capped" | "done";
     startedAt: string;
     cwd: string;
 }

package/package.json

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