claude-overnight 1.2.2 → 1.4.0

package/README.md

@@ -70,7 +70,9 @@ An orchestrator agent reads all design documents and synthesizes concrete execut
 
 ### 3. Iterative execution
 
-Tasks run in parallel (each agent in its own git worktree). After each wave, steering assesses: "how good is this?" — not "what's missing?" It can:
+Tasks run in parallel (each agent in its own git worktree). After completing its task, each agent automatically runs a **simplify pass** — reviewing its own `git diff` for code reuse opportunities, quality issues, and inefficiencies, then fixing them before the framework commits.
+
+After each wave, steering assesses: "how good is this?" — not "what's missing?" It can:
 
 - **Execute** more tasks to build features, fix bugs, polish UX
 - **Reflect** by spinning up 1-2 review agents for deep quality/architecture audits
@@ -178,7 +180,7 @@ claude-overnight "fix auth bug in src/auth.ts" "add tests for user model"
 | `--usage-cap=N` | unlimited | Stop at N% utilization |
 | `--allow-extra-usage` | off | Allow extra/overage usage (billed separately) |
 | `--extra-usage-budget=N` | — | Max $ for extra usage (implies --allow-extra-usage) |
-| `--timeout=SECONDS` | `300` | Inactivity timeout per agent |
+| `--timeout=SECONDS` | `900` | Inactivity timeout per agent (nudges at timeout, kills at 2×) |
 | `--no-flex` | — | Disable multi-wave steering |
 | `--dry-run` | — | Show planned tasks without running |
 
@@ -226,6 +228,7 @@ The usage bar cycles through all rate limit windows (5h, 7d, etc.) every 3 secon
 Built for unattended runs lasting hours or days.
 
 - **Smooth overage transition**: when extra usage is allowed, plan limit rejection is seamless — no dispatch blocking, agents continue into overage
+- **Interrupt + resume**: agents and planner queries that go silent are interrupted and resumed with full conversation context via SDK session resume — not killed and restarted from scratch
 - **Hard block**: pauses until the rate limit window resets, then resumes
 - **Soft throttle**: slows dispatch at >75% utilization
 - **Extra usage guard**: detects overage billing and stops unless explicitly allowed

package/dist/index.js

