claude-overnight 1.10.0 → 1.11.2

package/dist/cli.js

@@ -6,8 +6,8 @@ import chalk from "chalk";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 // ── CLI flag parsing ──
 export function parseCliFlags(argv) {
-    const known = new Set(["concurrency", "model", "timeout", "budget", "usage-cap", "extra-usage-budget"]);
-    const booleans = new Set(["--dry-run", "-h", "--help", "-v", "--version", "--no-flex", "--allow-extra-usage"]);
+    const known = new Set(["concurrency", "model", "timeout", "budget", "usage-cap", "extra-usage-budget", "merge", "perm"]);
+    const booleans = new Set(["--dry-run", "-h", "--help", "-v", "--version", "--no-flex", "--allow-extra-usage", "--worktrees", "--no-worktrees", "--yolo"]);
     const flags = {};
     const positional = [];
     for (let i = 0; i < argv.length; i++) {

package/dist/index.js

@@ -42,6 +42,11 @@ async function main() {
     --extra-usage-budget=N Max $ for extra usage ${chalk.dim("(implies --allow-extra-usage)")}
     --timeout=SECONDS      Agent inactivity timeout ${chalk.dim("(default: 900s, nudges at timeout, kills at 2×)")}
     --no-flex              Disable adaptive multi-wave planning ${chalk.dim("(run all tasks in one shot)")}
+    --worktrees            Force worktree isolation on ${chalk.dim("(default: auto-detect git repo)")}
+    --no-worktrees         Disable worktree isolation ${chalk.dim("(all agents work in real cwd)")}
+    --merge=MODE           Merge strategy: yolo or branch ${chalk.dim("(default: yolo)")}
+    --perm=MODE            Permission mode: auto, bypassPermissions, default ${chalk.dim("(default: auto)")}
+    --yolo                 Shorthand for --perm=bypassPermissions --no-worktrees
 
   ${chalk.cyan("Defaults")} ${chalk.dim("(non-interactive)")}
     model: first available    concurrency: 5    worktrees: auto    merge: yolo    perms: auto
@@ -251,6 +256,9 @@ async function main() {
     let usageCap;
     let allowExtraUsage = false;
     let extraUsageBudget;
+    let permissionMode = "auto";
+    let useWorktrees = false;
+    let mergeStrategy = "yolo";
     if (resuming) {
         workerModel = resumeState.workerModel;
         plannerModel = resumeState.plannerModel;
@@ -260,6 +268,9 @@ async function main() {
         usageCap = resumeState.usageCap;
         allowExtraUsage = resumeState.allowExtraUsage ?? false;
         extraUsageBudget = resumeState.extraUsageBudget;
+        permissionMode = resumeState.permissionMode;
+        useWorktrees = resumeState.useWorktrees;
+        mergeStrategy = resumeState.mergeStrategy;
     }
     else if (!nonInteractive) {
         while (true) {
@@ -279,6 +290,17 @@ async function main() {
             console.error(chalk.red(`  Budget must be a positive number`));
             process.exit(1);
         }
+        // ③ Max concurrency (skip if --concurrency set)
+        if (cliFlags.concurrency) {
+            concurrency = parseInt(cliFlags.concurrency);
+        }
+        else {
+            const defaultC = Math.min(5, budget);
+            const concAns = await ask(`\n  ${chalk.cyan("③")} ${chalk.dim("Max concurrency")} ${chalk.dim("[")}${chalk.white(String(defaultC))}${chalk.dim("]:")} `);
+            concurrency = parseInt(concAns) || defaultC;
+            if (concurrency < 1)
+                concurrency = 1;
+        }
         let modelFrame = 0;
         const modelSpinner = setInterval(() => {
             process.stdout.write(`\x1B[2K\r  ${chalk.cyan(BRAILLE[modelFrame++ % BRAILLE.length])} ${chalk.dim("loading models...")}`);
@@ -293,19 +315,19 @@ async function main() {
         }
         plannerModel = models[0]?.value || "claude-sonnet-4-6";
         if (models.length > 0) {
-            workerModel = await select(`${chalk.cyan("③")} Worker model:`, models.map(m => ({ name: m.displayName, value: m.value, hint: m.description })));
+            workerModel = await select(`${chalk.cyan("④")} Worker model:`, models.map(m => ({ name: m.displayName, value: m.value, hint: m.description })));
         }
         else {
-            const ans = await ask(`  ${chalk.cyan("③")} ${chalk.dim("Worker model [claude-sonnet-4-6]:")} `);
+            const ans = await ask(`  ${chalk.cyan("④")} ${chalk.dim("Worker model [claude-sonnet-4-6]:")} `);
             workerModel = ans || "claude-sonnet-4-6";
         }
-        usageCap = await select(`${chalk.cyan("④")} Usage cap:`, [
+        usageCap = await select(`${chalk.cyan("⑤")} Usage cap:`, [
             { name: "Unlimited", value: undefined, hint: "full capacity, wait through rate limits" },
             { name: "90%", value: 0.9, hint: "leave 10% for other work" },
             { name: "75%", value: 0.75, hint: "conservative, plenty of headroom" },
             { name: "50%", value: 0.5, hint: "use half, keep the rest" },
         ]);
-        const extraChoice = await select(`${chalk.cyan("⑤")} Allow extra usage ${chalk.dim("(billed separately)")}:`, [
+        const extraChoice = await select(`${chalk.cyan("⑥")} Allow extra usage ${chalk.dim("(billed separately)")}:`, [
             { name: "No", value: "no", hint: "stop when plan limits are reached" },
             { name: "Yes, with $ limit", value: "budget", hint: "set a spending cap" },
             { name: "Yes, unlimited", value: "unlimited", hint: "keep going no matter what" },
@@ -319,7 +341,44 @@ async function main() {
         }
         else if (extraChoice === "unlimited")
             allowExtraUsage = true;
-        concurrency = Math.min(5, budget);
+        // ⑦ Permission mode (skip if --yolo or --perm set)
+        const cliYolo = argv.includes("--yolo");
+        if (cliFlags.perm) {
+            permissionMode = cliFlags.perm;
+        }
+        else if (cliYolo) {
+            permissionMode = "bypassPermissions";
+        }
+        else {
+            permissionMode = await select(`${chalk.cyan("⑦")} Permissions:`, [
+                { name: "Auto", value: "auto", hint: "accept low-risk, reject high-risk" },
+                { name: "Bypass all", value: "bypassPermissions", hint: "agents can run anything (yolo)" },
+                { name: "Prompt each", value: "default", hint: "ask for every dangerous op" },
+            ]);
+        }
+        // ⑧ Worktrees + merge (skip if --yolo, --worktrees, --no-worktrees, or --merge set)
+        const gitRepo = isGitRepo(cwd);
+        if (cliYolo || argv.includes("--no-worktrees")) {
+            useWorktrees = false;
+            mergeStrategy = cliFlags.merge || "yolo";
+        }
+        else if (argv.includes("--worktrees")) {
+            useWorktrees = true;
+            mergeStrategy = cliFlags.merge || "yolo";
+        }
+        else if (gitRepo) {
+            const wtChoice = await select(`${chalk.cyan("⑧")} Git isolation:`, [
+                { name: "Worktrees + yolo merge", value: "wt-yolo", hint: "isolate agents, merge into current branch" },
+                { name: "Worktrees + new branch", value: "wt-branch", hint: "isolate agents, merge into a new branch" },
+                { name: "No worktrees", value: "no-wt", hint: "all agents share the working directory" },
+            ]);
+            useWorktrees = wtChoice !== "no-wt";
+            mergeStrategy = wtChoice === "wt-branch" ? "branch" : "yolo";
+        }
+        else {
+            useWorktrees = false;
+            mergeStrategy = "yolo";
+        }
         const parts = [];
         if (workerModel !== plannerModel)
             parts.push(`${detectModelTier(workerModel)} → ${detectModelTier(plannerModel)}`);
@@ -331,6 +390,12 @@ async function main() {
         if (usageCap != null)
             parts.push(`cap ${Math.round(usageCap * 100)}%`);
         parts.push(allowExtraUsage ? (extraUsageBudget ? `extra $${extraUsageBudget}` : "extra ∞") : "no extra");
+        if (permissionMode !== "auto")
+            parts.push(permissionMode === "bypassPermissions" ? "yolo" : "prompt");
+        if (useWorktrees)
+            parts.push(mergeStrategy === "branch" ? "wt→branch" : "wt→yolo");
+        else
+            parts.push("no wt");
         if (completedRuns.length > 0)
             parts.push(`${completedRuns.length} prior`);
         const inner = parts.join(chalk.dim(" · "));
@@ -375,11 +440,28 @@ async function main() {
         }
     }
     validateConcurrency(concurrency);
-    const permissionMode = resuming ? resumeState.permissionMode : (fileCfg?.permissionMode ?? "auto");
-    const useWorktrees = resuming ? resumeState.useWorktrees : (fileCfg?.useWorktrees ?? isGitRepo(cwd));
+    // Resolve permissionMode, useWorktrees, mergeStrategy for non-interactive + non-resume
+    if (!resuming && nonInteractive) {
+        const yolo = argv.includes("--yolo");
+        permissionMode = cliFlags.perm ? cliFlags.perm
+            : yolo ? "bypassPermissions"
+                : (fileCfg?.permissionMode ?? "auto");
+        if (!["auto", "bypassPermissions", "default"].includes(permissionMode)) {
+            console.error(chalk.red(`  --perm must be auto, bypassPermissions, or default (got ${permissionMode})`));
+            process.exit(1);
+        }
+        useWorktrees = argv.includes("--no-worktrees") || yolo ? false
+            : argv.includes("--worktrees") ? true
+                : (fileCfg?.useWorktrees ?? isGitRepo(cwd));
+        mergeStrategy = cliFlags.merge ? cliFlags.merge
+            : (fileCfg?.mergeStrategy ?? "yolo");
+        if (!["yolo", "branch"].includes(mergeStrategy)) {
+            console.error(chalk.red(`  --merge must be yolo or branch (got ${mergeStrategy})`));
+            process.exit(1);
+        }
+    }
     if (useWorktrees)
         validateGitRepo(cwd);
-    const mergeStrategy = resuming ? resumeState.mergeStrategy : (fileCfg?.mergeStrategy ?? "yolo");
     if (nonInteractive) {
         const capStr = usageCap != null ? `  cap=${Math.round(usageCap * 100)}%` : "";
         const extraStr = allowExtraUsage ? (extraUsageBudget ? `  extra=$${extraUsageBudget}` : "  extra=∞") : "  extra=off";
@@ -416,7 +498,7 @@ async function main() {
                     for (let i = 0; i < themes.length; i++)
                         console.log(chalk.dim(`  ${String(i + 1).padStart(3)}.`) + ` ${themes[i]}`);
                     console.log(chalk.dim(`\n  ${thinkingCount} thinking agents → orchestrate → ${(budget ?? 10) - thinkingCount} execution sessions\n`));
-                    const action = await selectKey(`${chalk.white(`${themes.length} themes`)} ${chalk.dim(`· ${thinkingCount} thinking · ${concurrency} concurrent`)}`, [{ key: "r", desc: "un" }, { key: "e", desc: "dit" }, { key: "q", desc: "uit" }]);
+                    const action = await selectKey(`${chalk.white(`${themes.length} themes`)} ${chalk.dim(`· ${thinkingCount} thinking · ${concurrency} concurrent`)}`, [{ key: "r", desc: "un" }, { key: "e", desc: "dit" }, { key: "c", desc: "hat" }, { key: "q", desc: "uit" }]);
                     if (action === "r") {
                         reviewing = false;
                         break;
@@ -435,6 +517,28 @@ async function main() {
                         }
                         planRestore();
                     }
+                    else if (action === "c") {
+                        const question = await ask(`\n  ${chalk.bold("Ask about the themes:")}\n  ${chalk.cyan(">")} `);
+                        if (!question)
+                            continue;
+                        process.stdout.write("\x1B[?25l");
+                        try {
+                            let answer = "";
+                            for await (const msg of query({
+                                prompt: `You're planning work for: "${objective}"\n\nThemes identified:\n${themes.map((t, i) => `${i + 1}. ${t}`).join("\n")}\n\nUser question: ${question}`,
+                                options: { cwd, model: plannerModel, permissionMode, persistSession: false },
+                            })) {
+                                if (msg.type === "result" && msg.subtype === "success")
+                                    answer = msg.result || "";
+                            }
+                            planRestore();
+                            if (answer)
+                                console.log(chalk.dim(`\n  ${answer.slice(0, 500)}\n`));
+                        }
+                        catch {
+                            planRestore();
+                        }
+                    }
                     else {
                         console.log(chalk.dim("\n  Aborted.\n"));
                         process.exit(0);

package/dist/render.js

@@ -183,7 +183,8 @@ export function renderFrame(swarm, showHotkeys, runInfo) {
     if (showHotkeys) {
         const pending = runInfo?.pendingSteer ?? 0;
         const chip = pending > 0 ? chalk.cyan(`  \u270E ${pending} steer queued`) : "";
-        out.push(chalk.dim("  [b] budget  [t] threshold  [s] steer  [?] ask  [q] stop") + chip);
+        const fixChip = swarm.failed > 0 && swarm.active > 0 ? chalk.yellow("  [f] fix") : "";
+        out.push(chalk.dim("  [b] budget  [t] threshold  [s] steer  [?] ask  [q] stop") + fixChip + chip);
     }
     out.push("");
     return out.join("\n");

package/dist/run.js

@@ -30,7 +30,7 @@ export async function executeRun(cfg) {
     const waveHistory = [];
     let accCost, accCompleted, accFailed, accTools;
     let accIn = 0, accOut = 0;
-    let lastCapped = false, lastAborted = false, objectiveComplete = false;
+    let lastCapped = false, lastAborted = false, objectiveComplete = false, lastHealed = false;
     const branches = [];
     if (cfg.resuming && cfg.resumeState) {
         const rs = cfg.resumeState;
@@ -161,7 +161,6 @@ export async function executeRun(cfg) {
     }
     const waveMerge = (flex && runBranch) ? "yolo" : mergeStrategy;
     let stopping = false;
-    let steeringFailed = false;
     const gracefulStop = () => {
         if (stopping) {
             currentSwarm?.cleanup();
@@ -236,9 +235,17 @@ export async function executeRun(cfg) {
                     display.appendSteeringEvent(`Steering failed (attempt ${steerAttempts}/3) — retrying...`);
                     continue;
                 }
-                display.stop();
-                console.log(chalk.yellow(`  Steering failed after ${steerAttempts} attempts: ${err.message?.slice(0, 80)} — stopping\n`));
-                steeringFailed = true;
+                display.appendSteeringEvent(`Steering failed ${steerAttempts}× — falling back`);
+                let fallbackStatus = "";
+                try {
+                    fallbackStatus = readFileSync(join(runDir, "status.md"), "utf-8");
+                }
+                catch { }
+                currentTasks = [{
+                        id: "fallback-0",
+                        prompt: `Steering couldn't decide the next step. Read the project, assess what's done vs. remaining, and do the most impactful work.\n\nObjective: ${objective}${fallbackStatus ? `\n\nStatus:\n${fallbackStatus}` : ""}`,
+                    }];
+                steered = true;
                 break;
             }
         }
@@ -256,6 +263,16 @@ export async function executeRun(cfg) {
     display.start();
     // ── Main wave loop ──
     while (remaining > 0 && currentTasks.length > 0 && !stopping) {
+        if (!lastHealed) {
+            const healTask = checkProjectHealth(cwd);
+            if (healTask && remaining > 0) {
+                lastHealed = true;
+                currentTasks = [healTask];
+            }
+        }
+        else {
+            lastHealed = false;
+        }
         if (currentTasks.length > remaining)
             currentTasks = currentTasks.slice(0, remaining);
         syncRunInfo();
@@ -329,7 +346,7 @@ export async function executeRun(cfg) {
     // ── Finalize ──
     const trulyDone = objectiveComplete || (!flex && remaining <= 0);
     const wasCapped = lastCapped || lastAborted;
-    const finalPhase = trulyDone ? "done" : steeringFailed ? "steering" : wasCapped ? "capped" : remaining <= 0 ? "capped" : "stopped";
+    const finalPhase = trulyDone ? "done" : wasCapped ? "capped" : remaining <= 0 ? "capped" : "stopped";
     saveRunState(runDir, {
         id: `run-${new Date().toISOString().slice(0, 19)}`, objective: objective ?? "", budget: cfg.budget,
         remaining, workerModel, plannerModel, concurrency, permissionMode,
@@ -370,8 +387,6 @@ export async function executeRun(cfg) {
     console.log(chalk.green(`  ${bannerChar.repeat(Math.min(termW - 4, 60))}`));
     if (trulyDone)
         console.log(chalk.bold.green(`  CLAUDE OVERNIGHT — COMPLETE`));
-    else if (steeringFailed)
-        console.log(chalk.bold.yellow(`  CLAUDE OVERNIGHT — STEERING FAILED`));
     else if (remaining <= 0)
         console.log(chalk.bold.yellow(`  CLAUDE OVERNIGHT — BUDGET EXHAUSTED`));
     else if (lastCapped)
@@ -426,3 +441,40 @@ export async function executeRun(cfg) {
     if (lastAborted || accCompleted === 0)
         process.exit(2);
 }
+function checkProjectHealth(cwd) {
+    let pkg;
+    try {
+        pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf-8"));
+    }
+    catch {
+        return undefined;
+    }
+    const scripts = pkg.scripts || {};
+    let scriptName;
+    for (const name of ["typecheck", "check:types", "type-check", "build"]) {
+        if (scripts[name]) {
+            scriptName = name;
+            break;
+        }
+    }
+    if (!scriptName)
+        return undefined;
+    const pm = existsSync(join(cwd, "pnpm-lock.yaml")) ? "pnpm"
+        : existsSync(join(cwd, "bun.lockb")) || existsSync(join(cwd, "bun.lock")) ? "bun"
+            : existsSync(join(cwd, "yarn.lock")) ? "yarn" : "npm";
+    const cmd = `${pm} run ${scriptName}`;
+    try {
+        execSync(cmd, { cwd, encoding: "utf-8", stdio: "pipe", timeout: 60_000 });
+        return undefined;
+    }
+    catch (err) {
+        if (err.killed)
+            return undefined;
+        const output = ((err.stdout || "") + "\n" + (err.stderr || "")).trim();
+        const trimmed = output.length > 4000 ? output.slice(0, 2000) + "\n…\n" + output.slice(-2000) : output;
+        return {
+            id: "heal-0",
+            prompt: `Fix the broken build. \`${cmd}\` fails after merging parallel work:\n\`\`\`\n${trimmed}\n\`\`\`\nFix every error. Run \`${cmd}\` when done to verify.`,
+        };
+    }
+}

package/dist/steering.js

@@ -26,11 +26,13 @@ export async function steerWave(objective, history, remainingBudget, cwd, planne
     const recentWaves = history.slice(-3);
     const recentText = recentWaves.length > 0 ? recentWaves.map(w => {
         const lines = w.tasks.map(t => {
-            const files = t.filesChanged ? ` (${t.filesChanged} files)` : "";
+            const files = t.filesChanged ? ` (${t.filesChanged} files)` : " (0 files)";
             const err = t.error ? ` — ${t.error}` : "";
             return `  - [${t.status}] ${t.prompt.slice(0, 120)}${files}${err}`;
         }).join("\n");
-        return `Wave ${w.wave + 1}:\n${lines}`;
+        const zeroChange = w.tasks.filter(t => t.status === "done" && !t.filesChanged).length;
+        const warn = zeroChange > w.tasks.length / 2 ? `\n  ⚠ ${zeroChange}/${w.tasks.length} agents changed 0 files — tasks may be mis-scoped or blocked` : "";
+        return `Wave ${w.wave + 1}:\n${lines}${warn}`;
     }).join("\n\n") : "(first wave)";
     const cap = (s, max) => s.length > max ? s.slice(0, max) + "\n...(truncated)" : s;
     const statusBlock = runMemory?.status ? `\nCurrent project status:\n${runMemory.status}\n` : "";

package/dist/swarm.d.ts

@@ -59,6 +59,8 @@ export declare class Swarm {
     get pending(): number;
     run(): Promise<void>;
     abort(): void;
+    /** Re-queue all errored agents' tasks for retry within this wave. */
+    requeueFailed(): number;
     logSequence: number;
     log(agentId: number, text: string): void;
     cleanup(): void;

package/dist/swarm.js

@@ -110,6 +110,21 @@ export class Swarm {
         this.activeQueries.forEach(q => q.close());
         this.activeQueries.clear();
     }
+    /** Re-queue all errored agents' tasks for retry within this wave. */
+    requeueFailed() {
+        const errored = this.agents.filter(a => a.status === "error");
+        if (errored.length === 0)
+            return 0;
+        for (const a of errored) {
+            this.queue.push(a.task);
+            a.status = "pending";
+            a.error = undefined;
+            a.finishedAt = undefined;
+        }
+        this.failed -= errored.length;
+        this.log(-1, `Re-queued ${errored.length} failed task(s)`);
+        return errored.length;
+    }
     logSequence = 0;
     log(agentId, text) {
         const entry = { time: Date.now(), agentId, text };
@@ -201,21 +216,39 @@ export class Swarm {
         this.agents.push(agent);
         let agentCwd = task.cwd || this.config.cwd;
         if (this.config.useWorktrees && this.worktreeBase && !task.noWorktree) {
-            try {
-                const branch = `swarm/task-${id}`;
-                const dir = join(this.worktreeBase, `agent-${id}`);
-                gitExec(`git worktree add -b "${branch}" "${dir}" HEAD`, this.config.cwd);
+            const branch = `swarm/task-${id}`;
+            const dir = join(this.worktreeBase, `agent-${id}`);
+            let worktreeOk = false;
+            for (let wt = 0; wt < 2 && !worktreeOk; wt++) {
+                try {
+                    gitExec(`git worktree add -b "${branch}" "${dir}" HEAD`, this.config.cwd);
+                    worktreeOk = true;
+                }
+                catch (e) {
+                    if (wt === 0) {
+                        this.log(id, `Worktree failed, cleaning up: ${e.message?.slice(0, 50)}`);
+                        try {
+                            gitExec(`git branch -D "${branch}"`, this.config.cwd);
+                        }
+                        catch { }
+                        try {
+                            rmSync(dir, { recursive: true, force: true });
+                        }
+                        catch { }
+                        try {
+                            gitExec("git worktree prune", this.config.cwd);
+                        }
+                        catch { }
+                    }
+                }
+            }
+            if (worktreeOk) {
                 agentCwd = dir;
                 agent.branch = branch;
                 this.log(id, `Worktree: ${branch}`);
             }
-            catch (e) {
-                this.log(id, `Worktree failed: ${e.message?.slice(0, 60)}`);
-                agent.status = "error";
-                agent.error = "worktree creation failed";
-                agent.finishedAt = Date.now();
-                this.failed++;
-                return;
+            else {
+                this.log(id, `Worktree failed after retry — running without isolation`);
             }
         }
         this.log(id, `Starting: ${task.prompt.slice(0, 60)}`);

package/dist/ui.d.ts

@@ -87,6 +87,8 @@ export declare class RunDisplay {
     resume(): void;
     stop(): void;
     private resumeInterval;
+    /** Write the full frame to stdout, clamped to terminal height. */
+    private flush;
     private render;
     private renderInputPrompt;
     private renderAskPanel;

package/dist/ui.js

@@ -112,15 +112,20 @@ export class RunDisplay {
         catch {
             return;
         }
-        this.interval = setInterval(() => {
-            try {
-                process.stdout.write("\x1B[H\x1B[J");
-                process.stdout.write(this.render());
-            }
-            catch {
-                this.pause();
-            }
-        }, 250);
+        this.interval = setInterval(() => this.flush(), 250);
+    }
+    /** Write the full frame to stdout, clamped to terminal height. */
+    flush() {
+        try {
+            const maxRows = (process.stdout.rows || 40) - 1;
+            const frame = this.render();
+            const lines = frame.split("\n");
+            process.stdout.write("\x1B[H\x1B[J");
+            process.stdout.write(lines.length > maxRows ? lines.slice(0, maxRows).join("\n") : frame);
+        }
+        catch {
+            this.pause();
+        }
     }
     render() {
         let frame = "";
@@ -223,6 +228,7 @@ export class RunDisplay {
                 else if (/^[0-9.]$/.test(s)) {
                     this.inputBuf += s;
                 }
+                this.flush();
                 return;
             }
             if (this.inputMode === "steer" || this.inputMode === "ask") {
@@ -238,11 +244,20 @@ export class RunDisplay {
                             else
                                 this.onSteer?.(text);
                         }
+                        this.flush();
                         return;
                     }
-                    if (ch === "\x1B" || ch === "\x03") {
+                    if (ch === "\x03") {
                         this.inputMode = "none";
                         this.inputBuf = "";
+                        this.flush();
+                        return;
+                    }
+                    // Ignore raw ESC only — let ANSI sequences (arrows etc.) fall through
+                    if (ch === "\x1B" && s.length === 1) {
+                        this.inputMode = "none";
+                        this.inputBuf = "";
+                        this.flush();
                         return;
                     }
                     if (ch === "\x7F" || ch === "\b") {
@@ -254,6 +269,12 @@ export class RunDisplay {
                         this.inputBuf += ch;
                     }
                 }
+                this.flush();
+                return;
+            }
+            // Dismiss completed ask panel on Escape
+            if (s === "\x1B" && this.askState && !this.askState.streaming) {
+                this.askState = undefined;
                 return;
             }
             if (s === "b" || s === "B") {
@@ -266,11 +287,19 @@ export class RunDisplay {
                     this.inputBuf = "";
                 }
             }
+            else if ((s === "f" || s === "F") && this.swarm && this.swarm.failed > 0 && this.swarm.active > 0) {
+                this.swarm.requeueFailed();
+            }
             else if ((s === "s" || s === "S") && this.onSteer) {
                 this.inputMode = "steer";
                 this.inputBuf = "";
             }
             else if (s === "?" && this.onAsk && this.swarm && !this.askBusy) {
+                // If ask panel is showing a completed answer, dismiss it instead of opening new
+                if (this.askState && !this.askState.streaming) {
+                    this.askState = undefined;
+                    return;
+                }
                 this.inputMode = "ask";
                 this.inputBuf = "";
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.10.0",
+  "version": "1.11.2",
   "description": "Run 10, 100, or 1000 Claude agents overnight. Parallel autonomous AI coding with thinking waves, iterative quality steering, crash recovery, and rate limit handling. Built on the Claude Agent SDK.",
   "type": "module",
   "bin": {