swarm-code 0.1.0

package/dist/main.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env tsx
+/**
+ * swarm — Swarm-native coding agent orchestrator
+ *
+ * Entry point for the `swarm` command.
+ *
+ *   swarm --dir ./project "task" → swarm mode (coding agent orchestration)
+ *   swarm --dir ./project        → interactive REPL (no query)
+ *   swarm mcp [--dir ./project]  → MCP server (stdio transport)
+ *   swarm run                    → single-shot RLM CLI run
+ *   swarm viewer                 → browse trajectory files
+ *   swarm benchmark              → run benchmarks
+ *   swarm                        → interactive terminal (RLM mode, default)
+ */
+export declare function buildHelp(): string;

package/dist/main.js

@@ -0,0 +1,242 @@
+#!/usr/bin/env tsx
+/**
+ * swarm — Swarm-native coding agent orchestrator
+ *
+ * Entry point for the `swarm` command.
+ *
+ *   swarm --dir ./project "task" → swarm mode (coding agent orchestration)
+ *   swarm --dir ./project        → interactive REPL (no query)
+ *   swarm mcp [--dir ./project]  → MCP server (stdio transport)
+ *   swarm run                    → single-shot RLM CLI run
+ *   swarm viewer                 → browse trajectory files
+ *   swarm benchmark              → run benchmarks
+ *   swarm                        → interactive terminal (RLM mode, default)
+ */
+import { bold, coral, cyan, dim, isTTY, symbols, termWidth, yellow } from "./ui/theme.js";
+export function buildHelp() {
+    const w = Math.max(Math.min(termWidth(), 60), 24);
+    const lines = [];
+    if (isTTY) {
+        const title = " swarm ";
+        const sub = " cli ";
+        const padLen = Math.max(0, w - title.length - sub.length - 4);
+        const l = symbols.horizontal.repeat(Math.floor(padLen / 2));
+        const r = symbols.horizontal.repeat(Math.ceil(padLen / 2));
+        lines.push("");
+        lines.push(`  ${cyan(`${symbols.topLeft}${l}`)}${bold(coral(title))}${dim(sub)}${cyan(`${r}${symbols.topRight}`)}`);
+        lines.push(`  ${cyan(symbols.vertLine)}${" ".repeat(w - 2)}${cyan(symbols.vertLine)}`);
+        lines.push(`  ${cyan(symbols.vertLine)}  ${dim("Open-source orchestrator for parallel coding agents")}${" ".repeat(Math.max(0, w - 55))}${cyan(symbols.vertLine)}`);
+        lines.push(`  ${cyan(symbols.vertLine)}  ${dim("Built on RLM (arXiv:2512.24601)")}${" ".repeat(Math.max(0, w - 36))}${cyan(symbols.vertLine)}`);
+        lines.push(`  ${cyan(symbols.vertLine)}${" ".repeat(w - 2)}${cyan(symbols.vertLine)}`);
+        lines.push(`  ${cyan(symbols.bottomLeft)}${cyan(symbols.horizontal.repeat(w - 2))}${cyan(symbols.bottomRight)}`);
+    }
+    else {
+        lines.push("\nswarm — Open-source orchestrator for parallel coding agents");
+    }
+    lines.push("");
+    lines.push(`  ${bold("SWARM MODE")} ${dim("(coding agent orchestration)")}`);
+    lines.push(`    ${yellow("swarm")} --dir ./project ${dim('"add error handling to all API routes"')}`);
+    lines.push(`    ${yellow("swarm")} --dir ./project --orchestrator claude-sonnet-4-6 ${dim('"task"')}`);
+    lines.push(`    ${yellow("swarm")} --dir ./project --dry-run ${dim('"plan refactor"')}`);
+    lines.push(`    ${yellow("swarm")} --dir ./project --max-budget 5.00 ${dim('"task"')}`);
+    lines.push(`    ${yellow("swarm")} --dir ./project              ${dim("Interactive REPL (no query)")}`);
+    lines.push("");
+    lines.push(`  ${bold("MCP SERVER")} ${dim("(expose swarm as tools for Claude Code, Cursor, etc.)")}`);
+    lines.push(`    ${yellow("swarm mcp")}                       ${dim("Start MCP server (stdio)")}`);
+    lines.push(`    ${yellow("swarm mcp")} --dir ./project       ${dim("Start with default directory")}`);
+    lines.push("");
+    lines.push(`  ${bold("RLM MODE")} ${dim("(text processing, inherited from rlm-cli)")}`);
+    lines.push(`    ${yellow("swarm")}                          ${dim("Interactive terminal (default)")}`);
+    lines.push(`    ${yellow("swarm run")} [options] "<query>"  ${dim("Run a single query")}`);
+    lines.push(`    ${yellow("swarm viewer")}                    ${dim("Browse saved trajectory files")}`);
+    lines.push(`    ${yellow("swarm benchmark")} <name> [--idx]  ${dim("Run benchmark")}`);
+    lines.push("");
+    lines.push(`  ${bold("SWARM OPTIONS")}`);
+    lines.push(`    ${cyan("--dir")} <path>           Target repository directory`);
+    lines.push(`    ${cyan("--orchestrator")} <model> Model for the orchestrator LLM`);
+    lines.push(`    ${cyan("--agent")} <backend>      Default agent backend ${dim("(opencode)")}`);
+    lines.push(`    ${cyan("--dry-run")}              Plan only, don't spawn threads`);
+    lines.push(`    ${cyan("--max-budget")} <usd>     Maximum session budget in USD`);
+    lines.push(`    ${cyan("--verbose")}              Show detailed progress`);
+    lines.push(`    ${cyan("--quiet")} / ${cyan("-q")}           Suppress non-essential output`);
+    lines.push(`    ${cyan("--json")}                 Machine-readable JSON output`);
+    lines.push("");
+    lines.push(`  ${bold("RUN OPTIONS")}`);
+    lines.push(`    ${cyan("--model")} <id>     Override model ${dim("(RLM_MODEL from .env)")}`);
+    lines.push(`    ${cyan("--file")} <path>    Read context from a file`);
+    lines.push(`    ${cyan("--url")} <url>      Fetch context from a URL`);
+    lines.push(`    ${cyan("--stdin")}          Read context from stdin`);
+    lines.push("");
+    lines.push(`  ${bold("CONFIGURATION")}`);
+    lines.push(`    ${dim(".env file (pick one provider):")}`);
+    lines.push(`      ANTHROPIC_API_KEY=sk-ant-...`);
+    lines.push(`      OPENAI_API_KEY=sk-...`);
+    lines.push(`      GEMINI_API_KEY=AIza...`);
+    lines.push("");
+    lines.push(`    ${dim("swarm_config.yaml:")}`);
+    lines.push(`      max_threads: 5`);
+    lines.push(`      default_agent: opencode`);
+    lines.push(`      compression_strategy: structured`);
+    return lines.join("\n");
+}
+// Lazy — evaluated on first use, not at module load
+let _help;
+function getHelp() {
+    if (!_help)
+        _help = buildHelp();
+    return _help;
+}
+/**
+ * Check if args contain positional (non-flag) arguments.
+ * Skips known flags that take a value argument.
+ */
+function hasPositionalArgs(args) {
+    const flagsWithValue = new Set(["--dir", "--orchestrator", "--agent", "--max-budget", "--model", "--file", "--url"]);
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith("--") || arg === "-q" || arg === "-h") {
+            // Skip flags with values
+            if (flagsWithValue.has(arg) && i + 1 < args.length) {
+                i++; // skip the value
+            }
+            continue;
+        }
+        // Found a positional argument
+        return true;
+    }
+    return false;
+}
+async function main() {
+    const args = process.argv.slice(2);
+    // Check if this is swarm mode (has --dir flag)
+    const dirIdx = args.indexOf("--dir");
+    if (dirIdx !== -1) {
+        // Check if there's a query (positional args that aren't flags/flag-values)
+        const hasQuery = hasPositionalArgs(args);
+        if (hasQuery) {
+            // Single-shot swarm mode — dynamic import to avoid loading all swarm deps upfront
+            const { runSwarmMode } = await import("./swarm.js");
+            await runSwarmMode(args);
+        }
+        else {
+            // Interactive swarm mode — no query provided, launch REPL
+            const { runInteractiveSwarm } = await import("./interactive-swarm.js");
+            await runInteractiveSwarm(args);
+        }
+        return;
+    }
+    const command = args[0] || "interactive";
+    switch (command) {
+        case "interactive":
+        case "i": {
+            await import("./interactive.js");
+            break;
+        }
+        case "viewer":
+        case "view": {
+            process.argv = [process.argv[0], process.argv[1], ...args.slice(1)];
+            await import("./viewer.js");
+            break;
+        }
+        case "mcp": {
+            const { startMcpServer } = await import("./mcp/server.js");
+            await startMcpServer(args.slice(1));
+            break;
+        }
+        case "run": {
+            process.argv = [process.argv[0], process.argv[1], ...args.slice(1)];
+            await import("./cli.js");
+            break;
+        }
+        case "benchmark":
+        case "bench": {
+            const benchName = args[1];
+            const benchArgs = args.slice(2);
+            const benchScripts = {
+                oolong: "benchmarks/oolong_synth.ts",
+                longbench: "benchmarks/longbench_narrativeqa.ts",
+            };
+            if (benchName && benchScripts[benchName]) {
+                const { spawn } = await import("node:child_process");
+                const { dirname, join } = await import("node:path");
+                const { fileURLToPath } = await import("node:url");
+                const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+                const script = join(root, benchScripts[benchName]);
+                const tsxBin = join(root, "node_modules", ".bin", "tsx");
+                await new Promise((resolve, reject) => {
+                    const child = spawn(tsxBin, [script, ...benchArgs], {
+                        stdio: "inherit",
+                        cwd: root,
+                    });
+                    child.on("exit", (code) => {
+                        process.exitCode = code ?? 1;
+                        resolve();
+                    });
+                    child.on("error", (err) => {
+                        reject(new Error(`Failed to spawn benchmark: ${err.message}`));
+                    });
+                });
+            }
+            else {
+                console.log(`${cyan(bold("swarm benchmark"))} ${dim("— Run direct LLM vs RLM comparison")}\n`);
+                console.log(bold("USAGE"));
+                console.log(`  ${yellow("swarm benchmark oolong")}    [--idx N]  Oolong Synth`);
+                console.log(`  ${yellow("swarm benchmark longbench")} [--idx N]  LongBench NarrativeQA\n`);
+            }
+            break;
+        }
+        case "help":
+        case "--help":
+        case "-h": {
+            console.log(getHelp());
+            break;
+        }
+        case "version":
+        case "--version":
+        case "-v": {
+            try {
+                const { readFileSync } = await import("node:fs");
+                const { dirname, join } = await import("node:path");
+                const { fileURLToPath } = await import("node:url");
+                const __dir = dirname(fileURLToPath(import.meta.url));
+                const pkgPath = join(__dir, "..", "package.json");
+                const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+                console.log(`swarm v${pkg.version}`);
+            }
+            catch {
+                console.log("swarm (version unknown)");
+            }
+            break;
+        }
+        default: {
+            if (command.startsWith("--")) {
+                // Flags without subcommand — check for --dir (swarm mode)
+                if (command === "--dir") {
+                    if (hasPositionalArgs(args)) {
+                        const { runSwarmMode } = await import("./swarm.js");
+                        await runSwarmMode(args);
+                    }
+                    else {
+                        const { runInteractiveSwarm } = await import("./interactive-swarm.js");
+                        await runInteractiveSwarm(args);
+                    }
+                }
+                else {
+                    // Assume "run" mode, pass all args through
+                    process.argv = [process.argv[0], process.argv[1], ...args];
+                    await import("./cli.js");
+                }
+            }
+            else {
+                console.error(`Unknown command: ${command}`);
+                console.error('Run "swarm help" for usage information.');
+                process.exit(1);
+            }
+        }
+    }
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=main.js.map

package/dist/mcp/server.d.ts

@@ -0,0 +1,15 @@
+/**
+ * MCP server for swarm-code.
+ *
+ * Exposes swarm capabilities as MCP tools that can be called by
+ * Claude Code, Cursor, or any MCP-compatible client.
+ *
+ * Transport: stdio (reads JSON-RPC from stdin, writes to stdout).
+ * IMPORTANT: Never use console.log() — it corrupts the MCP protocol.
+ * All logging goes to stderr via process.stderr.write().
+ *
+ * Usage:
+ *   swarm mcp                     # Start MCP server
+ *   swarm mcp --dir ./my-project  # Start with default directory
+ */
+export declare function startMcpServer(args: string[]): Promise<void>;

package/dist/mcp/server.js

@@ -0,0 +1,72 @@
+/**
+ * MCP server for swarm-code.
+ *
+ * Exposes swarm capabilities as MCP tools that can be called by
+ * Claude Code, Cursor, or any MCP-compatible client.
+ *
+ * Transport: stdio (reads JSON-RPC from stdin, writes to stdout).
+ * IMPORTANT: Never use console.log() — it corrupts the MCP protocol.
+ * All logging goes to stderr via process.stderr.write().
+ *
+ * Usage:
+ *   swarm mcp                     # Start MCP server
+ *   swarm mcp --dir ./my-project  # Start with default directory
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { cleanupAllSessions } from "./session.js";
+import { killActiveSubprocesses, registerTools } from "./tools.js";
+// ── Logging ────────────────────────────────────────────────────────────────
+function log(msg) {
+    process.stderr.write(`[swarm-mcp] ${msg}\n`);
+}
+// ── Server ─────────────────────────────────────────────────────────────────
+export async function startMcpServer(args) {
+    // Parse --dir from args
+    let defaultDir;
+    const dirIdx = args.indexOf("--dir");
+    if (dirIdx !== -1 && dirIdx + 1 < args.length) {
+        defaultDir = args[dirIdx + 1];
+    }
+    // Create MCP server
+    const server = new McpServer({
+        name: "swarm-code",
+        version: getVersion(),
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // Register all tools
+    registerTools(server, defaultDir);
+    // Handle graceful shutdown — kill subprocesses, cleanup sessions
+    const shutdown = async () => {
+        log("Shutting down...");
+        killActiveSubprocesses();
+        await cleanupAllSessions();
+        await server.close();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    // Connect via stdio transport
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    log(`Server started${defaultDir ? ` (default dir: ${defaultDir})` : ""}`);
+}
+// ── Helpers ────────────────────────────────────────────────────────────────
+function getVersion() {
+    try {
+        const __dir = dirname(fileURLToPath(import.meta.url));
+        const pkgPath = join(__dir, "..", "..", "package.json");
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        return pkg.version || "0.1.0";
+    }
+    catch {
+        return "0.1.0";
+    }
+}
+//# sourceMappingURL=server.js.map

package/dist/mcp/session.d.ts

@@ -0,0 +1,73 @@
+/**
+ * MCP session manager — maintains per-directory swarm state.
+ *
+ * Each directory gets its own session with:
+ *   - ThreadManager (spawning/tracking threads)
+ *   - SwarmConfig (loaded from the project dir)
+ *   - AbortController (for cancellation)
+ *   - BudgetState (cost tracking)
+ *
+ * Sessions are lazily initialized on first tool call and persist
+ * across multiple MCP tool invocations.
+ *
+ * Concurrency:
+ *   - pendingSessions deduplicates concurrent init for the same dir
+ *   - loadConfig(cwd) avoids process.chdir() race conditions
+ */
+import type { SwarmConfig } from "../config.js";
+import type { BudgetState, CompressedResult, MergeResult, ThreadState } from "../core/types.js";
+import { ThreadManager } from "../threads/manager.js";
+export interface SwarmSession {
+    dir: string;
+    config: SwarmConfig;
+    threadManager: ThreadManager;
+    abortController: AbortController;
+    createdAt: number;
+}
+export interface ThreadSpawnParams {
+    task: string;
+    files?: string[];
+    agent?: string;
+    model?: string;
+    context?: string;
+}
+/**
+ * Get or create a session for a directory.
+ * The directory is resolved to an absolute path and used as the session key.
+ * Concurrent calls for the same directory are deduplicated.
+ */
+export declare function getSession(dir: string): Promise<SwarmSession>;
+/**
+ * Spawn a thread in a session.
+ */
+export declare function spawnThread(session: SwarmSession, params: ThreadSpawnParams): Promise<CompressedResult>;
+/**
+ * Get all threads in a session.
+ */
+export declare function getThreads(session: SwarmSession): ThreadState[];
+/**
+ * Get budget state for a session.
+ */
+export declare function getBudgetState(session: SwarmSession): BudgetState;
+/**
+ * Merge completed threads.
+ */
+export declare function mergeThreads(session: SwarmSession): Promise<MergeResult[]>;
+/**
+ * Cancel a specific thread or all threads.
+ * Per-thread cancellation uses ThreadManager.cancelThread() which
+ * aborts the thread's individual AbortController.
+ */
+export declare function cancelThreads(session: SwarmSession, threadId?: string): {
+    cancelled: boolean;
+    message: string;
+};
+/**
+ * Cleanup a session — destroy worktrees, remove session.
+ */
+export declare function cleanupSession(dir: string): Promise<string>;
+/**
+ * Cleanup all sessions. Snapshots keys first to avoid
+ * mutating the map during iteration.
+ */
+export declare function cleanupAllSessions(): Promise<void>;

package/dist/mcp/session.js

@@ -0,0 +1,184 @@
+/**
+ * MCP session manager — maintains per-directory swarm state.
+ *
+ * Each directory gets its own session with:
+ *   - ThreadManager (spawning/tracking threads)
+ *   - SwarmConfig (loaded from the project dir)
+ *   - AbortController (for cancellation)
+ *   - BudgetState (cost tracking)
+ *
+ * Sessions are lazily initialized on first tool call and persist
+ * across multiple MCP tool invocations.
+ *
+ * Concurrency:
+ *   - pendingSessions deduplicates concurrent init for the same dir
+ *   - loadConfig(cwd) avoids process.chdir() race conditions
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { loadConfig } from "../config.js";
+import { ThreadManager } from "../threads/manager.js";
+import { mergeAllThreads } from "../worktree/merge.js";
+// ── Session Manager ────────────────────────────────────────────────────────
+const sessions = new Map();
+/** Deduplicates concurrent getSession() calls for the same directory. */
+const pendingSessions = new Map();
+/**
+ * Lazily init agent backends (only once).
+ * Agent modules self-register when imported.
+ * The flag is set eagerly to prevent duplicate imports even if
+ * the first call hasn't finished awaiting yet.
+ */
+let agentsRegistered = false;
+async function ensureAgentsRegistered() {
+    if (agentsRegistered)
+        return;
+    agentsRegistered = true;
+    // Each agent module calls registerAgent() at module level on import
+    const modules = [
+        import("../agents/opencode.js"),
+        import("../agents/claude-code.js"),
+        import("../agents/codex.js"),
+        import("../agents/aider.js"),
+        import("../agents/direct-llm.js"),
+    ];
+    // Import all, ignoring individual failures
+    await Promise.allSettled(modules);
+}
+/**
+ * Get or create a session for a directory.
+ * The directory is resolved to an absolute path and used as the session key.
+ * Concurrent calls for the same directory are deduplicated.
+ */
+export async function getSession(dir) {
+    const absDir = path.resolve(dir);
+    if (!fs.existsSync(absDir)) {
+        throw new Error(`Directory does not exist: ${absDir}`);
+    }
+    // Return existing session
+    const existing = sessions.get(absDir);
+    if (existing)
+        return existing;
+    // Deduplicate concurrent init for the same dir
+    const pending = pendingSessions.get(absDir);
+    if (pending)
+        return pending;
+    const initPromise = initSession(absDir);
+    pendingSessions.set(absDir, initPromise);
+    try {
+        const session = await initPromise;
+        return session;
+    }
+    finally {
+        pendingSessions.delete(absDir);
+    }
+}
+/**
+ * Initialize a new session for a directory.
+ * Uses loadConfig(cwd) to avoid process.chdir() race conditions.
+ */
+async function initSession(absDir) {
+    await ensureAgentsRegistered();
+    // Load config from project dir without chdir (concurrency-safe)
+    const config = loadConfig(absDir);
+    const abortController = new AbortController();
+    // ThreadManager creates its own WorktreeManager internally,
+    // so we don't need a separate one at the session level.
+    const threadManager = new ThreadManager(absDir, config, 
+    // Progress callback — log to stderr (stdout is MCP protocol)
+    (threadId, phase, detail) => {
+        const msg = detail ? `[${threadId}] ${phase}: ${detail}` : `[${threadId}] ${phase}`;
+        process.stderr.write(`[swarm-mcp] ${msg}\n`);
+    }, abortController.signal);
+    await threadManager.init();
+    const session = {
+        dir: absDir,
+        config,
+        threadManager,
+        abortController,
+        createdAt: Date.now(),
+    };
+    sessions.set(absDir, session);
+    return session;
+}
+/**
+ * Spawn a thread in a session.
+ */
+export async function spawnThread(session, params) {
+    const threadId = `mcp-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+    const threadConfig = {
+        id: threadId,
+        task: params.task,
+        context: params.context || "",
+        agent: {
+            backend: params.agent || session.config.default_agent,
+            model: params.model || session.config.default_model,
+        },
+        files: params.files || [],
+    };
+    return session.threadManager.spawnThread(threadConfig);
+}
+/**
+ * Get all threads in a session.
+ */
+export function getThreads(session) {
+    return session.threadManager.getThreads();
+}
+/**
+ * Get budget state for a session.
+ */
+export function getBudgetState(session) {
+    return session.threadManager.getBudgetState();
+}
+/**
+ * Merge completed threads.
+ */
+export async function mergeThreads(session) {
+    const threads = session.threadManager.getThreads();
+    return mergeAllThreads(session.dir, threads, { continueOnConflict: true });
+}
+/**
+ * Cancel a specific thread or all threads.
+ * Per-thread cancellation uses ThreadManager.cancelThread() which
+ * aborts the thread's individual AbortController.
+ */
+export function cancelThreads(session, threadId) {
+    if (threadId) {
+        const cancelled = session.threadManager.cancelThread(threadId);
+        if (!cancelled) {
+            const threads = session.threadManager.getThreads();
+            const thread = threads.find((t) => t.id === threadId);
+            if (!thread)
+                return { cancelled: false, message: `Thread ${threadId} not found` };
+            return { cancelled: false, message: `Thread ${threadId} is ${thread.status}, cannot cancel` };
+        }
+        return { cancelled: true, message: `Thread ${threadId} cancelled` };
+    }
+    // Cancel all — abort the session controller
+    session.abortController.abort();
+    return { cancelled: true, message: "All threads cancelled" };
+}
+/**
+ * Cleanup a session — destroy worktrees, remove session.
+ */
+export async function cleanupSession(dir) {
+    const absDir = path.resolve(dir);
+    const session = sessions.get(absDir);
+    if (!session)
+        return "No active session for this directory";
+    session.abortController.abort();
+    await session.threadManager.cleanup();
+    sessions.delete(absDir);
+    return `Session cleaned up for ${absDir}`;
+}
+/**
+ * Cleanup all sessions. Snapshots keys first to avoid
+ * mutating the map during iteration.
+ */
+export async function cleanupAllSessions() {
+    const dirs = [...sessions.keys()];
+    for (const dir of dirs) {
+        await cleanupSession(dir);
+    }
+}
+//# sourceMappingURL=session.js.map

package/dist/mcp/tools.d.ts

@@ -0,0 +1,15 @@
+/**
+ * MCP tool definitions and handlers for swarm-code.
+ *
+ * Tools:
+ *   - swarm_run:     Full orchestrated swarm execution (subprocess)
+ *   - swarm_thread:  Spawn a single coding agent thread in a worktree
+ *   - swarm_status:  Get current session status (threads, budget)
+ *   - swarm_merge:   Merge completed thread branches
+ *   - swarm_cancel:  Cancel running thread(s)
+ *   - swarm_cleanup: Destroy session and worktrees
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/** Kill all tracked subprocesses. Called during server shutdown. */
+export declare function killActiveSubprocesses(): void;
+export declare function registerTools(server: McpServer, defaultDir?: string): void;