claude-overnight 0.1.0 → 0.1.2

package/README.md

@@ -1,8 +1,8 @@
 # claude-overnight
 
-Run parallel Claude Code agents with a real-time terminal UI.
+Set a task budget, describe an objective, walk away. Come back to shipped work.
 
-Give it an objective and it plans, executes, and merges the results — or feed it explicit tasks. Each agent gets full Claude Code tooling (Read, Edit, Bash, etc.) and optionally runs in an isolated git worktree. A live TUI shows progress, cost, rate limits, and per-agent status.
+Tell it what to build. Set a budget — 10 tasks, 100, 1000, whatever the job needs. A planner agent analyzes your codebase and breaks the objective into that many independent tasks. Then they all run: parallel autonomous Claude Code agents, each in its own git worktree, each with full tooling (Read, Edit, Bash, grep, tests — everything). Rate limits hit? It waits. Windows reset? It resumes. It doesn't stop until every task is done or you tell it to.
 
 ## Install
 
@@ -20,7 +20,7 @@ Requires Node.js >= 20 and a valid Claude authentication (OAuth via `claude` CLI
 claude-overnight
 ```
 
-Prompts for model, concurrency, and permission mode, then asks for an objective. A planner agent analyzes your codebase and breaks it into parallel tasks.
+Describe your objective, set a task budget, pick a model. The planner generates the task breakdown — you can review, edit, chat about it, then run.
 
 ### Task file
 
@@ -38,8 +38,6 @@ Each quoted argument becomes one parallel task.
 
 ## Task file format
 
-A JSON file with a `tasks` array and optional configuration:
-
 ```json
 {
   "tasks": [
@@ -59,7 +57,7 @@ A plain JSON array of strings also works: `["task one", "task two"]`.
 | `tasks` | `(string \| {prompt, cwd?, model?})[]` | required | Tasks to run in parallel |
 | `model` | `string` | prompted | Model for all agents (per-task overridable) |
 | `concurrency` | `number` | `5` | Max agents running simultaneously |
-| `worktrees` | `boolean` | prompted | Isolate each agent in a git worktree |
+| `worktrees` | `boolean` | auto (git repo) | Isolate each agent in a git worktree |
 | `permissionMode` | `"auto" \| "bypassPermissions" \| "default"` | `"auto"` | How agents handle dangerous operations |
 | `cwd` | `string` | `process.cwd()` | Working directory for all agents |
 | `allowedTools` | `string[]` | all | Restrict which tools agents can use |
@@ -69,14 +67,27 @@ A plain JSON array of strings also works: `["task one", "task two"]`.
 
 | Flag | Default | Description |
 |---|---|---|
-| `--concurrency=N` | `5` | Max parallel agents (overrides task file) |
+| `--budget=N` | `10` | How many tasks the planner generates — the total size of the run |
+| `--concurrency=N` | `5` | How many agents run at the same time (budget = total, concurrency = pace) |
 | `--model=NAME` | — | Model override for all agents |
 | `--timeout=SECONDS` | `300` | Agent inactivity timeout (kills only silent agents) |
 | `--dry-run` | — | Show planned tasks without executing them |
+| `-h, --help` | — | Show help |
+| `-v, --version` | — | Print version |
+
+## Rate limits and long runs
+
+claude-overnight is built to run unattended for hours, days, weeks, or months. It handles API rate limits without supervision:
+
+- **Hard block**: when the API rejects a request and returns a reset timestamp, the swarm pauses and resumes exactly when the window opens.
+- **Soft throttle**: at >75% utilization, dispatch slows proactively to avoid hitting the limit.
+- **Retry with backoff**: transient errors (429, overloaded, connection reset) retry with exponential backoff.
+
+No tasks are dropped. Set a budget of 1000, go to sleep, and it will work through every rate limit window until the run is complete.
 
 ## Worktrees and merging
 
-When worktrees are enabled, each agent runs in an isolated git worktree on a `swarm/task-N` branch. Changes are auto-committed when the agent finishes. After all agents complete, branches are merged back sequentially. The default `"yolo"` strategy merges directly into your current branch; `"branch"` creates a new `swarm/run-{timestamp}` branch instead. If a merge conflicts, the swarm retries with `-X theirs`; if that still fails, the branch is preserved for manual resolution. Stale worktrees and orphaned `swarm/*` branches from previous runs are cleaned up automatically on startup.
+Each agent runs in an isolated git worktree on a `swarm/task-N` branch. Changes are auto-committed when the agent finishes. After all agents complete, branches merge back sequentially. The default `"yolo"` strategy merges directly into your current branch; `"branch"` creates a new `swarm/run-{timestamp}` branch instead. Merge conflicts retry with `-X theirs`; if that still fails, the branch is preserved for manual resolution. Stale worktrees and orphaned `swarm/*` branches from previous runs are cleaned up automatically on startup.
 
 ## Exit codes
 

package/dist/index.js

@@ -7,11 +7,11 @@ import { createInterface } from "readline";
 import chalk from "chalk";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { Swarm } from "./swarm.js";
-import { planTasks } from "./planner.js";
+import { planTasks, refinePlan } from "./planner.js";
 import { startRenderLoop, renderSummary } from "./ui.js";
 // ── CLI flag parsing ──
 function parseCliFlags(argv) {
-    const known = new Set(["concurrency", "model", "timeout"]);
+    const known = new Set(["concurrency", "model", "timeout", "budget"]);
     const booleans = new Set(["--dry-run", "-h", "--help", "-v", "--version"]);
     const flags = {};
     const positional = [];
@@ -19,13 +19,11 @@ function parseCliFlags(argv) {
         const arg = argv[i];
         if (booleans.has(arg))
             continue;
-        // --key=value
         const eq = arg.match(/^--(\w[\w-]*)=(.+)$/);
         if (eq && known.has(eq[1])) {
             flags[eq[1]] = eq[2];
             continue;
         }
-        // --key value
         const bare = arg.match(/^--(\w[\w-]*)$/);
         if (bare && known.has(bare[1]) && i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
             flags[bare[1]] = argv[++i];
@@ -40,13 +38,9 @@ function parseCliFlags(argv) {
 const AUTH_PATTERNS = ["unauthorized", "forbidden", "invalid_api_key", "authentication"];
 function isAuthError(err) {
     const msg = err instanceof Error ? err.message : String(err);
-    const lower = msg.toLowerCase();
-    return AUTH_PATTERNS.some((p) => lower.includes(p));
+    return AUTH_PATTERNS.some((p) => msg.toLowerCase().includes(p));
 }
-function authErrorMessage() {
-    return "Authentication failed — check your API key or run: claude auth";
-}
-// ── Fetch models via SDK (works with OAuth / Max / API key) ──
+// ── Fetch models via SDK ──
 async function fetchModels(timeoutMs = 10_000) {
     let q;
     try {
@@ -61,89 +55,99 @@ async function fetchModels(timeoutMs = 10_000) {
     catch (err) {
         q?.close();
         if (err.message === "model_fetch_timeout") {
-            console.warn(chalk.yellow("\n  ⚠ Model fetch timed out — continuing with defaults"));
+            console.warn(chalk.yellow("\n  Model fetch timed out — continuing with defaults"));
         }
         return [];
     }
 }
-// ── Interactive prompts ──
+// ── Interactive primitives ──
 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());
-        });
+        rl.question(question, (answer) => { rl.close(); res(answer.trim()); });
     });
 }
-async function pickModel(models) {
-    if (models.length === 0) {
-        console.log(chalk.yellow("  Could not fetch models. Enter model ID manually."));
-        const ans = await ask(chalk.dim("  Model: "));
-        return ans || "claude-sonnet-4-6";
-    }
-    console.log(chalk.bold("\n  Model:"));
-    for (let i = 0; i < models.length; i++) {
-        const marker = i === 0 ? chalk.green("→") : " ";
-        const name = models[i].displayName;
-        const desc = models[i].description ? chalk.dim(` — ${models[i].description}`) : "";
-        const label = i === 0 ? chalk.green(name) + desc : chalk.dim(name) + desc;
-        console.log(`  ${marker} ${i + 1}. ${label}`);
-    }
-    const ans = await ask(chalk.dim(`  Choose [1]: `));
-    const idx = ans ? parseInt(ans) - 1 : 0;
-    const pick = models[idx] ?? models[0];
-    console.log(chalk.dim(`  Using ${pick.displayName}`));
-    return pick.value;
-}
-async function pickConcurrency() {
-    const ans = await ask(chalk.dim("  Concurrency [5]: "));
-    return parseInt(ans) || 5;
-}
-async function pickWorktrees() {
-    const ans = await ask(chalk.dim("  Use git worktrees? [Y/n]: "));
-    return ans.toLowerCase() !== "n";
-}
-async function pickMergeStrategy() {
-    console.log(chalk.bold("\n  Merge strategy:"));
-    console.log(`  ${chalk.green("→")} 1. ${chalk.green("YOLO")}${chalk.dim(" — merge into current branch")}`);
-    console.log(`    2. ${chalk.dim("New branch")}${chalk.dim(" — merge into a new branch (safe for PRs)")}`);
-    const ans = await ask(chalk.dim("  Choose [1]: "));
-    const pick = ans === "2" ? "branch" : "yolo";
-    console.log(chalk.dim(`  Using ${pick === "yolo" ? "YOLO (merge into current)" : "new branch"}`));
-    return pick;
-}
-const PERM_MODES = [
-    { label: "Auto", value: "auto", desc: "AI decides what's safe" },
-    { label: "Bypass permissions", value: "bypassPermissions", desc: "skip all prompts (dangerous)" },
-    { label: "Default", value: "default", desc: "prompt for dangerous ops" },
-];
-async function pickPermissionMode() {
-    console.log(chalk.bold("\n  Permission mode:"));
-    for (let i = 0; i < PERM_MODES.length; i++) {
-        const marker = i === 0 ? chalk.green("→") : " ";
-        const name = i === 0 ? chalk.green(PERM_MODES[i].label) : chalk.dim(PERM_MODES[i].label);
-        const desc = chalk.dim(` — ${PERM_MODES[i].desc}`);
-        console.log(`  ${marker} ${i + 1}. ${name}${desc}`);
-    }
-    const ans = await ask(chalk.dim("  Choose [1]: "));
-    const idx = ans ? parseInt(ans) - 1 : 0;
-    const pick = PERM_MODES[idx] ?? PERM_MODES[0];
-    console.log(chalk.dim(`  Using ${pick.label}`));
-    return pick.value;
-}
-async function pickObjective() {
-    console.log("");
-    while (true) {
-        const ans = await ask(chalk.bold("  What should the swarm do?\n  > "));
-        if (!ans)
-            return ans;
-        if (ans.split(/\s+/).length < 5) {
-            console.log(chalk.yellow('  Tip: be specific about what you want, e.g. "refactor auth module and add tests"'));
-            continue;
+async function select(label, items, defaultIdx = 0) {
+    const { stdin, stdout } = process;
+    let idx = defaultIdx;
+    const draw = (first = false) => {
+        if (!first)
+            stdout.write(`\x1B[${items.length}A`);
+        for (let i = 0; i < items.length; i++) {
+            const arrow = i === idx ? chalk.green("  → ") : "    ";
+            const name = i === idx ? chalk.green(items[i].name) : chalk.dim(items[i].name);
+            const hint = items[i].hint ? chalk.dim(` — ${items[i].hint}`) : "";
+            stdout.write(`\x1B[2K${arrow}${name}${hint}\n`);
         }
-        return ans;
-    }
+    };
+    stdout.write(`\n  ${chalk.bold(label)}\n`);
+    draw(true);
+    return new Promise((resolve) => {
+        stdin.setRawMode(true);
+        stdin.resume();
+        const done = (val) => {
+            stdin.setRawMode(false);
+            stdin.removeListener("data", handler);
+            stdin.pause();
+            resolve(val);
+        };
+        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")
+                done(items[idx].value);
+            else if (s === "\x03") {
+                stdin.setRawMode(false);
+                process.exit(0);
+            }
+            else if (/^[1-9]$/.test(s)) {
+                const n = parseInt(s) - 1;
+                if (n < items.length) {
+                    idx = n;
+                    draw();
+                    done(items[idx].value);
+                }
+            }
+        };
+        stdin.on("data", handler);
+    });
+}
+async function selectKey(label, options) {
+    const { stdin, stdout } = process;
+    const keys = options.map((o) => o.key.toLowerCase());
+    stdout.write(`\n  ${label}  ${options.map((o) => `[${chalk.bold(o.key.toUpperCase())}]${chalk.dim(o.desc)}`).join("  ")}\n  `);
+    return new Promise((resolve) => {
+        stdin.setRawMode(true);
+        stdin.resume();
+        const handler = (buf) => {
+            const s = buf.toString().toLowerCase();
+            if (s === "\x03") {
+                stdin.setRawMode(false);
+                process.exit(0);
+            }
+            if (s === "\r") {
+                stdin.setRawMode(false);
+                stdin.removeListener("data", handler);
+                stdin.pause();
+                resolve(keys[0]);
+                return;
+            }
+            if (keys.includes(s)) {
+                stdin.setRawMode(false);
+                stdin.removeListener("data", handler);
+                stdin.pause();
+                resolve(s);
+            }
+        };
+        stdin.on("data", handler);
+    });
 }
 const KNOWN_TASK_FILE_KEYS = new Set([
     "tasks", "concurrency", "cwd", "model", "permissionMode", "allowedTools", "worktrees", "mergeStrategy",
@@ -167,15 +171,12 @@ function loadTaskFile(file) {
     const parsed = Array.isArray(json)
         ? { tasks: json }
         : json;
-    // Reject unknown top-level keys
     if (!Array.isArray(json) && typeof json === "object" && json !== null) {
         const unknown = Object.keys(json).filter((k) => !KNOWN_TASK_FILE_KEYS.has(k));
         if (unknown.length > 0) {
-            throw new Error(`Unknown key${unknown.length > 1 ? "s" : ""} in task file: ${unknown.join(", ")}. ` +
-                `Allowed keys: ${[...KNOWN_TASK_FILE_KEYS].join(", ")}`);
+            throw new Error(`Unknown key${unknown.length > 1 ? "s" : ""} in task file: ${unknown.join(", ")}. Allowed: ${[...KNOWN_TASK_FILE_KEYS].join(", ")}`);
         }
     }
-    // Validate tasks array
     if (!Array.isArray(parsed.tasks)) {
         throw new Error(`Task file must contain a "tasks" array (got ${typeof parsed.tasks})`);
     }
@@ -189,19 +190,16 @@ function loadTaskFile(file) {
             tasks.push({ id, prompt: t });
         }
         else if (typeof t === "object" && t !== null) {
-            if (typeof t.prompt !== "string" || !t.prompt.trim()) {
+            if (typeof t.prompt !== "string" || !t.prompt.trim())
                 throw new Error(`Task ${i} is missing a "prompt" string`);
-            }
             tasks.push({ id, prompt: t.prompt, cwd: t.cwd ? resolve(t.cwd) : undefined, model: t.model });
         }
         else {
             throw new Error(`Task ${i} must be a string or object with a "prompt" field (got ${typeof t})`);
         }
     }
-    // Validate concurrency if present
-    if (parsed.concurrency !== undefined) {
+    if (parsed.concurrency !== undefined)
         validateConcurrency(parsed.concurrency);
-    }
     return {
         tasks,
         concurrency: parsed.concurrency,
@@ -219,11 +217,6 @@ function validateConcurrency(value) {
         throw new Error(`Concurrency must be a positive integer (got ${JSON.stringify(value)})`);
     }
 }
-function validateCwd(cwd) {
-    if (!existsSync(cwd)) {
-        throw new Error(`Working directory does not exist: ${cwd}`);
-    }
-}
 function isGitRepo(cwd) {
     try {
         execSync("git rev-parse --git-dir", { cwd, encoding: "utf-8", stdio: "pipe" });
@@ -236,11 +229,17 @@ function isGitRepo(cwd) {
 function validateGitRepo(cwd) {
     if (!isGitRepo(cwd)) {
         throw new Error(`Worktrees require a git repository, but ${cwd} is not inside one.\n` +
-            `  Run this to initialize one:\n\n` +
-            `    cd ${cwd} && git init\n\n` +
-            `  Or disable worktrees (set "worktrees": false in your task file).`);
+            `  Run: cd ${cwd} && git init\n` +
+            `  Or set "worktrees": false in your task file.`);
     }
 }
+// ── Show plan ──
+function showPlan(tasks) {
+    for (const t of tasks) {
+        console.log(chalk.dim(`    ${Number(t.id) + 1}. ${t.prompt.slice(0, 90)}`));
+    }
+    console.log("");
+}
 // ── Main ──
 async function main() {
     const argv = process.argv.slice(2);
@@ -255,7 +254,7 @@ async function main() {
   ${chalk.bold("claude-overnight")} — fire off Claude agents, come back to shipped work
 
   ${chalk.dim("Usage:")}
-    claude-overnight                          ${chalk.dim("interactive — pick model, concurrency, objective")}
+    claude-overnight                          ${chalk.dim("interactive — describe what to do, review plan, run")}
     claude-overnight tasks.json               ${chalk.dim("run tasks defined in a JSON file")}
     claude-overnight "fix auth" "add tests"   ${chalk.dim("run inline tasks in parallel")}
 
@@ -263,34 +262,29 @@ async function main() {
     -h, --help             Show this help
     -v, --version          Print version
     --dry-run              Show planned tasks without running them
-    --concurrency=N        Max parallel agents ${chalk.dim("(overrides task file & defaults)")}
-    --model=NAME           Model to use ${chalk.dim("(overrides task file & defaults)")}
+    --budget=N             Target number of agent runs ${chalk.dim("(planner aims for this many tasks)")}
+    --concurrency=N        Max parallel agents ${chalk.dim("(default: 5)")}
+    --model=NAME           Model override
     --timeout=SECONDS      Agent inactivity timeout ${chalk.dim("(default: 300s, kills only silent agents)")}
 
-  ${chalk.dim("Permission modes")} ${chalk.dim("(task file: \"permissionMode\", interactive: prompted)")}
-    auto               AI decides which ops are safe ${chalk.dim("(default)")}
-    bypassPermissions  Skip all permission prompts ${chalk.yellow("(dangerous)")}
-    default            Prompt before destructive operations
-
   ${chalk.dim("Non-interactive defaults (task file / inline / piped):")}
-    model: first available    concurrency: 5    worktrees: auto (git repo)    perms: auto
+    model: first available    concurrency: 5    worktrees: auto    perms: auto
     `);
         process.exit(0);
     }
     const dryRun = argv.includes("--dry-run");
     const { flags: cliFlags, positional: args } = parseCliFlags(argv);
-    // Validate CLI flag values early
     if (cliFlags.concurrency !== undefined) {
         const n = parseInt(cliFlags.concurrency);
         if (!Number.isInteger(n) || n < 1) {
-            console.error(chalk.red(`  --concurrency must be a positive integer (got "${cliFlags.concurrency}")`));
+            console.error(chalk.red(`  --concurrency must be a positive integer`));
             process.exit(1);
         }
     }
     if (cliFlags.timeout !== undefined) {
         const n = parseFloat(cliFlags.timeout);
         if (isNaN(n) || n <= 0) {
-            console.error(chalk.red(`  --timeout must be a positive number (got "${cliFlags.timeout}")`));
+            console.error(chalk.red(`  --timeout must be a positive number`));
             process.exit(1);
         }
     }
@@ -299,8 +293,7 @@ async function main() {
     let fileCfg;
     const jsonFiles = args.filter((a) => a.endsWith(".json"));
     if (jsonFiles.length > 1) {
-        console.error(chalk.red(`  Multiple task files provided: ${jsonFiles.join(", ")}`));
-        console.error(chalk.red(`  Only one .json task file is supported at a time.`));
+        console.error(chalk.red(`  Multiple task files provided. Only one .json file is supported.`));
         process.exit(1);
     }
     for (const arg of args) {
@@ -309,136 +302,186 @@ async function main() {
             tasks = fileCfg.tasks;
         }
         else if (!arg.startsWith("-") && existsSync(resolve(arg))) {
-            console.error(chalk.red(`  "${arg}" looks like a file path but doesn't end in .json.`));
-            console.error(chalk.red(`  To use it as a task file, rename it: mv ${arg} ${arg.replace(/(\.\w+)?$/, ".json")}`));
-            console.error(chalk.red(`  To run it as an inline task prompt, ignore this message and quote the string.`));
+            console.error(chalk.red(`  "${arg}" looks like a file but doesn't end in .json. Rename it or quote the string.`));
             process.exit(1);
         }
         else {
             tasks.push({ id: String(tasks.length), prompt: arg });
         }
     }
-    // ── Config: defaults for non-interactive, prompts for interactive ──
-    console.log(chalk.bold("\n  🌙 claude-overnight\n"));
+    // ── Determine mode ──
+    console.log(chalk.bold("\n  \uD83C\uDF19 claude-overnight\n"));
     const noTTY = !process.stdin.isTTY;
     const nonInteractive = noTTY || fileCfg !== undefined || tasks.length > 0;
     const cwd = fileCfg?.cwd ?? process.cwd();
     const allowedTools = fileCfg?.allowedTools;
-    validateCwd(cwd);
-    if (!nonInteractive) {
-        console.log(chalk.dim("  Run parallel Claude Code agents with real-time UI.\n"));
-        console.log(chalk.dim("    • Interactive  — describe an objective, auto-plan into tasks"));
-        console.log(chalk.dim("    • Task file    — claude-overnight tasks.json"));
-        console.log(chalk.dim("    • Inline args  — claude-overnight \"fix auth\" \"add tests\""));
-    }
-    if (noTTY) {
-        console.log(chalk.dim("  Non-interactive mode — using defaults"));
+    if (!existsSync(cwd)) {
+        console.error(chalk.red(`  Working directory does not exist: ${cwd}`));
+        process.exit(1);
     }
-    let models = [];
-    // Fetch models unless already overridden by CLI/file — non-interactive uses a shorter timeout
-    const modelAlreadySet = cliFlags.model || fileCfg?.model;
-    if (!modelAlreadySet) {
-        if (nonInteractive) {
-            models = await fetchModels(5_000);
+    if (noTTY)
+        console.log(chalk.dim("  Non-interactive mode — using defaults\n"));
+    // ── Interactive flow: Objective → Budget → Model → Plan → Review ──
+    let model;
+    let budget;
+    let concurrency;
+    let objective;
+    if (!nonInteractive) {
+        console.log(chalk.dim("  Fire off Claude agents, come back to shipped work.\n"));
+        // 1. Objective first — it's the whole point
+        while (true) {
+            objective = await ask(chalk.bold("  What should the agents do?\n  > "));
+            if (!objective) {
+                console.error(chalk.red("\n  No objective provided."));
+                process.exit(1);
+            }
+            if (objective.split(/\s+/).length >= 5)
+                break;
+            console.log(chalk.yellow('  Be specific, e.g. "refactor the auth module, add tests, and update docs"\n'));
+        }
+        // 2. Budget — how many agent runs to spend
+        const budgetAns = await ask(chalk.dim("\n  Agent budget [10]: "));
+        budget = parseInt(budgetAns) || 10;
+        // 3. Model — arrow keys
+        process.stdout.write(chalk.dim("  Fetching models..."));
+        const models = await fetchModels();
+        process.stdout.write(`\x1B[2K\r`);
+        if (models.length > 0) {
+            model = await select("Model:", models.map((m) => ({
+                name: m.displayName,
+                value: m.value,
+                hint: m.description,
+            })));
         }
         else {
-            process.stdout.write(chalk.dim("  Fetching available models..."));
-            models = await fetchModels();
-            process.stdout.write(`\x1B[2K\r`);
+            const ans = await ask(chalk.dim("  Model [claude-sonnet-4-6]: "));
+            model = ans || "claude-sonnet-4-6";
         }
+        // Concurrency defaults based on budget
+        concurrency = Math.min(5, budget);
+    }
+    else {
+        // Non-interactive: resolve config from file/flags/defaults
+        let models = [];
+        if (!cliFlags.model && !fileCfg?.model)
+            models = await fetchModels(5_000);
+        model = cliFlags.model ?? fileCfg?.model ?? (models[0]?.value || "claude-sonnet-4-6");
+        concurrency = cliFlags.concurrency ? parseInt(cliFlags.concurrency) : (fileCfg?.concurrency ?? 5);
+        budget = cliFlags.budget ? parseInt(cliFlags.budget) : undefined;
     }
-    // CLI flags override task file values, which override interactive defaults
-    const model = cliFlags.model ?? fileCfg?.model ?? (nonInteractive ? (models[0]?.value || "claude-sonnet-4-6") : await pickModel(models));
-    const permissionMode = fileCfg?.permissionMode ?? (nonInteractive ? "auto" : await pickPermissionMode());
-    const concurrency = cliFlags.concurrency ? parseInt(cliFlags.concurrency) : (fileCfg?.concurrency ?? (nonInteractive ? 5 : await pickConcurrency()));
     validateConcurrency(concurrency);
-    const useWorktrees = fileCfg?.useWorktrees ?? (nonInteractive ? (noTTY ? false : isGitRepo(cwd)) : await pickWorktrees());
+    const permissionMode = fileCfg?.permissionMode ?? "auto";
+    const useWorktrees = fileCfg?.useWorktrees ?? (isGitRepo(cwd));
     if (useWorktrees)
         validateGitRepo(cwd);
-    const mergeStrategy = fileCfg?.mergeStrategy ?? (useWorktrees && !nonInteractive ? await pickMergeStrategy() : "yolo");
+    const mergeStrategy = fileCfg?.mergeStrategy ?? "yolo";
     if (nonInteractive) {
         console.log(chalk.dim(`  ${model}  concurrency=${concurrency}  worktrees=${useWorktrees}  merge=${mergeStrategy}  perms=${permissionMode}`));
     }
-    // If no tasks yet, ask for an objective and plan
-    let planMode = tasks.length === 0;
-    let objective;
-    if (planMode) {
+    // ── Plan phase (interactive: review loop, non-interactive: auto-plan or skip) ──
+    const needsPlan = tasks.length === 0;
+    if (needsPlan) {
         if (noTTY) {
-            console.error(chalk.red("\n  No tasks provided and stdin is not a TTY. Provide tasks via args or a JSON file."));
+            console.error(chalk.red("  No tasks provided and stdin is not a TTY. Provide tasks via args or a .json file."));
             process.exit(1);
         }
-        objective = await pickObjective();
-        if (!objective) {
-            console.error(chalk.red("\n  No objective provided."));
-            process.exit(1);
-        }
-    }
-    // Hide cursor + graceful shutdown (swarm-aware handler installed after swarm is created)
-    process.stdout.write("\x1B[?25l");
-    const restore = () => process.stdout.write("\x1B[?25h\n");
-    process.on("SIGINT", () => { restore(); process.exit(0); });
-    process.on("SIGTERM", () => { restore(); process.exit(0); });
-    // ── Plan phase ──
-    if (planMode && objective) {
+        process.stdout.write("\x1B[?25l");
+        const restore = () => process.stdout.write("\x1B[?25h");
         console.log(chalk.magenta("\n  Planning...\n"));
         try {
-            tasks = await planTasks(objective, cwd, model, permissionMode, (text) => {
+            tasks = await planTasks(objective, cwd, model, permissionMode, budget, concurrency, (text) => {
                 process.stdout.write(`\x1B[2K\r  ${chalk.dim(text)}`);
             });
-            process.stdout.write(`\x1B[2K\r  ${chalk.green(`Generated ${tasks.length} tasks`)}\n\n`);
-            for (const t of tasks) {
-                console.log(chalk.dim(`    ${t.id}. ${t.prompt.slice(0, 70)}`));
-            }
-            console.log("");
-            process.stdout.write("\x1B[?25h"); // show cursor for prompt
-            const confirm = await ask(`  Run ${tasks.length} task${tasks.length === 1 ? "" : "s"} with concurrency ${concurrency}? [Y/n] `);
-            if (confirm.toLowerCase() === "n") {
-                restore();
-                console.log(chalk.dim("  Aborted.\n"));
-                process.exit(0);
-            }
-            process.stdout.write("\x1B[?25l"); // re-hide cursor
+            process.stdout.write(`\x1B[2K\r  ${chalk.green(`${tasks.length} tasks`)}\n\n`);
         }
         catch (err) {
             restore();
-            if (isAuthError(err)) {
-                console.error(chalk.red(`\n  ${authErrorMessage()}\n`));
-            }
-            else {
+            if (isAuthError(err))
+                console.error(chalk.red(`\n  Authentication failed — check your API key or run: claude auth\n`));
+            else
                 console.error(chalk.red(`\n  Planning failed: ${err.message}\n`));
-            }
             process.exit(1);
         }
+        // ── Review loop ──
+        restore();
+        let reviewing = true;
+        while (reviewing) {
+            showPlan(tasks);
+            const action = await selectKey(`${tasks.length} tasks, concurrency ${concurrency}.`, [
+                { key: "r", desc: "un" },
+                { key: "e", desc: "dit" },
+                { key: "c", desc: "hat" },
+                { key: "q", desc: "uit" },
+            ]);
+            switch (action) {
+                case "r":
+                    reviewing = false;
+                    break;
+                case "e": {
+                    const feedback = await ask(chalk.bold("\n  What should change?\n  > "));
+                    if (!feedback)
+                        break;
+                    console.log(chalk.magenta("\n  Re-planning...\n"));
+                    process.stdout.write("\x1B[?25l");
+                    try {
+                        tasks = await refinePlan(objective, tasks, feedback, cwd, model, permissionMode, budget, concurrency, (text) => {
+                            process.stdout.write(`\x1B[2K\r  ${chalk.dim(text)}`);
+                        });
+                        process.stdout.write(`\x1B[2K\r  ${chalk.green(`${tasks.length} tasks`)}\n\n`);
+                    }
+                    catch (err) {
+                        console.error(chalk.red(`\n  Re-planning failed: ${err.message}\n`));
+                    }
+                    restore();
+                    break;
+                }
+                case "c": {
+                    const question = await ask(chalk.bold("\n  Ask about the plan:\n  > "));
+                    if (!question)
+                        break;
+                    process.stdout.write("\x1B[?25l");
+                    try {
+                        let answer = "";
+                        for await (const msg of query({
+                            prompt: `You planned these tasks for the objective "${objective}":\n${tasks.map((t, i) => `${i + 1}. ${t.prompt}`).join("\n")}\n\nUser question: ${question}`,
+                            options: { cwd, model, permissionMode, persistSession: false },
+                        })) {
+                            if (msg.type === "result" && msg.subtype === "success")
+                                answer = msg.result || "";
+                        }
+                        restore();
+                        if (answer)
+                            console.log(chalk.dim(`\n  ${answer.slice(0, 500)}\n`));
+                    }
+                    catch {
+                        restore();
+                    }
+                    break;
+                }
+                case "q":
+                    console.log(chalk.dim("\n  Aborted.\n"));
+                    process.exit(0);
+            }
+        }
     }
     if (tasks.length === 0) {
-        restore();
         console.error("No tasks provided.");
         process.exit(1);
     }
     if (dryRun) {
-        restore();
         console.log(chalk.bold("  Tasks:"));
-        for (const t of tasks) {
-            console.log(`  ${chalk.dim(`${Number(t.id) + 1}.`)} ${t.prompt}`);
-        }
-        console.log("");
+        showPlan(tasks);
         process.exit(0);
     }
+    // ── Run ──
+    process.stdout.write("\x1B[?25l");
+    const restore = () => process.stdout.write("\x1B[?25h\n");
     const agentTimeoutMs = cliFlags.timeout ? parseFloat(cliFlags.timeout) * 1000 : undefined;
     const swarm = new Swarm({
-        tasks,
-        concurrency,
-        cwd,
-        model,
-        permissionMode,
-        allowedTools,
-        useWorktrees,
-        mergeStrategy,
-        agentTimeoutMs,
+        tasks, concurrency, cwd, model, permissionMode, allowedTools,
+        useWorktrees, mergeStrategy, agentTimeoutMs,
     });
-    // Replace simple handlers with graceful drain: first signal stops queue, second force-exits
-    process.removeAllListeners("SIGINT");
-    process.removeAllListeners("SIGTERM");
+    // Graceful drain
     let stopping = false;
     const gracefulStop = (signal) => {
         if (stopping) {
@@ -447,26 +490,13 @@ async function main() {
             process.exit(0);
         }
         stopping = true;
-        process.stdout.write(`\n  ${chalk.yellow(`${signal}: stopping... waiting for ${swarm.active} active agent(s) to finish (send again to force)`)}\n`);
+        process.stdout.write(`\n  ${chalk.yellow(`${signal}: stopping... ${swarm.active} active (send again to force)`)}\n`);
         swarm.abort();
     };
     process.on("SIGINT", () => gracefulStop("SIGINT"));
     process.on("SIGTERM", () => gracefulStop("SIGTERM"));
-    process.on("uncaughtException", (err) => {
-        swarm.abort();
-        swarm.cleanup();
-        restore();
-        console.error(chalk.red(`\n  Uncaught exception: ${err.message}`));
-        process.exit(1);
-    });
-    process.on("unhandledRejection", (reason) => {
-        swarm.abort();
-        swarm.cleanup();
-        restore();
-        const msg = reason instanceof Error ? reason.message : String(reason);
-        console.error(chalk.red(`\n  Unhandled rejection: ${msg}`));
-        process.exit(1);
-    });
+    process.on("uncaughtException", (err) => { swarm.abort(); swarm.cleanup(); restore(); console.error(chalk.red(`\n  Uncaught: ${err.message}`)); process.exit(1); });
+    process.on("unhandledRejection", (reason) => { swarm.abort(); swarm.cleanup(); restore(); console.error(chalk.red(`\n  Unhandled: ${reason instanceof Error ? reason.message : reason}`)); process.exit(1); });
     const stopRender = startRenderLoop(swarm);
     try {
         await swarm.run();
@@ -475,7 +505,7 @@ async function main() {
         if (isAuthError(err)) {
             stopRender();
             restore();
-            console.error(chalk.red(`\n  ${authErrorMessage()}\n`));
+            console.error(chalk.red(`\n  Authentication failed — check your API key or run: claude auth\n`));
             process.exit(1);
         }
         throw err;
@@ -487,18 +517,13 @@ async function main() {
         const summary = failedAgents.length > 0
             ? chalk.yellow(`${swarm.completed} done, ${failedAgents.length} failed`)
             : chalk.green(`${swarm.completed} done`);
-        const cost = swarm.totalCostUsd > 0
-            ? ` ($${swarm.totalCostUsd.toFixed(3)})`
-            : "";
+        const cost = swarm.totalCostUsd > 0 ? ` ($${swarm.totalCostUsd.toFixed(3)})` : "";
         console.log(`\n  ${chalk.bold("Complete:")} ${summary}${chalk.dim(cost)}`);
         if (failedAgents.length > 0) {
             console.log(chalk.red(`\n  Failed agents:`));
             for (const a of failedAgents) {
-                const prompt = a.task.prompt;
-                const label = prompt.slice(0, 60) + (prompt.length > 60 ? "…" : "");
-                const reason = a.error || "unknown error";
-                console.log(chalk.red(`    ✗ Agent ${a.id + 1}: ${label}`));
-                console.log(chalk.dim(`      ${reason}`));
+                console.log(chalk.red(`    \u2717 Agent ${a.id + 1}: ${a.task.prompt.slice(0, 60)}${a.task.prompt.length > 60 ? "\u2026" : ""}`));
+                console.log(chalk.dim(`      ${a.error || "unknown error"}`));
             }
         }
         const elapsed = Math.round((Date.now() - swarm.startedAt) / 1000);
@@ -514,33 +539,25 @@ async function main() {
                 const extra = autoResolved > 0 ? chalk.yellow(` (${autoResolved} auto-resolved)`) : "";
                 console.log(chalk.green(`  Merged ${merged.length} branch(es) into ${target}`) + extra);
             }
-            if (swarm.mergeBranch) {
+            if (swarm.mergeBranch)
                 console.log(chalk.dim(`  Branch: ${swarm.mergeBranch} — create a PR or: git merge ${swarm.mergeBranch}`));
-            }
             if (conflicts.length > 0) {
-                console.log(chalk.red(`  ${conflicts.length} branch(es) had unresolved conflicts:`));
-                for (const c of conflicts) {
+                console.log(chalk.red(`  ${conflicts.length} unresolved conflict(s):`));
+                for (const c of conflicts)
                     console.log(chalk.red(`    ${c.branch}`));
-                }
-                console.log(chalk.dim("  Branches preserved — merge manually with: git merge <branch>"));
+                console.log(chalk.dim("  Merge manually: git merge <branch>"));
             }
         }
-        if (swarm.logFile) {
+        if (swarm.logFile)
             console.log(chalk.dim(`  Log: ${swarm.logFile}`));
-        }
         console.log("");
     }
-    // Exit codes: 0 = all succeeded, 1 = some failed, 2 = all failed or aborted
-    if (swarm.aborted || swarm.completed === 0) {
+    if (swarm.aborted || swarm.completed === 0)
         process.exit(2);
-    }
-    if (swarm.failed > 0) {
+    if (swarm.failed > 0)
         process.exit(1);
-    }
-}
-function sleep(ms) {
-    return new Promise((r) => setTimeout(r, ms));
 }
+function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
 function fmtTokens(n) {
     if (n >= 1_000_000)
         return `${(n / 1_000_000).toFixed(1)}M`;

package/dist/planner.d.ts

@@ -1,5 +1,3 @@
 import type { Task, PermMode } from "./types.js";
-/**
- * Coordinator: analyzes the codebase, breaks objective into parallel tasks.
- */
-export declare function planTasks(objective: string, cwd: string, model: string, permissionMode: PermMode, onLog: (text: string) => void): Promise<Task[]>;
+export declare function planTasks(objective: string, cwd: string, model: string, permissionMode: PermMode, budget: number | undefined, concurrency: number, onLog: (text: string) => void): Promise<Task[]>;
+export declare function refinePlan(objective: string, previousTasks: Task[], feedback: string, cwd: string, model: string, permissionMode: PermMode, budget: number | undefined, concurrency: number, onLog: (text: string) => void): Promise<Task[]>;

package/dist/planner.js

@@ -1,13 +1,9 @@
 import { query } from "@anthropic-ai/claude-agent-sdk";
-/**
- * Coordinator: analyzes the codebase, breaks objective into parallel tasks.
- */
-export async function planTasks(objective, cwd, model, permissionMode, onLog) {
-    onLog("Analyzing codebase...");
-    const INACTIVITY_MS = 5 * 60 * 1000;
-    let resultText = "";
-    const plannerQuery = query({
-        prompt: `You are a task coordinator for a parallel agent swarm. Analyze this codebase and break the following objective into independent tasks.
+const INACTIVITY_MS = 5 * 60 * 1000;
+function plannerPrompt(objective, budget, concurrency) {
+    const budgetLine = budget ? `\n- Target exactly ~${budget} tasks (this is the user's agent budget)` : "\n- Aim for 3-15 tasks depending on scope";
+    const concLine = concurrency ? `\n- ${concurrency} agents will run in parallel — design tasks so parallel agents touch DIFFERENT files to avoid merge conflicts` : "";
+    return `You are a task coordinator for a parallel agent system. Analyze this codebase and break the following objective into independent tasks.
 
 Objective: ${objective}
 
@@ -15,8 +11,7 @@ Requirements:
 - Each task MUST be independent — no task depends on another
 - Each task should target specific files/areas to avoid merge conflicts
 - Be specific: mention exact file paths, function names, what to change
-- Keep tasks focused: one logical change per task
-- Aim for 3-15 tasks depending on scope
+- Keep tasks focused: one logical change per task${budgetLine}${concLine}
 
 Respond with ONLY a JSON object (no markdown fences):
 {
@@ -24,51 +19,50 @@ Respond with ONLY a JSON object (no markdown fences):
     { "prompt": "In src/foo.ts, refactor the bar() function to..." },
     { "prompt": "Add unit tests for the baz module in test/baz.test.ts..." }
   ]
-}`,
+}`;
+}
+async function runPlannerQuery(prompt, opts, onLog) {
+    let resultText = "";
+    const pq = query({
+        prompt,
         options: {
-            cwd,
-            model,
+            cwd: opts.cwd,
+            model: opts.model,
             tools: ["Read", "Glob", "Grep"],
             allowedTools: ["Read", "Glob", "Grep"],
-            permissionMode: permissionMode,
-            ...(permissionMode === "bypassPermissions" && { allowDangerouslySkipPermissions: true }),
+            permissionMode: opts.permissionMode,
+            ...(opts.permissionMode === "bypassPermissions" && { allowDangerouslySkipPermissions: true }),
             persistSession: false,
             includePartialMessages: true,
         },
     });
-    // Inactivity watchdog — only kills planner if it goes completely silent
     let lastActivity = Date.now();
     let timer;
     const watchdog = new Promise((_, reject) => {
         const check = () => {
             const silent = Date.now() - lastActivity;
             if (silent >= INACTIVITY_MS) {
-                plannerQuery.close();
+                pq.close();
                 reject(new Error(`Planner silent for ${Math.round(silent / 1000)}s — assumed hung`));
             }
-            else {
+            else
                 timer = setTimeout(check, Math.min(30_000, INACTIVITY_MS - silent + 1000));
-            }
         };
         timer = setTimeout(check, INACTIVITY_MS);
     });
     const consume = async () => {
-        for await (const msg of plannerQuery) {
+        for await (const msg of pq) {
             lastActivity = Date.now();
             if (msg.type === "stream_event") {
                 const ev = msg.event;
-                if (ev?.type === "content_block_start" &&
-                    ev.content_block?.type === "tool_use") {
+                if (ev?.type === "content_block_start" && ev.content_block?.type === "tool_use")
                     onLog(ev.content_block.name);
-                }
             }
             if (msg.type === "result") {
-                if (msg.subtype === "success") {
+                if (msg.subtype === "success")
                     resultText = msg.result || "";
-                }
-                else {
+                else
                     throw new Error(`Planner failed: ${msg.subtype}`);
-                }
             }
         }
     };
@@ -78,73 +72,47 @@ Respond with ONLY a JSON object (no markdown fences):
     finally {
         clearTimeout(timer);
     }
-    const parsed = await extractTaskJson(resultText, async () => {
-        onLog("Retrying for valid JSON...");
-        let retryText = "";
-        for await (const msg of query({
-            prompt: `Your previous response did not contain valid JSON. Output ONLY a JSON object with this shape, nothing else:\n{"tasks":[{"prompt":"..."}]}`,
-            options: {
-                cwd,
-                model,
-                permissionMode,
-                ...(permissionMode === "bypassPermissions" && { allowDangerouslySkipPermissions: true }),
-                persistSession: false,
-            },
-        })) {
-            if (msg.type === "result" && msg.subtype === "success") {
-                retryText = msg.result || "";
-            }
-        }
-        return retryText;
-    });
-    let tasks = (parsed.tasks || []).map((t, i) => ({
-        id: String(i),
-        prompt: typeof t === "string" ? t : t.prompt,
-    }));
-    // Filter garbage tasks (require at least 3 space-separated words)
+    return resultText;
+}
+function postProcess(raw, onLog) {
+    let tasks = raw;
+    // Filter garbage (< 3 words)
     const before = tasks.length;
     tasks = tasks.filter((t) => t.prompt && t.prompt.trim().split(/\s+/).length >= 3);
-    if (tasks.length < before) {
+    if (tasks.length < before)
         onLog(`Filtered ${before - tasks.length} task(s) with fewer than 3 words`);
-    }
-    // Deduplicate tasks with very similar prompts (>80% word overlap)
-    {
-        const dominated = new Set();
-        for (let i = 0; i < tasks.length; i++) {
-            if (dominated.has(i))
+    // Dedup >80% word overlap
+    const dominated = new Set();
+    for (let i = 0; i < tasks.length; i++) {
+        if (dominated.has(i))
+            continue;
+        const setA = new Set(tasks[i].prompt.toLowerCase().split(/\s+/));
+        for (let j = i + 1; j < tasks.length; j++) {
+            if (dominated.has(j))
                 continue;
-            const setA = new Set(tasks[i].prompt.toLowerCase().split(/\s+/));
-            for (let j = i + 1; j < tasks.length; j++) {
-                if (dominated.has(j))
-                    continue;
-                const setB = new Set(tasks[j].prompt.toLowerCase().split(/\s+/));
-                const shared = [...setA].filter((w) => setB.has(w)).length;
-                const overlap = shared / Math.min(setA.size, setB.size);
-                if (overlap > 0.8) {
-                    // Keep the more specific (longer) prompt
-                    const drop = setA.size >= setB.size ? j : i;
-                    const keep = drop === j ? i : j;
-                    onLog(`Dedup: task ${tasks[drop].id} >${Math.round(overlap * 100)}% overlap with ${tasks[keep].id}, dropping`);
-                    dominated.add(drop);
-                    if (drop === i)
-                        break;
-                }
+            const setB = new Set(tasks[j].prompt.toLowerCase().split(/\s+/));
+            const shared = [...setA].filter((w) => setB.has(w)).length;
+            const overlap = shared / Math.min(setA.size, setB.size);
+            if (overlap > 0.8) {
+                const drop = setA.size >= setB.size ? j : i;
+                dominated.add(drop);
+                if (drop === i)
+                    break;
             }
         }
-        if (dominated.size) {
-            tasks = tasks.filter((_, i) => !dominated.has(i));
-            onLog(`Deduplicated to ${tasks.length} tasks`);
-        }
     }
-    // Warn on compound tasks joining unrelated changes with 'and'
+    if (dominated.size) {
+        tasks = tasks.filter((_, i) => !dominated.has(i));
+        onLog(`Deduplicated to ${tasks.length} tasks`);
+    }
+    // Warn on compound tasks
     for (const t of tasks) {
         const parts = t.prompt.split(/\s+and\s+/i);
-        if (parts.length >= 2 &&
-            parts.every((p) => p.trim().split(/\s+/).length >= 3)) {
-            onLog(`⚠ Task ${t.id} looks compound ("…and…") — consider splitting into separate tasks`);
+        if (parts.length >= 2 && parts.every((p) => p.trim().split(/\s+/).length >= 3)) {
+            onLog(`Task ${t.id} looks compound — consider splitting`);
         }
     }
-    // Warn on file overlap between tasks
+    // Warn on file overlap
     const fileRe = /(?:^|\s)((?:[\w.-]+\/)+[\w.-]+\.\w+)/g;
     const pathToTasks = new Map();
     for (const t of tasks) {
@@ -160,21 +128,79 @@ Respond with ONLY a JSON object (no markdown fences):
         if (ids.length > 1)
             onLog(`Overlap risk: ${path} in tasks ${ids.join(", ")}`);
     }
-    // Warn if every task targets the same file — high merge conflict risk
-    if (tasks.length > 1 && pathToTasks.size === 1) {
-        const [singlePath] = pathToTasks.keys();
-        onLog(`⚠ All ${tasks.length} tasks target ${singlePath} — high merge conflict risk`);
-    }
-    // Cap at 20 tasks
-    if (tasks.length > 20) {
-        onLog(`Too many tasks (${tasks.length}), truncating to 20`);
-        tasks = tasks.slice(0, 20);
+    // Cap and sort (tests last)
+    if (tasks.length > 30) {
+        onLog(`Truncating ${tasks.length} → 30`);
+        tasks = tasks.slice(0, 30);
     }
+    tasks.sort((a, b) => Number(/\btest/i.test(a.prompt)) - Number(/\btest/i.test(b.prompt)));
+    // Re-index
+    tasks = tasks.map((t, i) => ({ ...t, id: String(i) }));
+    return tasks;
+}
+export async function planTasks(objective, cwd, model, permissionMode, budget, concurrency, onLog) {
+    onLog("Analyzing codebase...");
+    const resultText = await runPlannerQuery(plannerPrompt(objective, budget, concurrency), { cwd, model, permissionMode }, onLog);
+    const parsed = await extractTaskJson(resultText, async () => {
+        onLog("Retrying for valid JSON...");
+        let retryText = "";
+        for await (const msg of query({
+            prompt: `Your previous response did not contain valid JSON. Output ONLY a JSON object:\n{"tasks":[{"prompt":"..."}]}`,
+            options: { cwd, model, permissionMode, ...(permissionMode === "bypassPermissions" && { allowDangerouslySkipPermissions: true }), persistSession: false },
+        })) {
+            if (msg.type === "result" && msg.subtype === "success")
+                retryText = msg.result || "";
+        }
+        return retryText;
+    });
+    let tasks = (parsed.tasks || []).map((t, i) => ({
+        id: String(i),
+        prompt: typeof t === "string" ? t : t.prompt,
+    }));
+    tasks = postProcess(tasks, onLog);
     if (tasks.length === 0)
         throw new Error("Planner generated 0 tasks");
-    // Sort test-related tasks last — they benefit from other changes landing first
-    tasks.sort((a, b) => Number(/\btest/i.test(a.prompt)) - Number(/\btest/i.test(b.prompt)));
-    onLog(`Generated ${tasks.length} tasks`);
+    onLog(`${tasks.length} tasks`);
+    return tasks;
+}
+export async function refinePlan(objective, previousTasks, feedback, cwd, model, permissionMode, budget, concurrency, onLog) {
+    onLog("Refining plan...");
+    const prev = previousTasks.map((t, i) => `${i + 1}. ${t.prompt}`).join("\n");
+    const budgetLine = budget ? `Target ~${budget} tasks.` : "";
+    const prompt = `You are a task coordinator. You previously planned these tasks for the objective:
+
+Objective: ${objective}
+
+Previous plan:
+${prev}
+
+The user wants changes: ${feedback}
+
+${budgetLine} ${concurrency} agents run in parallel. Update the plan accordingly. Keep tasks independent and targeting different files.
+
+Respond with ONLY a JSON object (no markdown):
+{"tasks":[{"prompt":"..."}]}`;
+    const resultText = await runPlannerQuery(prompt, { cwd, model, permissionMode }, onLog);
+    const parsed = await extractTaskJson(resultText, async () => {
+        onLog("Retrying...");
+        let retryText = "";
+        for await (const msg of query({
+            prompt: `Output ONLY a JSON object:\n{"tasks":[{"prompt":"..."}]}`,
+            options: { cwd, model, permissionMode, ...(permissionMode === "bypassPermissions" && { allowDangerouslySkipPermissions: true }), persistSession: false },
+        })) {
+            if (msg.type === "result" && msg.subtype === "success")
+                retryText = msg.result || "";
+        }
+        return retryText;
+    });
+    let tasks = (parsed.tasks || []).map((t, i) => ({
+        id: String(i),
+        prompt: typeof t === "string" ? t : t.prompt,
+    }));
+    tasks = postProcess(tasks, onLog);
+    if (tasks.length === 0)
+        throw new Error("Refinement produced 0 tasks");
+    onLog(`${tasks.length} tasks`);
     return tasks;
 }
 /** Find the outermost balanced { } substring. */
@@ -196,14 +222,12 @@ function extractOutermostBraces(text) {
 /** Try multiple strategies to parse task JSON, with one retry callback. */
 async function extractTaskJson(raw, retry) {
     const attempt = (text) => {
-        // 1) Direct parse
         try {
             const obj = JSON.parse(text);
             if (obj?.tasks)
                 return obj;
         }
         catch { }
-        // 2) Outermost braces
         const braces = extractOutermostBraces(text);
         if (braces) {
             try {
@@ -213,7 +237,6 @@ async function extractTaskJson(raw, retry) {
             }
             catch { }
         }
-        // 3) Strip markdown fences and retry
         const stripped = text.replace(/```json?\s*/g, "").replace(/```/g, "").trim();
         if (stripped !== text) {
             try {
@@ -222,10 +245,10 @@ async function extractTaskJson(raw, retry) {
                     return obj;
             }
             catch { }
-            const braces2 = extractOutermostBraces(stripped);
-            if (braces2) {
+            const b2 = extractOutermostBraces(stripped);
+            if (b2) {
                 try {
-                    const obj = JSON.parse(braces2);
+                    const obj = JSON.parse(b2);
                     if (obj?.tasks)
                         return obj;
                 }
@@ -237,7 +260,6 @@ async function extractTaskJson(raw, retry) {
     const first = attempt(raw);
     if (first)
         return first;
-    // One retry with a shorter prompt
     const retryText = await retry();
     const second = attempt(retryText);
     if (second)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-overnight",
-  "version": "0.1.0",
-  "description": "Fire off parallel Claude Code agents, come back to shipped work",
+  "version": "0.1.2",
+  "description": "Fire off Claude agents, come back days later to shipped work. Maximizes every token in your plan.",
   "type": "module",
   "bin": {
     "claude-overnight": "dist/index.js"