claude-overnight 0.1.2 → 0.3.2

package/dist/index.js

@@ -7,12 +7,12 @@ import { createInterface } from "readline";
 import chalk from "chalk";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { Swarm } from "./swarm.js";
-import { planTasks, refinePlan } from "./planner.js";
+import { planTasks, refinePlan, detectModelTier, steerWave } from "./planner.js";
 import { startRenderLoop, renderSummary } from "./ui.js";
 // ── CLI flag parsing ──
 function parseCliFlags(argv) {
-    const known = new Set(["concurrency", "model", "timeout", "budget"]);
-    const booleans = new Set(["--dry-run", "-h", "--help", "-v", "--version"]);
+    const known = new Set(["concurrency", "model", "timeout", "budget", "usage-cap"]);
+    const booleans = new Set(["--dry-run", "-h", "--help", "-v", "--version", "--no-flex"]);
     const flags = {};
     const positional = [];
     for (let i = 0; i < argv.length; i++) {
@@ -43,20 +43,32 @@ function isAuthError(err) {
 // ── Fetch models via SDK ──
 async function fetchModels(timeoutMs = 10_000) {
     let q;
+    let timer;
     try {
         q = query({ prompt: "", options: { persistSession: false } });
         const models = await Promise.race([
             q.supportedModels(),
-            sleep(timeoutMs).then(() => { throw new Error("model_fetch_timeout"); }),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error("model_fetch_timeout")), timeoutMs);
+            }),
         ]);
+        clearTimeout(timer);
         q.close();
         return models;
     }
     catch (err) {
+        clearTimeout(timer);
         q?.close();
         if (err.message === "model_fetch_timeout") {
             console.warn(chalk.yellow("\n  Model fetch timed out — continuing with defaults"));
         }
+        else if (isAuthError(err)) {
+            console.error(chalk.red("\n  Authentication failed — check your API key or run: claude auth\n"));
+            process.exit(1);
+        }
+        else {
+            console.warn(chalk.yellow(`\n  Could not fetch models: ${String(err.message || err).slice(0, 80)} — continuing with defaults`));
+        }
         return [];
     }
 }
