claude-overnight 1.11.14 → 1.13.0

package/dist/index.js

@@ -656,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 {

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

@@ -8,7 +8,7 @@ import { getTotalPlannerCost, getPlannerRateLimitInfo, runPlannerQuery } from ".
 import { RunDisplay } from "./ui.js";
 import { renderSummary } from "./render.js";
 import { fmtTokens } from "./render.js";
-import { isAuthError } from "./cli.js";
+import { isAuthError, selectKey, ask } from "./cli.js";
 import { readRunMemory, writeStatus, writeGoalUpdate, saveRunState, saveWaveSession, loadWaveHistory, recordBranches, archiveMilestone, writeSteerInbox, consumeSteerInbox, countSteerInbox, appendOvernightLogStart, updateOvernightLogEnd, } from "./state.js";
 export async function executeRun(cfg) {
     const restore = () => { try {
@@ -25,12 +25,13 @@ 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;
     let accIn = 0, accOut = 0;
     let lastCapped = false, lastAborted = false, objectiveComplete = false, lastHealed = false;
+    let lastEstimate;
     const branches = [];
     if (cfg.resuming && cfg.resumeState) {
         const rs = cfg.resumeState;
@@ -216,6 +217,8 @@ export async function executeRun(cfg) {
                     writeStatus(runDir, steer.statusUpdate);
                 if (steer.goalUpdate)
                     writeGoalUpdate(runDir, steer.goalUpdate);
+                if (typeof steer.estimatedSessionsRemaining === "number")
+                    lastEstimate = steer.estimatedSessionsRemaining;
                 const steerDir = join(runDir, "steering");
                 mkdirSync(steerDir, { recursive: true });
                 writeFileSync(join(steerDir, `wave-${waveNum}-attempt-${steerAttempts}.json`), JSON.stringify({
@@ -283,93 +286,127 @@ export async function executeRun(cfg) {
     if (!display.runInfo.startedAt)
         display.runInfo.startedAt = cfg.runStartedAt;
     display.start();
-    // ── Main wave loop ──
-    while (remaining > 0 && currentTasks.length > 0 && !stopping) {
-        if (!lastHealed) {
-            const healTask = checkProjectHealth(cwd);
-            if (healTask && remaining > 0) {
-                lastHealed = true;
-                currentTasks = [healTask];
+    // ── Main wave loop (wrapped so exhaustion can prompt for an extension) ──
+    let runAnotherRound = true;
+    while (runAnotherRound) {
+        runAnotherRound = false;
+        while (remaining > 0 && currentTasks.length > 0 && !stopping) {
+            if (!lastHealed) {
+                const healTask = checkProjectHealth(cwd);
+                if (healTask && remaining > 0) {
+                    lastHealed = true;
+                    currentTasks = [healTask];
+                }
             }
+            else {
+                lastHealed = false;
+            }
+            if (currentTasks.length > remaining)
+                currentTasks = currentTasks.slice(0, remaining);
+            syncRunInfo();
+            const swarm = new Swarm({
+                tasks: currentTasks, concurrency, cwd, model: workerModel, permissionMode, allowedTools,
+                useWorktrees, mergeStrategy: waveMerge, agentTimeoutMs: cfg.agentTimeoutMs,
+                usageCap, allowExtraUsage: cfg.allowExtraUsage, extraUsageBudget: cfg.extraUsageBudget,
+                baseCostUsd: accCost,
+            });
+            currentSwarm = swarm;
+            display.setWave(swarm);
+            display.resume();
+            try {
+                await swarm.run();
+            }
+            catch (err) {
+                if (isAuthError(err)) {
+                    display.stop();
+                    restore();
+                    console.error(chalk.red(`\n  Authentication failed — check your API key or run: claude auth\n`));
+                    process.exit(1);
+                }
+                throw err;
+            }
+            display.pause();
+            console.log(renderSummary(swarm));
+            accCost += swarm.totalCostUsd;
+            accIn += swarm.totalInputTokens;
+            accOut += swarm.totalOutputTokens;
+            accCompleted += swarm.completed;
+            accFailed += swarm.failed;
+            accTools += swarm.agents.reduce((sum, a) => sum + a.toolCalls, 0);
+            remaining = Math.max(0, remaining - swarm.completed - swarm.failed);
+            const totalConsumed = accCompleted + accFailed + cfg.thinkingUsed;
+            const expectedFloor = Math.max(0, cfg.budget - totalConsumed);
+            if (remaining < expectedFloor)
+                remaining = expectedFloor;
+            if (liveConfig.dirty) {
+                remaining = liveConfig.remaining;
+                usageCap = liveConfig.usageCap;
+                liveConfig.dirty = false;
+            }
+            liveConfig.remaining = remaining;
+            lastCapped = swarm.cappedOut;
+            lastAborted = swarm.aborted;
+            recordBranches(swarm.agents, swarm.mergeResults, branches);
+            saveWaveSession(runDir, waveNum, swarm.agents, swarm.totalCostUsd);
+            // Tasks that never made it into the swarm (queue cleared on abort/cap)
+            // are preserved as currentTasks so resume picks them up. Budget for these
+            // wasn't decremented (only attempted agents were), so no refund needed.
+            const attemptedPrompts = new Set(swarm.agents.map(a => a.task.prompt));
+            const neverStarted = currentTasks.filter(t => !attemptedPrompts.has(t.prompt));
+            saveRunState(runDir, {
+                id: `run-${new Date().toISOString().slice(0, 19)}`, objective: objective ?? "", budget: cfg.budget,
+                remaining, workerModel, plannerModel, concurrency, permissionMode,
+                usageCap, allowExtraUsage: cfg.allowExtraUsage, extraUsageBudget: cfg.extraUsageBudget,
+                flex, useWorktrees, mergeStrategy, waveNum, currentTasks: neverStarted,
+                accCost, accCompleted, accFailed, accIn, accOut, accTools,
+                branches, phase: "steering", startedAt: new Date(cfg.runStartedAt).toISOString(), cwd,
+            });
+            waveHistory.push({
+                wave: waveNum,
+                tasks: swarm.agents.map(a => ({ prompt: a.task.prompt, status: a.status, filesChanged: a.filesChanged, error: a.error })),
+            });
+            if (!flex || remaining <= 0 || swarm.aborted || swarm.cappedOut)
+                break;
+            syncRunInfo();
+            display.setSteering(rlGetter, buildSteeringContext());
+            display.resume();
+            const steered = await runSteering();
+            if (!steered)
+                break;
+            waveNum++;
         }
-        else {
-            lastHealed = false;
-        }
-        if (currentTasks.length > remaining)
-            currentTasks = currentTasks.slice(0, remaining);
-        syncRunInfo();
-        const swarm = new Swarm({
-            tasks: currentTasks, concurrency, cwd, model: workerModel, permissionMode, allowedTools,
-            useWorktrees, mergeStrategy: waveMerge, agentTimeoutMs: cfg.agentTimeoutMs,
-            usageCap, allowExtraUsage: cfg.allowExtraUsage, extraUsageBudget: cfg.extraUsageBudget,
-            baseCostUsd: accCost,
-        });
-        currentSwarm = swarm;
-        display.setWave(swarm);
-        display.resume();
-        try {
-            await swarm.run();
-        }
-        catch (err) {
-            if (isAuthError(err)) {
+        display.stop();
+        // ── Budget-exhausted: offer to extend with the same settings ──
+        const exhaustedByBudget = !objectiveComplete && !stopping && !lastAborted && !lastCapped &&
+            remaining <= 0 && !!process.stdin.isTTY;
+        if (exhaustedByBudget) {
+            const ext = await promptBudgetExtension({
+                estimate: lastEstimate,
+                spent: accCost,
+                sessionsUsed: accCompleted + accFailed + cfg.thinkingUsed,
+                budget: cfg.budget,
+            });
+            if (ext > 0) {
+                remaining = ext;
+                cfg.budget += ext;
+                lastCapped = false;
+                lastAborted = false;
+                runInfoRef.sessionsBudget = cfg.budget;
+                runInfoRef.remaining = remaining;
+                liveConfig.remaining = remaining;
+                liveConfig.usageCap = usageCap;
+                display.setSteering(rlGetter, buildSteeringContext());
+                display.start();
+                const steered = await runSteering();
+                if (steered) {
+                    waveNum++;
+                    runAnotherRound = true;
+                    continue;
+                }
                 display.stop();
-                restore();
-                console.error(chalk.red(`\n  Authentication failed — check your API key or run: claude auth\n`));
-                process.exit(1);
             }
-            throw err;
         }
-        display.pause();
-        console.log(renderSummary(swarm));
-        accCost += swarm.totalCostUsd;
-        accIn += swarm.totalInputTokens;
-        accOut += swarm.totalOutputTokens;
-        accCompleted += swarm.completed;
-        accFailed += swarm.failed;
-        accTools += swarm.agents.reduce((sum, a) => sum + a.toolCalls, 0);
-        remaining = Math.max(0, remaining - swarm.completed - swarm.failed);
-        const totalConsumed = accCompleted + accFailed + cfg.thinkingUsed;
-        const expectedFloor = Math.max(0, cfg.budget - totalConsumed);
-        if (remaining < expectedFloor)
-            remaining = expectedFloor;
-        if (liveConfig.dirty) {
-            remaining = liveConfig.remaining;
-            usageCap = liveConfig.usageCap;
-            liveConfig.dirty = false;
-        }
-        liveConfig.remaining = remaining;
-        lastCapped = swarm.cappedOut;
-        lastAborted = swarm.aborted;
-        recordBranches(swarm.agents, swarm.mergeResults, branches);
-        saveWaveSession(runDir, waveNum, swarm.agents, swarm.totalCostUsd);
-        // Tasks that never made it into the swarm (queue cleared on abort/cap)
-        // are preserved as currentTasks so resume picks them up. Budget for these
-        // wasn't decremented (only attempted agents were), so no refund needed.
-        const attemptedPrompts = new Set(swarm.agents.map(a => a.task.prompt));
-        const neverStarted = currentTasks.filter(t => !attemptedPrompts.has(t.prompt));
-        saveRunState(runDir, {
-            id: `run-${new Date().toISOString().slice(0, 19)}`, objective: objective ?? "", budget: cfg.budget,
-            remaining, workerModel, plannerModel, concurrency, permissionMode,
-            usageCap, allowExtraUsage: cfg.allowExtraUsage, extraUsageBudget: cfg.extraUsageBudget,
-            flex, useWorktrees, mergeStrategy, waveNum, currentTasks: neverStarted,
-            accCost, accCompleted, accFailed, accIn, accOut, accTools,
-            branches, phase: "steering", startedAt: new Date(cfg.runStartedAt).toISOString(), cwd,
-        });
-        waveHistory.push({
-            wave: waveNum,
-            tasks: swarm.agents.map(a => ({ prompt: a.task.prompt, status: a.status, filesChanged: a.filesChanged, error: a.error })),
-        });
-        if (!flex || remaining <= 0 || swarm.aborted || swarm.cappedOut)
-            break;
-        syncRunInfo();
-        display.setSteering(rlGetter, buildSteeringContext());
-        display.resume();
-        const steered = await runSteering();
-        if (!steered)
-            break;
-        waveNum++;
-    }
-    display.stop();
+    } // end outer extension loop
     // ── Finalize ──
     const trulyDone = objectiveComplete || (!flex && remaining <= 0);
     const wasCapped = lastCapped || lastAborted;
@@ -479,6 +516,37 @@ export async function executeRun(cfg) {
     if (lastAborted || accCompleted === 0)
         process.exit(2);
 }
+async function promptBudgetExtension(ctx) {
+    const avg = ctx.sessionsUsed > 0 ? ctx.spent / ctx.sessionsUsed : 0;
+    const base = ctx.estimate && ctx.estimate > 0
+        ? ctx.estimate
+        : Math.max(10, Math.round(ctx.budget * 0.2));
+    // Wiggle room: 30% buffer, minimum 10, rounded up to a nearest-5.
+    const withBuffer = Math.max(10, Math.ceil(base * 1.3));
+    const suggested = Math.ceil(withBuffer / 5) * 5;
+    const estCost = avg > 0 ? ` · ~$${(suggested * avg).toFixed(2)}` : "";
+    const estLine = ctx.estimate != null
+        ? chalk.dim(`  Planner estimate: ${ctx.estimate} sessions to complete${avg > 0 ? ` (~$${(ctx.estimate * avg).toFixed(2)} at $${avg.toFixed(2)}/session)` : ""}`)
+        : chalk.dim(`  No planner estimate available — using default${avg > 0 ? ` (~$${avg.toFixed(2)}/session)` : ""}`);
+    console.log("");
+    console.log(chalk.yellow(`  Budget exhausted — run not yet complete.`));
+    console.log(estLine);
+    console.log(chalk.dim(`  Continue with ${chalk.bold.white(String(suggested))} more sessions${estCost}? Everything stays the same — just hit enter.`));
+    const action = await selectKey("", [
+        { key: "y", desc: "es (↵)" },
+        { key: "c", desc: "ustom" },
+        { key: "n", desc: "o — stop here" },
+    ]);
+    if (action === "y")
+        return suggested;
+    if (action === "n")
+        return 0;
+    const custom = await ask(`  How many more sessions? ${chalk.dim(`[${suggested}]: `)}`);
+    const n = parseInt(custom);
+    if (isNaN(n) || n <= 0)
+        return suggested;
+    return n;
+}
 function checkProjectHealth(cwd) {
     let pkg;
     try {

package/dist/steering.js

@@ -9,6 +9,7 @@ const STEER_SCHEMA = {
             reasoning: { type: "string" },
             statusUpdate: { type: "string" },
             goalUpdate: { type: "string" },
+            estimatedSessionsRemaining: { type: "number" },
             tasks: {
                 type: "array",
                 items: {
@@ -18,7 +19,7 @@ const STEER_SCHEMA = {
                 },
             },
         },
-        required: ["done", "tasks", "reasoning", "statusUpdate"],
+        required: ["done", "tasks", "reasoning", "statusUpdate", "estimatedSessionsRemaining"],
     },
 };
 export async function steerWave(objective, history, remainingBudget, cwd, plannerModel, workerModel, permissionMode, concurrency, onLog, runMemory) {
@@ -96,6 +97,7 @@ Respond with ONLY a JSON object (no markdown fences):
   "reasoning": "your assessment and why you chose this wave composition",
   "goalUpdate": "optional — refine what 'amazing' means as you learn more",
   "statusUpdate": "REQUIRED — concise project status: what's built, what works, what's rough, quality level, key gaps. This replaces the previous status.",
+  "estimatedSessionsRemaining": 15,
   "tasks": [
     {"prompt": "task instruction...", "model": "worker"},
     {"prompt": "review task...", "model": "planner"},
@@ -103,10 +105,12 @@ Respond with ONLY a JSON object (no markdown fences):
   ]
 }
 
+"estimatedSessionsRemaining" is REQUIRED. Your best honest estimate of how many MORE agent sessions (beyond the wave you just composed above) are needed to reach 'amazing' — include follow-up fixes, polish, verification, and anything else you'd want before shipping. Be realistic, not optimistic. Use 0 only if truly done.
+
 The "model" field on each task: use "worker" (${workerModel}) for implementation tasks, "planner" (${plannerModel}) for review/analysis/verification tasks. Default is "worker".
 Set "noWorktree": true for verify/user-test tasks — they need the real project directory with env files, dependencies, and local config.
 
-If done: {"done": true, "reasoning": "...", "statusUpdate": "...", "tasks": []}`;
+If done: {"done": true, "reasoning": "...", "statusUpdate": "...", "estimatedSessionsRemaining": 0, "tasks": []}`;
     onLog("Assessing...", "status");
     onLog(`Reading codebase — wave ${history.length + 1}`, "event");
     const resultText = await runPlannerQuery(prompt, { cwd, model: plannerModel, permissionMode, outputFormat: STEER_SCHEMA }, onLog);
@@ -124,8 +128,10 @@ If done: {"done": true, "reasoning": "...", "statusUpdate": "...", "tasks": []}`
     })();
     const isDone = parsed.done === true;
     const statusUpdate = parsed.statusUpdate || undefined;
+    const estRaw = parsed.estimatedSessionsRemaining;
+    const estimatedSessionsRemaining = typeof estRaw === "number" && estRaw >= 0 ? Math.round(estRaw) : undefined;
     if (isDone) {
-        return { done: true, tasks: [], reasoning: parsed.reasoning || "Objective complete", goalUpdate: parsed.goalUpdate, statusUpdate };
+        return { done: true, tasks: [], reasoning: parsed.reasoning || "Objective complete", goalUpdate: parsed.goalUpdate, statusUpdate, estimatedSessionsRemaining: estimatedSessionsRemaining ?? 0 };
     }
     let tasks = (parsed.tasks || []).map((t, i) => ({
         id: String(i),
@@ -134,5 +140,5 @@ If done: {"done": true, "reasoning": "...", "statusUpdate": "...", "tasks": []}`
         ...(t.noWorktree && { noWorktree: true }),
     }));
     tasks = postProcess(tasks, remainingBudget, onLog);
-    return { done: tasks.length === 0, tasks, reasoning: parsed.reasoning || "", goalUpdate: parsed.goalUpdate, statusUpdate };
+    return { done: tasks.length === 0, tasks, reasoning: parsed.reasoning || "", goalUpdate: parsed.goalUpdate, statusUpdate, estimatedSessionsRemaining };
 }

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 {
@@ -136,6 +138,7 @@ export interface SteerResult {
     reasoning: string;
     goalUpdate?: string;
     statusUpdate?: string;
+    estimatedSessionsRemaining?: number;
 }
 /** Accumulated run memory — designs, verifications, etc. — fed to the steerer. */
 export interface RunMemory {

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.14",
+  "version": "1.13.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": {