claude-overnight 1.16.2 → 1.16.5

package/README.md

@@ -1,10 +1,12 @@
 # claude-overnight
 
-Run 10, 100, or 1000 Claude agents overnight. Come back to shipped work.
+**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, explores your codebase, breaks the objective into tasks, launches parallel agents in isolated git worktrees, iterates toward quality, handles rate limits automatically, and resumes cleanly across crashes 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 runtimes like [Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview): this runs on your machine, against your real repo, as a parallel swarm — with spend caps, git worktree choreography, and multi-day crash-safe resume. Built on the [Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk). Works with Claude Opus, Sonnet, and Haiku — or route executors to Qwen / OpenRouter / 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
 
@@ -12,16 +14,7 @@ Different shape from hosted single-session runtimes like [Claude Managed Agents]
 npm install -g claude-overnight
 ```
 
-Requires Node.js >= 20 and Claude authentication (`claude auth login`, or set `ANTHROPIC_API_KEY`).
-
-### Claude Code plugin
-
-This repo also ships a Claude Code plugin so any Claude instance (inside this repo or any other) knows how to use, inspect, and resume `claude-overnight` runs:
-
-```
-/plugin marketplace add Fornace/claude-overnight
-/plugin install claude-overnight
-```
+Requires Node.js ≥ 20 and Claude authentication (`claude auth login` or `ANTHROPIC_API_KEY`).
 
 ## Quick start
 
@@ -62,50 +55,69 @@ 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.
+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.
+
+## How it differs
+
+- 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
+
+- **Overnight refactors** — "Modernize the auth system" at budget 200.
+- **Batch feature implementation** — dozens of features from a task file, parallelized.
+- **Codebase-wide cleanups** — deduplicate, simplify, rename, normalize.
+- **Test generation at scale** — integration tests for every route or module.
+- **Documentation sprints** — API docs, READMEs, inline comments, changelogs.
+- **Framework migrations** — version upgrades, type annotations, config format swaps.
+- **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 + walk away.
 
 ## How it works
 
-### 1. Thinking wave
+### 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. Orchestration
+### 2. Task orchestration
 
-An orchestrator agent 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. Iterative execution
+### 3. Parallel execution waves
 
-Tasks run in parallel (each agent in its own git worktree). After completing its task, each agent automatically runs a **simplify pass** — reviewing its own `git diff` for code reuse opportunities, quality issues, and inefficiencies, then fixing them before the framework commits.
+Tasks run in parallel agent sessions (each in its own git worktree). After completing its task, each session automatically runs a **simplify pass** — reviewing its own `git diff` for code reuse opportunities, quality issues, and inefficiencies, then fixing them before the framework commits.
 
 After each wave, steering assesses: "how good is this?" — not "what's missing?" It can:
 
 - **Execute** more tasks to build features, fix bugs, polish UX
-- **Reflect** by spinning up 1-2 review agents for deep quality/architecture audits
+- **Reflect** by spinning up 1-2 review sessions for deep quality/architecture audits
 - **Declare done** when the vision is met at high quality
 
-### 4. Goal refinement
+### 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
+### 5. Three-layer context memory
 
 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 and resume
+## Run history, resume, and knowledge carryforward
 
 Every run gets its own folder in `.claude-overnight/runs/`. Nothing is ever overwritten.
 
@@ -133,7 +145,7 @@ Any run that stops before the steering system declares the objective complete
 
 On resume: unmerged branches auto-merge, the wave loop continues, all context is preserved. Designs and reflections stay on disk until the objective is truly complete.
 
-If the thinking phase succeeds but orchestration crashes, the next run detects the orphaned design docs and reuses them — no re-running $9 worth of architect agents:
+If the thinking phase succeeds but orchestration crashes, the next run detects the orphaned design docs and reuses them — no re-running $9 worth of architect sessions:
 
 ```
   ✓ Reusing 5 design docs (from prior attempt)