@@ -525,7 +525,7 @@ async function main() {
     --usage-cap=N          Stop at N% utilization ${chalk.dim("(e.g. 90 to save 10% for other work)")}
     --allow-extra-usage    Allow extra/overage usage ${chalk.dim("(default: stop when plan limits hit)")}
     --extra-usage-budget=N Max $ for extra usage ${chalk.dim("(implies --allow-extra-usage)")}
-    --timeout=SECONDS      Agent inactivity timeout ${chalk.dim("(default: 300s, kills only silent agents)")}
+    --timeout=SECONDS      Agent inactivity timeout ${chalk.dim("(default: 900s, nudges at timeout, kills at 2×)")}
     --no-flex              Disable adaptive multi-wave planning ${chalk.dim("(run all tasks in one shot)")}
 
   ${chalk.cyan("Defaults")} ${chalk.dim("(non-interactive)")}

package/dist/planner.js

@@ -1,6 +1,8 @@
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { readFileSync } from "fs";
-const INACTIVITY_MS = 5 * 60 * 1000;
+import { NudgeError } from "./types.js";
+const NUDGE_MS = 15 * 60 * 1000; // 15 min — close & restart with "continue"
+const HARD_TIMEOUT_MS = 30 * 60 * 1000; // 30 min — give up
 export function detectModelTier(model) {
     const m = model.toLowerCase();
     if (m === "default" || m.includes("opus"))
@@ -155,11 +157,25 @@ function isRateLimitError(err) {
 async function runPlannerQuery(prompt, opts, onLog) {
     const MAX_RETRIES = 3;
     const BACKOFF = [30_000, 60_000, 120_000];
+    let currentPrompt = prompt;
+    let currentOpts = opts;
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
         try {
-            return await runPlannerQueryOnce(prompt, opts, onLog);
+            return await runPlannerQueryOnce(currentPrompt, currentOpts, onLog);
         }
         catch (err) {
+            if (err instanceof NudgeError) {
+                if (err.sessionId) {
+                    onLog("Silent 15m — resuming session with continue");
+                    currentPrompt = "Continue. Complete the task.";
+                    currentOpts = { ...opts, resumeSessionId: err.sessionId };
+                }
+                else {
+                    onLog("Silent 15m — restarting planner (no session to resume)");
+                    // No session captured, just retry from scratch
+                }
+                continue;
+            }
             if (attempt < MAX_RETRIES && isRateLimitError(err)) {
                 const waitMs = BACKOFF[attempt];
                 const waitSec = Math.round(waitMs / 1000);
@@ -181,6 +197,7 @@ async function runPlannerQueryOnce(prompt, opts, onLog) {
     _plannerRateLimitInfo = { utilization: 0, status: "", isUsingOverage: false, windows: new Map(), costUsd: 0 };
     let resultText = "";
     const startedAt = Date.now();
+    const isResume = !!opts.resumeSessionId;
     const pq = query({
         prompt,
         options: {
@@ -190,8 +207,9 @@ async function runPlannerQueryOnce(prompt, opts, onLog) {
             allowedTools: ["Read", "Glob", "Grep", "Write"],
             permissionMode: opts.permissionMode,
             ...(opts.permissionMode === "bypassPermissions" && { allowDangerouslySkipPermissions: true }),
-            persistSession: false,
+            persistSession: true, // needed for interrupt+resume
             includePartialMessages: true,
+            ...(isResume && { resume: opts.resumeSessionId }),
         },
     });
     // Progress ticker — fast updates with compact format
@@ -210,23 +228,34 @@ async function runPlannerQueryOnce(prompt, opts, onLog) {
         const extra = lastLogText ? ` · ${lastLogText}` : "";
         onLog(`${timeStr}${toolStr}${costStr}${rlStr}${extra}`);
     }, 500);
+    const timeoutMs = isResume ? HARD_TIMEOUT_MS : NUDGE_MS;
+    let sessionId;
     let lastActivity = Date.now();
     let timer;
     const watchdog = new Promise((_, reject) => {
         const check = () => {
             const silent = Date.now() - lastActivity;
-            if (silent >= INACTIVITY_MS) {
-                pq.close();
-                reject(new Error(`Planner silent for ${Math.round(silent / 1000)}s — assumed hung`));
+            if (silent >= timeoutMs) {
+                // Try interrupt (graceful), fall back to close (hard kill)
+                pq.interrupt().catch(() => pq.close());
+                if (isResume) {
+                    reject(new Error(`Planner silent for ${Math.round(silent / 1000)}s — assumed hung`));
+                }
+                else {
+                    reject(new NudgeError(sessionId, silent));
+                }
             }
             else
-                timer = setTimeout(check, Math.min(30_000, INACTIVITY_MS - silent + 1000));
+                timer = setTimeout(check, Math.min(30_000, timeoutMs - silent + 1000));
         };
-        timer = setTimeout(check, INACTIVITY_MS);
+        timer = setTimeout(check, timeoutMs);
     });
     const consume = async () => {
         for await (const msg of pq) {
             lastActivity = Date.now();
+            if (!sessionId && "session_id" in msg) {
+                sessionId = msg.session_id;
+            }
             if (msg.type === "stream_event") {
                 const ev = msg.event;
                 if (ev?.type === "content_block_start" && ev.content_block?.type === "tool_use") {

package/dist/swarm.d.ts

@@ -44,7 +44,6 @@ export declare class Swarm {
     cappedOut: boolean;
     mergeResults: MergeResult[];
     rateLimitUtilization: number;
-    rateLimitStatus: string;
     rateLimitResetsAt?: number;
     /** Per-window rate limit snapshots (updated on every rate_limit_event). */
     rateLimitWindows: Map<string, RateLimitWindow>;

package/dist/swarm.js

@@ -3,6 +3,16 @@ import { existsSync, mkdtempSync, rmSync, writeFileSync } from "fs";
 import { join } from "path";
 import { tmpdir } from "os";
 import { query } from "@anthropic-ai/claude-agent-sdk";
+import { NudgeError } from "./types.js";
+const SIMPLIFY_PROMPT = `You just finished your task. Now review and simplify your changes.
+
+Run \`git diff\` to see what you changed, then fix any issues:
+
+1. **Reuse**: Search the codebase — did you write something that already exists? Use existing utilities, helpers, patterns instead.
+2. **Quality**: Redundant state, copy-paste with slight variation, leaky abstractions, unnecessary wrappers/nesting, comments that narrate what the code does? Delete them.
+3. **Efficiency**: Redundant computations, sequential operations that could be parallel, unnecessary existence checks before operations, unbounded data structures, missing cleanup?
+
+Less code is better. Delete and simplify rather than add. Fix directly — no need to explain.`;
 export class Swarm {
     agents = [];
     logs = [];
@@ -20,7 +30,6 @@ export class Swarm {
     mergeResults = [];
     // Rate limit tracking for auto-concurrency
     rateLimitUtilization = 0;
-    rateLimitStatus = "";
     rateLimitResetsAt;
     /** Per-window rate limit snapshots (updated on every rate_limit_event). */
     rateLimitWindows = new Map();
@@ -212,7 +221,7 @@ export class Swarm {
         this.log(id, `Starting: ${task.prompt.slice(0, 60)}`);
         const maxRetries = this.config.maxRetries ?? 2;
         // Inactivity timeout: kill agent only if it goes silent (no messages)
-        const inactivityMs = this.config.agentTimeoutMs ?? 5 * 60 * 1000;
+        const inactivityMs = this.config.agentTimeoutMs ?? 15 * 60 * 1000;
         for (let attempt = 0; attempt <= maxRetries; attempt++) {
             if (attempt > 0) {
                 const backoffMs = Math.min(30000, 1000 * 2 ** (attempt - 1)) * (0.5 + Math.random());
@@ -224,51 +233,94 @@ export class Swarm {
             }
             try {
                 const perm = this.config.permissionMode ?? "auto";
-                const agentQuery = query({
-                    prompt: this.config.useWorktrees
-                        ? `You are working in an isolated git worktree. Focus only on this task. Do NOT commit your changes — the framework handles that.\n\n${task.prompt}`
-                        : task.prompt,
-                    options: {
-                        cwd: agentCwd,
-                        model: task.model || this.config.model,
-                        permissionMode: perm,
-                        ...(perm === "bypassPermissions" && { allowDangerouslySkipPermissions: true }),
-                        allowedTools: this.config.allowedTools,
-                        includePartialMessages: true,
-                        persistSession: false,
-                    },
-                });
-                // Inactivity watchdog: resets on every message, only fires if agent goes silent
-                let lastActivity = Date.now();
-                let timer;
-                const watchdog = new Promise((_, reject) => {
-                    const check = () => {
-                        const silent = Date.now() - lastActivity;
-                        if (silent >= inactivityMs) {
-                            agentQuery.close();
-                            reject(new AgentTimeoutError(silent));
-                        }
-                        else {
-                            timer = setTimeout(check, Math.min(30_000, inactivityMs - silent + 1000));
-                        }
-                    };
-                    timer = setTimeout(check, inactivityMs);
-                });
-                this.activeQueries.add(agentQuery);
-                try {
-                    await Promise.race([
-                        (async () => {
-                            for await (const msg of agentQuery) {
-                                lastActivity = Date.now();
-                                this.handleMsg(agent, msg);
+                let resumeSessionId;
+                let resumePrompt = "Continue. Complete the task.";
+                const runOnce = async (isResume) => {
+                    const agentPrompt = isResume
+                        ? resumePrompt
+                        : this.config.useWorktrees
+                            ? `You are working in an isolated git worktree. Focus only on this task. Do NOT commit your changes — the framework handles that.\n\n${task.prompt}`
+                            : task.prompt;
+                    const agentQuery = query({
+                        prompt: agentPrompt,
+                        options: {
+                            cwd: agentCwd,
+                            model: task.model || this.config.model,
+                            permissionMode: perm,
+                            ...(perm === "bypassPermissions" && { allowDangerouslySkipPermissions: true }),
+                            allowedTools: this.config.allowedTools,
+                            includePartialMessages: true,
+                            persistSession: true,
+                            ...(isResume && resumeSessionId && { resume: resumeSessionId }),
+                        },
+                    });
+                    const timeoutMs = isResume ? inactivityMs * 2 : inactivityMs;
+                    let sessionId;
+                    let lastActivity = Date.now();
+                    let timer;
+                    const watchdog = new Promise((_, reject) => {
+                        const check = () => {
+                            const silent = Date.now() - lastActivity;
+                            if (silent >= timeoutMs) {
+                                agentQuery.interrupt().catch(() => agentQuery.close());
+                                if (isResume) {
+                                    reject(new AgentTimeoutError(silent));
+                                }
+                                else {
+                                    reject(new NudgeError(sessionId, silent));
+                                }
+                            }
+                            else {
+                                timer = setTimeout(check, Math.min(30_000, timeoutMs - silent + 1000));
                             }
-                        })(),
-                        watchdog,
-                    ]);
+                        };
+                        timer = setTimeout(check, timeoutMs);
+                    });
+                    this.activeQueries.add(agentQuery);
+                    try {
+                        await Promise.race([
+                            (async () => {
+                                for await (const msg of agentQuery) {
+                                    lastActivity = Date.now();
+                                    if (!sessionId && "session_id" in msg) {
+                                        sessionId = msg.session_id;
+                                    }
+                                    this.handleMsg(agent, msg);
+                                }
+                            })(),
+                            watchdog,
+                        ]);
+                    }
+                    finally {
+                        clearTimeout(timer);
+                        this.activeQueries.delete(agentQuery);
+                        if (sessionId)
+                            resumeSessionId = sessionId;
+                    }
+                };
+                // Run with nudge: first attempt can be interrupted and resumed
+                try {
+                    await runOnce(false);
+                }
+                catch (nudgeErr) {
+                    if (nudgeErr instanceof NudgeError && resumeSessionId) {
+                        this.log(id, `Silent ${Math.round(inactivityMs / 60000)}m — resuming with continue`);
+                        await runOnce(true);
+                    }
+                    else {
+                        throw nudgeErr;
+                    }
                 }
-                finally {
-                    clearTimeout(timer);
-                    this.activeQueries.delete(agentQuery);
+                // Simplify pass: resume session with review prompt
+                if (resumeSessionId && agent.status === "running") {
+                    try {
+                        this.log(id, "Simplify pass");
+                        resumePrompt = SIMPLIFY_PROMPT;
+                        await runOnce(true);
+                    }
+                    catch {
+                        this.log(id, "Simplify pass skipped");
+                    }
                 }
                 if (agent.status === "running") {
                     agent.finishedAt = Date.now();
@@ -658,7 +710,6 @@ export class Swarm {
                 const rl = msg;
                 const info = rl.rate_limit_info;
                 this.rateLimitUtilization = info.utilization ?? 0;
-                this.rateLimitStatus = info.status;
                 if (info.status === "rejected" && info.resetsAt && !this.allowExtraUsage) {
                     // Only block dispatch on rejection if extra usage is NOT allowed.
                     // When extra usage is allowed, rejection is just the plan→overage transition.

package/dist/types.d.ts

@@ -110,6 +110,11 @@ export interface RateLimitWindow {
     status: string;
     resetsAt?: number;
 }
+/** Thrown when a query goes silent — carries session ID for interrupt+resume. */
+export declare class NudgeError extends Error {
+    sessionId: string | undefined;
+    constructor(sessionId: string | undefined, silentMs: number);
+}
 /** Persisted run state for crash recovery and resume. */
 export interface RunState {
     id: string;

package/dist/types.js

@@ -1 +1,9 @@
-export {};
+/** Thrown when a query goes silent — carries session ID for interrupt+resume. */
+export class NudgeError extends Error {
+    sessionId;
+    constructor(sessionId, silentMs) {
+        super(`Silent for ${Math.round(silentMs / 1000)}s — nudging`);
+        this.sessionId = sessionId;
+        this.name = "NudgeError";
+    }
+}

package/package.json

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