@@ -150,7 +162,7 @@ async function selectKey(label, options) {
     });
 }
 const KNOWN_TASK_FILE_KEYS = new Set([
-    "tasks", "concurrency", "cwd", "model", "permissionMode", "allowedTools", "worktrees", "mergeStrategy",
+    "tasks", "objective", "concurrency", "cwd", "model", "permissionMode", "allowedTools", "worktrees", "mergeStrategy", "usageCap", "flexiblePlan",
 ]);
 function loadTaskFile(file) {
     const path = resolve(file);
@@ -200,8 +212,18 @@ function loadTaskFile(file) {
     }
     if (parsed.concurrency !== undefined)
         validateConcurrency(parsed.concurrency);
+    const usageCap = parsed.usageCap;
+    if (usageCap != null && (typeof usageCap !== "number" || usageCap < 0 || usageCap > 100)) {
+        throw new Error(`usageCap must be a number between 0 and 100 (got ${JSON.stringify(usageCap)})`);
+    }
+    const flexiblePlan = parsed.flexiblePlan;
+    const objective = parsed.objective;
+    if (flexiblePlan && typeof objective !== "string") {
+        throw new Error(`flexiblePlan requires an "objective" string in the task file`);
+    }
     return {
         tasks,
+        objective: typeof objective === "string" ? objective : undefined,
         concurrency: parsed.concurrency,
         model: parsed.model,
         cwd: parsed.cwd ? resolve(parsed.cwd) : undefined,
@@ -209,6 +231,8 @@ function loadTaskFile(file) {
         allowedTools: parsed.allowedTools,
         useWorktrees: parsed.worktrees,
         mergeStrategy: parsed.mergeStrategy,
+        usageCap,
+        flexiblePlan,
     };
 }
 // ── Validation helpers ──
@@ -264,8 +288,10 @@ async function main() {
     --dry-run              Show planned tasks without running them
     --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
+    --model=NAME           Worker model override ${chalk.dim("(planner always uses best available)")}
+    --usage-cap=N          Stop at N% utilization ${chalk.dim("(e.g. 90 to save 10% for other work)")}
     --timeout=SECONDS      Agent inactivity timeout ${chalk.dim("(default: 300s, kills only silent agents)")}
+    --no-flex              Disable adaptive multi-wave planning ${chalk.dim("(run all tasks in one shot)")}
 
   ${chalk.dim("Non-interactive defaults (task file / inline / piped):")}
     model: first available    concurrency: 5    worktrees: auto    perms: auto
@@ -298,6 +324,10 @@ async function main() {
     }
     for (const arg of args) {
         if (arg.endsWith(".json")) {
+            if (tasks.length > 0) {
+                console.error(chalk.red(`  Cannot mix inline tasks with a task file. Use one or the other.`));
+                process.exit(1);
+            }
             fileCfg = loadTaskFile(arg);
             tasks = fileCfg.tasks;
         }
@@ -306,6 +336,10 @@ async function main() {
             process.exit(1);
         }
         else {
+            if (fileCfg) {
+                console.error(chalk.red(`  Cannot mix inline tasks with a task file. Use one or the other.`));
+                process.exit(1);
+            }
             tasks.push({ id: String(tasks.length), prompt: arg });
         }
     }
@@ -321,11 +355,13 @@ async function main() {
     }
     if (noTTY)
         console.log(chalk.dim("  Non-interactive mode — using defaults\n"));
-    // ── Interactive flow: Objective → Budget → Model → Plan → Review ──
-    let model;
+    // ── Interactive flow: Objective → Budget → Model → Usage cap → Plan → Review ──
+    let workerModel;
+    let plannerModel;
     let budget;
     let concurrency;
-    let objective;
+    let objective = fileCfg?.objective;
+    let usageCap;
     if (!nonInteractive) {
         console.log(chalk.dim("  Fire off Claude agents, come back to shipped work.\n"));
         // 1. Objective first — it's the whole point
@@ -342,21 +378,38 @@ async function main() {
         // 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
+        if (budget < 1) {
+            console.error(chalk.red(`  Budget must be a positive number`));
+            process.exit(1);
+        }
+        // 3. Worker model — planner always uses best available
         process.stdout.write(chalk.dim("  Fetching models..."));
         const models = await fetchModels();
         process.stdout.write(`\x1B[2K\r`);
+        // Pick best model for planner (first = most capable)
+        plannerModel = models[0]?.value || "claude-sonnet-4-6";
         if (models.length > 0) {
-            model = await select("Model:", models.map((m) => ({
+            workerModel = await select("Worker model (planner always uses best available):", models.map((m) => ({
                 name: m.displayName,
                 value: m.value,
                 hint: m.description,
             })));
         }
         else {
-            const ans = await ask(chalk.dim("  Model [claude-sonnet-4-6]: "));
-            model = ans || "claude-sonnet-4-6";
+            const ans = await ask(chalk.dim("  Worker model [claude-sonnet-4-6]: "));
+            workerModel = ans || "claude-sonnet-4-6";
         }
+        if (workerModel !== plannerModel) {
+            const tier = detectModelTier(workerModel);
+            console.log(chalk.dim(`\n  Planner: ${plannerModel} · Workers: ${workerModel} (${tier})`));
+        }
+        // 4. Usage cap — how much of your plan to use
+        usageCap = await select("Usage limit:", [
+            { name: "Unlimited", value: undefined, hint: "use full capacity, wait through rate limits" },
+            { name: "90%", value: 0.9, hint: "leave 10% for other work" },
+            { name: "75%", value: 0.75, hint: "conservative, plenty of headroom" },
+            { name: "50%", value: 0.5, hint: "use half, keep the rest" },
+        ]);
         // Concurrency defaults based on budget
         concurrency = Math.min(5, budget);
     }
@@ -365,9 +418,26 @@ async function main() {
         let models = [];
         if (!cliFlags.model && !fileCfg?.model)
             models = await fetchModels(5_000);
-        model = cliFlags.model ?? fileCfg?.model ?? (models[0]?.value || "claude-sonnet-4-6");
+        workerModel = cliFlags.model ?? fileCfg?.model ?? (models[0]?.value || "claude-sonnet-4-6");
+        plannerModel = models[0]?.value || workerModel;
         concurrency = cliFlags.concurrency ? parseInt(cliFlags.concurrency) : (fileCfg?.concurrency ?? 5);
         budget = cliFlags.budget ? parseInt(cliFlags.budget) : undefined;
+        if (budget != null && (isNaN(budget) || budget < 1)) {
+            console.error(chalk.red(`  --budget must be a positive integer`));
+            process.exit(1);
+        }
+        const capFlag = cliFlags["usage-cap"];
+        if (capFlag != null) {
+            const capVal = parseFloat(capFlag);
+            if (isNaN(capVal) || capVal < 0 || capVal > 100) {
+                console.error(chalk.red(`  --usage-cap must be between 0 and 100 (got ${capFlag})`));
+                process.exit(1);
+            }
+            usageCap = capVal / 100;
+        }
+        else {
+            usageCap = fileCfg?.usageCap != null ? fileCfg.usageCap / 100 : undefined;
+        }
     }
     validateConcurrency(concurrency);
     const permissionMode = fileCfg?.permissionMode ?? "auto";
@@ -376,8 +446,11 @@ async function main() {
         validateGitRepo(cwd);
     const mergeStrategy = fileCfg?.mergeStrategy ?? "yolo";
     if (nonInteractive) {
-        console.log(chalk.dim(`  ${model}  concurrency=${concurrency}  worktrees=${useWorktrees}  merge=${mergeStrategy}  perms=${permissionMode}`));
+        const capStr = usageCap != null ? `  cap=${Math.round(usageCap * 100)}%` : "";
+        console.log(chalk.dim(`  ${workerModel}  concurrency=${concurrency}  worktrees=${useWorktrees}  merge=${mergeStrategy}  perms=${permissionMode}${capStr}`));
     }
+    // ── Flex mode: adaptive multi-wave planning ──
+    const flex = !argv.includes("--no-flex") && (fileCfg?.flexiblePlan ?? objective != null) && objective != null && (budget ?? 10) > 2;
     // ── Plan phase (interactive: review loop, non-interactive: auto-plan or skip) ──
     const needsPlan = tasks.length === 0;
     if (needsPlan) {
@@ -385,17 +458,23 @@ async function main() {
             console.error(chalk.red("  No tasks provided and stdin is not a TTY. Provide tasks via args or a .json file."));
             process.exit(1);
         }
+        // In flex mode, plan ~50% of budget for wave 1, leaving room for steering
+        const waveBudget = flex ? Math.max(concurrency, Math.ceil((budget ?? 10) * 0.5)) : budget;
+        const flexNote = flex
+            ? `This is wave 1 of an adaptive multi-wave run (total budget: ${budget}). Plan the highest-impact foundational work first. Future waves will iterate, polish, and expand based on what's learned.`
+            : undefined;
         process.stdout.write("\x1B[?25l");
-        const restore = () => process.stdout.write("\x1B[?25h");
-        console.log(chalk.magenta("\n  Planning...\n"));
+        const planRestore = () => process.stdout.write("\x1B[?25h");
+        console.log(chalk.magenta(`\n  Planning${flex ? " wave 1" : ""}...\n`));
         try {
-            tasks = await planTasks(objective, cwd, model, permissionMode, budget, concurrency, (text) => {
+            tasks = await planTasks(objective, cwd, plannerModel, workerModel, permissionMode, waveBudget, concurrency, (text) => {
                 process.stdout.write(`\x1B[2K\r  ${chalk.dim(text)}`);
-            });
-            process.stdout.write(`\x1B[2K\r  ${chalk.green(`${tasks.length} tasks`)}\n\n`);
+            }, flexNote);
+            const flexHint = flex ? chalk.dim(` (wave 1, ${(budget ?? 10) - tasks.length} remaining)`) : "";
+            process.stdout.write(`\x1B[2K\r  ${chalk.green(`${tasks.length} tasks`)}${flexHint}\n\n`);
         }
         catch (err) {
-            restore();
+            planRestore();
             if (isAuthError(err))
                 console.error(chalk.red(`\n  Authentication failed — check your API key or run: claude auth\n`));
             else
@@ -403,7 +482,7 @@ async function main() {
             process.exit(1);
         }
         // ── Review loop ──
-        restore();
+        planRestore();
         let reviewing = true;
         while (reviewing) {
             showPlan(tasks);
@@ -424,7 +503,7 @@ async function main() {
                     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) => {
+                        tasks = await refinePlan(objective, tasks, feedback, cwd, plannerModel, workerModel, 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`);
@@ -432,7 +511,7 @@ async function main() {
                     catch (err) {
                         console.error(chalk.red(`\n  Re-planning failed: ${err.message}\n`));
                     }
-                    restore();
+                    planRestore();
                     break;
                 }
                 case "c": {
@@ -444,17 +523,17 @@ async function main() {
                         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 },
+                            options: { cwd, model: plannerModel, permissionMode, persistSession: false },
                         })) {
                             if (msg.type === "result" && msg.subtype === "success")
                                 answer = msg.result || "";
                         }
-                        restore();
+                        planRestore();
                         if (answer)
                             console.log(chalk.dim(`\n  ${answer.slice(0, 500)}\n`));
                     }
                     catch {
-                        restore();
+                        planRestore();
                     }
                     break;
                 }
@@ -473,52 +552,141 @@ async function main() {
         showPlan(tasks);
         process.exit(0);
     }
-    // ── Run ──
+    // ── Run (wave loop) ──
     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,
-    });
+    const runStartedAt = Date.now();
+    // Wave-loop state
+    let currentSwarm;
+    let remaining = budget ?? tasks.length;
+    let currentTasks = tasks;
+    let waveNum = 0;
+    const waveHistory = [];
+    let accCost = 0, accIn = 0, accOut = 0, accCompleted = 0, accFailed = 0, accTools = 0;
+    let lastCapped = false, lastAborted = false;
+    // For flex + branch strategy: create one target branch, waves merge via yolo into it
+    let runBranch;
+    let originalRef;
+    if (flex && mergeStrategy === "branch" && useWorktrees) {
+        try {
+            originalRef = execSync("git rev-parse --abbrev-ref HEAD", { cwd, encoding: "utf-8", stdio: "pipe" }).trim();
+            if (originalRef === "HEAD")
+                originalRef = execSync("git rev-parse HEAD", { cwd, encoding: "utf-8", stdio: "pipe" }).trim();
+            const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+            runBranch = `swarm/run-${ts}`;
+            execSync(`git checkout -b "${runBranch}"`, { cwd, encoding: "utf-8", stdio: "pipe" });
+            console.log(chalk.dim(`  Branch: ${runBranch}\n`));
+        }
+        catch { }
+    }
+    const waveMerge = (flex && runBranch) ? "yolo" : mergeStrategy;
     // Graceful drain
     let stopping = false;
     const gracefulStop = (signal) => {
         if (stopping) {
-            swarm.cleanup();
+            currentSwarm?.cleanup();
             restore();
             process.exit(0);
         }
         stopping = true;
-        process.stdout.write(`\n  ${chalk.yellow(`${signal}: stopping... ${swarm.active} active (send again to force)`)}\n`);
-        swarm.abort();
+        process.stdout.write(`\n  ${chalk.yellow(`${signal}: stopping... (send again to force)`)}\n`);
+        currentSwarm?.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: ${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();
-    }
-    catch (err) {
-        if (isAuthError(err)) {
+    process.on("uncaughtException", (err) => { currentSwarm?.abort(); currentSwarm?.cleanup(); restore(); console.error(chalk.red(`\n  Uncaught: ${err.message}`)); process.exit(1); });
+    process.on("unhandledRejection", (reason) => { currentSwarm?.abort(); currentSwarm?.cleanup(); restore(); console.error(chalk.red(`\n  Unhandled: ${reason instanceof Error ? reason.message : reason}`)); process.exit(1); });
+    while (remaining > 0 && currentTasks.length > 0 && !stopping) {
+        if (currentTasks.length > remaining)
+            currentTasks = currentTasks.slice(0, remaining);
+        if (flex) {
+            console.log(chalk.magenta(`\n  \u2500\u2500 Wave ${waveNum + 1} (${currentTasks.length} tasks, ${remaining} remaining) \u2500\u2500\n`));
+        }
+        const swarm = new Swarm({
+            tasks: currentTasks, concurrency, cwd, model: workerModel, permissionMode, allowedTools,
+            useWorktrees, mergeStrategy: waveMerge, agentTimeoutMs, usageCap,
+        });
+        currentSwarm = swarm;
+        const stopRender = startRenderLoop(swarm);
+        try {
+            await swarm.run();
+        }
+        catch (err) {
+            if (isAuthError(err)) {
+                stopRender();
+                restore();
+                console.error(chalk.red(`\n  Authentication failed — check your API key or run: claude auth\n`));
+                process.exit(1);
+            }
+            throw err;
+        }
+        finally {
             stopRender();
-            restore();
-            console.error(chalk.red(`\n  Authentication failed — check your API key or run: claude auth\n`));
-            process.exit(1);
+            console.log(renderSummary(swarm));
+        }
+        // Accumulate
+        accCost += swarm.totalCostUsd;
+        accIn += swarm.totalInputTokens;
+        accOut += swarm.totalOutputTokens;
+        accCompleted += swarm.completed;
+        accFailed += swarm.failed;
+        accTools += swarm.agents.reduce((sum, a) => sum + a.toolCalls, 0);
+        remaining -= swarm.completed + swarm.failed;
+        lastCapped = swarm.cappedOut;
+        lastAborted = swarm.aborted;
+        waveHistory.push({
+            wave: waveNum,
+            tasks: swarm.agents.map(a => ({
+                prompt: a.task.prompt,
+                status: a.status,
+                filesChanged: a.filesChanged,
+                error: a.error,
+            })),
+        });
+        if (!flex || remaining <= 0 || swarm.aborted || swarm.cappedOut)
+            break;
+        // ── Steer next wave ──
+        console.log(chalk.magenta("\n  Steering...\n"));
+        process.stdout.write("\x1B[?25l");
+        try {
+            const steer = await steerWave(objective, waveHistory, remaining, cwd, plannerModel, workerModel, permissionMode, concurrency, (text) => {
+                process.stdout.write(`\x1B[2K\r  ${chalk.dim(text)}`);
+            });
+            process.stdout.write(`\x1B[2K\r`);
+            process.stdout.write("\x1B[?25h");
+            if (steer.done) {
+                console.log(chalk.green(`  \u2713 ${steer.reasoning}\n`));
+                break;
+            }
+            console.log(chalk.dim(`  ${steer.reasoning}\n`));
+            currentTasks = steer.tasks;
+            waveNum++;
+        }
+        catch (err) {
+            process.stdout.write("\x1B[?25h");
+            console.log(chalk.yellow(`  Steering failed: ${err.message?.slice(0, 80)} \u2014 stopping\n`));
+            break;
+        }
+    }
+    // Switch back if we created a run branch
+    if (runBranch && originalRef) {
+        try {
+            execSync(`git checkout "${originalRef}"`, { cwd, encoding: "utf-8", stdio: "pipe" });
         }
-        throw err;
-    }
-    finally {
-        stopRender();
-        console.log(renderSummary(swarm));
-        const failedAgents = swarm.agents.filter((a) => a.status === "error");
-        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)})` : "";
-        console.log(`\n  ${chalk.bold("Complete:")} ${summary}${chalk.dim(cost)}`);
+        catch { }
+    }
+    // ── Final summary ──
+    const waves = waveNum + 1;
+    const cappedNote = lastCapped ? chalk.yellow(` (capped at ${usageCap != null ? Math.round(usageCap * 100) : 100}%)`) : "";
+    const summaryText = accFailed > 0
+        ? chalk.yellow(`${accCompleted} done, ${accFailed} failed`) + cappedNote
+        : chalk.green(`${accCompleted} done`) + cappedNote;
+    const costText = accCost > 0 ? ` ($${accCost.toFixed(3)})` : "";
+    const wavePart = waves > 1 ? `${waves} waves, ` : "";
+    console.log(`\n  ${chalk.bold("Complete:")} ${wavePart}${summaryText}${chalk.dim(costText)}`);
+    if (accFailed > 0 && waves === 1) {
+        const failedAgents = currentSwarm?.agents.filter((a) => a.status === "error") ?? [];
         if (failedAgents.length > 0) {
             console.log(chalk.red(`\n  Failed agents:`));
             for (const a of failedAgents) {
@@ -526,38 +694,39 @@ async function main() {
                 console.log(chalk.dim(`      ${a.error || "unknown error"}`));
             }
         }
-        const elapsed = Math.round((Date.now() - swarm.startedAt) / 1000);
-        const elapsedStr = elapsed < 60 ? `${elapsed}s` : `${Math.floor(elapsed / 60)}m ${elapsed % 60}s`;
-        const tools = swarm.agents.reduce((sum, a) => sum + a.toolCalls, 0);
-        console.log(chalk.dim(`  ${elapsedStr}  ${fmtTokens(swarm.totalInputTokens)} in / ${fmtTokens(swarm.totalOutputTokens)} out  ${tools} tool calls`));
-        if (swarm.mergeResults.length > 0) {
-            const merged = swarm.mergeResults.filter((r) => r.ok);
-            const autoResolved = merged.filter((r) => r.autoResolved).length;
-            const conflicts = swarm.mergeResults.filter((r) => !r.ok);
-            const target = swarm.mergeBranch || "HEAD";
-            if (merged.length > 0) {
-                const extra = autoResolved > 0 ? chalk.yellow(` (${autoResolved} auto-resolved)`) : "";
-                console.log(chalk.green(`  Merged ${merged.length} branch(es) into ${target}`) + extra);
-            }
-            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} unresolved conflict(s):`));
-                for (const c of conflicts)
-                    console.log(chalk.red(`    ${c.branch}`));
-                console.log(chalk.dim("  Merge manually: git merge <branch>"));
-            }
+    }
+    const elapsed = Math.round((Date.now() - runStartedAt) / 1000);
+    const elapsedStr = elapsed < 60 ? `${elapsed}s` : `${Math.floor(elapsed / 60)}m ${elapsed % 60}s`;
+    console.log(chalk.dim(`  ${elapsedStr}  ${fmtTokens(accIn)} in / ${fmtTokens(accOut)} out  ${accTools} tool calls`));
+    if (runBranch) {
+        console.log(chalk.dim(`  Branch: ${runBranch} \u2014 create a PR or: git merge ${runBranch}`));
+    }
+    else if (currentSwarm?.mergeResults && currentSwarm.mergeResults.length > 0) {
+        const merged = currentSwarm.mergeResults.filter((r) => r.ok);
+        const autoResolved = merged.filter((r) => r.autoResolved).length;
+        const conflicts = currentSwarm.mergeResults.filter((r) => !r.ok);
+        const target = currentSwarm.mergeBranch || "HEAD";
+        if (merged.length > 0) {
+            const extra = autoResolved > 0 ? chalk.yellow(` (${autoResolved} auto-resolved)`) : "";
+            console.log(chalk.green(`  Merged ${merged.length} branch(es) into ${target}`) + extra);
+        }
+        if (currentSwarm.mergeBranch)
+            console.log(chalk.dim(`  Branch: ${currentSwarm.mergeBranch} \u2014 create a PR or: git merge ${currentSwarm.mergeBranch}`));
+        if (conflicts.length > 0) {
+            console.log(chalk.red(`  ${conflicts.length} unresolved conflict(s):`));
+            for (const c of conflicts)
+                console.log(chalk.red(`    ${c.branch}`));
+            console.log(chalk.dim("  Merge manually: git merge <branch>"));
         }
-        if (swarm.logFile)
-            console.log(chalk.dim(`  Log: ${swarm.logFile}`));
-        console.log("");
     }
-    if (swarm.aborted || swarm.completed === 0)
-        process.exit(2);
-    if (swarm.failed > 0)
+    if (currentSwarm?.logFile)
+        console.log(chalk.dim(`  Log: ${currentSwarm.logFile}`));
+    console.log("");
+    if (accFailed > 0)
         process.exit(1);
+    if (lastAborted || accCompleted === 0)
+        process.exit(2);
 }
-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,3 +1,20 @@
 import type { Task, PermMode } from "./types.js";
-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[]>;
+export interface WaveSummary {
+    wave: number;
+    tasks: {
+        prompt: string;
+        status: string;
+        filesChanged?: number;
+        error?: string;
+    }[];
+}
+export interface SteerResult {
+    done: boolean;
+    tasks: Task[];
+    reasoning: string;
+}
+export type ModelTier = "opus" | "sonnet" | "haiku" | "unknown";
+export declare function detectModelTier(model: string): ModelTier;
+export declare function planTasks(objective: string, cwd: string, plannerModel: string, workerModel: string, permissionMode: PermMode, budget: number | undefined, concurrency: number, onLog: (text: string) => void, flexNote?: string): Promise<Task[]>;
+export declare function refinePlan(objective: string, previousTasks: Task[], feedback: string, cwd: string, plannerModel: string, workerModel: string, permissionMode: PermMode, budget: number | undefined, concurrency: number, onLog: (text: string) => void): Promise<Task[]>;
+export declare function steerWave(objective: string, history: WaveSummary[], remainingBudget: number, cwd: string, plannerModel: string, workerModel: string, permissionMode: PermMode, concurrency: number, onLog: (text: string) => void): Promise<SteerResult>;