@@ -143,15 +155,13 @@ If the thinking phase succeeds but orchestration crashes, the next run detects t
     ...
 ```
 
-**Knowledge carries forward** — new runs inherit knowledge from completed previous runs. Thinking agents and steering see what past runs built. Run 2 knows run 1 already built the auth system.
+**Knowledge carries forward** — new runs inherit knowledge from completed previous runs. Thinking sessions and steering see what past runs built. Run 2 knows run 1 already built the auth system.
 
 Add `.claude-overnight/` to your `.gitignore` (with the trailing slash — see below).
 
 A separate, tiny `claude-overnight.log.md` is also written at the repo root on every run. It's human-readable, append-only, one block per run (objective, start/finish, cost, outcome, branch), and is designed to be **committed** — so even after `.claude-overnight/` is cleaned up you can still recover which prompt produced which commits. Use `.claude-overnight/` (with trailing slash) in your gitignore so this file isn't matched by accident.
 
-## Other usage modes
-
-### Task file
+## Task file and inline modes
 
 ```bash
 claude-overnight tasks.json
@@ -181,7 +191,7 @@ For multi-wave runs, add `objective` and `flexiblePlan`:
 }
 ```
 
-### Inline
+Inline:
 
 ```bash
 claude-overnight "fix auth bug in src/auth.ts" "add tests for user model"
@@ -215,7 +225,7 @@ claude-overnight "fix auth bug in src/auth.ts" "add tests for user model"
 | `mergeStrategy` | `"yolo" \| "branch"` | `"yolo"` | Merge into HEAD or new branch |
 | `usageCap` | `number (0-100)` | unlimited | Stop at N% utilization |
 
-## Custom providers (Qwen, OpenRouter, anything Anthropic-compatible)
+## Custom providers (Qwen, OpenRouter, any Anthropic-compatible endpoint)
 
 Planner and executor are picked separately — pair Opus-on-Anthropic for the planner/thinker with a cheaper model on another provider for the bulk of execution.
 
