claude-overnight 1.16.12 → 1.16.16

package/QUICKSHEET_PLAYWRIGHT.md

@@ -0,0 +1,65 @@
+# Playwright Parallel Usage
+
+When running claude-overnight with parallel agents that use the Playwright MCP server, avoid lock conflicts and session cross-contamination.
+
+## Isolation Levels
+
+| Goal | Approach |
+|---|---|
+| Non-disruptive, no focus steal | Headless mode (default) |
+| Several agents in parallel, no shared cookies | Headless + each MCP server: `--isolated` (or `isolated: true`) |
+| Several agents, each with saved login | Headless + each MCP server: unique `userDataDir` or its own `--storage-state` file |
+| Anti-bot interception (CAPTCHA, Cloudflare) | Fall back to headed mode only when necessary |
+
+**Headless preferred by default.** Every headed browser launch becomes the foreground app on macOS, which is disruptive during long runs. Only fall back to headed when anti-bot detection (CAPTCHA, Cloudflare challenge, etc.) requires visible browser interaction.
+
+## MCP Server Configuration
+
+Add to your `settings.json` or `.claude/settings.local.json`:
+
+```json
+{
+  "mcpServers": {
+    "playwright-1": {
+      "command": "npx",
+      "args": ["@anthropic-ai/mcp-playwright@latest", "--isolated", "--headless"],
+      "env": {}
+    },
+    "playwright-2": {
+      "command": "npx",
+      "args": ["@anthropic-ai/mcp-playwright@latest", "--isolated", "--headless"],
+      "env": {}
+    }
+  }
+}
+```
+
+For saved logins, give each server its own `userDataDir`:
+
+```json
+{
+  "mcpServers": {
+    "playwright-agent-a": {
+      "command": "npx",
+      "args": ["@anthropic-ai/mcp-playwright@latest", "--headless", "--userDataDir", "/tmp/pw-agent-a"],
+      "env": {}
+    },
+    "playwright-agent-b": {
+      "command": "npx",
+      "args": ["@anthropic-ai/mcp-playwright@latest", "--headless", "--userDataDir", "/tmp/pw-agent-b"],
+      "env": {}
+    }
+  }
+}
+```
+
+## Context7 Documentation
+
+For the latest Playwright API docs and patterns:
+
+```bash
+npx ctx7@latest library playwright "parallel browser instances isolation"
+npx ctx7@latest docs <libraryId> "parallel browser instances"
+```
+
+**Note:** ctx7 requires authentication (`npx ctx7@latest login` or `CONTEXT7_API_KEY` env var). If unauthenticated, lookups will fail — agents should fall back to training data.

package/README.md

