claude-overnight 1.11.13 → 1.12.0

package/dist/index.js

@@ -269,15 +269,37 @@ async function main() {
             //      (saveRunState always stores [] — the plan is on disk in tasks.json).
             if (resumeState.currentTasks.length === 0) {
                 const loaded = salvageFromFile(join(resumeRunDir, "tasks.json"), resumeState.budget, () => { }, "resume");
-                if (!loaded && resumeState.phase === "planning") {
-                    console.error(chalk.red(`\n  Planning-phase run has no usable tasks.json — start Fresh instead.\n`));
-                    process.exit(1);
-                }
                 if (loaded) {
                     resumeState.currentTasks = loaded;
                     const label = resumeState.phase === "planning" ? "Resuming plan" : `Resuming ${resumeState.phase} run`;
                     console.log(chalk.green(`\n  ✓ ${label} · ${loaded.length} tasks loaded from tasks.json`));
                 }
+                else if (resumeState.phase === "planning") {
+                    // No tasks.json — the thinking wave got killed before orchestrate ran.
+                    // If design docs survived, re-orchestrate from them (salvages the
+                    // thinking spend instead of throwing it away).
+                    const designs = readMdDir(join(resumeRunDir, "designs"));
+                    if (!designs || !resumeState.objective) {
+                        console.error(chalk.red(`\n  Planning-phase run has no usable tasks.json or designs — start Fresh instead.\n`));
+                        process.exit(1);
+                    }
+                    const remainingBudget = Math.max(resumeState.concurrency, resumeState.budget - resumeState.accCompleted);
+                    const orchBudget = Math.min(50, Math.max(resumeState.concurrency, Math.ceil(remainingBudget * 0.5)));
+                    const flexNote = `This is wave 1 of an adaptive multi-wave run (total budget: ${remainingBudget}). Plan the highest-impact foundational work first. Future waves will iterate based on what's learned.`;
+                    console.log(chalk.cyan(`\n  ◆ Re-orchestrating plan from existing designs...\n`));
+                    process.stdout.write("\x1B[?25l");
+                    try {
+                        const orchTasks = await orchestrate(resumeState.objective, designs, cwd, resumeState.plannerModel, resumeState.workerModel, resumeState.permissionMode, orchBudget, resumeState.concurrency, makeProgressLog(), flexNote, join(resumeRunDir, "tasks.json"));
+                        resumeState.currentTasks = orchTasks;
+                        process.stdout.write(`\x1B[2K\r  ${chalk.green(`✓ ${orchTasks.length} tasks`)}\n`);
+                    }
+                    catch (err) {
+                        process.stdout.write("\x1B[?25h");
+                        console.error(chalk.red(`\n  Re-orchestration failed: ${err.message}\n  Start Fresh instead.\n`));
+                        process.exit(1);
+                    }
+                    process.stdout.write("\x1B[?25h");
+                }
             }
             const unmerged = resumeState.branches.filter(b => b.status === "unmerged").length;
             if (unmerged > 0) {
@@ -634,7 +656,7 @@ async function main() {
                         useWorktrees: false, mergeStrategy: "yolo", agentTimeoutMs, usageCap, allowExtraUsage, extraUsageBudget,
                     });
                     const thinkRunInfo = { accIn: 0, accOut: 0, accCost: 0, accCompleted: 0, accFailed: 0, sessionsBudget: budget ?? 10, waveNum: -1, remaining: budget ?? 10, model: plannerModel, startedAt: Date.now() };
-                    const thinkDisplay = new RunDisplay(thinkRunInfo, { remaining: 0, usageCap, dirty: false });
+                    const thinkDisplay = new RunDisplay(thinkRunInfo, { remaining: 0, usageCap, concurrency, paused: false, dirty: false });
                     thinkDisplay.setWave(thinkingSwarm);
                     thinkDisplay.start();
                     try {
@@ -651,6 +673,26 @@ async function main() {
                     thinkingOut = thinkingSwarm.totalOutputTokens;
                     thinkingTools = thinkingSwarm.agents.reduce((sum, a) => sum + a.toolCalls, 0);
                     thinkingHistory = { wave: -1, tasks: thinkingSwarm.agents.map(a => ({ prompt: a.task.prompt.slice(0, 200), status: a.status, filesChanged: a.filesChanged, error: a.error })) };
+                    // Persist thinking cost/count into run.json so if the user quits
+                    // between thinking and orchestrate, resume still sees the real spend
+                    // and the run stays visible in the picker (designs on disk = resumable).
+                    try {
+                        saveRunState(runDir, {
+                            id: runDir.split(/[/\\]/).pop() ?? "",
+                            objective: objective, budget: budget ?? 10, remaining: (budget ?? 10) - thinkingUsed,
+                            workerModel, plannerModel, concurrency, permissionMode,
+                            usageCap, allowExtraUsage, extraUsageBudget,
+                            flex, useWorktrees, mergeStrategy,
+                            waveNum: 0, currentTasks: [],
+                            accCost: thinkingCost, accCompleted: thinkingUsed, accFailed: 0,
+                            accIn: thinkingIn, accOut: thinkingOut, accTools: thinkingTools,
+                            branches: [],
+                            phase: "planning",
+                            startedAt: new Date().toISOString(),
+                            cwd,
+                        });
+                    }
+                    catch { }
                     if (thinkingSwarm.rateLimitResetsAt) {
                         const waitMs = thinkingSwarm.rateLimitResetsAt - Date.now();
                         if (waitMs > 0) {

package/dist/render.js

@@ -42,10 +42,16 @@ function renderHeader(out, w, p) {
     const bar = chalk.green("\u2588".repeat(filled)) + chalk.gray("\u2591".repeat(barW - filled));
     const modelTag = p.model ? chalk.dim(` [${p.model}]`) : "";
     const phaseTag = p.phase ? " " + p.phase : "";
+    const blocked = p.blocked ?? 0;
+    const working = Math.max(0, p.active - blocked);
+    const stuck = blocked > 0 && working === 0;
+    const activeChip = p.active > 0
+        ? (stuck ? chalk.yellow(`${p.active} blocked`) : chalk.cyan(`${working} active`) + (blocked > 0 ? chalk.yellow(` (${blocked} blocked)`) : ""))
+        : "";
     out.push("");
     out.push(`  ${chalk.bold.white("CLAUDE OVERNIGHT")}${modelTag}${phaseTag}  ${bar}  ` +
         `${p.barLabel}  ` +
-        (p.active > 0 ? chalk.cyan(`${p.active} active`) + "  " : "") +
+        (activeChip ? activeChip + "  " : "") +
         (p.queued > 0 ? chalk.gray(`${p.queued} queued`) + "  " : "") +
         chalk.gray(`\u23F1 ${fmtDur(Date.now() - p.startedAt)}`));
     const tokIn = fmtTokens(p.totalIn);
@@ -129,17 +135,19 @@ export function renderFrame(swarm, showHotkeys, runInfo) {
     const w = Math.max((process.stdout.columns ?? 80) || 80, 60);
     const out = [];
     const stoppingTag = swarm.aborted ? chalk.yellow("STOPPING") : "";
+    const pausedTag = swarm.paused ? chalk.yellow("PAUSED") : "";
+    const stallTag = swarm.stallLevel >= 3 ? chalk.red("STALL") : swarm.stallLevel > 0 ? chalk.yellow(`STALL L${swarm.stallLevel}`) : "";
     const phaseLabel = swarm.phase === "planning" ? chalk.magenta("PLANNING")
         : swarm.phase === "merging" ? chalk.yellow("MERGING")
             : swarm.rateLimitPaused > 0 ? chalk.yellow("COOLING") : "";
-    const phase = [phaseLabel, stoppingTag].filter(Boolean).join(" ");
+    const phase = [phaseLabel, pausedTag, stallTag, stoppingTag].filter(Boolean).join(" ");
     const waveUsed = swarm.completed + swarm.failed;
     renderHeader(out, w, {
         model: runInfo?.model ?? swarm.model,
         phase,
         barPct: swarm.total > 0 ? swarm.completed / swarm.total : 0,
         barLabel: `${swarm.completed}/${swarm.total}`,
-        active: swarm.active, queued: swarm.pending,
+        active: swarm.active, blocked: swarm.blocked, queued: swarm.pending,
         startedAt: runInfo?.startedAt ?? swarm.startedAt,
         totalIn: (runInfo?.accIn ?? 0) + swarm.totalInputTokens,
         totalOut: (runInfo?.accOut ?? 0) + swarm.totalOutputTokens,
@@ -187,7 +195,11 @@ export function renderFrame(swarm, showHotkeys, runInfo) {
         const pending = runInfo?.pendingSteer ?? 0;
         const chip = pending > 0 ? chalk.cyan(`  \u270E ${pending} steer queued`) : "";
         const fixChip = swarm.failed > 0 && swarm.active > 0 ? chalk.yellow("  [f] fix") : "";
-        out.push(chalk.dim("  [b] budget  [t] threshold  [s] steer  [?] ask  [q] stop") + fixChip + chip);
+        const pauseLabel = swarm.paused ? "[p] resume" : "[p] pause";
+        out.push(chalk.dim(`  [b] budget  [t] threshold  [c] conc  ${pauseLabel}  [s] steer  [?] ask  [q] stop`) + fixChip + chip);
+        if (swarm.blocked > 0 && swarm.blocked === swarm.active) {
+            out.push(chalk.yellow(`  all workers rate-limited — press [c] to reduce concurrency, [p] to pause, [q] to quit`));
+        }
     }
     out.push("");
     return out.join("\n");
@@ -368,12 +380,15 @@ function fmtRow(a, w) {
     const elapsed = a.status === "running" && a.startedAt ? " " + chalk.dim(fmtDur(Date.now() - a.startedAt)) : "";
     const spin = SPINNER[Math.floor(Date.now() / 250) % SPINNER.length];
     const icon = a.status === "running"
-        ? chalk.blue(`${spin} run`) + elapsed
+        ? (a.blockedAt ? chalk.yellow("\u25CF blk") : chalk.blue(`${spin} run`)) + elapsed
         : a.status === "done" ? chalk.green("\u2713 done") : chalk.red("\u2717 err ");
     const taskW = Math.max(20, Math.min(36, w - 50));
     const task = truncate(a.task.prompt, taskW).padEnd(taskW);
     let action;
-    if (a.currentTool) {
+    if (a.blockedAt) {
+        action = chalk.yellow(`rate-limited ${fmtDur(Date.now() - a.blockedAt)}`);
+    }
+    else if (a.currentTool) {
         action = chalk.yellow(a.currentTool);
     }
     else if (a.status === "running") {

package/dist/run.js

@@ -25,7 +25,7 @@ export async function executeRun(cfg) {
     let currentSwarm;
     let remaining;
     let currentTasks;
-    const liveConfig = { remaining: 0, usageCap, dirty: false };
+    const liveConfig = { remaining: 0, usageCap, concurrency, paused: false, dirty: false };
     let waveNum;
     const waveHistory = [];
     let accCost, accCompleted, accFailed, accTools;

package/dist/state.js

@@ -191,9 +191,12 @@ export function findIncompleteRuns(rootDir, filterCwd) {
             const state = loadRunState(runDir);
             if (!state || state.phase === "done" || state.cwd !== filterCwd)
                 continue;
-            // Planning-phase runs are only resumable if tasks.json was actually
-            // written — resuming without tasks is nothing to resume.
-            if (state.phase === "planning" && !existsSync(join(runDir, "tasks.json")))
+            // Planning-phase runs are resumable if either tasks.json was written
+            // (orchestrate completed) OR design docs exist on disk (thinking wave
+            // got killed mid-way — we can re-orchestrate from the designs on resume).
+            if (state.phase === "planning"
+                && !existsSync(join(runDir, "tasks.json"))
+                && !readMdDir(join(runDir, "designs")))
                 continue;
             results.push({ dir: runDir, state });
         }

package/dist/swarm.d.ts

@@ -41,6 +41,20 @@ export declare class Swarm {
     rateLimitPaused: number;
     isUsingOverage: boolean;
     overageCostUsd: number;
+    /** Live-adjustable concurrency target. Workers above this count exit on the next task boundary. */
+    targetConcurrency: number;
+    /** When true, dispatch is frozen — workers wait without starting new tasks. */
+    paused: boolean;
+    /** Wall-clock ms of the last sign of real progress (assistant msg, tool use, result). */
+    lastProgressAt: number;
+    /** 0 = normal, 1 = halved once, 2 = halved twice, 3 = long cooldown at c=1, 4 = aborted. */
+    stallLevel: number;
+    /** Last time the watchdog took an action; used to debounce escalations. */
+    private stallActionAt;
+    /** Live worker coroutine count (not agents). */
+    private workerCount;
+    /** Growable list of worker promises; run() awaits until empty. */
+    private workerPromises;
     private queue;
     private config;
     private nextId;
@@ -56,7 +70,12 @@ export declare class Swarm {
     mergeBranch?: string;
     constructor(config: SwarmConfig);
     get active(): number;
+    get blocked(): number;
     get pending(): number;
+    /** Live-adjust concurrency. Shrinks by having excess workers exit on next task boundary; grows by spawning new workers. */
+    setConcurrency(n: number): void;
+    /** Freeze/resume dispatch without killing the run. Paused workers block at the top of their loop. */
+    setPaused(b: boolean): void;
     run(): Promise<void>;
     abort(): void;
     /** Re-queue all errored agents' tasks for retry within this wave. */
@@ -65,6 +84,17 @@ export declare class Swarm {
     log(agentId: number, text: string): void;
     cleanup(): void;
     private worker;
+    /** Mark real progress — resets stall state. Called on any assistant/tool/result message. */
+    private markProgress;
+    /**
+     * Stall watchdog. Called each time a worker finishes a rate-limit wait. Escalates when
+     * the whole swarm has been stuck with no progress for a while:
+     *   L1 @ 5m → halve concurrency
+     *   L2 @ 10m → halve again
+     *   L3 @ 15m+ at c=1 → force a 10-minute cooldown instead of hammering every 60s
+     *   L4 @ 30m → abort the run so it can be resumed later without burning the budget
+     */
+    private checkStall;
     private capForOverage;
     private throttle;
     private runAgent;

package/dist/swarm.js

@@ -34,6 +34,20 @@ export class Swarm {
     rateLimitPaused = 0;
     isUsingOverage = false;
     overageCostUsd = 0;
+    /** Live-adjustable concurrency target. Workers above this count exit on the next task boundary. */
+    targetConcurrency;
+    /** When true, dispatch is frozen — workers wait without starting new tasks. */
+    paused = false;
+    /** Wall-clock ms of the last sign of real progress (assistant msg, tool use, result). */
+    lastProgressAt = Date.now();
+    /** 0 = normal, 1 = halved once, 2 = halved twice, 3 = long cooldown at c=1, 4 = aborted. */
+    stallLevel = 0;
+    /** Last time the watchdog took an action; used to debounce escalations. */
+    stallActionAt = 0;
+    /** Live worker coroutine count (not agents). */
+    workerCount = 0;
+    /** Growable list of worker promises; run() awaits until empty. */
+    workerPromises = [];
     queue;
     config;
     nextId = 0;
@@ -68,9 +82,33 @@ export class Swarm {
         this.baseCostUsd = config.baseCostUsd ?? 0;
         this.queue = [...config.tasks];
         this.total = config.tasks.length;
+        this.targetConcurrency = config.concurrency;
     }
     get active() { return this.agents.filter(a => a.status === "running").length; }
+    get blocked() { return this.agents.filter(a => a.status === "running" && a.blockedAt != null).length; }
     get pending() { return this.queue.length; }
+    /** Live-adjust concurrency. Shrinks by having excess workers exit on next task boundary; grows by spawning new workers. */
+    setConcurrency(n) {
+        if (!Number.isFinite(n) || n < 1)
+            return;
+        const prev = this.targetConcurrency;
+        if (n === prev)
+            return;
+        this.targetConcurrency = n;
+        this.log(-1, `Concurrency changed: ${prev} → ${n}`);
+        if (n > prev && this.queue.length > 0 && !this.aborted && !this.cappedOut) {
+            const toSpawn = Math.min(n - this.workerCount, this.queue.length);
+            for (let i = 0; i < toSpawn; i++)
+                this.workerPromises.push(this.worker());
+        }
+    }
+    /** Freeze/resume dispatch without killing the run. Paused workers block at the top of their loop. */
+    setPaused(b) {
+        if (this.paused === b)
+            return;
+        this.paused = b;
+        this.log(-1, b ? "Dispatch paused" : "Dispatch resumed");
+    }
     async run() {
         try {
             if (this.config.useWorktrees) {
@@ -80,8 +118,15 @@ export class Swarm {
                 this.log(-1, `Worktrees: ${this.worktreeBase}`);
             }
             this.phase = "running";
-            const n = Math.min(this.config.concurrency, this.queue.length);
-            await Promise.all(Array.from({ length: n }, () => this.worker()));
+            const n = Math.min(this.targetConcurrency, this.queue.length);
+            for (let i = 0; i < n; i++)
+                this.workerPromises.push(this.worker());
+            // setConcurrency() can grow workerPromises during execution, so drain in a loop.
+            while (this.workerPromises.length > 0) {
+                const batch = this.workerPromises.slice();
+                this.workerPromises.length = 0;
+                await Promise.all(batch);
+            }
             if (this.config.useWorktrees) {
                 this.phase = "merging";
                 const branches = this.agents.filter(a => a.branch && a.status === "done" && (a.filesChanged ?? 0) > 0)
@@ -96,7 +141,7 @@ export class Swarm {
         finally {
             this.cleanup();
             this.logFile = writeSwarmLog({
-                startedAt: this.startedAt, model: this.config.model, concurrency: this.config.concurrency,
+                startedAt: this.startedAt, model: this.config.model, concurrency: this.targetConcurrency,
                 useWorktrees: this.config.useWorktrees, mergeStrategy: this.config.mergeStrategy,
                 completed: this.completed, failed: this.failed, aborted: this.aborted,
                 cost: this.totalCostUsd, inputTokens: this.totalInputTokens, outputTokens: this.totalOutputTokens,
@@ -151,23 +196,83 @@ export class Swarm {
     }
     // ── Worker loop ──
     async worker() {
+        this.workerCount++;
         let tasksProcessed = 0;
-        while (this.queue.length > 0 && !this.aborted && !this.cappedOut) {
-            await this.throttle();
-            if (this.cappedOut)
-                break;
-            const task = this.queue.shift();
-            if (!task)
-                break;
-            try {
-                await this.runAgent(task);
-            }
-            catch (err) {
-                this.log(-1, `Worker error: ${String(err?.message || err).slice(0, 80)}`);
+        try {
+            while (this.queue.length > 0 && !this.aborted && !this.cappedOut) {
+                // Shrink: exit if we're above the live target.
+                if (this.workerCount > this.targetConcurrency) {
+                    this.log(-1, `Worker exiting (concurrency shrunk to ${this.targetConcurrency})`);
+                    return;
+                }
+                // Pause: block here without holding a task, so unpausing resumes cleanly.
+                while (this.paused && !this.aborted && !this.cappedOut)
+                    await sleep(500);
+                await this.throttle();
+                if (this.cappedOut || this.aborted)
+                    break;
+                if (this.workerCount > this.targetConcurrency)
+                    return;
+                const task = this.queue.shift();
+                if (!task)
+                    break;
+                try {
+                    await this.runAgent(task);
+                }
+                catch (err) {
+                    this.log(-1, `Worker error: ${String(err?.message || err).slice(0, 80)}`);
+                }
+                tasksProcessed++;
             }
-            tasksProcessed++;
+            this.log(-1, `Worker finished (${tasksProcessed} tasks)`);
+        }
+        finally {
+            this.workerCount--;
+        }
+    }
+    /** Mark real progress — resets stall state. Called on any assistant/tool/result message. */
+    markProgress() {
+        this.lastProgressAt = Date.now();
+        if (this.stallLevel > 0 && this.lastProgressAt > this.stallActionAt)
+            this.stallLevel = 0;
+    }
+    /**
+     * Stall watchdog. Called each time a worker finishes a rate-limit wait. Escalates when
+     * the whole swarm has been stuck with no progress for a while:
+     *   L1 @ 5m → halve concurrency
+     *   L2 @ 10m → halve again
+     *   L3 @ 15m+ at c=1 → force a 10-minute cooldown instead of hammering every 60s
+     *   L4 @ 30m → abort the run so it can be resumed later without burning the budget
+     */
+    checkStall() {
+        const stalledFor = Date.now() - this.lastProgressAt;
+        if (stalledFor < 5 * 60_000)
+            return;
+        // Debounce so multiple workers waking at once don't double-escalate.
+        if (Date.now() - this.stallActionAt < 60_000)
+            return;
+        if (stalledFor >= 30 * 60_000) {
+            this.stallLevel = 4;
+            this.stallActionAt = Date.now();
+            this.log(-1, `Stalled ${Math.round(stalledFor / 60000)}m with no progress — aborting run so you can resume later`);
+            this.abort();
+            return;
+        }
+        if (this.targetConcurrency <= 1 && stalledFor >= 15 * 60_000) {
+            this.stallLevel = 3;
+            this.stallActionAt = Date.now();
+            const until = Date.now() + 10 * 60_000;
+            this.rateLimitResetsAt = until;
+            this.log(-1, `Stalled at concurrency 1 for ${Math.round(stalledFor / 60000)}m — forcing 10m cooldown`);
+            return;
+        }
+        if (this.stallLevel < 2 && this.targetConcurrency > 1) {
+            const next = Math.max(1, Math.floor(this.targetConcurrency / 2));
+            this.stallLevel++;
+            this.stallActionAt = Date.now();
+            this.log(-1, `Auto-throttle L${this.stallLevel}: concurrency ${this.targetConcurrency} → ${next} (stalled ${Math.round(stalledFor / 60000)}m)`);
+            this.setConcurrency(next);
         }
-        this.log(-1, `Worker finished (${tasksProcessed} tasks)`);
     }
     capForOverage(reason) {
         if (this.cappedOut)
@@ -210,6 +315,9 @@ export class Swarm {
             this.rateLimitUtilization = 0;
             this.rateLimitResetsAt = undefined;
             consecutiveWaits++;
+            this.checkStall();
+            if (this.aborted || this.cappedOut)
+                return;
         }
     }
     // ── Agent execution ──
@@ -361,12 +469,12 @@ export class Swarm {
                         agent.status = "error";
                         agent.error = "Agent did no work — exited without tool use";
                         this.failed++;
+                        this.log(id, agent.error);
                     }
                     else {
                         agent.status = "done";
                         this.completed++;
                     }
-                    this.log(id, this.agentSummary(agent));
                 }
                 break;
             }
@@ -378,14 +486,23 @@ export class Swarm {
                     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)`);
+                    // If the whole swarm has been making zero progress for a while, stop giving
+                    // rate-limit retries a free pass — force them to count against maxRetries so
+                    // we eventually surrender instead of looping forever.
+                    const globallyStalled = Date.now() - this.lastProgressAt > 15 * 60_000;
+                    const freebie = !globallyStalled;
+                    this.log(id, `Rate limited — waiting ${Math.ceil(waitMs / 1000)}s${freebie ? " (attempt not counted)" : " (counted — swarm stalled)"}`);
+                    agent.blockedAt = Date.now();
                     this.rateLimitPaused++;
                     await sleep(waitMs);
                     this.rateLimitPaused--;
+                    agent.blockedAt = undefined;
                     this.isUsingOverage = false;
                     this.rateLimitUtilization = 0;
                     this.rateLimitResetsAt = undefined;
-                    attempt--; // don't count this against retries
+                    this.checkStall();
+                    if (freebie)
+                        attempt--; // normal case: don't count against retries
                     continue;
                 }
                 const canRetry = attempt < maxRetries && !this.aborted && isTransientError(err);
@@ -403,16 +520,26 @@ export class Swarm {
         if (this.config.useWorktrees && agent.branch) {
             agent.filesChanged = autoCommit(agent.id, agent.task.prompt, agentCwd, agent.baseRef, (id, text) => this.log(id, text));
         }
+        if (agent.status === "done")
+            this.log(agent.id, this.agentSummary(agent));
     }
     agentSummary(agent) {
         const dur = (agent.finishedAt ?? Date.now()) - (agent.startedAt ?? Date.now());
         const m = Math.floor(dur / 60000);
         const s = Math.round((dur % 60000) / 1000);
         const verb = agent.status === "error" ? "errored" : "done";
-        return `Agent ${agent.id} ${verb}: ${m}m ${s}s, ${agent.toolCalls} tools, ${agent.filesChanged ?? 0} files changed`;
+        const files = agent.filesChanged != null ? `, ${agent.filesChanged} files changed` : "";
+        return `Agent ${agent.id} ${verb}: ${m}m ${s}s, ${agent.toolCalls} tools${files}`;
     }
     // ── Message handler ──
     handleMsg(agent, msg) {
+        // Any message that isn't a rate-limit event counts as real progress and
+        // resets the stall watchdog + clears the per-agent blocked flag.
+        if (msg.type !== "rate_limit_event") {
+            this.markProgress();
+            if (agent.blockedAt != null)
+                agent.blockedAt = undefined;
+        }
         switch (msg.type) {
             case "assistant": {
                 const m = msg;
@@ -462,16 +589,39 @@ export class Swarm {
                     this.totalInputTokens += safeAdd(r.usage.input_tokens);
                     this.totalOutputTokens += safeAdd(r.usage.output_tokens);
                 }
+                // Surface SDK diagnostics so silent failures stop looking like "did no work".
+                const denials = r.permission_denials ?? [];
+                if (denials.length > 0) {
+                    const tools = Array.from(new Set(denials.map(d => d.tool_name))).join(", ");
+                    this.log(agent.id, `${denials.length} permission denial(s): ${tools}`);
+                }
+                if (r.terminal_reason && r.terminal_reason !== "completed") {
+                    this.log(agent.id, `terminal: ${r.terminal_reason}`);
+                }
+                if (r.stop_reason && r.stop_reason !== "end_turn" && r.stop_reason !== "stop_sequence") {
+                    this.log(agent.id, `stop: ${r.stop_reason}`);
+                }
+                if (typeof r.num_turns === "number" && r.num_turns > 0) {
+                    this.log(agent.id, `${r.num_turns} turns`);
+                }
                 if (r.subtype === "success") {
                     agent.status = "done";
                     this.completed++;
-                    this.log(agent.id, this.agentSummary(agent));
                 }
                 else {
                     agent.status = "error";
-                    agent.error = r.subtype;
+                    const parts = [r.subtype];
+                    if (r.terminal_reason && r.terminal_reason !== "completed")
+                        parts.push(r.terminal_reason);
+                    const errs = r.errors;
+                    if (Array.isArray(errs) && errs.length > 0) {
+                        parts.push(errs[0]);
+                        for (const e of errs.slice(1, 3))
+                            this.log(agent.id, `err: ${String(e).slice(0, 160)}`);
+                    }
+                    agent.error = parts.join(" — ").slice(0, 180);
                     this.failed++;
-                    this.log(agent.id, r.subtype);
+                    this.log(agent.id, agent.error);
                 }
                 break;
             }

package/dist/types.d.ts

@@ -68,6 +68,8 @@ export interface AgentState {
     baseRef?: string;
     /** Number of files changed by the agent (from git diff). */
     filesChanged?: number;
+    /** Unix timestamp (ms) when this agent entered a rate-limit wait inside its retry loop. Cleared when work resumes. */
+    blockedAt?: number;
 }
 /** A timestamped log line from an agent's execution. */
 export interface LogEntry {

package/dist/ui.d.ts

@@ -30,6 +30,8 @@ export interface RunInfo {
 export interface LiveConfig {
     remaining: number;
     usageCap: number | undefined;
+    concurrency: number;
+    paused: boolean;
     dirty: boolean;
 }
 /** State of an in-flight or recently-completed ask side query. */

package/dist/ui.js

@@ -161,6 +161,9 @@ export class RunDisplay {
         if (this.inputMode === "threshold") {
             return `\n  ${chalk.cyan(">")} New usage cap (0-100%): ${rendered}\u2588`;
         }
+        if (this.inputMode === "concurrency") {
+            return `\n  ${chalk.cyan(">")} New concurrency (min 1): ${rendered}\u2588`;
+        }
         if (this.inputMode === "steer") {
             return `\n  ${chalk.cyan(">")} ${chalk.bold("Steer next wave")} ${chalk.dim("(Enter to queue, Esc to cancel)")}\n  ${rendered}\u2588`;
         }
@@ -226,7 +229,7 @@ export class RunDisplay {
     }
     /** Handle a pasted block. Returns true if the frame needs a redraw. */
     handlePaste(text) {
-        if (this.inputMode === "budget" || this.inputMode === "threshold") {
+        if (this.inputMode === "budget" || this.inputMode === "threshold" || this.inputMode === "concurrency") {
             const clean = text.replace(/[^0-9.]/g, "");
             if (clean)
                 appendCharToSegments(this.inputSegs, clean);
@@ -243,7 +246,7 @@ export class RunDisplay {
     /** Handle a typed (non-pasted) chunk. Returns true if the frame needs a redraw. */
     handleTyped(s) {
         const lc = this.liveConfig;
-        if (this.inputMode === "budget" || this.inputMode === "threshold") {
+        if (this.inputMode === "budget" || this.inputMode === "threshold" || this.inputMode === "concurrency") {
             let dirty = false;
             for (const ch of s) {
                 if (ch === "\r" || ch === "\n") {
@@ -261,6 +264,12 @@ export class RunDisplay {
                             this.swarm.usageCap = lc.usageCap;
                         this.swarm?.log(-1, `Usage cap changed to ${val > 0 ? val + "%" : "unlimited"}`);
                     }
+                    else if (this.inputMode === "concurrency" && !isNaN(val) && val >= 1) {
+                        const n = Math.round(val);
+                        lc.concurrency = n;
+                        lc.dirty = true;
+                        this.swarm?.setConcurrency(n);
+                    }
                     this.inputMode = "none";
                     this.inputSegs = [];
                     return true;
@@ -340,6 +349,24 @@ export class RunDisplay {
             }
             return false;
         }
+        if (s === "c" || s === "C") {
+            if (this.swarm) {
+                this.inputMode = "concurrency";
+                this.inputSegs = [];
+                return true;
+            }
+            return false;
+        }
+        if (s === "p" || s === "P") {
+            if (this.swarm) {
+                const next = !this.swarm.paused;
+                this.swarm.setPaused(next);
+                lc.paused = next;
+                lc.dirty = true;
+                return true;
+            }
+            return false;
+        }
         if ((s === "f" || s === "F") && this.swarm && this.swarm.failed > 0 && this.swarm.active > 0) {
             this.swarm.requeueFailed();
             return false;

package/package.json

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