claude-overnight 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Francesco Fornace
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,87 @@
+# claude-overnight
+
+Run parallel Claude Code agents with a real-time terminal UI.
+
+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.
+
+## Install
+
+```bash
+npm install -g claude-overnight
+```
+
+Requires Node.js >= 20 and a valid Claude authentication (OAuth via `claude` CLI login, or `ANTHROPIC_API_KEY` env var).
+
+## Quick start
+
+### Interactive (planner mode)
+
+```bash
+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.
+
+### Task file
+
+```bash
+claude-overnight tasks.json
+```
+
+### Inline tasks
+
+```bash
+claude-overnight "fix auth bug in src/auth.ts" "add tests for user model"
+```
+
+Each quoted argument becomes one parallel task.
+
+## Task file format
+
+A JSON file with a `tasks` array and optional configuration:
+
+```json
+{
+  "tasks": [
+    "Add input validation to all API routes",
+    { "prompt": "Refactor database queries", "cwd": "./packages/api" }
+  ],
+  "model": "claude-sonnet-4-6",
+  "concurrency": 4,
+  "worktrees": true
+}
+```
+
+A plain JSON array of strings also works: `["task one", "task two"]`.
+
+| Field | Type | Default | Description |
+|---|---|---|---|
+| `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 |
+| `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 |
+| `mergeStrategy` | `"yolo" \| "branch"` | `"yolo"` | Merge into HEAD or into a new branch |
+
+## CLI flags
+
+| Flag | Default | Description |
+|---|---|---|
+| `--concurrency=N` | `5` | Max parallel agents (overrides task file) |
+| `--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 |
+
+## 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.
+
+## Exit codes
+
+| Code | Meaning |
+|---|---|
+| `0` | All tasks succeeded |
+| `1` | Some tasks failed |
+| `2` | All tasks failed or no tasks completed |

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,555 @@
+#!/usr/bin/env node
+import { readFileSync, existsSync } from "fs";
+import { resolve, dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+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 { startRenderLoop, renderSummary } from "./ui.js";
+// ── CLI flag parsing ──
+function parseCliFlags(argv) {
+    const known = new Set(["concurrency", "model", "timeout"]);
+    const booleans = new Set(["--dry-run", "-h", "--help", "-v", "--version"]);
+    const flags = {};
+    const positional = [];
+    for (let i = 0; i < argv.length; i++) {
+        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];
+            continue;
+        }
+        if (!arg.startsWith("--"))
+            positional.push(arg);
+    }
+    return { flags, positional };
+}
+// ── Auth error detection ──
+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));
+}
+function authErrorMessage() {
+    return "Authentication failed — check your API key or run: claude auth";
+}
+// ── Fetch models via SDK (works with OAuth / Max / API key) ──
+async function fetchModels(timeoutMs = 10_000) {
+    let q;
+    try {
+        q = query({ prompt: "", options: { persistSession: false } });
+        const models = await Promise.race([
+            q.supportedModels(),
+            sleep(timeoutMs).then(() => { throw new Error("model_fetch_timeout"); }),
+        ]);
+        q.close();
+        return models;
+    }
+    catch (err) {
+        q?.close();
+        if (err.message === "model_fetch_timeout") {
+            console.warn(chalk.yellow("\n  ⚠ Model fetch timed out — continuing with defaults"));
+        }
+        return [];
+    }
+}
+// ── Interactive prompts ──
+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());
+        });
+    });
+}
+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;
+        }
+        return ans;
+    }
+}
+const KNOWN_TASK_FILE_KEYS = new Set([
+    "tasks", "concurrency", "cwd", "model", "permissionMode", "allowedTools", "worktrees", "mergeStrategy",
+]);
+function loadTaskFile(file) {
+    const path = resolve(file);
+    let raw;
+    try {
+        raw = readFileSync(path, "utf-8");
+    }
+    catch {
+        throw new Error(`Cannot read task file: ${path}`);
+    }
+    let json;
+    try {
+        json = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Task file is not valid JSON: ${path}`);
+    }
+    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(", ")}`);
+        }
+    }
+    // Validate tasks array
+    if (!Array.isArray(parsed.tasks)) {
+        throw new Error(`Task file must contain a "tasks" array (got ${typeof parsed.tasks})`);
+    }
+    const tasks = [];
+    for (let i = 0; i < parsed.tasks.length; i++) {
+        const t = parsed.tasks[i];
+        const id = String(tasks.length);
+        if (typeof t === "string") {
+            if (!t.trim())
+                throw new Error(`Task ${i} is an empty string`);
+            tasks.push({ id, prompt: t });
+        }
+        else if (typeof t === "object" && t !== null) {
+            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) {
+        validateConcurrency(parsed.concurrency);
+    }
+    return {
+        tasks,
+        concurrency: parsed.concurrency,
+        model: parsed.model,
+        cwd: parsed.cwd ? resolve(parsed.cwd) : undefined,
+        permissionMode: parsed.permissionMode,
+        allowedTools: parsed.allowedTools,
+        useWorktrees: parsed.worktrees,
+        mergeStrategy: parsed.mergeStrategy,
+    };
+}
+// ── Validation helpers ──
+function validateConcurrency(value) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+        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" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+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).`);
+    }
+}
+// ── Main ──
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv.includes("-v") || argv.includes("--version")) {
+        const __dirname = dirname(fileURLToPath(import.meta.url));
+        const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+        console.log(`claude-overnight v${pkg.version}`);
+        process.exit(0);
+    }
+    if (argv.includes("-h") || argv.includes("--help")) {
+        console.log(`
+  ${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 tasks.json               ${chalk.dim("run tasks defined in a JSON file")}
+    claude-overnight "fix auth" "add tests"   ${chalk.dim("run inline tasks in parallel")}
+
+  ${chalk.dim("Flags:")}
+    -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)")}
+    --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
+    `);
+        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}")`));
+            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}")`));
+            process.exit(1);
+        }
+    }
+    // ── Load tasks from file or inline args ──
+    let tasks = [];
+    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.`));
+        process.exit(1);
+    }
+    for (const arg of args) {
+        if (arg.endsWith(".json")) {
+            fileCfg = loadTaskFile(arg);
+            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.`));
+            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"));
+    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"));
+    }
+    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);
+        }
+        else {
+            process.stdout.write(chalk.dim("  Fetching available models..."));
+            models = await fetchModels();
+            process.stdout.write(`\x1B[2K\r`);
+        }
+    }
+    // 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());
+    if (useWorktrees)
+        validateGitRepo(cwd);
+    const mergeStrategy = fileCfg?.mergeStrategy ?? (useWorktrees && !nonInteractive ? await pickMergeStrategy() : "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) {
+        if (noTTY) {
+            console.error(chalk.red("\n  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) {
+        console.log(chalk.magenta("\n  Planning...\n"));
+        try {
+            tasks = await planTasks(objective, cwd, model, permissionMode, (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
+        }
+        catch (err) {
+            restore();
+            if (isAuthError(err)) {
+                console.error(chalk.red(`\n  ${authErrorMessage()}\n`));
+            }
+            else {
+                console.error(chalk.red(`\n  Planning failed: ${err.message}\n`));
+            }
+            process.exit(1);
+        }
+    }
+    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("");
+        process.exit(0);
+    }
+    const agentTimeoutMs = cliFlags.timeout ? parseFloat(cliFlags.timeout) * 1000 : undefined;
+    const swarm = new Swarm({
+        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");
+    let stopping = false;
+    const gracefulStop = (signal) => {
+        if (stopping) {
+            swarm.cleanup();
+            restore();
+            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`);
+        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);
+    });
+    const stopRender = startRenderLoop(swarm);
+    try {
+        await swarm.run();
+    }
+    catch (err) {
+        if (isAuthError(err)) {
+            stopRender();
+            restore();
+            console.error(chalk.red(`\n  ${authErrorMessage()}\n`));
+            process.exit(1);
+        }
+        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)}`);
+        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}`));
+            }
+        }
+        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} branch(es) had unresolved conflicts:`));
+                for (const c of conflicts) {
+                    console.log(chalk.red(`    ${c.branch}`));
+                }
+                console.log(chalk.dim("  Branches preserved — merge manually with: git merge <branch>"));
+            }
+        }
+        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) {
+        process.exit(2);
+    }
+    if (swarm.failed > 0) {
+        process.exit(1);
+    }
+}
+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`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(1)}K`;
+    return String(n);
+}
+main().catch((err) => {
+    process.stdout.write("\x1B[?25h");
+    console.error(chalk.red(err.message || err));
+    process.exit(1);
+});

package/dist/planner.d.ts

@@ -0,0 +1,5 @@
+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[]>;