@@ -280,6 +280,36 @@ Saved providers live user-level at `~/.claude/claude-overnight/providers.json` (
 
 **Non-interactive / CI.** `claude-overnight --model=qwen3.6-plus` auto-resolves the model id to a saved provider — no separate `--provider` flag.
 
+## Parallel Playwright Testing
+
+When agents use the Playwright MCP server for testing, parallel instances conflict on browser locks and cookie state. Add multiple MCP entries to `settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "playwright-1": {
+      "command": "npx",
+      "args": ["@anthropic-ai/mcp-playwright@latest", "--isolated", "--headless"]
+    },
+    "playwright-2": {
+      "command": "npx",
+      "args": ["@anthropic-ai/mcp-playwright@latest", "--isolated", "--headless"]
+    }
+  }
+}
+```
+
+**Isolation levels:**
+
+| Goal | Approach |
+|---|---|
+| Non-disruptive, no focus steal | Headless mode (default) |
+| Parallel agents, no shared cookies | Headless + `--isolated` per MCP server |
+| Parallel agents, each with saved login | Headless + unique `userDataDir` or `--storage-state` per server |
+| Anti-bot interception (CAPTCHA, Cloudflare) | Drop `--headless` only when necessary |
+
+See `QUICKSHEET_PLAYWRIGHT.md` for full config examples.
+
 ## Spend caps and usage controls
 
 ### Extra usage protection

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.16",
   "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",
@@ -65,6 +68,8 @@
   "files": [
     "dist",
     "!dist/__tests__",
+    "plugins",
+    "QUICKSHEET_PLAYWRIGHT.md",
     "README.md",
     "LICENSE"
   ]

package/plugins/claude-overnight/.claude-plugin/plugin.json

@@ -0,0 +1,10 @@
+{
+  "name": "claude-overnight",
+  "version": "1.16.16",
+  "description": "Claude Code skill for understanding, installing, and inspecting claude-overnight runs — parallel Claude agents in git worktrees with thinking waves, multi-wave steering, and crash-safe resume.",
+  "author": {
+    "name": "Francesco Fornace"
+  },
+  "homepage": "https://github.com/Fornace/claude-overnight",
+  "license": "MIT"
+}

package/plugins/claude-overnight/skills/claude-overnight/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: claude-overnight
+description: >
+  Understand, install, and inspect claude-overnight runs — a CLI that
+  launches parallel Claude agents in git worktrees with thinking waves,
+  multi-wave steering, and crash-safe resume. Use when the user mentions
+  claude-overnight, a `.claude-overnight/` folder, an "overnight" or
+  "swarm" run, or asks to check status / resume / continue a
+  multi-phase plan. Not for Vercel Workflow DevKit.
+---
+
+# What it is
+
+`claude-overnight` is a CLI (npm: `claude-overnight`, bin: `claude-overnight`) that takes an objective + budget and launches many Claude agent sessions in parallel, each in an isolated git worktree. It's a local multi-session orchestrator built on top of the Claude Agent SDK — not itself an agent harness, but a layer that plans, dispatches, and steers many sessions that run on the SDK's harness. A "thinking wave" of architect sessions explores the codebase, an orchestrator synthesizes concrete tasks, executor waves run them in parallel, and steering decides between more execution, reflection, or declaring done. Rate limits, crashes, and usage caps are all resumable — nothing is lost.
+
+Repo: https://github.com/Fornace/claude-overnight
+
+# Install / run
+
+```bash
+npm install -g claude-overnight      # Node >= 20; needs Claude auth or ANTHROPIC_API_KEY (or Qwen 3.6 Plus — see repo README)
+claude-overnight                      # interactive in cwd
+claude-overnight tasks.json           # task file mode
+claude-overnight "task a" "task b"    # inline
+```
+
+Common flags: `--budget=N`, `--concurrency=N`, `--model=<name>`, `--usage-cap=N`, `--allow-extra-usage`, `--extra-usage-budget=N`, `--timeout=SECONDS`, `--no-flex`, `--dry-run`.
+
+Live keys while running: `b` change budget · `t` change usage cap · `q` graceful stop (twice = force).
+
+Exit codes: `0` all ok · `1` some failed · `2` all/none.
+
+# On-disk layout (this is how you inspect status)
+
+Every run lives at `<repo>/.claude-overnight/runs/<ISO-timestamp>/`:
+
+| File / dir           | What it tells you                                                                 |
+|----------------------|-----------------------------------------------------------------------------------|
+| `run.json`           | Machine state: objective, model, budget, cost, waves done, branches, done flag.   |
+| `status.md`          | **Living project snapshot**, rewritten by steering every wave. First line = short status. |
+| `goal.md`            | Evolving "north star" — what the run currently thinks "amazing" means.            |
+| `milestones/*.md`    | Strategic snapshots archived ~every 5 waves. Long-term memory of the run.         |
+| `designs/*.md`       | Architect outputs from the thinking wave. Deleted once the objective is complete. |
+| `sessions/wave-N.json` | Per-wave agent records: prompt, status, cost, files changed, branch, error.    |
+
+The newest subfolder under `runs/` is the current/last run. A run that never reached "done" is **resumable** — `run.json` will not be marked complete and `designs/` may still be present.
+
+To assess status of a run from scratch, read in this order: `goal.md` → `status.md` → newest file in `milestones/` → newest `sessions/wave-*.json` → `run.json`. Five reads and you know exactly where it stands.
+
+**Durable run history (committed, survives cleanup):** `claude-overnight.log.md` at the repo root is updated on every run with a block per run ID — original objective, start/finish times, cost, outcome, branch. If the user asks "what was my prompt" or "what did last night's run do" and `.claude-overnight/runs/` is empty, this file is the canonical recovery path.
+
+# Resume / continue
+
+Just run `claude-overnight` again in the same repo. It auto-detects the unfinished run and shows a **Resume / Fresh / Quit** prompt. On resume: unmerged `swarm/task-*` branches auto-merge, the wave loop continues, status/goal/milestones/designs are preserved. If orchestration crashed after the thinking wave, surviving `designs/*.md` are reused — no re-paying for architects.
+
+For **multi-phase plans** (task file with `objective` + `flexiblePlan: true`), resuming picks up at the next wave with full steering context. Don't hand-edit `run.json` to "fix" a stuck run unless something is demonstrably corrupt — prefer re-running and letting steering re-assess.
+
+Merged branches from prior runs are not re-run. Knowledge carries forward across runs: new runs see what completed runs built.
+
+# Diagnosing a stuck / failed run
+
+1. Read `status.md` (living snapshot) and the newest `sessions/wave-*.json`.
+2. Check for `swarm/task-*` branches left behind (`git branch --list 'swarm/*'`) — these are unmerged worktree outputs, usually from a conflict or crash.
+3. Look at `run.json` for `done`, `lastError`, usage/cost fields.
+4. If the thinking wave succeeded but orchestration crashed, `designs/` will still contain the architect docs — a resume will reuse them.
+5. If rate-limited, the tool waits and retries on its own — do not kill it unless the user asks.
+
+# What NOT to do
+
+- Don't micromanage the tool. It has its own planner, steering, and goal refinement — trust them.
+- Don't invent a resume procedure. The CLI handles resume itself; the correct action is almost always "re-run `claude-overnight` in the repo".
+- Don't delete `.claude-overnight/` to "clean up" — it holds the only record of what the run learned. It should be in `.gitignore`.
+- Don't truncate or summarize agent output files when reading them back — never discard expensive agent output.
+- Don't confuse this with Vercel Workflow DevKit — unrelated despite the word "workflow".
+
+# Playwright Parallel Usage
+
+When agents use the Playwright MCP server for testing, parallel instances conflict on browser locks and cookie state. See `QUICKSHEET_PLAYWRIGHT.md` at the repo root for the full reference.
+
+**Quick rules:**
+- **Headless by default** — prevents focus stealing on macOS. Only use headed when anti-bot detection (CAPTCHA, Cloudflare) forces it
+- **Isolated agents (no login):** Each MCP server needs `--isolated --headless`
+- **Isolated agents (with saved login):** Each needs its own `userDataDir` or `--storage-state` file, plus `--headless`
+- Multiple MCP entries in `settings.json` — one per concurrency slot, or use a single `--isolated` entry if cookies don't need to persist
+
+**Context7 (ctx7) docs:** Requires authentication (`npx ctx7@latest login` or `CONTEXT7_API_KEY`). Pre-flight check:
+
+```bash
+npx ctx7@latest library playwright "parallel browser instances"
+```
+
+If this fails with a quota/auth error, fall back to training data — don't block the run.