claude-overnight 1.9.1 → 1.10.0

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/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");
@@ -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();
     }
@@ -244,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");
 }

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.1",
+  "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": {