claude-overnight 1.16.4 → 1.16.7

package/README.md

@@ -1,10 +1,12 @@
 # claude-overnight
 
-**Run 10, 100, or 1000 Claude agents overnight.** A local multi-session orchestrator for the [Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk) — parallel Claude agent sessions in isolated git worktrees, spend caps, rate-limit handling, and crash-safe resume across days. Press Run and go to sleep.
+**A background lane for your Claude Max plan.** Runs a capped swarm of Claude Agent SDK sessions in isolated git worktrees — stops at a usage cap you set, so your interactive Claude Code always has headroom. Rate-limited? It waits. Crash? It resumes with full context.
 
-Local-first, git-native, budget-first. Describe what to build, set a spend cap, press Run. The tool plans with a thinking wave of architect sessions, breaks the objective into concrete tasks, launches parallel agent sessions in isolated git worktrees, iterates toward quality with a planner/executor/reflection loop, handles rate limits automatically, and resumes cleanly across crashes, rate-limit windows, and laptop sleeps. You wake up to merged commits.
+Your Max plan rate limits eat interactive coding time. One deep refactor and the 5-hour window is gone before lunch. `claude-overnight` runs background agent sessions up to the percentage cap you pick (90% is typical), leaving the rest free for your own Claude Code session. Hand it an objective and a session budget, walk away, review the diff when the run ends.
 
-Different shape from hosted single-session agent harnesses like [Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview): instead of one agent in one cloud container, you get many parallel agent sessions running on your own machine, in your real repo, coordinated by multi-wave steering. Works with Claude Opus, Sonnet, and Haiku — or pair an Anthropic planner with a cheaper executor on Qwen, OpenRouter, or any Anthropic-compatible endpoint via the `Other…` picker.
+Isolated by default. Every agent runs in its own git worktree on its own branch, so a misbehaving agent can't trash your working tree. You choose what agents can do before the run starts — no surprise escalation mid-flight. Unmerged branches are preserved for manual review, never discarded. Built on the [Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk) — not a Claude Code replacement, but a background lane that runs alongside it.
+
+Different shape from hosted agent harnesses like [Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview): instead of one agent in one cloud container billed separately, you get many parallel sessions on your own machine, in your real repo, against your own Max plan (or API key). Works with Claude Opus, Sonnet, and Haiku — or pair an Anthropic planner with a cheaper executor on Qwen, OpenRouter, or any Anthropic-compatible endpoint.
 
 ## Install
 
@@ -53,27 +55,22 @@ claude-overnight
 
 ◆ Thinking: 5 agents exploring...         ← architects analyze your codebase
 ◆ Orchestrating plan...                   ← synthesizes 50 concrete tasks
-◆ Wave 1 · 50 tasks · $4.20 spent        ← fully autonomous from here
+◆ Wave 1 · 50 tasks · $4.20 spent        ← runs unattended from here
   ↑ 1.2M in  ↓ 340K out  $4.20 / $4.24 total
 ◆ Assessing... how close to amazing?
 ◆ Wave 2 · 30 tasks · $18.50 spent       ← improvements from assessment
 ◆ Reflection: 2 agents reviewing          ← deep quality audit
 ◆ Wave 3 · 20 tasks · $31.00 spent       ← fixes from review findings
