claude-overnight 1.2.1 → 1.3.0

package/README.md

@@ -178,7 +178,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 |
 
@@ -225,6 +225,8 @@ 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,7 @@ 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";
 export class Swarm {
     agents = [];
     logs = [];
@@ -20,7 +21,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 +212,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 +224,82 @@ 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;
+                const runOnce = async (isResume) => {
+                    const agentPrompt = isResume
+                        ? "Continue. Complete the task."
+                        : 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));
+                                }
                             }
-                        })(),
-                        watchdog,
-                    ]);
+                            else {
+                                timer = setTimeout(check, Math.min(30_000, timeoutMs - silent + 1000));
+                            }
+                        };
+                        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);
                 }
-                finally {
-                    clearTimeout(timer);
-                    this.activeQueries.delete(agentQuery);
+                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;
+                    }
                 }
                 if (agent.status === "running") {
                     agent.finishedAt = Date.now();
@@ -658,10 +689,14 @@ 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) {
+                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.
                     this.rateLimitResetsAt = info.resetsAt;
                 }
+                else if (info.status !== "rejected") {
+                    this.rateLimitResetsAt = undefined;
+                }
                 // Track per-window state
                 const windowType = info.rateLimitType;
                 if (windowType) {
@@ -684,7 +719,10 @@ export class Swarm {
                 }
                 const pct = info.utilization != null ? `${Math.round(info.utilization * 100)}%` : "";
                 const overageTag = this.isUsingOverage ? " [EXTRA]" : "";
-                this.log(agent.id, `Rate: ${info.status} ${pct}${overageTag}${windowType ? ` (${windowType})` : ""}`);
+                const statusLabel = info.status === "rejected" && this.allowExtraUsage
+                    ? "switching to extra usage"
+                    : info.status;
+                this.log(agent.id, `Rate: ${statusLabel} ${pct}${overageTag}${windowType ? ` (${windowType})` : ""}`);
                 break;
             }
         }

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/dist/ui.js

@@ -75,14 +75,18 @@ export function renderFrame(swarm, showHotkeys = false) {
                     label = chalk.yellow(`Capped at ${capFrac != null ? Math.round(capFrac * 100) : 100}% — finishing active`);
                 }
             }
-            else if (swarm.rateLimitResetsAt) {
-                const waitSec = Math.max(0, Math.ceil((swarm.rateLimitResetsAt - Date.now()) / 1000));
+            else if (swarm.rateLimitResetsAt && swarm.rateLimitResetsAt > Date.now()) {
+                const waitSec = Math.ceil((swarm.rateLimitResetsAt - Date.now()) / 1000);
                 const mm = Math.floor(waitSec / 60);
                 const ss = waitSec % 60;
                 label = chalk.red(`Waiting for reset ${mm > 0 ? `${mm}m ${ss}s` : `${ss}s`}`);
             }
-            if (swarm.isUsingOverage && !swarm.cappedOut)
-                label += chalk.red(" [EXTRA USAGE]");
+            if (swarm.isUsingOverage && !swarm.cappedOut) {
+                const budgetInfo = swarm.extraUsageBudget != null
+                    ? ` $${swarm.overageCostUsd.toFixed(2)}/$${swarm.extraUsageBudget}`
+                    : "";
+                label += chalk.red(` [EXTRA USAGE${budgetInfo}]`);
+            }
             const prefix = windowLabel ? chalk.dim(windowLabel.padEnd(6)) : chalk.dim("Usage ");
             out.push(`  ${prefix}${barStr}  ${label}`);
         };

package/package.json

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