claude-overnight 1.11.3 → 1.11.5

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.isUsingOverage
+                ? chalk.red(`Extra usage budget 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`);

package/dist/run.js

@@ -390,7 +390,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 — EXTRA USAGE BUDGET HIT`));
     else if (stopping || lastAborted)
         console.log(chalk.bold.yellow(`  CLAUDE OVERNIGHT — INTERRUPTED`));
     else
@@ -406,7 +406,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(`Extra usage budget exhausted`)}`);
     console.log("");
     const statusFile = join(runDir, "status.md");
     if (existsSync(statusFile)) {

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,45 @@ 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
+        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)
+                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())
-                : 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 = overageBlocked ? "Extra usage blocked (plan limit)"
+                : 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;
-            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 +371,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 +476,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 +502,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.3",
+  "version": "1.11.5",
   "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": {