claude-overnight 1.9.0 → 1.10.0

package/dist/cli.js

@@ -1,3 +1,4 @@
+import { execSync } from "child_process";
 import { readFileSync } from "fs";
 import { resolve } from "path";
 import { createInterface } from "readline";
@@ -233,7 +234,6 @@ export function validateConcurrency(value) {
     }
 }
 export function isGitRepo(cwd) {
-    const { execSync } = require("child_process");
     try {
         execSync("git rev-parse --git-dir", { cwd, encoding: "utf-8", stdio: "pipe" });
         return true;

package/dist/index.js

@@ -408,7 +408,7 @@ async function main() {
         const thinkingCount = useThinking ? Math.min(Math.max(concurrency, Math.ceil((budget ?? 10) * 0.005)), 10) : 0;
         try {
             if (useThinking) {
-                let themes = await identifyThemes(objective, thinkingCount, plannerModel, permissionMode, makeProgressLog());
+                let themes = await identifyThemes(objective, thinkingCount, cwd, plannerModel, permissionMode, makeProgressLog());
                 process.stdout.write(`\x1B[2K\r  ${chalk.green(`✓ ${themes.length} themes`)}\n\n`);
                 planRestore();
                 let reviewing = true;
@@ -427,7 +427,7 @@ async function main() {
                             continue;
                         process.stdout.write("\x1B[?25l");
                         try {
-                            themes = await identifyThemes(`${objective}\n\nUser feedback: ${feedback}`, thinkingCount, plannerModel, permissionMode, makeProgressLog());
+                            themes = await identifyThemes(`${objective}\n\nUser feedback: ${feedback}`, thinkingCount, cwd, plannerModel, permissionMode, makeProgressLog());
                             process.stdout.write(`\x1B[2K\r  ${chalk.green(`✓ ${themes.length} themes`)}\n\n`);
                         }
                         catch (err) {

package/dist/planner-query.d.ts

@@ -1,4 +1,11 @@
 import type { Task, PermMode, RateLimitWindow } from "./types.js";
+/**
+ * Logging callback used by planner/steering queries.
+ * `kind` distinguishes ephemeral status updates (heartbeat ticker) from
+ * discrete events worth persisting in a scrollback log (tool uses, retries).
+ * Plain (text) callers still work — extra arg is ignored.
+ */
+export type PlannerLog = (text: string, kind?: "status" | "event") => void;
 export interface PlannerRateLimitInfo {
     utilization: number;
     status: string;
@@ -22,7 +29,7 @@ export declare function detectModelTier(model: string): ModelTier;
 export declare function modelCapabilityBlock(model: string): string;
 export declare function getTotalPlannerCost(): number;
 export declare function getPlannerRateLimitInfo(): PlannerRateLimitInfo;
-export declare function runPlannerQuery(prompt: string, opts: PlannerOpts, onLog: (text: string) => void): Promise<string>;
+export declare function runPlannerQuery(prompt: string, opts: PlannerOpts, onLog: PlannerLog): Promise<string>;
 export declare function postProcess(raw: Task[], budget: number | undefined, onLog: (text: string) => void): Task[];
 export declare function attemptJsonParse(text: string): any | null;
 export declare function extractTaskJson(raw: string, retry: () => Promise<string>, onLog?: (text: string) => void, outFile?: string): Promise<{

package/dist/planner-query.js

@@ -51,18 +51,18 @@ export async function runPlannerQuery(prompt, opts, onLog) {
         catch (err) {
             if (err instanceof NudgeError) {
                 if (err.sessionId) {
-                    onLog("Silent 15m — resuming session with continue");
+                    onLog("Silent 15m — resuming session with continue", "event");
                     currentPrompt = "Continue. Complete the task.";
                     currentOpts = { ...opts, resumeSessionId: err.sessionId };
                 }
                 else {
-                    onLog("Silent 15m — restarting planner (no session to resume)");
+                    onLog("Silent 15m — restarting planner (no session to resume)", "event");
                 }
                 continue;
             }
             if (attempt < MAX_RETRIES && isRateLimitError(err)) {
                 const waitMs = BACKOFF[attempt];
-                onLog(`Rate limited — waiting ${Math.round(waitMs / 1000)}s before retry ${attempt + 1}/${MAX_RETRIES}`);
+                onLog(`Rate limited — waiting ${Math.round(waitMs / 1000)}s before retry ${attempt + 1}/${MAX_RETRIES}`, "event");
                 await new Promise((r) => setTimeout(r, waitMs));
                 continue;
             }
@@ -105,7 +105,7 @@ async function runPlannerQueryOnce(prompt, opts, onLog) {
         const rlPct = _plannerRateLimitInfo.utilization;
         const rlStr = rlPct > 0 ? ` · ${Math.round(rlPct * 100)}%` : "";
         const extra = lastLogText ? ` · ${lastLogText}` : "";
-        onLog(`${timeStr}${toolStr}${costStr}${rlStr}${extra}`);
+        onLog(`${timeStr}${toolStr}${costStr}${rlStr}${extra}`, "status");
     }, 500);
     const timeoutMs = isResume ? HARD_TIMEOUT_MS : NUDGE_MS;
     let sessionId;
@@ -143,7 +143,7 @@ async function runPlannerQueryOnce(prompt, opts, onLog) {
                 if (ev?.type === "content_block_start" && ev.content_block?.type === "tool_use") {
                     toolCount++;
                     lastLogText = ev.content_block.name;
-                    onLog(ev.content_block.name);
+                    onLog(ev.content_block.name, "event");
                 }
                 if (ev?.type === "content_block_delta") {
                     const delta = ev.delta;

package/dist/planner.d.ts

@@ -1,7 +1,7 @@
 import type { Task, PermMode } from "./types.js";
 export declare const DESIGN_THINKING = "\nHOW TO THINK ABOUT EVERY TASK:\n\nStart from the user's job. What is someone hiring this product to do? \"I need to send money abroad cheaply\" \u2014 not \"I need a currency conversion API.\" Every decision \u2014 what to build, how fast it responds, what happens on error \u2014 flows from the job.\n\nThe experience IS the product. A 200ms server response is not a \"performance metric\" \u2014 it's the difference between an app that feels alive and one that feels broken. A loading state is not \"polish\" \u2014 it's the user knowing the app heard them. An error message is not \"error handling\" \u2014 it's the app being honest. There is no line between backend and UX. The server, the API, the database query, the render \u2014 they're all one experience the user either trusts or doesn't.\n\nBuild the core, verify it works, learn, iterate. Don't plan 20 features and build them all. Build the ONE thing that matters most, run it, see if it actually works from a user's chair. What you learn from seeing it run will change what you build next. Each wave should make what exists better before adding what doesn't exist yet.\n\nConsistency is what makes complex things feel simple. One design system, rigid rules, no exceptions. This is how Revolut ships a super-app with 30+ features that doesn't feel like chaos.\n";
 export declare function planTasks(objective: string, cwd: string, plannerModel: string, workerModel: string, permissionMode: PermMode, budget: number | undefined, concurrency: number, onLog: (text: string) => void, flexNote?: string, outFile?: string): Promise<Task[]>;
-export declare function identifyThemes(objective: string, count: number, model: string, permissionMode: PermMode, onLog?: (text: string) => void): Promise<string[]>;
+export declare function identifyThemes(objective: string, count: number, cwd: string, model: string, permissionMode: PermMode, onLog?: (text: string) => void): Promise<string[]>;
 export declare function buildThinkingTasks(objective: string, themes: string[], designDir: string, plannerModel: string, previousKnowledge?: string): Task[];
 export declare function orchestrate(objective: string, designDocs: string, cwd: string, plannerModel: string, workerModel: string, permissionMode: PermMode, budget: number, concurrency: number, onLog: (text: string) => void, flexNote?: string, outFile?: string): Promise<Task[]>;
 export declare function refinePlan(objective: string, previousTasks: Task[], feedback: string, cwd: string, plannerModel: string, workerModel: string, permissionMode: PermMode, budget: number | undefined, concurrency: number, onLog: (text: string) => void): Promise<Task[]>;

package/dist/planner.js

@@ -1,4 +1,4 @@
-import { runPlannerQuery, extractTaskJson, postProcess, detectModelTier, modelCapabilityBlock } from "./planner-query.js";
+import { runPlannerQuery, extractTaskJson, attemptJsonParse, postProcess, detectModelTier, modelCapabilityBlock } from "./planner-query.js";
 // The core framing for all planning. Not a checklist — a way of thinking.
 export const DESIGN_THINKING = `
 HOW TO THINK ABOUT EVERY TASK:
@@ -166,9 +166,9 @@ export async function planTasks(objective, cwd, plannerModel, workerModel, permi
     onLog(`${tasks.length} tasks`);
     return tasks;
 }
-export async function identifyThemes(objective, count, model, permissionMode, onLog = () => { }) {
-    const resultText = await runPlannerQuery(`Split this objective into exactly ${count} independent research angles for architects exploring a codebase. Each angle should cover a distinct aspect.\n\nObjective: ${objective}\n\nReturn ONLY a JSON object: {"themes": ["angle description", ...]}`, { cwd: process.cwd(), model, permissionMode, outputFormat: THEMES_SCHEMA }, onLog);
-    const parsed = (await import("./planner-query.js")).attemptJsonParse(resultText);
+export async function identifyThemes(objective, count, cwd, model, permissionMode, onLog = () => { }) {
+    const resultText = await runPlannerQuery(`Split this objective into exactly ${count} independent research angles for architects exploring a codebase. Each angle should cover a distinct aspect.\n\nObjective: ${objective}\n\nReturn ONLY a JSON object: {"themes": ["angle description", ...]}`, { cwd, model, permissionMode, outputFormat: THEMES_SCHEMA }, onLog);
+    const parsed = attemptJsonParse(resultText);
     if (parsed?.themes && Array.isArray(parsed.themes))
         return parsed.themes.slice(0, count);
     const fallback = ["architecture, patterns, and conventions", "data models, state, and persistence", "user-facing flows, components, and UX", "APIs, integrations, and services", "testing, quality, and error handling", "security, performance, and infrastructure", "build, deployment, and configuration", "documentation and developer experience"];

package/dist/render.d.ts

@@ -1,6 +1,6 @@
 import type { Swarm } from "./swarm.js";
 import type { RateLimitWindow } from "./types.js";
-import type { RunInfo } from "./ui.js";
+import type { RunInfo, SteeringContext, SteeringEvent } from "./ui.js";
 export declare function truncate(s: string, max: number): string;
 export declare function fmtTokens(n: number): string;
 export declare function fmtDur(ms: number): string;
@@ -11,6 +11,14 @@ type RLGetter = () => {
     resetsAt?: number;
 };
 export declare function renderFrame(swarm: Swarm, showHotkeys: boolean, runInfo?: RunInfo): string;
-export declare function renderSteeringFrame(runInfo: RunInfo, steeringText: string, showHotkeys: boolean, rlGetter?: RLGetter): string;
+export interface SteeringViewData {
+    /** The ephemeral ticker heartbeat — elapsed, tool count, cost, current reasoning snippet. */
+    statusLine: string;
+    /** Persistent scrollback of discrete events (tool uses, retries, nudges). */
+    events: SteeringEvent[];
+    /** Optional context read from disk at setSteering() time. */
+    context?: SteeringContext;
+}
+export declare function renderSteeringFrame(runInfo: RunInfo, data: SteeringViewData, showHotkeys: boolean, rlGetter?: RLGetter): string;
 export declare function renderSummary(swarm: Swarm): string;
 export {};

package/dist/render.js

@@ -180,12 +180,86 @@ export function renderFrame(swarm, showHotkeys, runInfo) {
         const tag = entry.agentId < 0 ? chalk.magenta("[sys]") : chalk.cyan(`[${entry.agentId}]`);
         out.push(chalk.gray(`  ${t} `) + tag + ` ${colorEvent(truncate(entry.text, w - 22))}`);
     }
-    if (showHotkeys)
-        out.push(chalk.dim("  [b] budget  [t] threshold  [q] stop"));
+    if (showHotkeys) {
+        const pending = runInfo?.pendingSteer ?? 0;
+        const chip = pending > 0 ? chalk.cyan(`  \u270E ${pending} steer queued`) : "";
+        out.push(chalk.dim("  [b] budget  [t] threshold  [s] steer  [?] ask  [q] stop") + chip);
+    }
     out.push("");
     return out.join("\n");
 }
-export function renderSteeringFrame(runInfo, steeringText, showHotkeys, rlGetter) {
+function section(out, w, title) {
+    const inner = ` ${title} `;
+    const dashW = Math.max(3, Math.min(w - 6, 96) - inner.length);
+    out.push(chalk.gray("  \u2500\u2500\u2500" + inner + "\u2500".repeat(dashW)));
+}
+function renderSteeringUsageBar(out, w, rl) {
+    const rlBarW = Math.min(30, w - 40);
+    const draw = (pct, label) => {
+        let barStr = "";
+        const f = Math.round(pct * rlBarW);
+        for (let i = 0; i < rlBarW; i++) {
+            if (i < f)
+                barStr += pct > 0.9 ? chalk.red("\u2588") : pct > 0.75 ? chalk.yellow("\u2588") : chalk.blue("\u2588");
+            else
+                barStr += chalk.gray("\u2591");
+        }
+        let lbl = `${Math.round(pct * 100)}% used`;
+        if (rl.isUsingOverage)
+            lbl += chalk.red(" [EXTRA USAGE]");
+        if (rl.resetsAt && rl.resetsAt > Date.now()) {
+            const waitSec = Math.ceil((rl.resetsAt - Date.now()) / 1000);
+            const mm = Math.floor(waitSec / 60), ss = waitSec % 60;
+            lbl = chalk.red(`Waiting for reset ${mm > 0 ? `${mm}m ${ss}s` : `${ss}s`}`);
+        }
+        const prefix = label ? chalk.dim(label.padEnd(6)) : chalk.dim("Usage ");
+        out.push(`  ${prefix}${barStr}  ${lbl}`);
+    };
+    if (rl.windows.size > 1) {
+        const wins = Array.from(rl.windows.values());
+        const idx = Math.floor(Date.now() / 3000) % wins.length;
+        draw(wins[idx].utilization, wins[idx].type.replace(/_/g, " ").slice(0, 5));
+    }
+    else {
+        draw(rl.utilization);
+    }
+}
+function renderLastWave(out, w, lw) {
+    section(out, w, `Wave ${lw.wave + 1} summary`);
+    const done = lw.tasks.filter(t => t.status === "done").length;
+    const failed = lw.tasks.filter(t => t.status === "error").length;
+    const running = lw.tasks.filter(t => t.status === "running").length;
+    const parts = [];
+    if (done > 0)
+        parts.push(chalk.green(`\u2713 ${done} done`));
+    if (failed > 0)
+        parts.push(chalk.red(`\u2717 ${failed} failed`));
+    if (running > 0)
+        parts.push(chalk.blue(`~ ${running} running`));
+    if (parts.length === 0)
+        parts.push(chalk.dim("(no tasks)"));
+    out.push("  " + parts.join("  "));
+    const show = lw.tasks.slice(0, 5);
+    for (const t of show) {
+        const icon = t.status === "done" ? chalk.green("\u2713")
+            : t.status === "error" ? chalk.red("\u2717")
+                : t.status === "running" ? chalk.blue("~")
+                    : chalk.gray("\u00b7");
+        const line = t.prompt.replace(/\n/g, " ");
+        out.push(`    ${icon} ${chalk.dim(truncate(line, w - 8))}`);
+    }
+    if (lw.tasks.length > 5)
+        out.push(chalk.dim(`    \u2026 + ${lw.tasks.length - 5} more`));
+}
+function renderStatusBlock(out, w, status) {
+    const lines = status.trim().split("\n").filter(l => l.trim()).slice(0, 6);
+    if (lines.length === 0)
+        return;
+    section(out, w, "Status");
+    for (const ln of lines)
+        out.push(`  ${chalk.dim(truncate(ln.trim(), w - 4))}`);
+}
+export function renderSteeringFrame(runInfo, data, showHotkeys, rlGetter) {
     const w = Math.max((process.stdout.columns ?? 80) || 80, 60);
     const out = [];
     const totalUsed = runInfo.accCompleted + runInfo.accFailed;
@@ -201,45 +275,43 @@ export function renderSteeringFrame(runInfo, steeringText, showHotkeys, rlGetter
         sessionsUsed: totalUsed, sessionsBudget: runInfo.sessionsBudget, remaining: runInfo.remaining,
     });
     const rl = rlGetter?.();
-    if (rl && (rl.utilization > 0 || rl.windows.size > 0)) {
-        const rlBarW = Math.min(30, w - 40);
-        const renderBar = (pct, label) => {
-            const f = Math.round(pct * rlBarW);
-            let barStr = "";
-            for (let i = 0; i < rlBarW; i++) {
-                if (i < f)
-                    barStr += pct > 0.9 ? chalk.red("\u2588") : pct > 0.75 ? chalk.yellow("\u2588") : chalk.blue("\u2588");
-                else
-                    barStr += chalk.gray("\u2591");
-            }
-            let lbl = `${Math.round(pct * 100)}% used`;
-            if (rl.isUsingOverage)
-                lbl += chalk.red(" [EXTRA USAGE]");
-            if (rl.resetsAt && rl.resetsAt > Date.now()) {
-                const waitSec = Math.ceil((rl.resetsAt - Date.now()) / 1000);
-                const mm = Math.floor(waitSec / 60), ss = waitSec % 60;
-                lbl = chalk.red(`Waiting for reset ${mm > 0 ? `${mm}m ${ss}s` : `${ss}s`}`);
-            }
-            const prefix = label ? chalk.dim(label.padEnd(6)) : chalk.dim("Usage ");
-            out.push(`  ${prefix}${barStr}  ${lbl}`);
-        };
-        if (rl.windows.size > 1) {
-            const wins = Array.from(rl.windows.values());
-            const idx = Math.floor(Date.now() / 3000) % wins.length;
-            renderBar(wins[idx].utilization, wins[idx].type.replace(/_/g, " ").slice(0, 5));
-        }
-        else {
-            renderBar(rl.utilization);
+    if (rl && (rl.utilization > 0 || rl.windows.size > 0))
+        renderSteeringUsageBar(out, w, rl);
+    out.push("");
+    const ctx = data.context;
+    if (ctx?.objective) {
+        const obj = ctx.objective.replace(/\s+/g, " ").trim();
+        out.push(`  ${chalk.bold.white("Objective")}  ${chalk.dim(truncate(obj, w - 15))}`);
+        out.push("");
+    }
+    if (ctx?.lastWave && ctx.lastWave.tasks.length > 0) {
+        renderLastWave(out, w, ctx.lastWave);
+        out.push("");
+    }
+    if (ctx?.status) {
+        renderStatusBlock(out, w, ctx.status);
+        out.push("");
+    }
+    section(out, w, "Planner activity");
+    const events = data.events.slice(-10);
+    if (events.length === 0) {
+        out.push(chalk.dim("  (waiting for planner\u2026)"));
+    }
+    else {
+        for (const e of events) {
+            const t = new Date(e.time).toLocaleTimeString("en", { hour12: false });
+            out.push(chalk.gray(`  ${t} `) + chalk.magenta("[plan] ") + colorEvent(truncate(e.text, w - 22)));
         }
     }
     out.push("");
-    out.push(chalk.gray("  " + "\u2500".repeat(Math.min(w - 4, 60))));
-    const clean = steeringText.replace(/\n/g, " ");
-    const maxTextW = w - 8;
-    out.push(`  ${chalk.cyan("\u25C6")} ${clean.length > maxTextW ? clean.slice(0, maxTextW - 1) + "\u2026" : clean}`);
+    const liveClean = data.statusLine.replace(/\n/g, " ");
+    out.push(`  ${chalk.cyan("\u25B6")} ${chalk.dim(truncate(liveClean, w - 6))}`);
     out.push("");
-    if (showHotkeys)
-        out.push(chalk.dim("  [b] budget  [q] stop"));
+    if (showHotkeys) {
+        const pending = runInfo?.pendingSteer ?? 0;
+        const chip = pending > 0 ? chalk.cyan(`  \u270E ${pending} steer queued`) : "";
+        out.push(chalk.dim("  [b] budget  [s] steer  [q] stop") + chip);
+    }
     out.push("");
     return out.join("\n");
 }

package/dist/run.js

@@ -4,12 +4,12 @@ import { execSync } from "child_process";
 import chalk from "chalk";
 import { Swarm } from "./swarm.js";
 import { steerWave } from "./steering.js";
-import { getTotalPlannerCost, getPlannerRateLimitInfo } from "./planner-query.js";
+import { getTotalPlannerCost, getPlannerRateLimitInfo, runPlannerQuery } from "./planner-query.js";
 import { RunDisplay } from "./ui.js";
 import { renderSummary } from "./render.js";
 import { fmtTokens } from "./render.js";
 import { isAuthError } from "./cli.js";
-import { readRunMemory, writeStatus, writeGoalUpdate, saveRunState, saveWaveSession, loadWaveHistory, recordBranches, archiveMilestone, } from "./state.js";
+import { readRunMemory, writeStatus, writeGoalUpdate, saveRunState, saveWaveSession, loadWaveHistory, recordBranches, archiveMilestone, writeSteerInbox, consumeSteerInbox, countSteerInbox, } from "./state.js";
 export async function executeRun(cfg) {
     const restore = () => { try {
         process.stdout.write("\x1B[?25h\n");
@@ -34,7 +34,7 @@ export async function executeRun(cfg) {
     const branches = [];
     if (cfg.resuming && cfg.resumeState) {
         const rs = cfg.resumeState;
-        remaining = Math.max(1, (rs.budget ?? 0) - rs.accCompleted);
+        remaining = Math.max(1, rs.remaining);
         currentTasks = rs.currentTasks;
         waveNum = rs.waveNum;
         accCost = rs.accCost;
@@ -71,13 +71,79 @@ export async function executeRun(cfg) {
         accIn, accOut, accCost, accCompleted, accFailed,
         sessionsBudget: cfg.budget, waveNum, remaining,
         model: workerModel, startedAt: cfg.runStartedAt,
+        pendingSteer: countSteerInbox(runDir),
     };
-    const display = new RunDisplay(runInfoRef, liveConfig);
+    let display;
+    const onSteer = (text) => {
+        try {
+            writeSteerInbox(runDir, text);
+            runInfoRef.pendingSteer = countSteerInbox(runDir);
+            if (currentSwarm)
+                currentSwarm.log(-1, `Steer queued: ${text.slice(0, 80)}`);
+        }
+        catch { }
+    };
+    let askInFlight = false;
+    const onAsk = (question) => {
+        if (askInFlight)
+            return;
+        askInFlight = true;
+        display.setAskBusy(true);
+        display.setAsk({ question, answer: "", streaming: true });
+        void (async () => {
+            const plannerCostBefore = getTotalPlannerCost();
+            try {
+                const memory = readRunMemory(runDir, previousKnowledge || undefined);
+                const cap = (s, max) => s && s.length > max ? s.slice(0, max) + "\n...(truncated)" : (s || "");
+                const memBlob = [
+                    objective ? `Objective: ${objective}` : "",
+                    memory.goal ? `Goal:\n${cap(memory.goal, 1500)}` : "",
+                    memory.status ? `Current status:\n${cap(memory.status, 2000)}` : "",
+                    memory.verifications ? `Latest verification:\n${cap(memory.verifications, 1500)}` : "",
+                    memory.reflections ? `Latest reflections:\n${cap(memory.reflections, 1500)}` : "",
+                    waveHistory.length ? `Waves completed: ${waveHistory.length}` : "",
+                ].filter(Boolean).join("\n\n");
+                const prompt = `You are answering a user question about an in-progress autonomous agent run. Use the context below; read files in the repo if needed. Answer concisely (a few sentences) and cite files or waves when relevant.\n\n${memBlob}\n\n---\nUser question: ${question}`;
+                const answer = await runPlannerQuery(prompt, { cwd, model: plannerModel, permissionMode }, () => { });
+                accCost += getTotalPlannerCost() - plannerCostBefore;
+                syncRunInfo();
+                display.setAsk({ question, answer: answer.trim() || "(no answer)", streaming: false });
+            }
+            catch (err) {
+                accCost += getTotalPlannerCost() - plannerCostBefore;
+                syncRunInfo();
+                display.setAsk({ question, answer: "", streaming: false, error: err?.message?.slice(0, 200) || "ask failed" });
+            }
+            finally {
+                askInFlight = false;
+                display.setAskBusy(false);
+            }
+        })();
+    };
+    display = new RunDisplay(runInfoRef, liveConfig, { onSteer, onAsk });
     const rlGetter = () => {
         const rl = getPlannerRateLimitInfo();
         return { utilization: rl.utilization, isUsingOverage: rl.isUsingOverage, windows: rl.windows, resetsAt: rl.resetsAt };
     };
     const syncRunInfo = () => Object.assign(runInfoRef, { accIn, accOut, accCost, accCompleted, accFailed, waveNum, remaining });
+    const buildSteeringContext = () => {
+        let status;
+        try {
+            status = readFileSync(join(runDir, "status.md"), "utf-8");
+        }
+        catch { }
+        return {
+            objective: objective || undefined,
+            status,
+            lastWave: waveHistory[waveHistory.length - 1],
+        };
+    };
+    const steeringLog = (text, kind) => {
+        if (kind === "event")
+            display.appendSteeringEvent(text);
+        else
+            display.updateSteeringStatus(text);
+    };
     // For flex + branch strategy: create one target branch
     let runBranch;
     let originalRef;
@@ -119,7 +185,10 @@ export async function executeRun(cfg) {
             const plannerCostBefore = getTotalPlannerCost();
             try {
                 const memory = readRunMemory(runDir, previousKnowledge || undefined);
-                const steer = await steerWave(objective, waveHistory, remaining, cwd, plannerModel, workerModel, permissionMode, concurrency, (text) => display.updateText(text), memory);
+                const appliedGuidance = memory.userGuidance;
+                if (appliedGuidance)
+                    display.appendSteeringEvent(`User directives applied: ${appliedGuidance.slice(0, 80)}`);
+                const steer = await steerWave(objective, waveHistory, remaining, cwd, plannerModel, workerModel, permissionMode, concurrency, steeringLog, memory);
                 accCost += getTotalPlannerCost() - plannerCostBefore;
                 syncRunInfo();
                 if (steer.statusUpdate)
@@ -131,13 +200,18 @@ export async function executeRun(cfg) {
                 writeFileSync(join(steerDir, `wave-${waveNum}-attempt-${steerAttempts}.json`), JSON.stringify({
                     done: steer.done, reasoning: steer.reasoning,
                     taskCount: steer.tasks.length, statusUpdate: steer.statusUpdate, goalUpdate: steer.goalUpdate,
+                    appliedGuidance: appliedGuidance || undefined,
                 }, null, 2), "utf-8");
+                if (appliedGuidance) {
+                    consumeSteerInbox(runDir, waveNum);
+                    runInfoRef.pendingSteer = countSteerInbox(runDir);
+                }
                 if (waveHistory.length > 0 && waveHistory.length % 5 === 0)
                     archiveMilestone(runDir, waveNum);
                 if (steer.done || steer.tasks.length === 0) {
                     const hasVerification = waveHistory.some(w => w.tasks.some(t => t.prompt.toLowerCase().includes("verif")));
                     if (!hasVerification && remaining >= 1) {
-                        display.updateText(`Done blocked — auto-composing verification wave`);
+                        display.appendSteeringEvent("Done blocked — auto-composing verification wave");
                         currentTasks = [{
                                 id: "verify-0",
                                 prompt: `## Verification: Build, run, and test the application end-to-end\n\nYou are the final gatekeeper before this run is marked complete. The steerer believes the objective is done. Your job: prove it or disprove it.\n\n1. Run the build (npm run build, or whatever this project uses). Report ALL errors.\n2. Start the dev server. If a port is taken, try another. If a dependency is missing, install it.\n3. Navigate key flows as a real user would. Check that the main features work.\n4. Write your findings to .claude-overnight/latest/verifications/final-verify.md\n\nBe relentless. Do not give up if the first approach fails. Search the codebase for dev login routes, test tokens, seed users, env vars, CLI auth commands, or any bypass.`,
@@ -159,7 +233,7 @@ export async function executeRun(cfg) {
             catch (err) {
                 accCost += getTotalPlannerCost() - plannerCostBefore;
                 if (steerAttempts < 3) {
-                    display.updateText(`Steering failed (attempt ${steerAttempts}/3) — retrying...`);
+                    display.appendSteeringEvent(`Steering failed (attempt ${steerAttempts}/3) — retrying...`);
                     continue;
                 }
                 display.stop();
@@ -172,7 +246,7 @@ export async function executeRun(cfg) {
     };
     // Resume: steer immediately if no queued tasks
     if (cfg.resuming && flex && currentTasks.length === 0 && remaining > 0) {
-        display.setSteering(rlGetter);
+        display.setSteering(rlGetter, buildSteeringContext());
         display.start();
         await runSteering();
     }
@@ -215,7 +289,8 @@ export async function executeRun(cfg) {
         accFailed += swarm.failed;
         accTools += swarm.agents.reduce((sum, a) => sum + a.toolCalls, 0);
         remaining = Math.max(0, remaining - swarm.completed - swarm.failed);
-        const expectedFloor = Math.max(0, cfg.budget - accCompleted - accFailed);
+        const totalConsumed = accCompleted + accFailed + cfg.thinkingUsed;
+        const expectedFloor = Math.max(0, cfg.budget - totalConsumed);
         if (remaining < expectedFloor)
             remaining = expectedFloor;
         if (liveConfig.dirty) {
@@ -243,7 +318,7 @@ export async function executeRun(cfg) {
         if (!flex || remaining <= 0 || swarm.aborted || swarm.cappedOut)
             break;
         syncRunInfo();
-        display.setSteering(rlGetter);
+        display.setSteering(rlGetter, buildSteeringContext());
         display.resume();
         const steered = await runSteering();
         if (!steered)

package/dist/state.d.ts

@@ -1,6 +1,14 @@
 import type { RunState, BranchRecord, AgentState, RunMemory, WaveSummary } from "./types.js";
 export declare function readMdDir(dir: string): string;
 export declare function readRunMemory(runDir: string, previousRuns?: string): RunMemory;
+/** Read pending .md files in steer-inbox/ (top-level only, not processed/). */
+export declare function readSteerInbox(runDir: string): string;
+/** Count pending steer files without reading them. */
+export declare function countSteerInbox(runDir: string): number;
+/** Append a user directive to the inbox as its own timestamped file. Returns the file path. */
+export declare function writeSteerInbox(runDir: string, text: string): string;
+/** Move all pending .md files from steer-inbox/ into steer-inbox/processed/wave-N/. Returns moved count. */
+export declare function consumeSteerInbox(runDir: string, waveNum: number): number;
 export declare function writeStatus(baseDir: string, status: string): void;
 export declare function writeGoalUpdate(baseDir: string, update: string): void;
 export declare function saveRunState(runDir: string, state: RunState): void;

package/dist/state.js

@@ -1,4 +1,4 @@
-import { readFileSync, existsSync, mkdirSync, readdirSync, writeFileSync, symlinkSync, unlinkSync } from "fs";
+import { readFileSync, existsSync, mkdirSync, readdirSync, writeFileSync, symlinkSync, unlinkSync, renameSync } from "fs";
 import { execSync } from "child_process";
 import { join } from "path";
 import chalk from "chalk";
@@ -31,8 +31,68 @@ export function readRunMemory(runDir, previousRuns) {
         verifications: readMdDir(join(runDir, "verifications")),
         milestones: readMdDir(join(runDir, "milestones")),
         status, goal, previousRuns,
+        userGuidance: readSteerInbox(runDir),
     };
 }
+// ── Steer inbox (user directives queued for the next steering call) ──
+/** Read pending .md files in steer-inbox/ (top-level only, not processed/). */
+export function readSteerInbox(runDir) {
+    const dir = join(runDir, "steer-inbox");
+    try {
+        const files = readdirSync(dir).filter(f => f.endsWith(".md")).sort();
+        return files.map(f => {
+            try {
+                return readFileSync(join(dir, f), "utf-8").trim();
+            }
+            catch {
+                return "";
+            }
+        }).filter(Boolean).join("\n\n---\n\n");
+    }
+    catch {
+        return "";
+    }
+}
+/** Count pending steer files without reading them. */
+export function countSteerInbox(runDir) {
+    try {
+        return readdirSync(join(runDir, "steer-inbox")).filter(f => f.endsWith(".md")).length;
+    }
+    catch {
+        return 0;
+    }
+}
+/** Append a user directive to the inbox as its own timestamped file. Returns the file path. */
+export function writeSteerInbox(runDir, text) {
+    const dir = join(runDir, "steer-inbox");
+    mkdirSync(dir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const rand = Math.random().toString(36).slice(2, 6);
+    const path = join(dir, `${ts}-${rand}.md`);
+    writeFileSync(path, text.trim() + "\n", "utf-8");
+    return path;
+}
+/** Move all pending .md files from steer-inbox/ into steer-inbox/processed/wave-N/. Returns moved count. */
+export function consumeSteerInbox(runDir, waveNum) {
+    const dir = join(runDir, "steer-inbox");
+    let moved = 0;
+    try {
+        const files = readdirSync(dir).filter(f => f.endsWith(".md"));
+        if (files.length === 0)
+            return 0;
+        const processedDir = join(dir, "processed", `wave-${waveNum}`);
+        mkdirSync(processedDir, { recursive: true });
+        for (const f of files) {
+            try {
+                renameSync(join(dir, f), join(processedDir, f));
+                moved++;
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return moved;
+}
 export function writeStatus(baseDir, status) {
     writeFileSync(join(baseDir, "status.md"), status, "utf-8");
 }
@@ -98,6 +158,8 @@ export function findOrphanedDesigns(rootDir) {
 // ── History display ──
 export function formatTimeAgo(isoStr) {
     const ms = Date.now() - new Date(isoStr).getTime();
+    if (!isFinite(ms))
+        return "unknown";
     const mins = Math.floor(ms / 60000);
     if (mins < 1)
         return "just now";

package/dist/steering.d.ts

@@ -1,2 +1,3 @@
 import type { PermMode, SteerResult, RunMemory, WaveSummary } from "./types.js";
-export declare function steerWave(objective: string, history: WaveSummary[], remainingBudget: number, cwd: string, plannerModel: string, workerModel: string, permissionMode: PermMode, concurrency: number, onLog: (text: string) => void, runMemory?: RunMemory): Promise<SteerResult>;
+import { type PlannerLog } from "./planner-query.js";
+export declare function steerWave(objective: string, history: WaveSummary[], remainingBudget: number, cwd: string, plannerModel: string, workerModel: string, permissionMode: PermMode, concurrency: number, onLog: PlannerLog, runMemory?: RunMemory): Promise<SteerResult>;

package/dist/steering.js

@@ -40,8 +40,9 @@ export async function steerWave(objective, history, remainingBudget, cwd, planne
     const verificationBlock = runMemory?.verifications ? `\nVerification results (from actually running the app):\n${cap(runMemory.verifications, 3000)}\n` : "";
     const goalBlock = runMemory?.goal ? `\nNorth star — what "amazing" means:\n${runMemory.goal}\n` : "";
     const prevRunBlock = runMemory?.previousRuns ? `\nKnowledge from previous runs:\n${cap(runMemory.previousRuns, 3000)}\n` : "";
+    const guidanceBlock = runMemory?.userGuidance ? `\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\nUSER DIRECTIVES — highest priority\nThese come directly from the user running this session. They override prior assumptions about status, goal, and next steps. Incorporate them into the wave you compose below. If they conflict with earlier decisions, the user wins. Reflect the new direction in statusUpdate so future waves remember.\n\n${cap(runMemory.userGuidance, 4000)}\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n` : "";
     const prompt = `You are the quality director for an autonomous multi-wave agent system. Your job is to push the work toward "amazing," not just "done."
-
+${guidanceBlock}
 Objective: ${objective}
 ${goalBlock}${statusBlock}${milestoneBlock}${prevRunBlock}
 Recent waves:
@@ -104,13 +105,14 @@ The "model" field on each task: use "worker" (${workerModel}) for implementation
 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": []}`;
-    onLog("Assessing...");
+    onLog("Assessing...", "status");
+    onLog(`Reading codebase — wave ${history.length + 1}`, "event");
     const resultText = await runPlannerQuery(prompt, { cwd, model: plannerModel, permissionMode, outputFormat: STEER_SCHEMA }, onLog);
     const parsed = await (async () => {
         const first = attemptJsonParse(resultText);
         if (first)
             return first;
-        onLog(`Steering parse failed (${resultText.length} chars). Asking model to fix...`);
+        onLog(`Steering parse failed (${resultText.length} chars). Asking model to fix...`, "event");
         const snippet = resultText.length > 2000 ? resultText.slice(0, 1000) + "\n...\n" + resultText.slice(-800) : resultText;
         const retryText = await runPlannerQuery(`Your previous steering response could not be parsed as JSON. Here is what you returned:\n\n---\n${snippet}\n---\n\nExtract or rewrite the above as ONLY a valid JSON object with this schema: {"done":boolean,"reasoning":"...","statusUpdate":"...","tasks":[{"prompt":"..."}]}\n\nRespond with ONLY the JSON, no markdown fences, no explanation.`, { cwd, model: plannerModel, permissionMode, outputFormat: STEER_SCHEMA }, onLog);
         const retryParsed = attemptJsonParse(retryText);

package/dist/types.d.ts

@@ -144,6 +144,8 @@ export interface RunMemory {
     status: string;
     goal: string;
     previousRuns?: string;
+    /** Pending user directives from the steer inbox, consumed by the next successful steering call. */
+    userGuidance?: string;
 }
 /** Persisted run state for crash recovery and resume. */
 export interface RunState {

package/dist/ui.d.ts

@@ -1,5 +1,16 @@
 import type { Swarm } from "./swarm.js";
-import type { RateLimitWindow } from "./types.js";
+import type { RateLimitWindow, WaveSummary } from "./types.js";
+/** Short-lived context the steering view renders around its live log. */
+export interface SteeringContext {
+    objective?: string;
+    status?: string;
+    lastWave?: WaveSummary;
+}
+/** One scrollback line in the steering event log. */
+export interface SteeringEvent {
+    time: number;
+    text: string;
+}
 /** Cumulative run-level stats — mutable, updated between phases. */
 export interface RunInfo {
     accIn: number;
@@ -12,6 +23,8 @@ export interface RunInfo {
     remaining: number;
     model?: string;
     startedAt: number;
+    /** Number of pending directives in the steer inbox; displayed as a chip in the hotkey row. */
+    pendingSteer?: number;
 }
 /** Mutable config that can be changed live during execution. */
 export interface LiveConfig {
@@ -19,6 +32,13 @@ export interface LiveConfig {
     usageCap: number | undefined;
     dirty: boolean;
 }
+/** State of an in-flight or recently-completed ask side query. */
+export interface AskState {
+    question: string;
+    answer: string;
+    streaming: boolean;
+    error?: string;
+}
 type RLGetter = () => {
     utilization: number;
     isUsingOverage: boolean;
@@ -29,7 +49,10 @@ export declare class RunDisplay {
     readonly runInfo: RunInfo;
     private liveConfig?;
     private swarm?;
-    private steeringText?;
+    private steeringActive;
+    private steeringStatusLine;
+    private steeringEvents;
+    private steeringContext?;
     private rlGetter?;
     private interval?;
     private keyHandler?;
@@ -39,16 +62,34 @@ export declare class RunDisplay {
     private readonly isTTY;
     private lastSeq;
     private lastCompleted;
-    constructor(runInfo: RunInfo, liveConfig?: LiveConfig);
+    private askState?;
+    private askBusy;
+    private onSteer?;
+    private onAsk?;
+    constructor(runInfo: RunInfo, liveConfig?: LiveConfig, callbacks?: {
+        onSteer?: (text: string) => void;
+        onAsk?: (text: string) => void;
+    });
+    /** Replace the ask state. Called by run.ts as the side query streams and completes. */
+    setAsk(state: AskState | undefined): void;
+    /** Signal to the UI whether an ask is in progress (prevents duplicate firings). */
+    setAskBusy(busy: boolean): void;
     start(): void;
     setWave(swarm: Swarm): void;
-    setSteering(rlGetter?: RLGetter): void;
+    setSteering(rlGetter?: RLGetter, ctx?: SteeringContext): void;
+    /** Replace the single live status line (ticker heartbeat). */
+    updateSteeringStatus(text: string): void;
+    /** Append a discrete, persistent line to the steering scrollback. */
+    appendSteeringEvent(text: string): void;
+    /** Backwards-compat alias — treats input as the current status line. */
     updateText(text: string): void;
     pause(): void;
     resume(): void;
     stop(): void;
     private resumeInterval;
     private render;
+    private renderInputPrompt;
+    private renderAskPanel;
     private hasHotkeys;
     private setupHotkeys;
     private plainTick;

package/dist/ui.js

@@ -1,10 +1,15 @@
 import chalk from "chalk";
 import { renderFrame, renderSteeringFrame } from "./render.js";
+const MAX_STEERING_EVENTS = 60;
+const MAX_INPUT_LEN = 600;
 export class RunDisplay {
     runInfo;
     liveConfig;
     swarm;
-    steeringText;
+    steeringActive = false;
+    steeringStatusLine = "Assessing...";
+    steeringEvents = [];
+    steeringContext;
     rlGetter;
     interval;
     keyHandler;
@@ -14,11 +19,21 @@ export class RunDisplay {
     isTTY;
     lastSeq = 0;
     lastCompleted = -1;
-    constructor(runInfo, liveConfig) {
+    askState;
+    askBusy = false;
+    onSteer;
+    onAsk;
+    constructor(runInfo, liveConfig, callbacks) {
         this.runInfo = runInfo;
         this.liveConfig = liveConfig;
+        this.onSteer = callbacks?.onSteer;
+        this.onAsk = callbacks?.onAsk;
         this.isTTY = !!process.stdout.isTTY;
     }
+    /** Replace the ask state. Called by run.ts as the side query streams and completes. */
+    setAsk(state) { this.askState = state; }
+    /** Signal to the UI whether an ask is in progress (prevents duplicate firings). */
+    setAskBusy(busy) { this.askBusy = busy; }
     start() {
         if (this.started)
             return;
@@ -28,17 +43,29 @@ export class RunDisplay {
     }
     setWave(swarm) {
         this.swarm = swarm;
-        this.steeringText = undefined;
+        this.steeringActive = false;
         this.rlGetter = undefined;
         this.lastSeq = 0;
         this.lastCompleted = -1;
     }
-    setSteering(rlGetter) {
+    setSteering(rlGetter, ctx) {
         this.swarm = undefined;
-        this.steeringText = "Assessing...";
+        this.steeringActive = true;
+        this.steeringStatusLine = "Assessing...";
+        this.steeringEvents = [];
+        this.steeringContext = ctx;
         this.rlGetter = rlGetter;
     }
-    updateText(text) { this.steeringText = text; }
+    /** Replace the single live status line (ticker heartbeat). */
+    updateSteeringStatus(text) { this.steeringStatusLine = text; }
+    /** Append a discrete, persistent line to the steering scrollback. */
+    appendSteeringEvent(text) {
+        this.steeringEvents.push({ time: Date.now(), text });
+        if (this.steeringEvents.length > MAX_STEERING_EVENTS)
+            this.steeringEvents.shift();
+    }
+    /** Backwards-compat alias — treats input as the current status line. */
+    updateText(text) { this.updateSteeringStatus(text); }
     pause() {
         if (this.interval) {
             clearInterval(this.interval);
@@ -96,23 +123,61 @@ export class RunDisplay {
         }, 250);
     }
     render() {
+        let frame = "";
         if (this.swarm) {
-            let frame = renderFrame(this.swarm, this.hasHotkeys(), this.runInfo);
-            if (this.inputMode !== "none") {
-                const label = this.inputMode === "budget" ? "New budget (remaining sessions)" : "New usage cap (0-100%)";
-                frame += `\n  ${chalk.cyan(">")} ${label}: ${this.inputBuf}\u2588`;
-            }
-            return frame;
+            frame = renderFrame(this.swarm, this.hasHotkeys(), this.runInfo);
         }
-        if (this.steeringText != null) {
-            let frame = renderSteeringFrame(this.runInfo, this.steeringText, this.hasHotkeys(), this.rlGetter);
-            if (this.inputMode === "budget") {
-                frame += `\n  ${chalk.cyan(">")} New budget (remaining sessions): ${this.inputBuf}\u2588`;
-            }
-            return frame;
+        else if (this.steeringActive) {
+            frame = renderSteeringFrame(this.runInfo, {
+                statusLine: this.steeringStatusLine,
+                events: this.steeringEvents,
+                context: this.steeringContext,
+            }, this.hasHotkeys(), this.rlGetter);
+        }
+        else {
+            return "";
+        }
+        frame += this.renderInputPrompt();
+        frame += this.renderAskPanel();
+        return frame;
+    }
+    renderInputPrompt() {
+        if (this.inputMode === "none")
+            return "";
+        if (this.inputMode === "budget") {
+            return `\n  ${chalk.cyan(">")} New budget (remaining sessions): ${this.inputBuf}\u2588`;
+        }
+        if (this.inputMode === "threshold") {
+            return `\n  ${chalk.cyan(">")} New usage cap (0-100%): ${this.inputBuf}\u2588`;
+        }
+        if (this.inputMode === "steer") {
+            return `\n  ${chalk.cyan(">")} ${chalk.bold("Steer next wave")} ${chalk.dim("(Enter to queue, Esc to cancel)")}\n  ${this.inputBuf}\u2588`;
+        }
+        if (this.inputMode === "ask") {
+            return `\n  ${chalk.cyan(">")} ${chalk.bold("Ask the planner")} ${chalk.dim("(Enter to send, Esc to cancel)")}\n  ${this.inputBuf}\u2588`;
         }
         return "";
     }
+    renderAskPanel() {
+        const a = this.askState;
+        if (!a)
+            return "";
+        const out = ["", chalk.gray("  \u2500\u2500\u2500 Ask " + "\u2500".repeat(40))];
+        out.push(`  ${chalk.bold.cyan("Q:")} ${a.question}`);
+        if (a.error) {
+            out.push(`  ${chalk.red("A:")} ${chalk.red(a.error)}`);
+        }
+        else if (a.streaming) {
+            out.push(`  ${chalk.dim("A: " + (a.answer || "thinking..."))}`);
+        }
+        else {
+            const lines = a.answer.split("\n").slice(0, 20);
+            out.push(`  ${chalk.bold.green("A:")} ${lines[0] || ""}`);
+            for (const ln of lines.slice(1))
+                out.push(`     ${ln}`);
+        }
+        return "\n" + out.join("\n");
+    }
     hasHotkeys() {
         return !!this.liveConfig && !!process.stdin.isTTY;
     }
@@ -129,7 +194,7 @@ export class RunDisplay {
         const lc = this.liveConfig;
         this.keyHandler = (buf) => {
             const s = buf.toString();
-            if (this.inputMode !== "none") {
+            if (this.inputMode === "budget" || this.inputMode === "threshold") {
                 if (s === "\r" || s === "\n") {
                     const val = parseFloat(this.inputBuf);
                     if (this.inputMode === "budget" && !isNaN(val) && val > 0) {
@@ -160,6 +225,37 @@ export class RunDisplay {
                 }
                 return;
             }
+            if (this.inputMode === "steer" || this.inputMode === "ask") {
+                for (const ch of s) {
+                    if (ch === "\r" || ch === "\n") {
+                        const text = this.inputBuf.trim();
+                        const wasAsk = this.inputMode === "ask";
+                        this.inputMode = "none";
+                        this.inputBuf = "";
+                        if (text) {
+                            if (wasAsk)
+                                this.onAsk?.(text);
+                            else
+                                this.onSteer?.(text);
+                        }
+                        return;
+                    }
+                    if (ch === "\x1B" || ch === "\x03") {
+                        this.inputMode = "none";
+                        this.inputBuf = "";
+                        return;
+                    }
+                    if (ch === "\x7F" || ch === "\b") {
+                        this.inputBuf = this.inputBuf.slice(0, -1);
+                        continue;
+                    }
+                    const code = ch.charCodeAt(0);
+                    if (code >= 0x20 && code <= 0x7E && this.inputBuf.length < MAX_INPUT_LEN) {
+                        this.inputBuf += ch;
+                    }
+                }
+                return;
+            }
             if (s === "b" || s === "B") {
                 this.inputMode = "budget";
                 this.inputBuf = "";
@@ -170,6 +266,14 @@ export class RunDisplay {
                     this.inputBuf = "";
                 }
             }
+            else if ((s === "s" || s === "S") && this.onSteer) {
+                this.inputMode = "steer";
+                this.inputBuf = "";
+            }
+            else if (s === "?" && this.onAsk && this.swarm && !this.askBusy) {
+                this.inputMode = "ask";
+                this.inputBuf = "";
+            }
             else if (s === "q" || s === "Q" || s === "\x03") {
                 if (this.swarm) {
                     if (this.swarm.aborted)

package/package.json

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