claude-overnight 1.16.12 → 1.16.15

package/dist/cli.js

@@ -219,10 +219,12 @@ export function ask(question) {
                         redraw();
                         continue;
                     }
-                    // Skip ESC and any bytes that are part of an ANSI escape sequence
-                    // (arrow keys, function keys, etc. arrive as \x1B [ ... letter)
+                    // ESC submits the current input (same as Enter)
                     if (ch === "\x1B") {
-                        continue;
+                        stdout.write("\n");
+                        cleanup();
+                        resolve(segmentsToString(segs).trim());
+                        return;
                     }
                     const code = ch.charCodeAt(0);
                     if (code < 0x20)

package/dist/index.js

@@ -541,7 +541,7 @@ async function main() {
         const plannerPick = await pickModel(`${chalk.cyan("④")} Planner model ${chalk.dim("(thinking, steering — use your strongest)")}:`, models);
         plannerModel = plannerPick.model;
         plannerProvider = plannerPick.provider;
-        const workerPick = await pickModel(`${chalk.cyan("⑤")} Executor model ${chalk.dim("(what runs the tasks — Qwen/OpenRouter/etc via Other…)")}:`, models);
+        const workerPick = await pickModel(`${chalk.cyan("⑤")} Executor model ${chalk.dim("(what runs the tasks — Qwen 3.6 Plus / OpenRouter / etc via Other…)")}:`, models);
         workerModel = workerPick.model;
         workerProvider = workerPick.provider;
         usageCap = await select(`${chalk.cyan("⑥")} Usage cap:`, [

package/dist/providers.js

@@ -92,7 +92,7 @@ export async function pickModel(label, anthropicModels, currentModelId) {
             const keySrc = p.keyEnv ? `env ${p.keyEnv}` : "stored key";
             items.push({ name: `${p.displayName}`, value: { kind: "provider", provider: p }, hint: `${p.model} · ${keySrc}` });
         }
-        items.push({ name: chalk.cyan("Other…"), value: { kind: "other" }, hint: "custom OpenAI/Anthropic-compatible endpoint" });
+        items.push({ name: chalk.cyan("Other…"), value: { kind: "other" }, hint: "Qwen 3.6 Plus, OpenRouter, or any Anthropic-compatible endpoint" });
         let defaultIdx = 0;
         if (currentModelId) {
             const i = items.findIndex(it => {
@@ -126,11 +126,11 @@ async function promptNewProvider() {
     if (!displayName)
         return null;
     const id = slugify(displayName);
-    const baseURLRaw = await ask(`\n  ${chalk.cyan("Base URL")} ${chalk.dim("(e.g. https://dashscope-intl.aliyuncs.com/api/v2/apps/claude-code-proxy):")} `);
+    const baseURLRaw = await ask(`\n  ${chalk.cyan("Base URL")} ${chalk.dim("(e.g. https://dashscope-intl.aliyuncs.com/apps/anthropic for Qwen 3.6 Plus):")} `);
     if (!baseURLRaw)
         return null;
     const baseURL = normalizeBaseURL(baseURLRaw);
-    const model = await ask(`\n  ${chalk.cyan("Model id")} ${chalk.dim("(e.g. qwen3-coder-plus):")} `);
+    const model = await ask(`\n  ${chalk.cyan("Model id")} ${chalk.dim("(e.g. qwen3.6-plus):")} `);
     if (!model)
         return null;
     const keyMode = await select(`  ${chalk.cyan("API key source")}:`, [

package/dist/render.d.ts

@@ -1,9 +1,40 @@
 import type { Swarm } from "./swarm.js";
 import type { RateLimitWindow } from "./types.js";
 import type { RunInfo, SteeringContext, SteeringEvent } from "./ui.js";
+export interface Section {
+    title: string;
+    rows: string[];
+    scrollable?: boolean;
+    highlightKey?: string;
+}
+export interface ContentRenderer {
+    /** Returns an array of sections to render in the content area */
+    sections(): Section[];
+}
 export declare function truncate(s: string, max: number): string;
 export declare function fmtTokens(n: number): string;
 export declare function fmtDur(ms: number): string;
+export declare function renderUnifiedFrame(params: {
+    model?: string;
+    phase: string;
+    barPct: number;
+    barLabel: string;
+    active?: number;
+    blocked?: number;
+    queued?: number;
+    startedAt: number;
+    totalIn: number;
+    totalOut: number;
+    totalCost: number;
+    waveNum: number;
+    sessionsUsed: number;
+    sessionsBudget: number;
+    remaining: number;
+    usageBarRender?: (out: string[], w: number) => void;
+    content: ContentRenderer;
+    hotkeyRow?: string;
+    extraFooterRows?: string[];
+}): string;
 type RLGetter = () => {
     utilization: number;
     isUsingOverage: boolean;

package/dist/render.js

@@ -138,9 +138,57 @@ function renderUsageBars(out, w, swarm) {
         out.push(`  ${chalk.dim("Extra ")}${barStr}  ${label}`);
     }
 }
-export function renderFrame(swarm, showHotkeys, runInfo, selectedAgentId) {
+// ── Unified frame renderer ──
+export function renderUnifiedFrame(params) {
     const w = Math.max((process.stdout.columns ?? 80) || 80, 60);
     const out = [];
+    // Header
+    renderHeader(out, w, {
+        model: params.model,
+        phase: params.phase,
+        barPct: params.barPct,
+        barLabel: params.barLabel,
+        active: params.active ?? 0,
+        blocked: params.blocked,
+        queued: params.queued ?? 0,
+        startedAt: params.startedAt,
+        totalIn: params.totalIn,
+        totalOut: params.totalOut,
+        totalCost: params.totalCost,
+        waveNum: params.waveNum,
+        sessionsUsed: params.sessionsUsed,
+        sessionsBudget: params.sessionsBudget,
+        remaining: params.remaining,
+    });
+    // Usage bar
+    if (params.usageBarRender) {
+        params.usageBarRender(out, w);
+    }
+    out.push("");
+    // Content sections
+    const sections = params.content.sections();
+    for (const sec of sections) {
+        if (sec.title) {
+            section(out, w, sec.title);
+        }
+        for (const row of sec.rows) {
+            out.push(row);
+        }
+    }
+    // Footer
+    out.push("");
+    if (params.hotkeyRow) {
+        out.push(params.hotkeyRow);
+    }
+    if (params.extraFooterRows) {
+        for (const row of params.extraFooterRows) {
+            out.push(row);
+        }
+    }
+    out.push("");
+    return out.join("\n");
+}
+export function renderFrame(swarm, showHotkeys, runInfo, selectedAgentId) {
     const stoppingTag = swarm.aborted ? chalk.yellow("STOPPING") : "";
     const pausedTag = swarm.paused ? chalk.yellow("PAUSED") : "";
     const stallTag = swarm.stallLevel >= 3 ? chalk.red("STALL") : swarm.stallLevel > 0 ? chalk.yellow(`STALL L${swarm.stallLevel}`) : "";
@@ -149,93 +197,90 @@ export function renderFrame(swarm, showHotkeys, runInfo, selectedAgentId) {
             : swarm.rateLimitPaused > 0 ? chalk.yellow("COOLING") : "";
     const phase = [phaseLabel, pausedTag, stallTag, stoppingTag].filter(Boolean).join(" ");
     const waveUsed = swarm.completed + swarm.failed;
-    renderHeader(out, w, {
-        model: runInfo?.model ?? swarm.model,
-        phase,
-        barPct: swarm.total > 0 ? swarm.completed / swarm.total : 0,
-        barLabel: `${swarm.completed}/${swarm.total}`,
-        active: swarm.active, blocked: swarm.blocked, queued: swarm.pending,
-        startedAt: runInfo?.startedAt ?? swarm.startedAt,
-        totalIn: (runInfo?.accIn ?? 0) + swarm.totalInputTokens,
-        totalOut: (runInfo?.accOut ?? 0) + swarm.totalOutputTokens,
-        totalCost: (runInfo?.accCost ?? swarm.baseCostUsd) + swarm.totalCostUsd,
-        waveNum: runInfo?.waveNum ?? -1,
-        sessionsUsed: (runInfo ? runInfo.accCompleted + runInfo.accFailed : 0) + waveUsed,
-        sessionsBudget: runInfo?.sessionsBudget ?? swarm.total,
-        remaining: Math.max(0, (runInfo?.remaining ?? swarm.total) - waveUsed),
-    });
-    renderUsageBars(out, w, swarm);
-    out.push("");
-    // Agent table
     const running = swarm.agents.filter(a => a.status === "running");
     const finished = swarm.agents.filter(a => a.status !== "running");
     const showFinished = finished.slice(-Math.max(2, 12 - running.length));
     const show = [...running, ...showFinished];
-    if (show.length > 0) {
-        out.push(chalk.gray("  #   Status   Task" + " ".repeat(Math.max(1, w - 56)) + "Action"));
-        out.push(chalk.gray("  " + "\u2500".repeat(Math.min(w - 4, 100))));
-        for (const a of show)
-            out.push(fmtRow(a, w, a.id === (selectedAgentId ?? -1)));
-        if (swarm.pending > 0)
-            out.push(chalk.gray(`  ... + ${swarm.pending} queued`));
-    }
-    // ── Agent detail (progressive discovery) ──
     const detailAgent = selectedAgentId != null
         ? swarm.agents.find(a => a.id === selectedAgentId)
         : undefined;
-    if (detailAgent) {
-        out.push("");
-        section(out, w, `Agent ${detailAgent.id} detail \u00b7 [d] next \u00b7 [Esc] close`);
-        const taskLines = detailAgent.task.prompt.split("\n");
-        const maxTaskLines = Math.min(6, taskLines.length);
-        for (let i = 0; i < maxTaskLines; i++) {
-            out.push(`  ${chalk.dim(truncate(taskLines[i].trim(), w - 6))}`);
-        }
-        if (taskLines.length > maxTaskLines)
-            out.push(chalk.dim(`  \u2026 + ${taskLines.length - maxTaskLines} more lines`));
-        const meta = [];
-        if (detailAgent.currentTool)
-            meta.push(chalk.yellow(`tool: ${detailAgent.currentTool}`));
-        if (detailAgent.lastText)
-            meta.push(chalk.dim(truncate(detailAgent.lastText, 60)));
-        if (detailAgent.filesChanged != null)
-            meta.push(chalk.dim(`${detailAgent.filesChanged} files`));
-        if (detailAgent.costUsd != null)
-            meta.push(chalk.yellow(`$${detailAgent.costUsd.toFixed(3)}`));
-        if (detailAgent.toolCalls > 0)
-            meta.push(chalk.dim(`${detailAgent.toolCalls} tools`));
-        if (meta.length > 0)
-            out.push(`  ${meta.join(chalk.dim("  \u00b7 "))}`);
-    }
-    // Merge results
-    if (swarm.mergeResults.length > 0) {
-        out.push("");
-        out.push(chalk.gray("  \u2500\u2500\u2500 Merges " + "\u2500".repeat(Math.min(w - 16, 90))));
-        for (const mr of swarm.mergeResults) {
-            const icon = mr.ok ? chalk.green("\u2713") : chalk.red("\u2717");
-            const info = mr.ok ? chalk.dim(`${mr.filesChanged} file(s)`) : chalk.red(truncate(mr.error || "conflict", 40));
-            out.push(`  ${icon} ${mr.branch}  ${info}`);
-        }
-    }
-    // Event log
-    out.push("");
-    out.push(chalk.gray("  \u2500\u2500\u2500 Events " + "\u2500".repeat(Math.min(w - 16, 90))));
-    const logN = Math.min(12, swarm.logs.length);
-    for (const entry of swarm.logs.slice(-logN)) {
-        const t = new Date(entry.time).toLocaleTimeString("en", { hour12: false });
-        const tag = entry.agentId < 0 ? chalk.magenta("[sys]") : chalk.cyan(`[${entry.agentId}]`);
-        // Tool-use events with target get a secondary detail line
-        const arrowIdx = entry.text.indexOf(" \u2192 ");
-        if (arrowIdx > 0 && arrowIdx < 20) {
-            const toolName = entry.text.slice(0, arrowIdx);
-            const target = entry.text.slice(arrowIdx + 3);
-            out.push(chalk.gray(`  ${t} `) + tag + ` ${chalk.yellow(toolName)}`);
-            out.push(chalk.dim(`      ${truncate(target, w - 10)}`));
-        }
-        else {
-            out.push(chalk.gray(`  ${t} `) + tag + ` ${colorEvent(truncate(entry.text, w - 22))}`);
-        }
-    }
+    const content = {
+        sections() {
+            const secs = [];
+            // Agent table (undecorated — raw header + rows)
+            if (show.length > 0) {
+                const rows = [
+                    chalk.gray("  #   Status   Task" + " ".repeat(Math.max(1, (process.stdout.columns ?? 80) || 80, 60) - 56)) + "Action",
+                    chalk.gray("  " + "\u2500".repeat(Math.min(Math.max((process.stdout.columns ?? 80) || 80, 60) - 4, 100))),
+                ];
+                for (const a of show)
+                    rows.push(fmtRow(a, (process.stdout.columns ?? 80) || 80, a.id === (selectedAgentId ?? -1)));
+                if (swarm.pending > 0)
+                    rows.push(chalk.gray(`  ... + ${swarm.pending} queued`));
+                secs.push({ title: "", rows });
+            }
+            // Agent detail (decorated)
+            if (detailAgent) {
+                const rows = [];
+                const taskLines = detailAgent.task.prompt.split("\n");
+                const maxTaskLines = Math.min(6, taskLines.length);
+                const ww = Math.max((process.stdout.columns ?? 80) || 80, 60);
+                for (let i = 0; i < maxTaskLines; i++) {
+                    rows.push(`  ${chalk.dim(truncate(taskLines[i].trim(), ww - 6))}`);
+                }
+                if (taskLines.length > maxTaskLines)
+                    rows.push(chalk.dim(`  \u2026 + ${taskLines.length - maxTaskLines} more lines`));
+                const meta = [];
+                if (detailAgent.currentTool)
+                    meta.push(chalk.yellow(`tool: ${detailAgent.currentTool}`));
+                if (detailAgent.lastText)
+                    meta.push(chalk.dim(truncate(detailAgent.lastText, 60)));
+                if (detailAgent.filesChanged != null)
+                    meta.push(chalk.dim(`${detailAgent.filesChanged} files`));
+                if (detailAgent.costUsd != null)
+                    meta.push(chalk.yellow(`$${detailAgent.costUsd.toFixed(3)}`));
+                if (detailAgent.toolCalls > 0)
+                    meta.push(chalk.dim(`${detailAgent.toolCalls} tools`));
+                if (meta.length > 0)
+                    rows.push(`  ${meta.join(chalk.dim("  \u00b7 "))}`);
+                secs.push({ title: `Agent ${detailAgent.id} detail \u00b7 [d] next \u00b7 [Esc] close`, rows });
+            }
+            // Merge results (undecorated)
+            if (swarm.mergeResults.length > 0) {
+                const ww = Math.max((process.stdout.columns ?? 80) || 80, 60);
+                const rows = [chalk.gray("  \u2500\u2500\u2500 Merges " + "\u2500".repeat(Math.min(ww - 16, 90)))];
+                for (const mr of swarm.mergeResults) {
+                    const icon = mr.ok ? chalk.green("\u2713") : chalk.red("\u2717");
+                    const info = mr.ok ? chalk.dim(`${mr.filesChanged} file(s)`) : chalk.red(truncate(mr.error || "conflict", 40));
+                    rows.push(`  ${icon} ${mr.branch}  ${info}`);
+                }
+                secs.push({ title: "", rows });
+            }
+            // Event log (undecorated)
+            const ww = Math.max((process.stdout.columns ?? 80) || 80, 60);
+            const eventRows = [chalk.gray("  \u2500\u2500\u2500 Events " + "\u2500".repeat(Math.min(ww - 16, 90)))];
+            const logN = Math.min(12, swarm.logs.length);
+            for (const entry of swarm.logs.slice(-logN)) {
+                const t = new Date(entry.time).toLocaleTimeString("en", { hour12: false });
+                const tag = entry.agentId < 0 ? chalk.magenta("[sys]") : chalk.cyan(`[${entry.agentId}]`);
+                const arrowIdx = entry.text.indexOf(" \u2192 ");
+                if (arrowIdx > 0 && arrowIdx < 20) {
+                    const toolName = entry.text.slice(0, arrowIdx);
+                    const target = entry.text.slice(arrowIdx + 3);
+                    eventRows.push(chalk.gray(`  ${t} `) + tag + ` ${chalk.yellow(toolName)}`);
+                    eventRows.push(chalk.dim(`      ${truncate(target, ww - 10)}`));
+                }
+                else {
+                    eventRows.push(chalk.gray(`  ${t} `) + tag + ` ${colorEvent(truncate(entry.text, ww - 22))}`);
+                }
+            }
+            secs.push({ title: "", rows: eventRows });
+            return secs;
+        },
+    };
+    // Build footer
+    let hotkeyRow;
+    const extraFooterRows = [];
     if (showHotkeys) {
         const pending = runInfo?.pendingSteer ?? 0;
         const chip = pending > 0 ? chalk.cyan(`  \u270E ${pending} steer queued`) : "";
@@ -244,13 +289,32 @@ export function renderFrame(swarm, showHotkeys, runInfo, selectedAgentId) {
         const pauseLabel = swarm.paused ? "[p] resume" : "[p] pause";
         const detailChip = swarm.active > 0 ? chalk.dim("  [d] detail") : "";
         const selectChip = swarm.active > 0 && running.length <= 10 ? chalk.dim("  [0-9] select") : "";
-        out.push(chalk.dim(`  [b] budget  [t] cap  [c] conc  [e] extra  ${pauseLabel}  [s] steer  [?] ask  [q] stop`) + fixChip + retryChip + chip + detailChip + selectChip);
+        hotkeyRow = chalk.dim(`  [b] budget  [t] cap  [c] conc  [e] extra  ${pauseLabel}  [s] steer  [?] ask  [q] stop`) + fixChip + retryChip + chip + detailChip + selectChip;
         if (swarm.blocked > 0 && swarm.blocked === swarm.active) {
-            out.push(chalk.yellow(`  all workers rate-limited — [r] retry-now, [c] reduce concurrency, [p] pause, [q] quit`));
+            extraFooterRows.push(chalk.yellow(`  all workers rate-limited — [r] retry-now, [c] reduce concurrency, [p] pause, [q] quit`));
         }
     }
-    out.push("");
-    return out.join("\n");
+    return renderUnifiedFrame({
+        model: runInfo?.model ?? swarm.model,
+        phase,
+        barPct: swarm.total > 0 ? swarm.completed / swarm.total : 0,
+        barLabel: `${swarm.completed}/${swarm.total}`,
+        active: swarm.active,
+        blocked: swarm.blocked,
+        queued: swarm.pending,
+        startedAt: runInfo?.startedAt ?? swarm.startedAt,
+        totalIn: (runInfo?.accIn ?? 0) + swarm.totalInputTokens,
+        totalOut: (runInfo?.accOut ?? 0) + swarm.totalOutputTokens,
+        totalCost: (runInfo?.accCost ?? swarm.baseCostUsd) + swarm.totalCostUsd,
+        waveNum: runInfo?.waveNum ?? -1,
+        sessionsUsed: (runInfo ? runInfo.accCompleted + runInfo.accFailed : 0) + waveUsed,
+        sessionsBudget: runInfo?.sessionsBudget ?? swarm.total,
+        remaining: Math.max(0, (runInfo?.remaining ?? swarm.total) - waveUsed),
+        usageBarRender: (out, w) => renderUsageBars(out, w, swarm),
+        content,
+        hotkeyRow,
+        extraFooterRows,
+    });
 }
 function section(out, w, title) {
     const inner = ` ${title} `;
@@ -324,70 +388,99 @@ function renderStatusBlock(out, w, status) {
         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;
-    renderHeader(out, w, {
-        model: runInfo.model,
-        phase: chalk.magenta("STEERING"),
-        barPct: runInfo.sessionsBudget > 0 ? totalUsed / runInfo.sessionsBudget : 0,
-        barLabel: `${totalUsed}/${runInfo.sessionsBudget}`,
-        active: 0, queued: 0,
-        startedAt: runInfo.startedAt,
-        totalIn: runInfo.accIn, totalOut: runInfo.accOut, totalCost: runInfo.accCost,
-        waveNum: runInfo.waveNum,
-        sessionsUsed: totalUsed, sessionsBudget: runInfo.sessionsBudget, remaining: runInfo.remaining,
-    });
-    const rl = rlGetter?.();
-    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(-15);
-    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 });
-            // Tool-use events with target get a secondary detail line
-            const arrowIdx = e.text.indexOf(" \u2192 ");
-            if (arrowIdx > 0 && arrowIdx < 30) {
-                const toolName = e.text.slice(0, arrowIdx);
-                const target = e.text.slice(arrowIdx + 3);
-                out.push(chalk.gray(`  ${t} `) + chalk.magenta("[plan] ") + chalk.yellow(toolName));
-                out.push(chalk.dim(`      ${truncate(target, w - 10)}`));
+    const content = {
+        sections() {
+            const secs = [];
+            const ww = Math.max((process.stdout.columns ?? 80) || 80, 60);
+            // Objective (undecorated — raw line)
+            if (ctx?.objective) {
+                const obj = ctx.objective.replace(/\s+/g, " ").trim();
+                secs.push({ title: "", rows: [
+                        `  ${chalk.bold.white("Objective")}  ${chalk.dim(truncate(obj, ww - 15))}`,
+                        "",
+                    ] });
+            }
+            // Status (decorated via renderStatusBlock)
+            if (ctx?.status) {
+                const statusRows = [];
+                renderStatusBlock(statusRows, ww, ctx.status);
+                if (statusRows.length > 0) {
+                    statusRows.push("");
+                    secs.push({ title: "", rows: statusRows });
+                }
+            }
+            // Last wave (decorated via renderLastWave)
+            if (ctx?.lastWave && ctx.lastWave.tasks.length > 0) {
+                const lwRows = [];
+                renderLastWave(lwRows, ww, ctx.lastWave);
+                lwRows.push("");
+                secs.push({ title: "", rows: lwRows });
+            }
+            // Planner activity (decorated)
+            const plannerRows = [];
+            const events = data.events.slice(-15);
+            if (events.length === 0) {
+                plannerRows.push(chalk.dim("  (waiting for planner\u2026)"));
             }
             else {
-                out.push(chalk.gray(`  ${t} `) + chalk.magenta("[plan] ") + colorEvent(truncate(e.text, w - 22)));
+                for (const e of events) {
+                    const t = new Date(e.time).toLocaleTimeString("en", { hour12: false });
+                    const arrowIdx = e.text.indexOf(" \u2192 ");
+                    if (arrowIdx > 0 && arrowIdx < 30) {
+                        const toolName = e.text.slice(0, arrowIdx);
+                        const target = e.text.slice(arrowIdx + 3);
+                        plannerRows.push(chalk.gray(`  ${t} `) + chalk.magenta("[plan] ") + chalk.yellow(toolName));
+                        plannerRows.push(chalk.dim(`      ${truncate(target, ww - 10)}`));
+                    }
+                    else {
+                        plannerRows.push(chalk.gray(`  ${t} `) + chalk.magenta("[plan] ") + colorEvent(truncate(e.text, ww - 22)));
+                    }
+                }
+            }
+            secs.push({ title: "Planner activity", rows: plannerRows });
+            // Status line (undecorated)
+            const liveClean = data.statusLine.replace(/\n/g, " ");
+            secs.push({ title: "", rows: [`  ${chalk.cyan("\u25B6")} ${chalk.dim(truncate(liveClean, ww - 6))}`] });
+            return secs;
+        },
+    };
+    // Usage bar
+    const usageBarRender = rlGetter
+        ? (out, w) => {
+            const rl = rlGetter();
+            if (rl && (rl.utilization > 0 || rl.windows.size > 0)) {
+                renderSteeringUsageBar(out, w, rl);
             }
         }
-    }
-    out.push("");
-    const liveClean = data.statusLine.replace(/\n/g, " ");
-    out.push(`  ${chalk.cyan("\u25B6")} ${chalk.dim(truncate(liveClean, w - 6))}`);
-    out.push("");
+        : undefined;
+    // Footer
+    let hotkeyRow;
     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);
+        hotkeyRow = chalk.dim("  [b] budget  [s] steer  [q] stop") + chip;
     }
-    out.push("");
-    return out.join("\n");
+    return renderUnifiedFrame({
+        model: runInfo.model,
+        phase: chalk.magenta(`STEERING \u2192 wave ${runInfo.waveNum + 2}`),
+        barPct: runInfo.sessionsBudget > 0 ? totalUsed / runInfo.sessionsBudget : 0,
+        barLabel: `${totalUsed}/${runInfo.sessionsBudget}`,
+        active: 0,
+        queued: 0,
+        startedAt: runInfo.startedAt,
+        totalIn: runInfo.accIn,
+        totalOut: runInfo.accOut,
+        totalCost: runInfo.accCost,
+        waveNum: runInfo.waveNum,
+        sessionsUsed: totalUsed,
+        sessionsBudget: runInfo.sessionsBudget,
+        remaining: runInfo.remaining,
+        usageBarRender,
+        content,
+        hotkeyRow,
+    });
 }
 export function renderSummary(swarm) {
     const w = Math.max((process.stdout.columns ?? 80) || 80, 60);

package/dist/run.js

@@ -205,8 +205,35 @@ export async function executeRun(cfg) {
     };
     process.on("SIGINT", gracefulStop);
     process.on("SIGTERM", gracefulStop);
-    process.on("uncaughtException", (err) => { currentSwarm?.abort(); currentSwarm?.cleanup(); display.stop(); restore(); console.error(chalk.red(`\n  Uncaught: ${err.message}`)); process.exit(1); });
-    process.on("unhandledRejection", (reason) => { currentSwarm?.abort(); currentSwarm?.cleanup(); display.stop(); restore(); console.error(chalk.red(`\n  Unhandled: ${reason instanceof Error ? reason.message : reason}`)); process.exit(1); });
+    const crashHandler = (label, detail) => {
+        // Save run state with currentTasks so resume can pick up where we left off.
+        try {
+            saveRunState(runDir, {
+                id: `run-${new Date().toISOString().slice(0, 19)}`, objective: objective ?? "", budget: cfg.budget,
+                remaining, workerModel, plannerModel,
+                workerProviderId: cfg.workerProvider?.id, plannerProviderId: cfg.plannerProvider?.id,
+                concurrency, permissionMode,
+                usageCap, allowExtraUsage: cfg.allowExtraUsage, extraUsageBudget: cfg.extraUsageBudget,
+                flex, useWorktrees, mergeStrategy, waveNum, currentTasks,
+                accCost, accCompleted, accFailed, accIn, accOut, accTools,
+                branches, phase: "stopped", startedAt: new Date(cfg.runStartedAt).toISOString(), cwd,
+            });
+        }
+        catch { }
+        // Save partial wave session if swarm was running.
+        if (currentSwarm?.agents.length) {
+            try {
+                saveWaveSession(runDir, waveNum, currentSwarm.agents, currentSwarm.totalCostUsd);
+            }
+            catch { }
+        }
+        display.stop();
+        restore();
+        console.error(chalk.red(`\n  ${label}: ${detail}`));
+        process.exit(1);
+    };
+    process.on("uncaughtException", (err) => { currentSwarm?.abort(); currentSwarm?.cleanup(); crashHandler("Uncaught", err instanceof Error ? err.message : String(err)); });
+    process.on("unhandledRejection", (reason) => { currentSwarm?.abort(); currentSwarm?.cleanup(); crashHandler("Unhandled", reason instanceof Error ? reason.message : String(reason)); });
     // Shared steering logic used by both resume-steering and in-loop steering
     const runSteering = async () => {
         let steered = false;
@@ -300,19 +327,33 @@ export async function executeRun(cfg) {
     while (runAnotherRound) {
         runAnotherRound = false;
         while (remaining > 0 && currentTasks.length > 0 && !stopping) {
+            // Health check: runs once per process start to fix a broken build before
+            // any real work begins. Only triggers when there's nothing else queued —
+            // it must NEVER override tasks that steering has already planned.
             if (!lastHealed) {
+                lastHealed = true;
+                // Only replace tasks with health fix if the queue was essentially empty.
+                // Steering-planned tasks always take priority.
                 const healTask = checkProjectHealth(cwd);
-                if (healTask && remaining > 0) {
-                    lastHealed = true;
+                if (healTask && remaining > 0 && currentTasks.length <= 1) {
                     currentTasks = [healTask];
                 }
             }
-            else {
-                lastHealed = false;
-            }
             if (currentTasks.length > remaining)
                 currentTasks = currentTasks.slice(0, remaining);
             syncRunInfo();
+            // Save run state BEFORE the swarm — if the process crashes mid-swarm,
+            // resume picks up currentTasks. This is the critical resilience checkpoint.
+            saveRunState(runDir, {
+                id: `run-${new Date().toISOString().slice(0, 19)}`, objective: objective ?? "", budget: cfg.budget,
+                remaining, workerModel, plannerModel,
+                workerProviderId: cfg.workerProvider?.id, plannerProviderId: cfg.plannerProvider?.id,
+                concurrency, permissionMode,
+                usageCap, allowExtraUsage: cfg.allowExtraUsage, extraUsageBudget: cfg.extraUsageBudget,
+                flex, useWorktrees, mergeStrategy, waveNum, currentTasks,
+                accCost, accCompleted, accFailed, accIn, accOut, accTools,
+                branches, phase: "steering", startedAt: new Date(cfg.runStartedAt).toISOString(), cwd,
+            });
             const swarm = new Swarm({
                 tasks: currentTasks, concurrency, cwd, model: workerModel, permissionMode, allowedTools,
                 useWorktrees, mergeStrategy: waveMerge, agentTimeoutMs: cfg.agentTimeoutMs,
@@ -332,6 +373,15 @@ export async function executeRun(cfg) {
                     console.error(chalk.red(`\n  Authentication failed — check your API key or run: claude auth\n`));
                     process.exit(1);
                 }
+                // Swarm crashed mid-execution — save partial results before propagating.
+                // The pre-swarm saveRunState already preserved currentTasks for resume.
+                // Also save the wave session with whatever agents completed.
+                if (swarm.agents.length > 0) {
+                    try {
+                        saveWaveSession(runDir, waveNum, swarm.agents, swarm.totalCostUsd);
+                    }
+                    catch { }
+                }
                 throw err;
             }
             display.pause();

package/dist/ui.d.ts

@@ -71,6 +71,7 @@ export declare class RunDisplay {
     private askTempFile?;
     /** ID of the agent whose detail panel is open; undefined = no detail shown. */
     private selectedAgentId?;
+    private navState;
     private onSteer?;
     private onAsk?;
     constructor(runInfo: RunInfo, liveConfig?: LiveConfig, callbacks?: {
@@ -87,6 +88,15 @@ export declare class RunDisplay {
     selectAgent(id: number): void;
     /** Clear the agent detail panel. */
     clearSelectedAgent(): void;
+    /** Arrow-key navigation dispatched by the demux in handleTyped(). */
+    navigate(direction: "up" | "down" | "left" | "right" | "enter"): boolean;
+    /** Get the agents visible in the table (running + last N finished). */
+    private getVisibleAgents;
+    /** Discover sections from the current render state for navigation boundaries. */
+    private getSections;
+    private clampNavState;
+    /** Returns the unique highlight key for the currently focused row, used by renderer. */
+    getHighlightKey(): string | undefined;
     private clearAskTempFile;
     /** Get the currently selected agent's ID for rendering. */
     getSelectedAgentId(): number | undefined;
@@ -112,7 +122,19 @@ export declare class RunDisplay {
     private setupHotkeys;
     /** Handle a pasted block. Returns true if the frame needs a redraw. */
     private handlePaste;
-    /** Handle a typed (non-pasted) chunk. Returns true if the frame needs a redraw. */
+    /** Handle a typed (non-pasted) chunk. Returns true if the frame needs a redraw.
+     *
+     * Demux pipeline — routes arrow keys and ESC BEFORE hotkey matching:
+     *   Raw stdin chunk → splitPaste
+     *     ├─ paste → handlePaste (existing, fine)
+     *     └─ typed → demux
+     *          ├─ ESC + [A/B/C/D  → this.navigate("up"/"down"/"right"/"left")
+     *          ├─ ESC             → cancel input / close detail / dismiss panel
+     *          ├─ Enter           → submit / reveal / select
+     *          ├─ Ctrl+C          → abort
+     *          ├─ Backspace       → delete
+     *          └─ printable       → hotkey matching (b, t, c, e, p, s, q, ?, d, 0-9)
+     */
     private handleTyped;
     private plainTick;
 }

package/dist/ui.js

@@ -31,6 +31,7 @@ export class RunDisplay {
     askTempFile;
     /** ID of the agent whose detail panel is open; undefined = no detail shown. */
     selectedAgentId;
+    navState = { focusSection: 0, focusRow: 0, scrollOffset: 0 };
     onSteer;
     onAsk;
     constructor(runInfo, liveConfig, callbacks) {
@@ -86,6 +87,160 @@ export class RunDisplay {
     }
     /** Clear the agent detail panel. */
     clearSelectedAgent() { this.selectedAgentId = undefined; }
+    /** Arrow-key navigation dispatched by the demux in handleTyped(). */
+    navigate(direction) {
+        const sections = this.getSections();
+        const nav = this.navState;
+        const section = sections[Math.min(nav.focusSection, sections.length - 1)];
+        let changed = false;
+        switch (direction) {
+            case "up":
+                if (nav.focusRow > 0) {
+                    nav.focusRow--;
+                    nav.scrollOffset = Math.max(0, nav.scrollOffset - 1);
+                    changed = true;
+                }
+                else if (nav.focusSection > 0) {
+                    nav.focusSection--;
+                    const prevSection = sections[nav.focusSection];
+                    nav.focusRow = Math.max(0, prevSection.rowCount - 1);
+                    changed = true;
+                }
+                break;
+            case "down":
+                if (nav.focusRow < section.rowCount - 1) {
+                    nav.focusRow++;
+                    changed = true;
+                }
+                else if (nav.focusSection < sections.length - 1) {
+                    nav.focusSection++;
+                    nav.focusRow = 0;
+                    changed = true;
+                }
+                break;
+            case "left":
+                if (this.selectedAgentId != null) {
+                    this.clearSelectedAgent();
+                    changed = true;
+                }
+                else if (nav.focusSection > 0) {
+                    nav.focusSection--;
+                    nav.focusRow = 0;
+                    changed = true;
+                }
+                break;
+            case "right":
+                if (this.swarm && this.selectedAgentId == null) {
+                    const agents = this.getVisibleAgents();
+                    const agent = agents[nav.focusRow];
+                    if (agent && agent.status === "running") {
+                        this.selectAgent(agent.id);
+                        changed = true;
+                    }
+                }
+                else if (nav.focusSection < sections.length - 1) {
+                    nav.focusSection++;
+                    nav.focusRow = 0;
+                    changed = true;
+                }
+                break;
+            case "enter":
+                if (this.swarm) {
+                    const agents = this.getVisibleAgents();
+                    const agent = agents[nav.focusRow];
+                    if (agent) {
+                        if (this.selectedAgentId === agent.id) {
+                            this.clearSelectedAgent();
+                        }
+                        else {
+                            this.selectAgent(agent.id);
+                        }
+                        changed = true;
+                    }
+                }
+                break;
+        }
+        this.clampNavState(sections);
+        return changed;
+    }
+    /** Get the agents visible in the table (running + last N finished). */
+    getVisibleAgents() {
+        if (!this.swarm)
+            return [];
+        const running = this.swarm.agents.filter(a => a.status === "running");
+        const finished = this.swarm.agents.filter(a => a.status !== "running");
+        const showFinished = finished.slice(-Math.max(2, 12 - running.length));
+        return [...running, ...showFinished];
+    }
+    /** Discover sections from the current render state for navigation boundaries. */
+    getSections() {
+        const sections = [];
+        if (this.swarm) {
+            // Agent table section
+            const show = this.getVisibleAgents();
+            sections.push({
+                title: "Agents",
+                rowCount: show.length,
+                highlightKeyForRow: (row) => show[row]?.id != null ? `agent-${show[row].id}` : undefined,
+            });
+            // Agent detail section
+            if (this.selectedAgentId != null) {
+                sections.push({
+                    title: "Detail",
+                    rowCount: 1,
+                    highlightKeyForRow: () => "detail",
+                });
+            }
+            // Merge results section
+            if (this.swarm.mergeResults.length > 0) {
+                sections.push({
+                    title: "Merges",
+                    rowCount: this.swarm.mergeResults.length,
+                    highlightKeyForRow: (row) => `merge-${row}`,
+                });
+            }
+            // Event log section
+            sections.push({
+                title: "Events",
+                rowCount: Math.min(12, this.swarm.logs.length),
+                highlightKeyForRow: (row) => `event-${row}`,
+            });
+        }
+        else if (this.steeringActive) {
+            // Steering mode sections
+            if (this.steeringContext?.objective) {
+                sections.push({ title: "Objective", rowCount: 1, highlightKeyForRow: () => "objective" });
+            }
+            if (this.steeringContext?.status) {
+                sections.push({ title: "Status", rowCount: 1, highlightKeyForRow: () => "status" });
+            }
+            if (this.steeringContext?.lastWave) {
+                sections.push({ title: "LastWave", rowCount: Math.min(6, this.steeringContext.lastWave.tasks.length + 1), highlightKeyForRow: (row) => `wave-task-${row}` });
+            }
+            sections.push({ title: "PlannerActivity", rowCount: Math.min(15, this.steeringEvents.length), highlightKeyForRow: (row) => `steer-event-${row}` });
+            sections.push({ title: "StatusLine", rowCount: 1, highlightKeyForRow: () => "status-line" });
+        }
+        // Ensure at least one section
+        if (sections.length === 0) {
+            sections.push({ title: "Content", rowCount: 1, highlightKeyForRow: () => "content" });
+        }
+        return sections;
+    }
+    clampNavState(sections) {
+        const nav = this.navState;
+        nav.focusSection = Math.min(Math.max(0, nav.focusSection), sections.length - 1);
+        const s = sections[nav.focusSection];
+        if (s) {
+            nav.focusRow = Math.min(Math.max(0, nav.focusRow), Math.max(0, s.rowCount - 1));
+        }
+    }
+    /** Returns the unique highlight key for the currently focused row, used by renderer. */
+    getHighlightKey() {
+        const sections = this.getSections();
+        const nav = this.navState;
+        const section = sections[Math.min(nav.focusSection, sections.length - 1)];
+        return section?.highlightKeyForRow?.(nav.focusRow);
+    }
     clearAskTempFile() {
         if (this.askTempFile) {
             try {
@@ -325,9 +480,62 @@ export class RunDisplay {
         }
         return false;
     }
-    /** Handle a typed (non-pasted) chunk. Returns true if the frame needs a redraw. */
+    /** Handle a typed (non-pasted) chunk. Returns true if the frame needs a redraw.
+     *
+     * Demux pipeline — routes arrow keys and ESC BEFORE hotkey matching:
+     *   Raw stdin chunk → splitPaste
+     *     ├─ paste → handlePaste (existing, fine)
+     *     └─ typed → demux
+     *          ├─ ESC + [A/B/C/D  → this.navigate("up"/"down"/"right"/"left")
+     *          ├─ ESC             → cancel input / close detail / dismiss panel
+     *          ├─ Enter           → submit / reveal / select
+     *          ├─ Ctrl+C          → abort
+     *          ├─ Backspace       → delete
+     *          └─ printable       → hotkey matching (b, t, c, e, p, s, q, ?, d, 0-9)
+     */
     handleTyped(s) {
         const lc = this.liveConfig;
+        // ── 1. Arrow keys: \x1B[A = up, \x1B[B = down, \x1B[C = right, \x1B[D = left ──
+        if (s.startsWith("\x1B[")) {
+            const dir = s[2];
+            if (dir === "A") {
+                this.navigate("up");
+                return true;
+            }
+            if (dir === "B") {
+                this.navigate("down");
+                return true;
+            }
+            if (dir === "C") {
+                this.navigate("right");
+                return true;
+            }
+            if (dir === "D") {
+                this.navigate("left");
+                return true;
+            }
+            // Other ANSI sequences — swallow silently
+            return true;
+        }
+        // ── 2. Standalone ESC ──
+        if (s === "\x1B") {
+            if (this.inputMode !== "none") {
+                this.inputMode = "none";
+                this.inputSegs = [];
+                return true;
+            }
+            if (this.selectedAgentId != null) {
+                this.clearSelectedAgent();
+                return true;
+            }
+            if (this.askState && !this.askState.streaming) {
+                this.askState = undefined;
+                this.clearAskTempFile();
+                return true;
+            }
+            return false;
+        }
+        // ── 3. Input mode: budget / threshold / concurrency / extra ──
         if (this.inputMode === "budget" || this.inputMode === "threshold" || this.inputMode === "concurrency" || this.inputMode === "extra") {
             let dirty = false;
             for (const ch of s) {
@@ -366,12 +574,6 @@ export class RunDisplay {
                     this.inputSegs = [];
                     return true;
                 }
-                // ESC cancels input mode
-                if (ch === "\x1B") {
-                    this.inputMode = "none";
-                    this.inputSegs = [];
-                    return true;
-                }
                 if (ch === "\x7F") {
                     backspaceSegments(this.inputSegs);
                     dirty = true;
@@ -384,6 +586,7 @@ export class RunDisplay {
             }
             return dirty;
         }
+        // ── 4. Input mode: steer / ask ──
         if (this.inputMode === "steer" || this.inputMode === "ask") {
             let dirty = false;
             for (let ci = 0; ci < s.length; ci++) {
@@ -406,18 +609,11 @@ export class RunDisplay {
                     this.inputSegs = [];
                     return true;
                 }
-                // ESC cancels — consume this byte and any following ANSI sequence bytes
+                // ESC cancels input mode (no ANSI-byte consumption loop — arrows arrive
+                // as "\x1B[A" in a single call and are caught by step 1 above)
                 if (ch === "\x1B") {
                     this.inputMode = "none";
                     this.inputSegs = [];
-                    // Skip any remaining ANSI sequence bytes (e.g. [A for arrow keys)
-                    while (ci + 1 < s.length) {
-                        const next = s[ci + 1];
-                        const nc = next.charCodeAt(0);
-                        ci++;
-                        if ((nc >= 0x40 && nc <= 0x7E) || nc === 0x7F)
-                            break; // final byte
-                    }
                     return true;
                 }
                 if (ch === "\x7F" || ch === "\b") {
@@ -427,9 +623,9 @@ export class RunDisplay {
                 }
                 const code = ch.charCodeAt(0);
                 if (code < 0x20)
-                    continue; // control chars
+                    continue;
                 if (code >= 0x7F && code < 0xA0)
-                    continue; // DEL + C1 controls
+                    continue;
                 if (code >= 0x20 && code <= 0x7E && segmentsToString(this.inputSegs).length < MAX_INPUT_LEN) {
                     appendCharToSegments(this.inputSegs, ch);
                     dirty = true;
@@ -437,16 +633,9 @@ export class RunDisplay {
             }
             return dirty;
         }
-        // Hotkey mode — only accept single printable ASCII characters
-        // Skip ESC and ANSI sequences entirely
-        if (s.length > 1 && (s[0] === "\x1B" || s.charCodeAt(0) < 0x20))
-            return false;
-        if (s.length !== 1)
-            return false;
-        const key = s[0];
-        const code = key.charCodeAt(0);
-        // Allow \r / \n through for Enter-to-reveal
-        if (code === 0x0D || code === 0x0A) {
+        // ── 5. Hotkey mode ──
+        // Enter
+        if (s === "\r" || s === "\n") {
             if (this.askTempFile) {
                 try {
                     execSync(`open -R ${JSON.stringify(this.askTempFile)}`);
@@ -455,12 +644,21 @@ export class RunDisplay {
             }
             return true;
         }
-        // ESC clears ask answer panel when in hotkey mode (check before the control-char filter below)
-        if (key === "\x1B" && this.askState && !this.askState.streaming) {
-            this.askState = undefined;
-            this.clearAskTempFile();
-            return false;
+        // Ctrl+C
+        if (s === "\x03") {
+            if (this.swarm && !this.swarm.aborted) {
+                this.swarm.abort();
+            }
+            else {
+                process.exit(0);
+            }
+            return true;
         }
+        // Only single printable ASCII characters reach hotkey matching
+        if (s.length !== 1)
+            return false;
+        const key = s[0];
+        const code = key.charCodeAt(0);
         if (code < 0x20 || code > 0x7E)
             return false;
         if (key === "b" || key === "B") {
@@ -527,15 +725,7 @@ export class RunDisplay {
         }
         // [d] cycle agent detail panel
         if ((key === "d" || key === "D") && this.swarm && this.swarm.active > 0) {
-            if (this.selectedAgentId != null)
-                this.cycleSelectedAgent();
-            else
-                this.cycleSelectedAgent();
-            return true;
-        }
-        // ESC closes detail panel
-        if (key === "\x1B" && this.selectedAgentId != null) {
-            this.clearSelectedAgent();
+            this.cycleSelectedAgent();
             return true;
         }
         // Number keys 0-9 select a specific agent by row index in the visible table
@@ -547,7 +737,7 @@ export class RunDisplay {
                 return true;
             }
         }
-        if (key === "q" || key === "Q" || key === "\x03") {
+        if (key === "q" || key === "Q") {
             if (this.swarm) {
                 if (this.swarm.aborted)
                     process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.16.12",
+  "version": "1.16.15",
   "description": "Background lane for your Claude Max plan. Parallel Claude Agent SDK sessions in git worktrees with a usage cap that reserves headroom for your interactive Claude Code. Crash-safe resume. Opus/Sonnet/Haiku + Qwen/OpenRouter.",
   "type": "module",
   "bin": {
@@ -10,6 +10,7 @@
     "build": "tsc",
     "dev": "tsc --watch",
     "start": "node dist/bin.js",
+    "test": "node --test dist/__tests__/*.test.js",
     "prepublishOnly": "node scripts/sync-plugin-version.js"
   },
   "dependencies": {
@@ -18,6 +19,8 @@
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
+    "node-pty": "^1.1.0",
+    "strip-ansi": "^7.1.0",
     "typescript": "^5.7.0"
   },
   "license": "MIT",