claude-overnight 1.11.7 → 1.11.11

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/index.js

@@ -11,7 +11,7 @@ import { RunDisplay } from "./ui.js";
 import { renderSummary } from "./render.js";
 import { executeRun } from "./run.js";
 import { parseCliFlags, isAuthError, fetchModels, ask, select, selectKey, loadTaskFile, validateConcurrency, isGitRepo, validateGitRepo, showPlan, BRAILLE, makeProgressLog, } from "./cli.js";
-import { loadRunState, findIncompleteRuns, findOrphanedDesigns, formatTimeAgo, showRunHistory, readPreviousRunKnowledge, createRunDir, updateLatestSymlink, readMdDir, saveRunState, autoMergeBranches, } from "./state.js";
+import { loadRunState, findIncompleteRuns, findOrphanedDesigns, backfillOrphanedPlans, formatTimeAgo, showRunHistory, readPreviousRunKnowledge, createRunDir, updateLatestSymlink, readMdDir, saveRunState, autoMergeBranches, } from "./state.js";
 function countTasksInFile(path) {
     try {
         const parsed = JSON.parse(readFileSync(path, "utf-8"));
@@ -123,6 +123,12 @@ async function main() {
     // ── Run history ──
     const rootDir = join(cwd, ".claude-overnight");
     const runsDir = join(rootDir, "runs");
+    // Backfill run.json for pre-1.11.7 orphaned plans so they become visible
+    // to the resume picker. One-shot, idempotent, silent if there's nothing.
+    const backfilled = backfillOrphanedPlans(rootDir, cwd);
+    if (backfilled > 0 && !noTTY) {
+        console.log(chalk.dim(`\n  ↻ Recovered ${backfilled} orphaned plan${backfilled > 1 ? "s" : ""} from disk`));
+    }
     const allRuns = [];
     try {
         for (const d of readdirSync(runsDir).sort().reverse()) {
@@ -256,17 +262,22 @@ async function main() {
             }
         }
         if (resuming && resumeState && resumeRunDir) {
-            // Planning-phase resume: the prior run died before executeRun ran any
-            // wave, but the orchestrate agent wrote tasks.json to disk. Load those
-            // tasks into currentTasks so executeRun can pick them up as wave 0.
-            if (resumeState.phase === "planning") {
+            // If currentTasks is empty but tasks.json exists on disk, reload it.
+            // Covers two cases:
+            //   1. Planning-phase resumes (the prior run died before executeRun).
+            //   2. Stopped/capped runs whose state was saved with currentTasks: []
+            //      (saveRunState always stores [] — the plan is on disk in tasks.json).
+            if (resumeState.currentTasks.length === 0) {
                 const loaded = salvageFromFile(join(resumeRunDir, "tasks.json"), resumeState.budget, () => { }, "resume");
-                if (!loaded) {
+                if (!loaded && resumeState.phase === "planning") {
                     console.error(chalk.red(`\n  Planning-phase run has no usable tasks.json — start Fresh instead.\n`));
                     process.exit(1);
                 }
-                resumeState.currentTasks = loaded;
-                console.log(chalk.green(`\n  ✓ Resuming plan · ${loaded.length} tasks loaded from tasks.json`));
+                if (loaded) {
+                    resumeState.currentTasks = loaded;
+                    const label = resumeState.phase === "planning" ? "Resuming plan" : `Resuming ${resumeState.phase} run`;
+                    console.log(chalk.green(`\n  ✓ ${label} · ${loaded.length} tasks loaded from tasks.json`));
+                }
             }
             const unmerged = resumeState.branches.filter(b => b.status === "unmerged").length;
             if (unmerged > 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 = [];
@@ -162,11 +177,16 @@ export function cleanStaleWorktrees(cwd, log) {
     try {
         const list = gitExec("git worktree list --porcelain", cwd);
         const stale = [];
-        const tmp = tmpdir();
+        // Match any worktree whose path contains our mkdtemp prefix. We used to
+        // gate on `startsWith(tmpdir())` too, but on macOS `os.tmpdir()` returns
+        // `/var/folders/...` while git reports worktrees as `/private/var/...`
+        // (realpath-resolved), so the prefix never matched and stale worktrees
+        // silently accumulated. The `claude-overnight-` substring is unambiguous
+        // enough on its own — nothing else in the repo uses that prefix.
         for (const line of list.split("\n")) {
             if (line.startsWith("worktree ")) {
                 const wpath = line.slice("worktree ".length);
-                if (wpath.startsWith(tmp) && wpath.includes("claude-overnight-"))
+                if (wpath.includes("/claude-overnight-"))
                     stale.push(wpath);
             }
         }
@@ -189,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/state.d.ts

@@ -36,6 +36,19 @@ export declare function findIncompleteRuns(rootDir: string, filterCwd: string):
     state: RunState;
 }[];
 export declare function findOrphanedDesigns(rootDir: string): string | null;
+/**
+ * Backfill run.json for pre-1.11.7 orphaned plans: runs where orchestrate's
+ * agent wrote tasks.json via its Write tool but the process died before
+ * executeRun ever got to saveRunState. Without this, those runs are invisible
+ * to findIncompleteRuns forever.
+ *
+ * Idempotent: runs with an existing run.json are skipped. Synthesizes a
+ * minimal "planning" state from what can be read off disk — dir name for
+ * timestamp, task count for budget, sane defaults for everything else.
+ * The cwd field is set to filterCwd so findIncompleteRuns picks it up on the
+ * current project (which is safe — rootDir is already scoped to `cwd`).
+ */
+export declare function backfillOrphanedPlans(rootDir: string, filterCwd: string): number;
 export declare function formatTimeAgo(isoStr: string): string;
 export declare function showRunHistory(allRuns: {
     dir: string;

package/dist/state.js

@@ -219,6 +219,70 @@ export function findOrphanedDesigns(rootDir) {
     catch { }
     return null;
 }
+/**
+ * Backfill run.json for pre-1.11.7 orphaned plans: runs where orchestrate's
+ * agent wrote tasks.json via its Write tool but the process died before
+ * executeRun ever got to saveRunState. Without this, those runs are invisible
+ * to findIncompleteRuns forever.
+ *
+ * Idempotent: runs with an existing run.json are skipped. Synthesizes a
+ * minimal "planning" state from what can be read off disk — dir name for
+ * timestamp, task count for budget, sane defaults for everything else.
+ * The cwd field is set to filterCwd so findIncompleteRuns picks it up on the
+ * current project (which is safe — rootDir is already scoped to `cwd`).
+ */
+export function backfillOrphanedPlans(rootDir, filterCwd) {
+    const runsDir = join(rootDir, "runs");
+    let count = 0;
+    try {
+        const dirs = readdirSync(runsDir);
+        for (const d of dirs) {
+            const runDir = join(runsDir, d);
+            if (existsSync(join(runDir, "run.json")))
+                continue;
+            const tasksFile = join(runDir, "tasks.json");
+            if (!existsSync(tasksFile))
+                continue;
+            let taskCount = 0;
+            try {
+                const parsed = JSON.parse(readFileSync(tasksFile, "utf-8"));
+                if (!Array.isArray(parsed?.tasks))
+                    continue;
+                taskCount = parsed.tasks.length;
+            }
+            catch {
+                continue;
+            }
+            if (taskCount === 0)
+                continue;
+            // Dir name format: 2026-04-12T13-03-57 (UTC). Convert to ISO.
+            const m = d.match(/^(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})$/);
+            const startedAt = m ? `${m[1]}T${m[2]}:${m[3]}:${m[4]}.000Z` : new Date(0).toISOString();
+            try {
+                saveRunState(runDir, {
+                    id: d,
+                    objective: `(recovered pre-1.11.7 plan · ${taskCount} tasks)`,
+                    budget: taskCount, remaining: taskCount,
+                    workerModel: "claude-opus-4-6", plannerModel: "claude-opus-4-6",
+                    concurrency: 5, permissionMode: "bypassPermissions",
+                    flex: false, useWorktrees: true, mergeStrategy: "yolo",
+                    allowExtraUsage: false,
+                    waveNum: 0, currentTasks: [],
+                    accCost: 0, accCompleted: 0, accFailed: 0,
+                    accIn: 0, accOut: 0, accTools: 0,
+                    branches: [],
+                    phase: "planning",
+                    startedAt,
+                    cwd: filterCwd,
+                });
+                count++;
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return count;
+}
 // ── History display ──
 export function formatTimeAgo(isoStr) {
     const ms = Date.now() - new Date(isoStr).getTime();
@@ -377,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 {
@@ -397,7 +403,7 @@ 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) {

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.7",
+  "version": "1.11.11",
   "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": {