@@ -245,7 +255,7 @@ Saved providers live user-level at `~/.claude/claude-overnight/providers.json` (
 
 **Non-interactive / CI.** `claude-overnight --model=qwen3-coder-plus` auto-resolves the model id to a saved provider — no separate `--provider` flag.
 
-## Usage controls
+## Spend caps and usage controls
 
 ### Extra usage protection
 
@@ -272,7 +282,7 @@ The usage bar cycles through all rate limit windows (5h, 7d, etc.) every 3 secon
 
 When using extra usage with a budget, a dedicated progress bar shows spend vs limit with color-coded fill (magenta → yellow → red).
 
-## Rate limits
+## Rate-limit handling and crash-safe recovery
 
 Built for unattended runs lasting hours or days.
 
@@ -286,15 +296,24 @@ Built for unattended runs lasting hours or days.
 - **Usage cap**: set a ceiling, active agents finish, no new ones start — run is resumable
 - **Planner retries**: steering and orchestration retry on rate limits (30s/60s/120s backoff) with full context
 
-## Worktrees and merging
+## Git worktrees and branch merging
 
-Each agent gets an isolated git worktree (`swarm/task-N` branch). Changes auto-commit. After all agents complete, branches merge back.
+Each agent session gets an isolated git worktree (`swarm/task-N` branch). Changes auto-commit. After all sessions complete, branches merge back.
 
 - `"yolo"` (default): merges into your current branch
 - `"branch"`: creates a new `swarm/run-{timestamp}` branch
 
 Conflicts retry with `-X theirs`. Unresolved branches are preserved for manual merge.
 
+## Claude Code plugin
+
+This repo also ships a Claude Code plugin so any Claude instance (inside this repo or any other) knows how to use, inspect, and resume `claude-overnight` runs:
+
+```
+/plugin marketplace add Fornace/claude-overnight
+/plugin install claude-overnight
+```
+
 ## Exit codes
 
 | Code | Meaning |

package/dist/cli.js

@@ -158,10 +158,12 @@ export function ask(question) {
     }
     return new Promise((resolve) => {
         const segs = [];
-        const lastLine = question.split("\n").pop() ?? "";
+        // 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 redraw = () => {
-            stdout.write("\r\x1B[K" + lastLine + renderSegments(segs));
+            stdout.write("\x1B8\x1B[J" + question + renderSegments(segs));
         };
+        stdout.write("\x1B7");
         stdout.write(question);
         stdout.write("\x1B[?2004h");
         try {

package/dist/merge.d.ts

@@ -17,6 +17,15 @@ export declare function mergeAllBranches(agents: {
     branch: string;
     filesChanged: number;
 }[], cwd: string, strategy: MergeStrategy, log: (id: number, msg: string) => void): MergeAllResult;
+/**
+ * Last-resort merge: overlay the branch's file state onto HEAD without a real
+ * 3-way merge. Walks `git diff --name-status base..branch` and for each entry
+ * either checks out the branch's version (add/modify/rename) or removes the
+ * file (delete). Always succeeds unless the branch itself is broken. Trades
+ * merge-graph fidelity for "your changes actually land" — the right call for
+ * an autonomous swarm.
+ */
+export declare function forceMergeOverlay(branch: string, cwd: string): boolean;
 export declare function warnDirtyTree(cwd: string, log: (id: number, msg: string) => void): void;
 export declare function cleanStaleWorktrees(cwd: string, log: (id: number, msg: string) => void): void;
 export declare function writeSwarmLog(opts: {

package/dist/merge.js

@@ -5,20 +5,45 @@ import { tmpdir } from "os";
 export function gitExec(cmd, cwd) {
     return execSync(cmd, { cwd, encoding: "utf-8", stdio: "pipe" });
 }
+/** Total files the agent touched vs base — tracked changes + untracked. */
+function measureWork(worktreeCwd, baseRef) {
+    const seen = new Set();
+    try {
+        // Tracked: committed + staged + unstaged, all vs the worktree's base.
+        const diff = gitExec(`git diff --name-only ${baseRef} --`, worktreeCwd);
+        for (const p of diff.split("\n"))
+            if (p)
+                seen.add(p);
+    }
+    catch { }
+    try {
+        // Untracked files don't show in `git diff`; count them separately.
+        const untracked = gitExec("git ls-files --others --exclude-standard", worktreeCwd);
+        for (const p of untracked.split("\n"))
+            if (p)
+                seen.add(p);
+    }
+    catch { }
+    return seen.size;
+}
 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.
+    if (!baseRef)
+        return 0;
+    // Measure actual work BEFORE committing. This captures reality even if a
+    // pre-commit hook rejects the commit: we used to silently return 0 in that
+    // case and the worktree cleanup would destroy the changes.
+    const preCount = measureWork(worktreeCwd, baseRef);
     let status;
     try {
         status = gitExec("git status --porcelain", worktreeCwd);
     }
     catch (err) {
         log(agentId, `git status failed: ${String(err.message || err).slice(0, 120)}`);
-        return 0;
+        return preCount;
     }
     if (status.trim()) {
         try {
@@ -27,33 +52,49 @@ export function autoCommit(agentId, taskPrompt, worktreeCwd, baseRef, log) {
         catch (err) {
             log(agentId, `git add failed: ${String(err.message || err).slice(0, 120)}`);
         }
+        const msg = taskPrompt.slice(0, 72).replace(/'/g, "'\\''");
         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)}`);
+            if (!m.includes("nothing to commit")) {
+                // Hook-gated project: the user's pre-commit hooks rejected a
+                // potentially work-in-progress commit (lint errors, type errors,
+                // whatever). Retry bypassing hooks — this is swarm scaffolding,
+                // not a user-facing commit. Without this the branch stays empty,
+                // the merge gate drops it, and the work is destroyed when the
+                // worktree is cleaned up.
+                try {
+                    gitExec(`git commit --no-verify -m 'swarm: ${msg}'`, worktreeCwd);
+                    log(agentId, `Commit hooks bypassed (rejected swarm WIP commit)`);
+                }
+                catch (err2) {
+                    log(agentId, `git commit failed even with --no-verify: ${String(err2.message || err2).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;
+    // Authoritative post-commit count: this is what `mergeAllBranches` will
+    // actually see on the branch.
+    let landed = 0;
     try {
         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;
+        landed = diff.trim().split("\n").filter(Boolean).length;
     }
     catch (err) {
         log(agentId, `diff vs base failed: ${String(err.message || err).slice(0, 120)}`);
-        return 0;
     }
+    // Red-flag: work existed before the commit attempt but didn't land on the
+    // branch. Surfaces silent data loss (stuck hooks, writes outside the
+    // worktree, gitignored targets) that used to look like "agent did 0 work".
+    if (landed === 0 && preCount > 0) {
+        log(agentId, `${preCount} file(s) touched but did NOT land on branch — check hooks / gitignore / absolute paths`);
+        return preCount;
+    }
+    if (landed > 0)
+        log(agentId, `${landed} file(s) changed`);
+    return landed;
 }
 export function mergeAllBranches(agents, cwd, strategy, log) {
     const mergeResults = [];
@@ -121,8 +162,17 @@ export function mergeAllBranches(agents, cwd, strategy, log) {
                         gitExec("git merge --abort", cwd);
                     }
                     catch { }
-                    result.error = e.message?.slice(0, 80);
-                    log(agent.id, `Merge conflict: ${agent.branch}`);
+                    // 3rd tier: brute-force overlay. Handles rename/rename, rename/delete
+                    // and other tree-level conflicts that `-X theirs` can't resolve.
+                    if (forceMergeOverlay(agent.branch, cwd)) {
+                        result.ok = true;
+                        result.autoResolved = true;
+                        log(agent.id, `Force-merged ${agent.branch} (overlay)`);
+                    }
+                    else {
+                        result.error = e.message?.slice(0, 80);
+                        log(agent.id, `Merge conflict: ${agent.branch}`);
+                    }
                 }
             }
             mergeResults.push(result);
@@ -165,6 +215,70 @@ export function mergeAllBranches(agents, cwd, strategy, log) {
     }
     return { mergeResults, mergeBranch };
 }
+/**
+ * Last-resort merge: overlay the branch's file state onto HEAD without a real
+ * 3-way merge. Walks `git diff --name-status base..branch` and for each entry
+ * either checks out the branch's version (add/modify/rename) or removes the
+ * file (delete). Always succeeds unless the branch itself is broken. Trades
+ * merge-graph fidelity for "your changes actually land" — the right call for
+ * an autonomous swarm.
+ */
+export function forceMergeOverlay(branch, cwd) {
+    try {
+        const base = gitExec(`git merge-base HEAD "${branch}"`, cwd).trim();
+        const diff = gitExec(`git diff --name-status ${base} "${branch}"`, cwd);
+        for (const line of diff.split("\n")) {
+            if (!line)
+                continue;
+            const fields = line.split("\t");
+            const status = fields[0];
+            if (status.startsWith("R") || status.startsWith("C")) {
+                const from = fields[1];
+                const to = fields[2];
+                if (status.startsWith("R")) {
+                    try {
+                        gitExec(`git rm -f -- "${from}"`, cwd);
+                    }
+                    catch { }
+                }
+                try {
+                    gitExec(`git checkout "${branch}" -- "${to}"`, cwd);
+                    gitExec(`git add -- "${to}"`, cwd);
+                }
+                catch { }
+            }
+            else if (status.startsWith("D")) {
+                try {
+                    gitExec(`git rm -f -- "${fields[1]}"`, cwd);
+                }
+                catch { }
+            }
+            else {
+                try {
+                    gitExec(`git checkout "${branch}" -- "${fields[1]}"`, cwd);
+                    gitExec(`git add -- "${fields[1]}"`, cwd);
+                }
+                catch { }
+            }
+        }
+        const dirty = gitExec("git status --porcelain", cwd).trim();
+        if (!dirty)
+            return true;
+        gitExec(`git commit -m 'swarm: force-merge ${branch}'`, cwd);
+        return true;
+    }
+    catch {
+        try {
+            gitExec("git merge --abort", cwd);
+        }
+        catch { }
+        try {
+            gitExec("git reset --hard HEAD", cwd);
+        }
+        catch { }
+        return false;
+    }
+}
 export function warnDirtyTree(cwd, log) {
     try {
         const status = gitExec("git status --porcelain", cwd);

package/dist/planner-query.js

@@ -219,6 +219,19 @@ export function postProcess(raw, budget, onLog) {
     tasks = tasks.filter((t) => t.prompt && t.prompt.trim().split(/\s+/).length >= 3);
     if (tasks.length < before)
         onLog(`Filtered ${before - tasks.length} task(s) with fewer than 3 words`);
+    // Read-only tasks (verify/audit/user-test) shouldn't get a worktree: they
+    // don't change files, so they'd just create empty swarm branches that show
+    // up as "0 files changed" noise. Run them in the real project directory so
+    // env files, dependencies, and local config are available.
+    let readOnly = 0;
+    for (const t of tasks) {
+        if (!t.noWorktree && /^\s*(verify|audit|user[- ]?test)\b/i.test(t.prompt)) {
+            t.noWorktree = true;
+            readOnly++;
+        }
+    }
+    if (readOnly > 0)
+        onLog(`${readOnly} read-only task(s) marked noWorktree`);
     const dominated = new Set();
     for (let i = 0; i < tasks.length; i++) {
         if (dominated.has(i))

package/dist/state.js

@@ -2,6 +2,7 @@ import { readFileSync, existsSync, mkdirSync, readdirSync, writeFileSync, symlin
 import { execSync } from "child_process";
 import { join } from "path";
 import chalk from "chalk";
+import { forceMergeOverlay } from "./merge.js";
 // ── File I/O helpers ──
 export function readMdDir(dir) {
     try {
@@ -472,8 +473,14 @@ export function autoMergeBranches(cwd, branches, onLog) {
                     execSync("git merge --abort", { cwd, encoding: "utf-8", stdio: "pipe" });
                 }
                 catch { }
-                br.status = "merge-failed";
-                onLog(`  ✗ ${br.branch} (conflict — preserved for manual merge)`);
+                if (forceMergeOverlay(br.branch, cwd)) {
+                    br.status = "merged";
+                    onLog(`  ✓ ${br.branch} (force-merged)`);
+                }
+                else {
+                    br.status = "merge-failed";
+                    onLog(`  ✗ ${br.branch} (conflict — preserved for manual merge)`);
+                }
             }
         }
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-overnight",
-  "version": "1.16.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.",
+  "version": "1.16.5",
+  "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"
@@ -29,19 +29,34 @@
   },
   "keywords": [
     "claude",
+    "claude-code",
     "claude-agent-sdk",
+    "agent-sdk",
+    "managed-agents",
+    "anthropic",
     "ai-agents",
     "ai-coding",
-    "parallel-agents",
     "autonomous-coding",
+    "autonomous-agent",
+    "coding-agent",
+    "background-agent",
+    "async-coding",
+    "parallel-agents",
+    "multi-agent",
     "swarm",
     "overnight",
-    "cli",
+    "overnight-coding",
     "orchestration",
-    "multi-agent",
-    "code-generation",
-    "anthropic",
+    "orchestrator",
+    "cli",
     "worktrees",
+    "git-worktree",
+    "code-generation",
+    "code-automation",
+    "refactoring",
+    "migration",
+    "qwen",
+    "openrouter",
     "iterative"
   ],
   "engines": {