-◆ Assessing... ✓ Vision met
+◆ Assessing... ✓ Done
 ```
 
-You interact once (objective, budget, model, review themes), then everything runs autonomously — thinking, planning, executing, reflecting, steering. Rate-limited? It waits and retries. Crash? Resume where you left off. Capped at usage limit? Pick up next time with full context preserved.
-
-## How is this different?
-
-Claude already has several ways to run agents. `claude-overnight` fills a specific niche:
+You interact once (objective, budget, model, review themes), then the rest runs unattended — thinking, planning, executing, reflecting, steering. Rate-limited? It waits and retries. Crash? Resume where you left off. Capped at usage limit? Pick up next time with full context preserved.
 
-- **Claude Code** — interactive pair programming in your terminal. One agent, one conversation, you drive. `claude-overnight` is the inverse: many agents, no driver, you walk away and come back to merged commits.
-- **[Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview)** — a hosted single-session agent harness. One agent, one cloud container, stateful conversation. `claude-overnight` is a local multi-session *orchestrator* built on the [Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk): many parallel sessions on your machine, in your real repo, with spend caps and multi-day crash-safe resume.
-- **[Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk)** — primitives for building your own agent. `claude-overnight` is one specific thing built on top of it: an overnight swarm orchestrator you didn't have to write.
-- **IDE copilots (Cursor, Copilot, Cline, etc.)** — synchronous assistants that complete while you're at the keyboard. `claude-overnight` is asynchronous: you hand off an objective and a budget, close the laptop lid, and review a branch in the morning.
+## How it differs
 
-If you want to hand an objective and a spend cap to Claude and wake up to shipped work on your real repo, this is the shape.
+- vs **Claude Code**: many agents, no driver, capped so your Claude Code session keeps its headroom
+- vs **[Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview)**: on your machine, against your Max plan, in your real git history — not a cloud container billed separately
+- vs **Cursor / Copilot / Cline**: asynchronous, off the keyboard
 
 ## Use cases
 
@@ -86,17 +83,17 @@ If you want to hand an objective and a spend cap to Claude and wake up to shippe
 - **Quality audits** — reflection waves surface architectural issues and code smells.
 - **Long research runs** — architect sessions explore a large codebase before any code lands.
 
-Typical shape: one objective + a $20–$200 spend cap + sleep.
+Typical shape: one objective + a $20–$200 spend cap + walk away.
 
 ## How it works
 
-### 1. Thinking wave — parallel architect sessions
+### 1. Thinking phase — parallel architect sessions
 
 For budgets > 15, the tool launches **architect agents** that explore your codebase before any code is written. Each one gets a different research angle (architecture, data models, APIs, testing, etc.) and writes a structured design document. The number scales with budget: 5 for budget=50, 10 for budget=2000.
 
 ### 2. Task orchestration
 
-An orchestrator session reads all design documents and synthesizes concrete execution tasks — grounded in real files and patterns the architects found. No guesswork. The task plan is also written to a file for resilience — if orchestration is interrupted, partial results survive.
+An orchestrator session reads all design documents and synthesizes concrete execution tasks — grounded in real files and patterns the architects found. The task plan is also written to a file for resilience — if orchestration is interrupted, partial results survive.
 
 ### 3. Parallel execution waves
 
@@ -110,7 +107,7 @@ After each wave, steering assesses: "how good is this?" — not "what's missing?
 
 ### 4. Goal refinement and steering
 
-The tool starts with your broad objective but evolves its definition of "amazing" as it learns your codebase. Steering refines the goal after each wave. Late waves are informed by early discoveries.
+The tool starts with your broad objective but refines its definition of quality as it learns your codebase. Steering updates the goal after each wave. Late waves are informed by early discoveries.
 
 ### 5. Three-layer context memory
 
@@ -118,7 +115,7 @@ Long runs stay sharp because steering maintains three layers of memory:
 
 - **Status** — a living project snapshot, updated every wave. Compressed, never truncated.
 - **Milestones** — strategic snapshots archived every ~5 waves. Long-term memory.
-- **Goal** — the evolving north star. What "amazing" means for this codebase.
+- **Goal** — the evolving north star. What quality means for this codebase.
 
 ## Run history, resume, and knowledge carryforward
 

package/dist/cli.js

@@ -144,6 +144,9 @@ export function backspaceSegments(segs) {
         return;
     }
 }
+function stripAnsi(s) {
+    return s.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
+}
 // ── Interactive primitives ──
 /**
  * Read a line from the user with bracketed-paste awareness.
@@ -158,12 +161,22 @@ export function ask(question) {
     }
     return new Promise((resolve) => {
         const segs = [];
-        // DEC save/restore cursor + clear-to-end-of-screen so redraws don't pile
-        // up when the input wraps past the terminal width onto additional rows.
+        const tail = question.split("\n").pop() ?? "";
+        const tailVisibleLen = stripAnsi(tail).length;
+        let prevWrapRows = 0;
+        // Only rewrite the input line (and any wrapped continuation rows). The
+        // question header above is never touched, so redraws can't stack copies
+        // even if the initial write scrolled the viewport.
         const redraw = () => {
-            stdout.write("\x1B8\x1B[J" + question + renderSegments(segs));
+            const cols = stdout.columns || 80;
+            if (prevWrapRows > 0)
+                stdout.write(`\x1B[${prevWrapRows}A`);
+            stdout.write("\r\x1B[J");
+            const rendered = renderSegments(segs);
+            stdout.write(tail + rendered);
+            const visible = tailVisibleLen + stripAnsi(rendered).length;
+            prevWrapRows = visible > 0 ? Math.floor((visible - 1) / cols) : 0;
         };
-        stdout.write("\x1B7");
         stdout.write(question);
         stdout.write("\x1B[?2004h");
         try {
@@ -188,7 +201,8 @@ export function ask(question) {
                     redraw();
                     continue;
                 }
-                for (const ch of seg.text) {
+                for (let ci = 0; ci < seg.text.length; ci++) {
+                    const ch = seg.text[ci];
                     if (ch === "\r" || ch === "\n") {
                         stdout.write("\n");
                         cleanup();
@@ -202,11 +216,20 @@ export function ask(question) {
                     }
                     if (ch === "\x7F" || ch === "\b") {
                         backspaceSegments(segs);
+                        redraw();
+                        continue;
+                    }
+                    // Skip ESC and any bytes that are part of an ANSI escape sequence
+                    // (arrow keys, function keys, etc. arrive as \x1B [ ... letter)
+                    if (ch === "\x1B") {
                         continue;
                     }
                     const code = ch.charCodeAt(0);
-                    if (ch !== "\x1B" && code >= 0x20)
-                        appendCharToSegments(segs, ch);
+                    if (code < 0x20)
+                        continue; // control chars
+                    if (code >= 0x7F && code < 0xA0)
+                        continue; // DEL + C1 controls
+                    appendCharToSegments(segs, ch);
                 }
                 redraw();
             }
@@ -241,15 +264,10 @@ export async function select(label, items, defaultIdx = 0) {
         };
         const handler = (buf) => {
             const s = buf.toString();
-            if (s === "\x1B[A") {
-                idx = (idx - 1 + items.length) % items.length;
-                draw();
-            }
-            else if (s === "\x1B[B") {
-                idx = (idx + 1) % items.length;
-                draw();
-            }
-            else if (s === "\r")
+            // Ignore ANSI escape sequences (arrow keys etc.)
+            if (s[0] === "\x1B")
+                return;
+            if (s === "\r")
                 done(items[idx].value);
             else if (s === "\x03") {
                 stdin.setRawMode(false);
@@ -277,6 +295,9 @@ export async function selectKey(label, options) {
         stdin.resume();
         const handler = (buf) => {
             const s = buf.toString().toLowerCase();
+            // Ignore ANSI escape sequences
+            if (s[0] === "\x1B")
+                return;
             if (s === "\x03") {
                 stdin.setRawMode(false);
                 process.exit(0);
@@ -288,7 +309,7 @@ export async function selectKey(label, options) {
                 resolve(keys[0]);
                 return;
             }
-            if (keys.includes(s)) {
+            if (s.length === 1 && keys.includes(s)) {
                 stdin.setRawMode(false);
                 stdin.removeListener("data", handler);
                 stdin.pause();

package/dist/index.js

@@ -166,7 +166,7 @@ async function main() {
     }
     if (argv.includes("-h") || argv.includes("--help")) {
         console.log(`
-  ${chalk.bold("🌙  claude-overnight")} ${chalk.dim("— fire off Claude agents, come back to shipped work")}
+  ${chalk.bold("🌙  claude-overnight")} ${chalk.dim("— background lane for your Claude Max plan")}
   ${chalk.dim("─".repeat(60))}
 
   ${chalk.cyan("Usage")}

package/dist/ui.js

@@ -282,7 +282,13 @@ export class RunDisplay {
                     this.inputSegs = [];
                     return true;
                 }
-                if (ch === "\x1B" || ch === "\x03") {
+                if (ch === "\x03") {
+                    this.inputMode = "none";
+                    this.inputSegs = [];
+                    return true;
+                }
+                // ESC cancels input mode
+                if (ch === "\x1B") {
                     this.inputMode = "none";
                     this.inputSegs = [];
                     return true;
@@ -301,7 +307,8 @@ export class RunDisplay {
         }
         if (this.inputMode === "steer" || this.inputMode === "ask") {
             let dirty = false;
-            for (const ch of s) {
+            for (let ci = 0; ci < s.length; ci++) {
+                const ch = s[ci];
                 if (ch === "\r" || ch === "\n") {
                     const text = segmentsToString(this.inputSegs).trim();
                     const wasAsk = this.inputMode === "ask";
@@ -320,10 +327,18 @@ export class RunDisplay {
                     this.inputSegs = [];
                     return true;
                 }
-                // Ignore raw ESC only — let ANSI sequences (arrows etc.) fall through
-                if (ch === "\x1B" && s.length === 1) {
+                // ESC cancels — consume this byte and any following ANSI sequence bytes
+                if (ch === "\x1B") {
                     this.inputMode = "none";
                     this.inputSegs = [];
+                    // Skip any remaining ANSI sequence bytes (e.g. [A for arrow keys)
+                    while (ci + 1 < s.length) {
+                        const next = s[ci + 1];
+                        const nc = next.charCodeAt(0);
+                        ci++;
+                        if ((nc >= 0x40 && nc <= 0x7E) || nc === 0x7F)
+                            break; // final byte
+                    }
                     return true;
                 }
                 if (ch === "\x7F" || ch === "\b") {
@@ -332,6 +347,10 @@ export class RunDisplay {
                     continue;
                 }
                 const code = ch.charCodeAt(0);
+                if (code < 0x20)
+                    continue; // control chars
+                if (code >= 0x7F && code < 0xA0)
+                    continue; // DEL + C1 controls
                 if (code >= 0x20 && code <= 0x7E && segmentsToString(this.inputSegs).length < MAX_INPUT_LEN) {
                     appendCharToSegments(this.inputSegs, ch);
                     dirty = true;
@@ -339,17 +358,26 @@ export class RunDisplay {
             }
             return dirty;
         }
-        // Hotkey mode
-        if (s === "\x1B" && this.askState && !this.askState.streaming) {
+        // Hotkey mode — only accept single printable ASCII characters
+        // Skip ESC and ANSI sequences entirely
+        if (s.length > 1 && (s[0] === "\x1B" || s.charCodeAt(0) < 0x20))
+            return false;
+        if (s.length !== 1)
+            return false;
+        const key = s[0];
+        const code = key.charCodeAt(0);
+        if (code < 0x20 || code > 0x7E)
+            return false;
+        if (key === "\x1B" && this.askState && !this.askState.streaming) {
             this.askState = undefined;
             return false;
         }
-        if (s === "b" || s === "B") {
+        if (key === "b" || key === "B") {
             this.inputMode = "budget";
             this.inputSegs = [];
             return true;
         }
-        if (s === "t" || s === "T") {
+        if (key === "t" || key === "T") {
             if (this.swarm) {
                 this.inputMode = "threshold";
                 this.inputSegs = [];
@@ -357,7 +385,7 @@ export class RunDisplay {
             }
             return false;
         }
-        if (s === "c" || s === "C") {
+        if (key === "c" || key === "C") {
             if (this.swarm) {
                 this.inputMode = "concurrency";
                 this.inputSegs = [];
@@ -365,7 +393,7 @@ export class RunDisplay {
             }
             return false;
         }
-        if (s === "e" || s === "E") {
+        if (key === "e" || key === "E") {
             if (this.swarm) {
                 this.inputMode = "extra";
                 this.inputSegs = [];
@@ -373,7 +401,7 @@ export class RunDisplay {
             }
             return false;
         }
-        if (s === "p" || s === "P") {
+        if (key === "p" || key === "P") {
             if (this.swarm) {
                 const next = !this.swarm.paused;
                 this.swarm.setPaused(next);
@@ -383,20 +411,20 @@ export class RunDisplay {
             }
             return false;
         }
-        if ((s === "f" || s === "F") && this.swarm && this.swarm.failed > 0 && this.swarm.active > 0) {
+        if ((key === "f" || key === "F") && this.swarm && this.swarm.failed > 0 && this.swarm.active > 0) {
             this.swarm.requeueFailed();
             return false;
         }
-        if ((s === "r" || s === "R") && this.swarm && this.swarm.rateLimitPaused > 0) {
+        if ((key === "r" || key === "R") && this.swarm && this.swarm.rateLimitPaused > 0) {
             this.swarm.retryRateLimitNow();
             return true;
         }
-        if ((s === "s" || s === "S") && this.onSteer) {
+        if ((key === "s" || key === "S") && this.onSteer) {
             this.inputMode = "steer";
             this.inputSegs = [];
             return true;
         }
-        if (s === "?" && this.onAsk && this.swarm && !this.askBusy) {
+        if (key === "?" && this.onAsk && this.swarm && !this.askBusy) {
             if (this.askState && !this.askState.streaming) {
                 this.askState = undefined;
                 return false;
@@ -405,7 +433,7 @@ export class RunDisplay {
             this.inputSegs = [];
             return true;
         }
-        if (s === "q" || s === "Q" || s === "\x03") {
+        if (key === "q" || key === "Q" || key === "\x03") {
             if (this.swarm) {
                 if (this.swarm.aborted)
                     process.exit(0);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-overnight",
-  "version": "1.16.4",
-  "description": "Local multi-session orchestrator for the Claude Agent SDK. Runs parallel Claude agents in git worktrees overnight — spend caps, rate-limit handling, crash-safe resume, multi-wave steering. Opus/Sonnet/Haiku + Qwen/OpenRouter. A local alternative to hosted agent harnesses.",
+  "version": "1.16.7",
+  "description": "Background lane for your Claude Max plan. Parallel Claude Agent SDK sessions in git worktrees with a usage cap that reserves headroom for your interactive Claude Code. Crash-safe resume. Opus/Sonnet/Haiku + Qwen/OpenRouter.",
   "type": "module",
   "bin": {
     "claude-overnight": "dist/bin.js"