claude-overnight 1.16.11 → 1.16.15

package/README.md

@@ -8,13 +8,38 @@ Isolated by default. Every agent runs in its own git worktree on its own branch,
 
 Different shape from hosted agent harnesses like [Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview): instead of one agent in one cloud container billed separately, you get many parallel sessions on your own machine, in your real repo, against your own Max plan (or API key). Works with Claude Opus, Sonnet, and Haiku — or pair an Anthropic planner with a cheaper executor on Qwen, OpenRouter, or any Anthropic-compatible endpoint.
 
+## Run on Qwen 3.6 Plus
+
+Hit your Claude Max plan limits? Running on a tight budget? Qwen 3.6 Plus via Alibaba Cloud's DashScope gateway is a drop-in executor that speaks the Anthropic Messages API — same client, same flow, pennies per run.
+
+1. **Get an API key.** Sign up at [Alibaba Cloud](https://account.alibabacloud.com/login/login.htm?oauth_callback=https%3A%2F%2Fmodelstudio.console.alibabacloud.com%2Fap-southeast-1%3Ftab%3Ddashboard%23%2Fapi-key&clearRedirectCookie=1) — the link takes you straight to the API key dashboard.
+2. **Configure the provider.** Run `claude-overnight`, choose `Other…` on the executor step, and fill in:
+
+   | Field | Value |
+   |---|---|
+   | Name | `Qwen 3.6 Plus` |
+   | Base URL | `https://dashscope-intl.aliyuncs.com/apps/anthropic` |
+   | Model id | `qwen3.6-plus` |
+   | API key | your DashScope key |
+
+3. That's it. Planner runs on Sonnet (or Opus), executor runs on Qwen.
+
+Or set it via env directly:
+
+```bash
+export ANTHROPIC_BASE_URL="https://dashscope-intl.aliyuncs.com/apps/anthropic"
+export ANTHROPIC_API_KEY="sk-..."
+export ANTHROPIC_MODEL="qwen3.6-plus"
+claude-overnight
+```
+
 ## Install
 
 ```bash
 npm install -g claude-overnight
 ```
 
-Requires Node.js ≥ 20 and Claude authentication (`claude auth login` or `ANTHROPIC_API_KEY`).
+Requires Node.js ≥ 20 and Claude authentication (`claude auth login` or `ANTHROPIC_API_KEY`). No Anthropic plan or key? See **Run on Qwen 3.6 Plus** above — a cheap, drop-in alternative.
 
 ## Quick start
 
@@ -35,7 +60,7 @@ claude-overnight
   ● Opus — Opus 4.6 · Most capable
   ○ Sonnet — Sonnet 4.6 · Best for everyday tasks
 
-⑤ Executor model (what runs the tasks — Qwen/OpenRouter/etc via Other…):
+⑤ Executor model (what runs the tasks — Qwen 3.6 Plus / OpenRouter / etc via Other…):
   ● Sonnet — Sonnet 4.6 · Best for everyday tasks
   ○ Opus — Opus 4.6 · Most capable
   ○ Other… · custom OpenAI/Anthropic-compatible endpoint
@@ -232,14 +257,14 @@ Planner and executor are picked separately — pair Opus-on-Anthropic for the pl
 From the interactive picker, choose `Other…` on the planner or executor step:
 
 ```
-⑤ Executor model (what runs the tasks — Qwen/OpenRouter/etc via Other…):
+⑤ Executor model (what runs the tasks — Qwen 3.6 Plus / OpenRouter / etc via Other…):
   ○ Sonnet
   ○ Opus
   ● Other…
 
-  Name: Qwen Coder
-  Base URL: https://dashscope-intl.aliyuncs.com/api/v2/apps/claude-code-proxy
-  Model id: qwen3-coder-plus
+  Name: Qwen 3.6 Plus
+  Base URL: https://dashscope-intl.aliyuncs.com/apps/anthropic
+  Model id: qwen3.6-plus
   API key source:
     ● Paste key now        · stored plaintext in ~/.claude/claude-overnight/providers.json (0600)
     ○ Read from env var    · nothing written to disk
@@ -253,7 +278,7 @@ Saved providers live user-level at `~/.claude/claude-overnight/providers.json` (
 
 **Resume.** Provider ids are persisted in `run.json` and rehydrated on resume. If you deleted a provider between runs, resume refuses to start and tells you exactly which id is missing.
 
-**Non-interactive / CI.** `claude-overnight --model=qwen3-coder-plus` auto-resolves the model id to a saved provider — no separate `--provider` flag.
+**Non-interactive / CI.** `claude-overnight --model=qwen3.6-plus` auto-resolves the model id to a saved provider — no separate `--provider` flag.
 
 ## Spend caps and usage controls
 

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.11",
+  "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",