claude-overnight 1.11.9 → 1.11.12

package/dist/cli.d.ts

@@ -6,6 +6,33 @@ export declare function parseCliFlags(argv: string[]): {
 };
 export declare function isAuthError(err: unknown): boolean;
 export declare function fetchModels(timeoutMs?: number): Promise<ModelInfo[]>;
+export declare const PASTE_START = "\u001B[200~";
+export declare const PASTE_END = "\u001B[201~";
+export declare const PASTE_PLACEHOLDER_MAX = 80;
+export type InputSegment = {
+    type: "text";
+    content: string;
+} | {
+    type: "paste";
+    content: string;
+};
+/** Split a raw stdin chunk into typed and pasted segments. */
+export declare function splitPaste(chunk: string): Array<{
+    type: "typed" | "paste";
+    text: string;
+}>;
+export declare function segmentsToString(segs: InputSegment[]): string;
+export declare function renderSegments(segs: InputSegment[]): string;
+export declare function appendCharToSegments(segs: InputSegment[], ch: string): void;
+/** Appends a pasted block. Short single-line pastes inline as text; the rest become placeholders. */
+export declare function appendPasteToSegments(segs: InputSegment[], text: string): void;
+/** Backspace removes one char, or an entire paste block atomically. */
+export declare function backspaceSegments(segs: InputSegment[]): void;
+/**
+ * Read a line from the user with bracketed-paste awareness.
+ * Pasted multi-line text stays in the buffer as a single block — only a typed
+ * Enter submits. Falls back to cooked readline when stdin isn't a TTY.
+ */
 export declare function ask(question: string): Promise<string>;
 export declare function select<T>(label: string, items: {
     name: string;

package/dist/cli.js

@@ -67,11 +67,149 @@ export async function fetchModels(timeoutMs = 10_000) {
         return [];
     }
 }
+// ── Bracketed paste + segment-based input ──
+//
+// When the terminal is in bracketed paste mode, pasted content is wrapped with
+// \x1B[200~ ... \x1B[201~ so we can distinguish typed Enter from pasted newlines.
+// Multi-line or long pastes are stored as opaque segments and shown as a compact
+// [Pasted +N lines] placeholder while editing — the full text is substituted on submit.
+export const PASTE_START = "\x1B[200~";
+export const PASTE_END = "\x1B[201~";
+export const PASTE_PLACEHOLDER_MAX = 80;
+/** Split a raw stdin chunk into typed and pasted segments. */
+export function splitPaste(chunk) {
+    const out = [];
+    let i = 0;
+    while (i < chunk.length) {
+        const start = chunk.indexOf(PASTE_START, i);
+        if (start === -1) {
+            out.push({ type: "typed", text: chunk.slice(i) });
+            break;
+        }
+        if (start > i)
+            out.push({ type: "typed", text: chunk.slice(i, start) });
+        const bodyStart = start + PASTE_START.length;
+        const end = chunk.indexOf(PASTE_END, bodyStart);
+        if (end === -1) {
+            out.push({ type: "paste", text: chunk.slice(bodyStart) });
+            break;
+        }
+        out.push({ type: "paste", text: chunk.slice(bodyStart, end) });
+        i = end + PASTE_END.length;
+    }
+    return out;
+}
+export function segmentsToString(segs) {
+    return segs.map((s) => s.content).join("");
+}
+export function renderSegments(segs) {
+    return segs.map((s) => {
+        if (s.type === "text")
+            return s.content;
+        const lines = s.content.split("\n").length;
+        return chalk.dim(`[Pasted +${lines} line${lines === 1 ? "" : "s"}]`);
+    }).join("");
+}
+export function appendCharToSegments(segs, ch) {
+    const last = segs[segs.length - 1];
+    if (last && last.type === "text")
+        last.content += ch;
+    else
+        segs.push({ type: "text", content: ch });
+}
+/** Appends a pasted block. Short single-line pastes inline as text; the rest become placeholders. */
+export function appendPasteToSegments(segs, text) {
+    if (!text)
+        return;
+    const norm = text.replace(/\r\n?/g, "\n");
+    if (!norm.includes("\n") && norm.length <= PASTE_PLACEHOLDER_MAX) {
+        appendCharToSegments(segs, norm);
+        return;
+    }
+    segs.push({ type: "paste", content: norm });
+}
+/** Backspace removes one char, or an entire paste block atomically. */
+export function backspaceSegments(segs) {
+    while (segs.length > 0) {
+        const last = segs[segs.length - 1];
+        if (last.type === "paste") {
+            segs.pop();
+            return;
+        }
+        if (last.content.length > 1) {
+            last.content = last.content.slice(0, -1);
+            return;
+        }
+        segs.pop();
+        return;
+    }
+}
 // ── Interactive primitives ──
+/**
+ * Read a line from the user with bracketed-paste awareness.
+ * Pasted multi-line text stays in the buffer as a single block — only a typed
+ * Enter submits. Falls back to cooked readline when stdin isn't a TTY.
+ */
 export function ask(question) {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    return new Promise((res) => {
-        rl.question(question, (answer) => { rl.close(); res(answer.trim()); });
+    const { stdin, stdout } = process;
+    if (!stdin.isTTY) {
+        const rl = createInterface({ input: stdin, output: stdout });
+        return new Promise((res) => rl.question(question, (a) => { rl.close(); res(a.trim()); }));
+    }
+    return new Promise((resolve) => {
+        const segs = [];
+        const lastLine = question.split("\n").pop() ?? "";
+        const redraw = () => {
+            stdout.write("\r\x1B[K" + lastLine + renderSegments(segs));
+        };
+        stdout.write(question);
+        stdout.write("\x1B[?2004h");
+        try {
+            stdin.setRawMode(true);
+        }
+        catch { }
+        stdin.resume();
+        const cleanup = () => {
+            stdout.write("\x1B[?2004l");
+            try {
+                stdin.setRawMode(false);
+            }
+            catch { }
+            stdin.removeListener("data", onData);
+            stdin.pause();
+        };
+        const onData = (buf) => {
+            const chunk = buf.toString();
+            for (const seg of splitPaste(chunk)) {
+                if (seg.type === "paste") {
+                    appendPasteToSegments(segs, seg.text);
+                    redraw();
+                    continue;
+                }
+                for (const ch of seg.text) {
+                    if (ch === "\r" || ch === "\n") {
+                        stdout.write("\n");
+                        cleanup();
+                        resolve(segmentsToString(segs).trim());
+                        return;
+                    }
+                    if (ch === "\x03") {
+                        cleanup();
+                        stdout.write("\n");
+                        process.exit(130);
+                    }
+                    if (ch === "\x7F" || ch === "\b") {
+                        backspaceSegments(segs);
+                        continue;
+                    }
+                    const code = ch.charCodeAt(0);
+                    if (ch !== "\x1B" && code >= 0x20)
+                        appendCharToSegments(segs, ch);
+                }
+                redraw();
+            }
+        };
+        stdin.on("data", onData);
     });
 }
 export async function select(label, items, defaultIdx = 0) {

package/dist/merge.d.ts

@@ -7,7 +7,7 @@ export interface MergeResult {
     error?: string;
     filesChanged: number;
 }
-export declare function autoCommit(agentId: number, taskPrompt: string, worktreeCwd: string, log: (id: number, msg: string) => void): number;
+export declare function autoCommit(agentId: number, taskPrompt: string, worktreeCwd: string, baseRef: string | undefined, log: (id: number, msg: string) => void): number;
 export interface MergeAllResult {
     mergeResults: MergeResult[];
     mergeBranch?: string;

package/dist/merge.js

@@ -5,11 +5,13 @@ import { tmpdir } from "os";
 export function gitExec(cmd, cwd) {
     return execSync(cmd, { cwd, encoding: "utf-8", stdio: "pipe" });
 }
-export function autoCommit(agentId, taskPrompt, worktreeCwd, log) {
+export function autoCommit(agentId, taskPrompt, worktreeCwd, baseRef, log) {
     if (!existsSync(worktreeCwd)) {
         log(agentId, "Worktree directory gone, skipping commit");
         return 0;
     }
+    // Step 1: commit any uncommitted changes. Agents *may* commit their own work;
+    // we pick up whatever is still dirty.
     let status;
     try {
         status = gitExec("git status --porcelain", worktreeCwd);
@@ -18,27 +20,40 @@ export function autoCommit(agentId, taskPrompt, worktreeCwd, log) {
         log(agentId, `git status failed: ${String(err.message || err).slice(0, 120)}`);
         return 0;
     }
-    if (!status.trim())
-        return 0;
-    const lines = status.trim().split("\n").length;
-    try {
-        gitExec("git add -A", worktreeCwd);
-    }
-    catch (err) {
-        log(agentId, `git add failed: ${String(err.message || err).slice(0, 120)}`);
-        return lines;
+    if (status.trim()) {
+        try {
+            gitExec("git add -A", worktreeCwd);
+        }
+        catch (err) {
+            log(agentId, `git add failed: ${String(err.message || err).slice(0, 120)}`);
+        }
+        try {
+            const msg = taskPrompt.slice(0, 72).replace(/'/g, "'\\''");
+            gitExec(`git commit -m 'swarm: ${msg}'`, worktreeCwd);
+        }
+        catch (err) {
+            const m = String(err.message || err);
+            if (!m.includes("nothing to commit"))
+                log(agentId, `git commit failed: ${m.slice(0, 120)}`);
+        }
     }
+    // Step 2: measure against the worktree's origin commit — true regardless of
+    // who made the commits (agent or autoCommit). Pre-1.11.10 this counted
+    // `git status --porcelain` lines, which was zero whenever the agent committed
+    // its own work → filesChanged=0 → branch skipped by the merge gate → orphaned.
+    if (!baseRef)
+        return 0;
     try {
-        const msg = taskPrompt.slice(0, 72).replace(/'/g, "'\\''");
-        gitExec(`git commit -m 'swarm: ${msg}'`, worktreeCwd);
-        log(agentId, `Committed ${lines} file(s)`);
+        const diff = gitExec(`git diff --name-only ${baseRef}..HEAD`, worktreeCwd);
+        const count = diff.trim().split("\n").filter(Boolean).length;
+        if (count > 0)
+            log(agentId, `${count} file(s) changed`);
+        return count;
     }
     catch (err) {
-        const msg = String(err.message || err);
-        if (!msg.includes("nothing to commit"))
-            log(agentId, `git commit failed: ${msg.slice(0, 120)}`);
+        log(agentId, `diff vs base failed: ${String(err.message || err).slice(0, 120)}`);
+        return 0;
     }
-    return lines;
 }
 export function mergeAllBranches(agents, cwd, strategy, log) {
     const mergeResults = [];
@@ -194,14 +209,23 @@ export function cleanStaleWorktrees(cwd, log) {
             .split("\n")
             .map(b => b.trim().replace(/^\* /, ""))
             .filter(b => b.startsWith("swarm/task-") && !worktreeBranches.has(b));
+        // Use -d (safe delete) rather than -D: branches whose commits aren't in
+        // HEAD are orphaned work from a prior failed/unmerged run and must survive
+        // so the user can recover them. Only already-merged (ff) branches are
+        // actually deleted here.
+        let cleaned = 0;
         for (const b of branches) {
             try {
-                gitExec(`git branch -D "${b}"`, cwd);
+                gitExec(`git branch -d "${b}"`, cwd);
+                cleaned++;
             }
             catch { }
         }
-        if (branches.length > 0)
-            log(-1, `Cleaned ${branches.length} stale swarm branch(es)`);
+        if (cleaned > 0)
+            log(-1, `Cleaned ${cleaned} stale swarm branch(es)`);
+        const orphaned = branches.length - cleaned;
+        if (orphaned > 0)
+            log(-1, `Kept ${orphaned} orphaned swarm branch(es) with unmerged commits — resume to recover`);
     }
     catch { }
 }

package/dist/run.js

@@ -342,11 +342,16 @@ export async function executeRun(cfg) {
         lastAborted = swarm.aborted;
         recordBranches(swarm.agents, swarm.mergeResults, branches);
         saveWaveSession(runDir, waveNum, swarm.agents, swarm.totalCostUsd);
+        // Tasks that never made it into the swarm (queue cleared on abort/cap)
+        // are preserved as currentTasks so resume picks them up. Budget for these
+        // wasn't decremented (only attempted agents were), so no refund needed.
+        const attemptedPrompts = new Set(swarm.agents.map(a => a.task.prompt));
+        const neverStarted = currentTasks.filter(t => !attemptedPrompts.has(t.prompt));
         saveRunState(runDir, {
             id: `run-${new Date().toISOString().slice(0, 19)}`, objective: objective ?? "", budget: cfg.budget,
             remaining, workerModel, plannerModel, concurrency, permissionMode,
             usageCap, allowExtraUsage: cfg.allowExtraUsage, extraUsageBudget: cfg.extraUsageBudget,
-            flex, useWorktrees, mergeStrategy, waveNum, currentTasks: [],
+            flex, useWorktrees, mergeStrategy, waveNum, currentTasks: neverStarted,
             accCost, accCompleted, accFailed, accIn, accOut, accTools,
             branches, phase: "steering", startedAt: new Date(cfg.runStartedAt).toISOString(), cwd,
         });

package/dist/state.js

@@ -441,7 +441,10 @@ export function recordBranches(agents, mergeResults, branches) {
     }
 }
 export function autoMergeBranches(cwd, branches, onLog) {
-    const unmerged = branches.filter(b => b.status === "unmerged" && b.filesChanged > 0);
+    // Do NOT gate on filesChanged — pre-1.11.10 runs can record filesChanged=0
+    // for branches that actually contain real commits (agent self-committed).
+    // Feed every unmerged branch to git; it will no-op harmlessly if truly empty.
+    const unmerged = branches.filter(b => b.status === "unmerged");
     if (unmerged.length === 0)
         return;
     onLog(`Merging ${unmerged.length} unmerged branches...`);

package/dist/swarm.js

@@ -227,6 +227,11 @@ export class Swarm {
         if (this.config.useWorktrees && this.worktreeBase && !task.noWorktree) {
             const branch = `swarm/task-${id}`;
             const dir = join(this.worktreeBase, `agent-${id}`);
+            let baseRef;
+            try {
+                baseRef = gitExec("git rev-parse HEAD", this.config.cwd).trim();
+            }
+            catch { }
             let worktreeOk = false;
             for (let wt = 0; wt < 2 && !worktreeOk; wt++) {
                 try {
@@ -254,6 +259,7 @@ export class Swarm {
             if (worktreeOk) {
                 agentCwd = dir;
                 agent.branch = branch;
+                agent.baseRef = baseRef;
                 this.log(id, `Worktree: ${branch}`);
             }
             else {
@@ -327,6 +333,10 @@ export class Swarm {
                         this.activeQueries.delete(agentQuery);
                         if (sessionId)
                             resumeSessionId = sessionId;
+                        try {
+                            agentQuery.close();
+                        }
+                        catch { }
                     }
                 };
                 try {
@@ -355,7 +365,7 @@ export class Swarm {
                     const duration = agent.finishedAt - (agent.startedAt || agent.finishedAt);
                     if (agent.toolCalls === 0 && (agent.costUsd ?? 0) < 0.001 && duration < 15_000) {
                         agent.status = "error";
-                        agent.error = "Agent did no work (likely rate-limited before starting)";
+                        agent.error = "Agent did no work — exited without tool use";
                         this.failed++;
                     }
                     else {
@@ -397,14 +407,15 @@ export class Swarm {
             }
         }
         if (this.config.useWorktrees && agent.branch) {
-            agent.filesChanged = autoCommit(agent.id, agent.task.prompt, agentCwd, (id, text) => this.log(id, text));
+            agent.filesChanged = autoCommit(agent.id, agent.task.prompt, agentCwd, agent.baseRef, (id, text) => this.log(id, text));
         }
     }
     agentSummary(agent) {
         const dur = (agent.finishedAt ?? Date.now()) - (agent.startedAt ?? Date.now());
         const m = Math.floor(dur / 60000);
         const s = Math.round((dur % 60000) / 1000);
-        return `Agent ${agent.id} done: ${m}m ${s}s, ${agent.toolCalls} tools, ${agent.filesChanged ?? 0} files changed`;
+        const verb = agent.status === "error" ? "errored" : "done";
+        return `Agent ${agent.id} ${verb}: ${m}m ${s}s, ${agent.toolCalls} tools, ${agent.filesChanged ?? 0} files changed`;
     }
     // ── Message handler ──
     handleMsg(agent, msg) {
@@ -489,6 +500,12 @@ export class Swarm {
                 const pct = info.utilization != null ? `${Math.round(info.utilization * 100)}%` : "";
                 const overageTag = this.isUsingOverage ? " [EXTRA]" : "";
                 this.log(agent.id, `Rate: ${info.status} ${pct}${overageTag}${windowType ? ` (${windowType})` : ""}`);
+                if (info.status === "rejected") {
+                    if (!this.rateLimitResetsAt || this.rateLimitResetsAt <= Date.now()) {
+                        this.rateLimitResetsAt = Date.now() + 60_000;
+                    }
+                    throw new Error("rate limit rejected — retrying");
+                }
                 break;
             }
         }

package/dist/types.d.ts

@@ -64,6 +64,8 @@ export interface AgentState {
     costUsd?: number;
     /** Git branch name when using worktree isolation. */
     branch?: string;
+    /** Commit the worktree branch was created from — the baseline for measuring filesChanged. */
+    baseRef?: string;
     /** Number of files changed by the agent (from git diff). */
     filesChanged?: number;
 }

package/dist/ui.d.ts

@@ -57,7 +57,7 @@ export declare class RunDisplay {
     private interval?;
     private keyHandler?;
     private inputMode;
-    private inputBuf;
+    private inputSegs;
     private started;
     private readonly isTTY;
     private lastSeq;
@@ -94,6 +94,10 @@ export declare class RunDisplay {
     private renderAskPanel;
     private hasHotkeys;
     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. */
+    private handleTyped;
     private plainTick;
 }
 export {};

package/dist/ui.js

@@ -1,5 +1,6 @@
 import chalk from "chalk";
 import { renderFrame, renderSteeringFrame } from "./render.js";
+import { splitPaste, segmentsToString, renderSegments, appendCharToSegments, appendPasteToSegments, backspaceSegments, } from "./cli.js";
 const MAX_STEERING_EVENTS = 60;
 const MAX_INPUT_LEN = 600;
 export class RunDisplay {
@@ -14,7 +15,7 @@ export class RunDisplay {
     interval;
     keyHandler;
     inputMode = "none";
-    inputBuf = "";
+    inputSegs = [];
     started = false;
     isTTY;
     lastSeq = 0;
@@ -87,6 +88,10 @@ export class RunDisplay {
         if (this.keyHandler) {
             process.stdin.removeListener("data", this.keyHandler);
             this.keyHandler = undefined;
+            try {
+                process.stdout.write("\x1B[?2004l");
+            }
+            catch { }
             try {
                 process.stdin.setRawMode(false);
                 process.stdin.pause();
@@ -149,17 +154,18 @@ export class RunDisplay {
     renderInputPrompt() {
         if (this.inputMode === "none")
             return "";
+        const rendered = renderSegments(this.inputSegs);
         if (this.inputMode === "budget") {
-            return `\n  ${chalk.cyan(">")} New budget (remaining sessions): ${this.inputBuf}\u2588`;
+            return `\n  ${chalk.cyan(">")} New budget (remaining sessions): ${rendered}\u2588`;
         }
         if (this.inputMode === "threshold") {
-            return `\n  ${chalk.cyan(">")} New usage cap (0-100%): ${this.inputBuf}\u2588`;
+            return `\n  ${chalk.cyan(">")} New usage cap (0-100%): ${rendered}\u2588`;
         }
         if (this.inputMode === "steer") {
-            return `\n  ${chalk.cyan(">")} ${chalk.bold("Steer next wave")} ${chalk.dim("(Enter to queue, Esc to cancel)")}\n  ${this.inputBuf}\u2588`;
+            return `\n  ${chalk.cyan(">")} ${chalk.bold("Steer next wave")} ${chalk.dim("(Enter to queue, Esc to cancel)")}\n  ${rendered}\u2588`;
         }
         if (this.inputMode === "ask") {
-            return `\n  ${chalk.cyan(">")} ${chalk.bold("Ask the planner")} ${chalk.dim("(Enter to send, Esc to cancel)")}\n  ${this.inputBuf}\u2588`;
+            return `\n  ${chalk.cyan(">")} ${chalk.bold("Ask the planner")} ${chalk.dim("(Enter to send, Esc to cancel)")}\n  ${rendered}\u2588`;
         }
         return "";
     }
@@ -196,12 +202,52 @@ export class RunDisplay {
         catch {
             return;
         }
-        const lc = this.liveConfig;
+        try {
+            process.stdout.write("\x1B[?2004h");
+        }
+        catch { }
         this.keyHandler = (buf) => {
-            const s = buf.toString();
-            if (this.inputMode === "budget" || this.inputMode === "threshold") {
-                if (s === "\r" || s === "\n") {
-                    const val = parseFloat(this.inputBuf);
+            const chunk = buf.toString();
+            let dirty = false;
+            for (const seg of splitPaste(chunk)) {
+                if (seg.type === "paste") {
+                    if (this.handlePaste(seg.text))
+                        dirty = true;
+                }
+                else {
+                    if (this.handleTyped(seg.text))
+                        dirty = true;
+                }
+            }
+            if (dirty)
+                this.flush();
+        };
+        process.stdin.on("data", this.keyHandler);
+    }
+    /** Handle a pasted block. Returns true if the frame needs a redraw. */
+    handlePaste(text) {
+        if (this.inputMode === "budget" || this.inputMode === "threshold") {
+            const clean = text.replace(/[^0-9.]/g, "");
+            if (clean)
+                appendCharToSegments(this.inputSegs, clean);
+            return !!clean;
+        }
+        if (this.inputMode === "steer" || this.inputMode === "ask") {
+            if (segmentsToString(this.inputSegs).length + text.length > MAX_INPUT_LEN)
+                return false;
+            appendPasteToSegments(this.inputSegs, text);
+            return true;
+        }
+        return false;
+    }
+    /** Handle a typed (non-pasted) chunk. Returns true if the frame needs a redraw. */
+    handleTyped(s) {
+        const lc = this.liveConfig;
+        if (this.inputMode === "budget" || this.inputMode === "threshold") {
+            let dirty = false;
+            for (const ch of s) {
+                if (ch === "\r" || ch === "\n") {
+                    const val = parseFloat(segmentsToString(this.inputSegs));
                     if (this.inputMode === "budget" && !isNaN(val) && val > 0) {
                         lc.remaining = Math.round(val);
                         lc.dirty = true;
@@ -216,105 +262,113 @@ export class RunDisplay {
                         this.swarm?.log(-1, `Usage cap changed to ${val > 0 ? val + "%" : "unlimited"}`);
                     }
                     this.inputMode = "none";
-                    this.inputBuf = "";
+                    this.inputSegs = [];
+                    return true;
                 }
-                else if (s === "\x1B" || s === "\x03") {
+                if (ch === "\x1B" || ch === "\x03") {
                     this.inputMode = "none";
-                    this.inputBuf = "";
+                    this.inputSegs = [];
+                    return true;
                 }
-                else if (s === "\x7F") {
-                    this.inputBuf = this.inputBuf.slice(0, -1);
+                if (ch === "\x7F") {
+                    backspaceSegments(this.inputSegs);
+                    dirty = true;
+                    continue;
                 }
-                else if (/^[0-9.]$/.test(s)) {
-                    this.inputBuf += s;
+                if (/^[0-9.]$/.test(ch)) {
+                    appendCharToSegments(this.inputSegs, ch);
+                    dirty = true;
                 }
-                this.flush();
-                return;
             }
-            if (this.inputMode === "steer" || this.inputMode === "ask") {
-                for (const ch of s) {
-                    if (ch === "\r" || ch === "\n") {
-                        const text = this.inputBuf.trim();
-                        const wasAsk = this.inputMode === "ask";
-                        this.inputMode = "none";
-                        this.inputBuf = "";
-                        if (text) {
-                            if (wasAsk)
-                                this.onAsk?.(text);
-                            else
-                                this.onSteer?.(text);
-                        }
-                        this.flush();
-                        return;
-                    }
-                    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") {
-                        this.inputBuf = this.inputBuf.slice(0, -1);
-                        continue;
-                    }
-                    const code = ch.charCodeAt(0);
-                    if (code >= 0x20 && code <= 0x7E && this.inputBuf.length < MAX_INPUT_LEN) {
-                        this.inputBuf += ch;
+            return dirty;
+        }
+        if (this.inputMode === "steer" || this.inputMode === "ask") {
+            let dirty = false;
+            for (const ch of s) {
+                if (ch === "\r" || ch === "\n") {
+                    const text = segmentsToString(this.inputSegs).trim();
+                    const wasAsk = this.inputMode === "ask";
+                    this.inputMode = "none";
+                    this.inputSegs = [];
+                    if (text) {
+                        if (wasAsk)
+                            this.onAsk?.(text);
+                        else
+                            this.onSteer?.(text);
                     }
+                    return true;
                 }
-                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") {
-                this.inputMode = "budget";
-                this.inputBuf = "";
-            }
-            else if (s === "t" || s === "T") {
-                if (this.swarm) {
-                    this.inputMode = "threshold";
-                    this.inputBuf = "";
+                if (ch === "\x03") {
+                    this.inputMode = "none";
+                    this.inputSegs = [];
+                    return true;
+                }
+                // Ignore raw ESC only — let ANSI sequences (arrows etc.) fall through
+                if (ch === "\x1B" && s.length === 1) {
+                    this.inputMode = "none";
+                    this.inputSegs = [];
+                    return true;
+                }
+                if (ch === "\x7F" || ch === "\b") {
+                    backspaceSegments(this.inputSegs);
+                    dirty = true;
+                    continue;
+                }
+                const code = ch.charCodeAt(0);
+                if (code >= 0x20 && code <= 0x7E && segmentsToString(this.inputSegs).length < MAX_INPUT_LEN) {
+                    appendCharToSegments(this.inputSegs, ch);
+                    dirty = true;
                 }
             }
-            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 = "";
+            return dirty;
+        }
+        // Hotkey mode
+        if (s === "\x1B" && this.askState && !this.askState.streaming) {
+            this.askState = undefined;
+            return false;
+        }
+        if (s === "b" || s === "B") {
+            this.inputMode = "budget";
+            this.inputSegs = [];
+            return true;
+        }
+        if (s === "t" || s === "T") {
+            if (this.swarm) {
+                this.inputMode = "threshold";
+                this.inputSegs = [];
+                return true;
             }
-            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 = "";
+            return false;
+        }
+        if ((s === "f" || s === "F") && this.swarm && this.swarm.failed > 0 && this.swarm.active > 0) {
+            this.swarm.requeueFailed();
+            return false;
+        }
+        if ((s === "s" || s === "S") && this.onSteer) {
+            this.inputMode = "steer";
+            this.inputSegs = [];
+            return true;
+        }
+        if (s === "?" && this.onAsk && this.swarm && !this.askBusy) {
+            if (this.askState && !this.askState.streaming) {
+                this.askState = undefined;
+                return false;
             }
-            else if (s === "q" || s === "Q" || s === "\x03") {
-                if (this.swarm) {
-                    if (this.swarm.aborted)
-                        process.exit(0);
-                    this.swarm.abort();
-                }
-                else {
+            this.inputMode = "ask";
+            this.inputSegs = [];
+            return true;
+        }
+        if (s === "q" || s === "Q" || s === "\x03") {
+            if (this.swarm) {
+                if (this.swarm.aborted)
                     process.exit(0);
-                }
+                this.swarm.abort();
             }
-        };
-        process.stdin.on("data", this.keyHandler);
+            else {
+                process.exit(0);
+            }
+        }
+        return false;
     }
     plainTick() {
         if (!this.swarm)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.11.9",
+  "version": "1.11.12",
   "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": {