claude-overnight 1.13.1 → 1.14.0

package/dist/index.js

@@ -21,6 +21,133 @@ function countTasksInFile(path) {
         return 0;
     }
 }
+async function promptResumeOverrides(state, cliFlags, argv, noTTY, runDir) {
+    // ── Apply CLI flag overrides first ──
+    if (cliFlags.model)
+        state.workerModel = cliFlags.model;
+    if (cliFlags.concurrency) {
+        const n = parseInt(cliFlags.concurrency);
+        if (n >= 1)
+            state.concurrency = n;
+    }
+    if (cliFlags.budget) {
+        const n = parseInt(cliFlags.budget);
+        if (n > 0) {
+            state.remaining = n;
+            state.budget = state.accCompleted + state.accFailed + n;
+        }
+    }
+    if (cliFlags["usage-cap"] != null) {
+        const v = parseFloat(cliFlags["usage-cap"]);
+        if (!isNaN(v) && v >= 0 && v <= 100)
+            state.usageCap = v > 0 ? v / 100 : undefined;
+    }
+    if (cliFlags["extra-usage-budget"] != null) {
+        const v = parseFloat(cliFlags["extra-usage-budget"]);
+        if (!isNaN(v) && v > 0) {
+            state.extraUsageBudget = v;
+            state.allowExtraUsage = true;
+        }
+    }
+    if (argv.includes("--allow-extra-usage"))
+        state.allowExtraUsage = true;
+    if (cliFlags.perm)
+        state.permissionMode = cliFlags.perm;
+    if (noTTY) {
+        try {
+            saveRunState(runDir, state);
+        }
+        catch { }
+        return;
+    }
+    // ── Interactive review ──
+    const fmtSummary = () => {
+        const tier = detectModelTier(state.workerModel);
+        const remaining = Math.max(1, state.remaining);
+        const capStr = state.usageCap != null ? `${Math.round(state.usageCap * 100)}%` : "unlimited";
+        const extraStr = state.allowExtraUsage
+            ? (state.extraUsageBudget ? `$${state.extraUsageBudget}` : "unlimited")
+            : "off";
+        console.log();
+        console.log(`  ${chalk.dim("Resume settings")}`);
+        console.log(`  ${chalk.dim("─".repeat(40))}`);
+        console.log(`  ${chalk.dim("model      ")}${chalk.white(state.workerModel)} ${chalk.dim(`(${tier})`)}`);
+        console.log(`  ${chalk.dim("remaining  ")}${chalk.white(String(remaining))} ${chalk.dim("sessions")}`);
+        console.log(`  ${chalk.dim("concur     ")}${chalk.white(String(state.concurrency))}`);
+        console.log(`  ${chalk.dim("usage cap  ")}${chalk.white(capStr)}`);
+        console.log(`  ${chalk.dim("extra      ")}${chalk.white(extraStr)}`);
+    };
+    fmtSummary();
+    const action = await selectKey("", [
+        { key: "r", desc: "esume" },
+        { key: "e", desc: "dit" },
+        { key: "q", desc: "uit" },
+    ]);
+    if (action === "q")
+        process.exit(0);
+    if (action === "r")
+        return;
+    // ── Edit walk ──
+    const models = await fetchModels(5_000);
+    if (models.length > 0) {
+        const currentIdx = Math.max(0, models.findIndex(m => m.value === state.workerModel));
+        state.workerModel = await select(`${chalk.cyan("①")} Worker model:`, models.map(m => ({ name: m.displayName, value: m.value, hint: m.description })), currentIdx);
+    }
+    else {
+        const ans = await ask(`\n  ${chalk.cyan("①")} Worker model ${chalk.dim(`[${state.workerModel}]:`)} `);
+        if (ans.trim())
+            state.workerModel = ans.trim();
+    }
+    const remAns = await ask(`\n  ${chalk.cyan("②")} Remaining sessions ${chalk.dim(`[${state.remaining}]:`)} `);
+    const parsedRem = parseInt(remAns);
+    if (!isNaN(parsedRem) && parsedRem > 0) {
+        state.remaining = parsedRem;
+        state.budget = state.accCompleted + state.accFailed + parsedRem;
+    }
+    const concAns = await ask(`\n  ${chalk.cyan("③")} Concurrency ${chalk.dim(`[${state.concurrency}]:`)} `);
+    const parsedConc = parseInt(concAns);
+    if (!isNaN(parsedConc) && parsedConc >= 1)
+        state.concurrency = parsedConc;
+    const currentCap = state.usageCap != null ? String(Math.round(state.usageCap * 100)) : "off";
+    const capAns = await ask(`\n  ${chalk.cyan("④")} Usage cap % ${chalk.dim(`[${currentCap}]`)} ${chalk.dim("(0 = off):")} `);
+    if (capAns.trim()) {
+        const v = parseFloat(capAns);
+        if (!isNaN(v) && v >= 0 && v <= 100)
+            state.usageCap = v > 0 ? v / 100 : undefined;
+    }
+    const currentExtra = state.allowExtraUsage
+        ? (state.extraUsageBudget ? `$${state.extraUsageBudget}` : "unlimited")
+        : "off";
+    const extraChoice = await select(`${chalk.cyan("⑤")} Extra usage ${chalk.dim(`[current: ${currentExtra}]`)}:`, [
+        { name: "Keep current", value: "keep" },
+        { name: "Off", value: "off", hint: "stop at plan limit" },
+        { name: "With $ cap", value: "budget", hint: "set a spending cap" },
+        { name: "Unlimited", value: "unlimited", hint: "no cap, billed as overage" },
+    ]);
+    if (extraChoice === "off") {
+        state.allowExtraUsage = false;
+        state.extraUsageBudget = undefined;
+    }
+    else if (extraChoice === "budget") {
+        const bAns = await ask(`  ${chalk.dim("Max extra $:")} `);
+        const bVal = parseFloat(bAns);
+        if (!isNaN(bVal) && bVal > 0) {
+            state.extraUsageBudget = bVal;
+            state.allowExtraUsage = true;
+        }
+    }
+    else if (extraChoice === "unlimited") {
+        state.allowExtraUsage = true;
+        state.extraUsageBudget = undefined;
+    }
+    try {
+        saveRunState(runDir, state);
+    }
+    catch { }
+    console.log(chalk.green("\n  ✓ Settings updated"));
+    fmtSummary();
+    console.log();
+}
 async function main() {
     const argv = process.argv.slice(2);
     if (argv.includes("-v") || argv.includes("--version")) {
@@ -310,6 +437,7 @@ async function main() {
                 }
                 catch { }
             }
+            await promptResumeOverrides(resumeState, cliFlags, argv, noTTY, resumeRunDir);
         }
     }
     // ── Config resolution ──

package/dist/render.js

@@ -196,7 +196,7 @@ export function renderFrame(swarm, showHotkeys, runInfo) {
         const chip = pending > 0 ? chalk.cyan(`  \u270E ${pending} steer queued`) : "";
         const fixChip = swarm.failed > 0 && swarm.active > 0 ? chalk.yellow("  [f] fix") : "";
         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);
+        out.push(chalk.dim(`  [b] budget  [t] cap  [c] conc  [e] extra  ${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`));
         }

package/dist/run.js

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

package/dist/swarm.d.ts

@@ -65,7 +65,7 @@ export declare class Swarm {
     readonly model: string | undefined;
     usageCap: number | undefined;
     readonly allowExtraUsage: boolean;
-    readonly extraUsageBudget: number | undefined;
+    extraUsageBudget: number | undefined;
     readonly baseCostUsd: number;
     mergeBranch?: string;
     constructor(config: SwarmConfig);
@@ -76,6 +76,8 @@ export declare class Swarm {
     setConcurrency(n: number): void;
     /** Freeze/resume dispatch without killing the run. Paused workers block at the top of their loop. */
     setPaused(b: boolean): void;
+    /** Live-adjust the overage spend cap. `undefined` = unlimited. If already over the new cap, stop dispatch. */
+    setExtraUsageBudget(n: number | undefined): void;
     run(): Promise<void>;
     abort(): void;
     /** Re-queue all errored agents' tasks for retry within this wave. */

package/dist/swarm.js

@@ -109,6 +109,18 @@ export class Swarm {
         this.paused = b;
         this.log(-1, b ? "Dispatch paused" : "Dispatch resumed");
     }
+    /** Live-adjust the overage spend cap. `undefined` = unlimited. If already over the new cap, stop dispatch. */
+    setExtraUsageBudget(n) {
+        if (this.extraUsageBudget === n)
+            return;
+        const prev = this.extraUsageBudget;
+        this.extraUsageBudget = n;
+        const fmt = (v) => v != null ? `$${v}` : "unlimited";
+        this.log(-1, `Extra usage budget: ${fmt(prev)} → ${fmt(n)}`);
+        if (n != null && this.isUsingOverage && this.overageCostUsd >= n) {
+            this.capForOverage(`Extra usage budget $${n} exceeded ($${this.overageCostUsd.toFixed(2)} spent) — stopping dispatch`);
+        }
+    }
     async run() {
         try {
             if (this.config.useWorktrees) {

package/dist/ui.d.ts

@@ -33,6 +33,8 @@ export interface LiveConfig {
     concurrency: number;
     paused: boolean;
     dirty: boolean;
+    /** Overage spend cap ($) — undefined = unlimited. Synced from the [e] hotkey. */
+    extraUsageBudget?: number;
 }
 /** State of an in-flight or recently-completed ask side query. */
 export interface AskState {

package/dist/ui.js

@@ -164,6 +164,9 @@ export class RunDisplay {
         if (this.inputMode === "concurrency") {
             return `\n  ${chalk.cyan(">")} New concurrency (min 1): ${rendered}\u2588`;
         }
+        if (this.inputMode === "extra") {
+            return `\n  ${chalk.cyan(">")} Extra usage $ cap (0 = stop on overage): ${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`;
         }
@@ -229,7 +232,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" || this.inputMode === "concurrency") {
+        if (this.inputMode === "budget" || this.inputMode === "threshold" || this.inputMode === "concurrency" || this.inputMode === "extra") {
             const clean = text.replace(/[^0-9.]/g, "");
             if (clean)
                 appendCharToSegments(this.inputSegs, clean);
@@ -246,7 +249,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" || this.inputMode === "concurrency") {
+        if (this.inputMode === "budget" || this.inputMode === "threshold" || this.inputMode === "concurrency" || this.inputMode === "extra") {
             let dirty = false;
             for (const ch of s) {
                 if (ch === "\r" || ch === "\n") {
@@ -270,6 +273,11 @@ export class RunDisplay {
                         lc.dirty = true;
                         this.swarm?.setConcurrency(n);
                     }
+                    else if (this.inputMode === "extra" && !isNaN(val) && val >= 0) {
+                        lc.extraUsageBudget = val;
+                        lc.dirty = true;
+                        this.swarm?.setExtraUsageBudget(val);
+                    }
                     this.inputMode = "none";
                     this.inputSegs = [];
                     return true;
@@ -357,6 +365,14 @@ export class RunDisplay {
             }
             return false;
         }
+        if (s === "e" || s === "E") {
+            if (this.swarm) {
+                this.inputMode = "extra";
+                this.inputSegs = [];
+                return true;
+            }
+            return false;
+        }
         if (s === "p" || s === "P") {
             if (this.swarm) {
                 const next = !this.swarm.paused;

package/package.json

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