swarm-code 0.1.5 → 0.1.7

package/dist/config.js

@@ -23,7 +23,7 @@ const DEFAULTS = {
     max_session_budget_usd: 10.0,
     default_agent: "opencode",
     default_model: "anthropic/claude-sonnet-4-6",
-    auto_model_selection: false,
+    auto_model_selection: true,
     compression_strategy: "structured",
     compression_max_tokens: 1000,
     worktree_base_dir: ".swarm-worktrees",

package/dist/hooks/runner.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Hook runner — executes user-defined commands at lifecycle points.
+ *
+ * Hooks provide deterministic control flow (not LLM-decided).
+ * They run shell commands and surface only errors — success is silent.
+ *
+ * Lifecycle points:
+ *   - post_thread: After a thread commits (before compression)
+ *   - post_merge: After merge_threads() completes
+ *   - post_session: When the session ends
+ */
+export interface HookConfig {
+    command: string;
+    on_failure: "warn" | "block";
+}
+export interface HooksConfig {
+    post_thread: HookConfig[];
+    post_merge: HookConfig[];
+    post_session: HookConfig[];
+}
+export interface HookResult {
+    success: boolean;
+    output: string;
+    command: string;
+}
+/**
+ * Load hooks from swarm_config.yaml hooks section, or from .swarm/hooks.yaml.
+ */
+export declare function loadHooks(projectDir: string): HooksConfig;
+/**
+ * Run hooks for a lifecycle point.
+ * Returns results for each hook. On "block" failure, throws.
+ * Success output is swallowed — only errors are surfaced.
+ */
+export declare function runHooks(hooks: HookConfig[], cwd: string, label: string): HookResult[];

package/dist/hooks/runner.js

@@ -0,0 +1,95 @@
+/**
+ * Hook runner — executes user-defined commands at lifecycle points.
+ *
+ * Hooks provide deterministic control flow (not LLM-decided).
+ * They run shell commands and surface only errors — success is silent.
+ *
+ * Lifecycle points:
+ *   - post_thread: After a thread commits (before compression)
+ *   - post_merge: After merge_threads() completes
+ *   - post_session: When the session ends
+ */
+import { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+const DEFAULT_HOOKS = {
+    post_thread: [],
+    post_merge: [],
+    post_session: [],
+};
+/**
+ * Load hooks from swarm_config.yaml hooks section, or from .swarm/hooks.yaml.
+ */
+export function loadHooks(projectDir) {
+    const hooksFile = path.join(projectDir, ".swarm", "hooks.yaml");
+    if (!fs.existsSync(hooksFile))
+        return { ...DEFAULT_HOOKS };
+    try {
+        const raw = fs.readFileSync(hooksFile, "utf-8");
+        return parseHooksYaml(raw);
+    }
+    catch {
+        return { ...DEFAULT_HOOKS };
+    }
+}
+function parseHooksYaml(raw) {
+    const hooks = { post_thread: [], post_merge: [], post_session: [] };
+    let currentSection = null;
+    for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        if (trimmed === "post_thread:" || trimmed === "post_merge:" || trimmed === "post_session:") {
+            currentSection = trimmed.replace(":", "");
+            continue;
+        }
+        if (currentSection && trimmed.startsWith("- command:")) {
+            const command = trimmed
+                .replace("- command:", "")
+                .trim()
+                .replace(/^["']|["']$/g, "");
+            if (command) {
+                hooks[currentSection].push({ command, on_failure: "warn" });
+            }
+        }
+        if (currentSection && trimmed.startsWith("on_failure:")) {
+            const val = trimmed.replace("on_failure:", "").trim();
+            const last = hooks[currentSection][hooks[currentSection].length - 1];
+            if (last && (val === "warn" || val === "block")) {
+                last.on_failure = val;
+            }
+        }
+    }
+    return hooks;
+}
+/**
+ * Run hooks for a lifecycle point.
+ * Returns results for each hook. On "block" failure, throws.
+ * Success output is swallowed — only errors are surfaced.
+ */
+export function runHooks(hooks, cwd, label) {
+    const results = [];
+    for (const hook of hooks) {
+        try {
+            execSync(hook.command, {
+                cwd,
+                stdio: ["ignore", "pipe", "pipe"],
+                timeout: 60_000,
+                encoding: "utf-8",
+            });
+            // Success — silent (context-efficient per harness engineering best practice)
+            results.push({ success: true, output: "", command: hook.command });
+        }
+        catch (err) {
+            const stderr = err.stderr || err.stdout || err.message || "unknown error";
+            // Only surface error output
+            const output = `[${label}] Hook failed: ${hook.command}\n${stderr}`.trim();
+            results.push({ success: false, output, command: hook.command });
+            if (hook.on_failure === "block") {
+                throw new Error(output);
+            }
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=runner.js.map

package/dist/interactive-swarm.js

@@ -80,8 +80,7 @@ function parseInteractiveArgs(args) {
         // Silently ignore unknown flags and positional args
     }
     if (!dir) {
-        logError("--dir <path> is required for interactive swarm mode");
-        process.exit(1);
+        dir = process.cwd();
     }
     return {
         dir: path.resolve(dir),

package/dist/main.d.ts

@@ -10,6 +10,6 @@
  *   swarm run                    → single-shot RLM CLI run
  *   swarm viewer                 → browse trajectory files
  *   swarm benchmark              → run benchmarks
- *   swarm                        → interactive terminal (RLM mode, default)
+ *   swarm                        → interactive REPL (uses current directory)
  */
 export declare function buildHelp(): string;

package/dist/main.js

@@ -10,7 +10,7 @@
  *   swarm run                    → single-shot RLM CLI run
  *   swarm viewer                 → browse trajectory files
  *   swarm benchmark              → run benchmarks
- *   swarm                        → interactive terminal (RLM mode, default)
+ *   swarm                        → interactive REPL (uses current directory)
  */
 import { bold, coral, cyan, dim, isTTY, symbols, termWidth, yellow } from "./ui/theme.js";
 export function buildHelp() {
@@ -45,8 +45,10 @@ export function buildHelp() {
     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("INTERACTIVE")} ${dim("(default — uses current directory)")}`);
+    lines.push(`    ${yellow("swarm")}                          ${dim("Interactive REPL in current dir")}`);
+    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")}`);
@@ -125,13 +127,14 @@ async function main() {
         }
         return;
     }
-    const command = args[0] || "interactive";
+    const command = args[0] || "";
+    // Default: no command → interactive swarm mode using current directory
+    if (!command || command === "interactive" || command === "i") {
+        const { runInteractiveSwarm } = await import("./interactive-swarm.js");
+        await runInteractiveSwarm(["--dir", process.cwd(), ...args.slice(command ? 1 : 0)]);
+        return;
+    }
     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)];

package/dist/prompts/orchestrator.js

@@ -56,11 +56,11 @@ ${agentDescriptions}
 
 1. **Analyze first**: Use \`llm_query()\` or direct Python to understand the codebase/task
 2. **Decompose**: Break the task into independent, parallelizable units
-3. **Extract context**: For each thread, extract ONLY the relevant code/context — don't send everything
+3. **Extract context**: For each thread, extract ONLY the relevant code/context — don't send everything. Keep thread context under 5000 chars; agents have access to the full worktree
 4. **Spawn threads**: Use \`async_thread()\` + \`asyncio.gather()\` for parallel work
 5. **Inspect results**: Check each thread's result for success/failure
 6. **Merge**: Call \`merge_threads()\` to integrate changes
-7. **Verify**: Optionally spawn a test thread to verify the merged result
+7. **Verify**: ALWAYS spawn a verification thread after merging — run the project's test/typecheck/lint commands. If verification fails, fix before calling FINAL()
 8. **Report**: Call \`FINAL()\` with a summary
 
 ## Episode Quality & Caching
@@ -77,7 +77,8 @@ ${agentDescriptions}
 4. Use \`print()\` for intermediate output visible in the next iteration
 5. Max ${config.max_threads} concurrent threads, ${config.max_total_threads} total per session
 6. Thread timeout: ${config.thread_timeout_ms / 1000}s per thread
-7. Don't call FINAL prematurely — verify thread results first
+7. Don't call FINAL prematurely — verify thread results first. Always run verification after merge.
+8. Prefer cheap models for sub-agent threads (haiku, gpt-4o-mini) — save premium models for complex work
 8. The REPL persists state — variables survive across iterations
 
 ## Examples

package/dist/swarm.js

@@ -25,6 +25,7 @@ await import("./agents/claude-code.js");
 await import("./agents/codex.js");
 await import("./agents/aider.js");
 import { randomBytes } from "node:crypto";
+import { loadHooks, runHooks } from "./hooks/runner.js";
 import { EpisodicMemory } from "./memory/episodic.js";
 import { buildSwarmSystemPrompt } from "./prompts/orchestrator.js";
 import { classifyTaskComplexity, describeAvailableAgents, FailureTracker, routeTask } from "./routing/model-router.js";
@@ -296,6 +297,7 @@ function resolveModel(modelId) {
 export async function runSwarmMode(rawArgs) {
     const args = parseSwarmArgs(rawArgs);
     const config = loadConfig();
+    const hooks = loadHooks(args.dir);
     // Configure UI
     if (args.json)
         setJsonMode(true);
@@ -420,6 +422,12 @@ export async function runSwarmMode(rawArgs) {
         }
         // Thread handler
         const threadHandler = async (task, threadContext, agentBackend, model, files) => {
+            // Context-size guard: warn and truncate if orchestrator sends too much context
+            const MAX_THREAD_CONTEXT = 50_000;
+            if (threadContext.length > MAX_THREAD_CONTEXT) {
+                logWarn(`Thread context too large (${(threadContext.length / 1024).toFixed(0)}KB) — truncating to ${MAX_THREAD_CONTEXT / 1000}KB. Agents have full worktree access; pass only relevant excerpts.`);
+                threadContext = `${threadContext.slice(0, MAX_THREAD_CONTEXT)}\n\n[... truncated — ${threadContext.length - MAX_THREAD_CONTEXT} chars removed ...]`;
+            }
             let resolvedAgent = agentBackend || config.default_agent;
             let resolvedModel = model || config.default_model;
             let routeSlot = "";
@@ -449,6 +457,18 @@ export async function runSwarmMode(rawArgs) {
                 },
                 files,
             });
+            // Run post-thread hooks (typecheck, lint, etc.) — success is silent, only errors surface
+            if (result.success && hooks.post_thread.length > 0) {
+                try {
+                    const worktreePath = path.join(args.dir, config.worktree_base_dir, `wt-${threadId}`);
+                    if (fs.existsSync(worktreePath)) {
+                        runHooks(hooks.post_thread, worktreePath, "post_thread");
+                    }
+                }
+                catch (hookErr) {
+                    logWarn(`Post-thread hook failed: ${hookErr.message}`);
+                }
+            }
             // Track failure in the failure tracker for routing adjustments
             if (!result.success) {
                 failureTracker.recordFailure(resolvedAgent, resolvedModel, task, result.summary || "unknown error");
@@ -494,6 +514,26 @@ export async function runSwarmMode(rawArgs) {
             const summary = results
                 .map((r) => (r.success ? `Merged ${r.branch}: ${r.message}` : `FAILED ${r.branch}: ${r.message}`))
                 .join("\n");
+            // Run post-merge hooks (tests, etc.) — success is silent
+            if (merged > 0 && hooks.post_merge.length > 0) {
+                try {
+                    const hookResults = runHooks(hooks.post_merge, args.dir, "post_merge");
+                    const hookFailures = hookResults.filter((r) => !r.success);
+                    if (hookFailures.length > 0) {
+                        const hookOutput = hookFailures.map((r) => r.output).join("\n");
+                        return {
+                            result: `${summary}\n\nPost-merge verification failed:\n${hookOutput}`,
+                            success: false,
+                        };
+                    }
+                }
+                catch (hookErr) {
+                    return {
+                        result: `${summary}\n\nPost-merge hook blocked: ${hookErr.message}`,
+                        success: false,
+                    };
+                }
+            }
             return {
                 result: summary || "No threads to merge",
                 success: results.every((r) => r.success),

package/dist/ui/onboarding.js

@@ -10,11 +10,12 @@
  *
  * Triggered once on first `swarm --dir` invocation. Saves ~/.swarm/.initialized marker.
  */
-import { spawn } from "node:child_process";
+import { execFileSync, execSync, spawn, spawn as spawnChild } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import * as readline from "node:readline";
+import { fileURLToPath } from "node:url";
 import { getLogLevel, isJsonMode } from "./log.js";
 import { bold, coral, cyan, dim, green, isTTY, red, stripAnsi, symbols, termWidth, yellow } from "./theme.js";
 // ── Constants ─────────────────────────────────────────────────────────────────
@@ -22,7 +23,19 @@ const SWARM_DIR = path.join(os.homedir(), ".swarm");
 const MARKER_FILE = path.join(SWARM_DIR, ".initialized");
 const CRED_FILE = path.join(SWARM_DIR, "credentials");
 const USER_CONFIG_FILE = path.join(SWARM_DIR, "config.yaml");
-const VERSION = "0.1.0";
+// Read version from package.json instead of hardcoding
+function getVersion() {
+    try {
+        const __dir = path.dirname(fileURLToPath(import.meta.url));
+        const pkgPath = path.join(__dir, "..", "..", "package.json");
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        return pkg.version || "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+const VERSION = getVersion();
 /** Which API key each agent backend requires (or supports). */
 const AGENT_PROVIDERS = {
     opencode: {
@@ -127,6 +140,147 @@ async function checkAgentBackends() {
     results.push({ name: "direct-llm", ok: true, detail: "built-in" });
     return results;
 }
+// ── Ollama helpers ────────────────────────────────────────────────────────────
+function isOllamaInstalled() {
+    try {
+        execFileSync("ollama", ["--version"], { stdio: ["ignore", "pipe", "pipe"], timeout: 5000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isOllamaModelAvailable(model) {
+    try {
+        const output = execFileSync("ollama", ["list"], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: 10000,
+        });
+        return output.includes(model);
+    }
+    catch {
+        return false;
+    }
+}
+async function installOllama() {
+    process.stderr.write(`\n  ${bold("Installing Ollama...")}\n\n`);
+    if (process.platform === "darwin") {
+        try {
+            execFileSync("brew", ["--version"], { stdio: "ignore", timeout: 5000 });
+            process.stderr.write(`  ${dim("Using Homebrew...")}\n`);
+            try {
+                execSync("brew install ollama", { stdio: "inherit", timeout: 120000 });
+                return true;
+            }
+            catch {
+                process.stderr.write(`  ${dim("Homebrew install failed, trying curl installer...")}\n`);
+            }
+        }
+        catch {
+            // No brew — fall through to curl
+        }
+    }
+    if (process.platform === "linux" || process.platform === "darwin") {
+        try {
+            execSync("curl -fsSL https://ollama.com/install.sh | sh", { stdio: "inherit", timeout: 180000 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    process.stderr.write(`  ${dim("Download Ollama from: https://ollama.com/download")}\n`);
+    return false;
+}
+function isOllamaServing() {
+    try {
+        execFileSync("curl", ["-sf", "http://127.0.0.1:11434/api/tags"], {
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: 3000,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function startOllamaServe() {
+    const child = spawnChild("ollama", ["serve"], { stdio: "ignore", detached: true });
+    child.unref();
+}
+async function pullOllamaModel(model) {
+    process.stderr.write(`\n  ${bold(`Pulling ${model}...`)} ${dim("(this may take a few minutes)")}\n\n`);
+    return new Promise((resolve) => {
+        const child = spawnChild("ollama", ["pull", model], { stdio: "inherit" });
+        child.on("close", (code) => resolve(code === 0));
+        child.on("error", () => resolve(false));
+    });
+}
+async function ensureOllamaSetup(promptFn, model) {
+    const shortModel = model.replace("ollama/", "");
+    if (!isOllamaInstalled()) {
+        process.stderr.write(`\n  ${dim("Ollama is not installed. It's needed to run open-source models locally.")}\n`);
+        const prompt = promptFn();
+        const install = await prompt.ask(`  ${coral(symbols.arrow)} Install Ollama now? [Y/n]: `);
+        prompt.close();
+        if (install.toLowerCase() !== "n" && install.toLowerCase() !== "no") {
+            const ok = await installOllama();
+            if (!ok) {
+                process.stderr.write(`\n  ${red("Failed to install Ollama.")}\n`);
+                process.stderr.write(`  ${dim("Install manually from https://ollama.com/download")}\n\n`);
+                return false;
+            }
+            process.stderr.write(`  ${green(symbols.check)} Ollama installed\n`);
+        }
+        else {
+            process.stderr.write(`\n  ${dim("Install later from https://ollama.com/download")}\n\n`);
+            return false;
+        }
+    }
+    else {
+        process.stderr.write(`  ${green(symbols.check)} Ollama installed\n`);
+    }
+    if (!isOllamaServing()) {
+        process.stderr.write(`  ${dim("Starting Ollama server...")}\n`);
+        startOllamaServe();
+        let retries = 10;
+        while (retries > 0 && !isOllamaServing()) {
+            await new Promise((r) => setTimeout(r, 1000));
+            retries--;
+        }
+        if (isOllamaServing()) {
+            process.stderr.write(`  ${green(symbols.check)} Ollama server running\n`);
+        }
+        else {
+            process.stderr.write(`  ${yellow(symbols.warn)} Could not start Ollama server. Run ${bold("ollama serve")} manually.\n`);
+            return false;
+        }
+    }
+    else {
+        process.stderr.write(`  ${green(symbols.check)} Ollama server running\n`);
+    }
+    if (isOllamaModelAvailable(shortModel)) {
+        process.stderr.write(`  ${green(symbols.check)} Model ${bold(shortModel)} ready\n\n`);
+        return true;
+    }
+    process.stderr.write(`  ${dim(`Model ${shortModel} not found locally.`)}\n`);
+    const prompt = promptFn();
+    const pull = await prompt.ask(`\n  ${coral(symbols.arrow)} Pull ${bold(shortModel)} now? [Y/n]: `);
+    prompt.close();
+    if (pull.toLowerCase() !== "n" && pull.toLowerCase() !== "no") {
+        const ok = await pullOllamaModel(shortModel);
+        if (!ok) {
+            process.stderr.write(`\n  ${red(`Failed to pull ${shortModel}.`)}\n`);
+            process.stderr.write(`  ${dim(`Try manually: ollama pull ${shortModel}`)}\n\n`);
+            return false;
+        }
+        process.stderr.write(`  ${green(symbols.check)} Model ${bold(shortModel)} ready\n\n`);
+        return true;
+    }
+    process.stderr.write(`\n  ${dim(`Run later: ollama pull ${shortModel}`)}\n\n`);
+    return false;
+}
 // ── Interactive helpers ───────────────────────────────────────────────────────
 function createPrompt() {
     const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
@@ -396,93 +550,174 @@ export async function runOnboarding() {
         process.stderr.write(`\n  ${dim("Using direct-llm (no coding agent) as fallback.")}\n`);
         chosenAgent = "direct-llm";
     }
-    // ── Step 2: Configure API keys ───────────────────────────────────────
+    // ── Step 2: Configure backend / API keys ────────────────────────────
     const agentInfo = AGENT_PROVIDERS[chosenAgent];
     const neededKeys = agentInfo?.required ?? ["ANTHROPIC_API_KEY"];
-    // For agents that accept any provider (opencode, aider), at least one key is needed
     const needsAnyKey = neededKeys.length > 1;
-    const missingKeys = neededKeys.filter((k) => !apiKeys.has(k));
     const hasAnyNeeded = neededKeys.some((k) => apiKeys.has(k));
-    if (missingKeys.length > 0 && !(needsAnyKey && hasAnyNeeded)) {
-        sectionHeader("API Keys", w);
-        if (needsAnyKey) {
-            process.stderr.write(`  ${bold(chosenAgent)} supports multiple providers. Configure at least one:\n\n`);
+    let chosenModel = "anthropic/claude-sonnet-4-6";
+    let usesOllama = false;
+    let usesOpenRouter = false;
+    // OpenCode with no API keys → offer Ollama (default) or OpenRouter
+    if (chosenAgent === "opencode" && !hasAnyNeeded) {
+        sectionHeader("Backend", w);
+        process.stderr.write(`  ${bold("OpenCode")} ${dim("— choose your backend:")}\n\n`);
+        process.stderr.write(`    ${cyan("1")}  Ollama       ${dim("Run models locally (free, requires download)")}\n`);
+        process.stderr.write(`    ${cyan("2")}  OpenRouter   ${dim("Cloud API for 200+ models (requires API key)")}\n`);
+        process.stderr.write(`    ${cyan("3")}  API Key      ${dim("Configure Anthropic/OpenAI/Google directly")}\n`);
+        process.stderr.write("\n");
+        const prompt = createPrompt();
+        const backendChoice = await prompt.ask(`  ${coral(symbols.arrow)} Backend [1]: `);
+        prompt.close();
+        const choice = backendChoice.trim();
+        if (choice === "2") {
+            // OpenRouter setup
+            process.stderr.write("\n");
+            const keyPrompt = createPrompt();
+            const orKey = await keyPrompt.ask(`  ${coral(symbols.arrow)} OPENROUTER_API_KEY: `);
+            keyPrompt.close();
+            if (orKey?.trim()) {
+                process.env.OPENROUTER_API_KEY = orKey.trim();
+                saveCredential("OPENROUTER_API_KEY", orKey.trim());
+                process.stderr.write(`  ${green(symbols.check)} OpenRouter configured\n`);
+                chosenModel = "openrouter/auto";
+                usesOpenRouter = true;
+            }
+            else {
+                process.stderr.write(`  ${dim("No key provided — you can set OPENROUTER_API_KEY in .env later")}\n`);
+            }
+        }
+        else if (choice === "3") {
+            // Fall through to standard API key setup below
         }
         else {
-            process.stderr.write(`  ${bold(chosenAgent)} needs the following API key(s):\n\n`);
+            // Default: Ollama setup
+            process.stderr.write("\n");
+            const ok = await ensureOllamaSetup(createPrompt, "ollama/deepseek-coder-v2");
+            if (ok) {
+                usesOllama = true;
+                chosenModel = "ollama/deepseek-coder-v2";
+            }
         }
-        for (const envVar of missingKeys) {
-            const provider = PROVIDERS.find((p) => p.envVar === envVar);
-            if (!provider)
-                continue;
-            const prompt = createPrompt();
-            const yn = await prompt.ask(`  ${coral(symbols.arrow)} Configure ${bold(provider.name)} (${dim(envVar)})? [y/n]: `);
-            prompt.close();
-            if (yn.toLowerCase() !== "y" && yn.toLowerCase() !== "yes") {
-                process.stderr.write(`  ${dim(symbols.dash)} Skipped ${provider.name}\n`);
-                continue;
+        // If choice was "3", do the standard API key flow
+        if (choice === "3") {
+            sectionHeader("API Keys", w);
+            process.stderr.write(`  ${bold(chosenAgent)} supports multiple providers. Configure at least one:\n\n`);
+            const missingKeys = neededKeys.filter((k) => !apiKeys.has(k));
+            for (const envVar of missingKeys) {
+                const provider = PROVIDERS.find((p) => p.envVar === envVar);
+                if (!provider)
+                    continue;
+                const kp = createPrompt();
+                const yn = await kp.ask(`  ${coral(symbols.arrow)} Configure ${bold(provider.name)} (${dim(envVar)})? [y/n]: `);
+                kp.close();
+                if (yn.toLowerCase() !== "y" && yn.toLowerCase() !== "yes") {
+                    process.stderr.write(`  ${dim(symbols.dash)} Skipped ${provider.name}\n`);
+                    continue;
+                }
+                process.stderr.write(`  ${dim(`Paste your ${provider.name} API key (input hidden):`)}\n`);
+                const key = await readHiddenInput(`  ${coral(symbols.arrow)} `);
+                if (key && key.length >= 10) {
+                    saveCredential(envVar, key);
+                    apiKeys.set(envVar, key);
+                    process.stderr.write(`  ${green(symbols.check)} Saved ${provider.name} key to ${dim("~/.swarm/credentials")}\n\n`);
+                }
+                else {
+                    process.stderr.write(`  ${dim("Skipped — set later in .env or ~/.swarm/credentials")}\n\n`);
+                }
+                if (apiKeys.has(envVar))
+                    break;
             }
-            process.stderr.write(`  ${dim(`Paste your ${provider.name} API key (input hidden):`)}\n`);
-            const key = await readHiddenInput(`  ${coral(symbols.arrow)} `);
-            if (key && key.length >= 10) {
-                saveCredential(envVar, key);
-                apiKeys.set(envVar, key);
-                process.stderr.write(`  ${green(symbols.check)} Saved ${provider.name} key to ${dim("~/.swarm/credentials")}\n\n`);
+        }
+    }
+    else if (!hasAnyNeeded) {
+        // Non-opencode agent with missing keys — standard API key flow
+        const missingKeys = neededKeys.filter((k) => !apiKeys.has(k));
+        if (missingKeys.length > 0) {
+            sectionHeader("API Keys", w);
+            if (needsAnyKey) {
+                process.stderr.write(`  ${bold(chosenAgent)} supports multiple providers. Configure at least one:\n\n`);
             }
             else {
-                process.stderr.write(`  ${dim("Skipped — set later in .env or ~/.swarm/credentials")}\n\n`);
+                process.stderr.write(`  ${bold(chosenAgent)} needs the following API key(s):\n\n`);
+            }
+            for (const envVar of missingKeys) {
+                const provider = PROVIDERS.find((p) => p.envVar === envVar);
+                if (!provider)
+                    continue;
+                const prompt = createPrompt();
+                const yn = await prompt.ask(`  ${coral(symbols.arrow)} Configure ${bold(provider.name)} (${dim(envVar)})? [y/n]: `);
+                prompt.close();
+                if (yn.toLowerCase() !== "y" && yn.toLowerCase() !== "yes") {
+                    process.stderr.write(`  ${dim(symbols.dash)} Skipped ${provider.name}\n`);
+                    continue;
+                }
+                process.stderr.write(`  ${dim(`Paste your ${provider.name} API key (input hidden):`)}\n`);
+                const key = await readHiddenInput(`  ${coral(symbols.arrow)} `);
+                if (key && key.length >= 10) {
+                    saveCredential(envVar, key);
+                    apiKeys.set(envVar, key);
+                    process.stderr.write(`  ${green(symbols.check)} Saved ${provider.name} key to ${dim("~/.swarm/credentials")}\n\n`);
+                }
+                else {
+                    process.stderr.write(`  ${dim("Skipped — set later in .env or ~/.swarm/credentials")}\n\n`);
+                }
+                if (needsAnyKey && apiKeys.has(envVar))
+                    break;
             }
-            // For multi-provider agents, stop after first successful key
-            if (needsAnyKey && apiKeys.has(envVar))
-                break;
         }
     }
-    else if (apiKeys.size > 0) {
-        // Keys already configured — just confirm
+    else {
         process.stderr.write(`  ${green(symbols.check)} API keys already configured\n`);
     }
     // ── Step 3: Choose default model ─────────────────────────────────────
-    // Suggest a model based on available keys
-    const configuredProviders = PROVIDERS.filter((p) => apiKeys.has(p.envVar));
-    let chosenModel = "anthropic/claude-sonnet-4-6"; // default
-    if (configuredProviders.length > 0) {
-        sectionHeader("Default Model", w);
-        const modelOptions = configuredProviders.flatMap((p) => {
-            const models = [];
-            if (p.envVar === "ANTHROPIC_API_KEY") {
-                models.push({
-                    label: `claude-sonnet-4-6 ${dim("(fast, capable)")}`,
-                    value: "anthropic/claude-sonnet-4-6",
-                    recommended: true,
-                }, { label: `claude-opus-4-6 ${dim("(most capable)")}`, value: "anthropic/claude-opus-4-6" });
-            }
-            else if (p.envVar === "OPENAI_API_KEY") {
-                models.push({ label: `gpt-4o ${dim("(fast, versatile)")}`, value: "openai/gpt-4o" }, { label: `o3 ${dim("(reasoning)")}`, value: "openai/o3" });
-            }
-            else if (p.envVar === "GEMINI_API_KEY") {
-                models.push({ label: `gemini-2.5-flash ${dim("(fast, cheap)")}`, value: "google/gemini-2.5-flash" }, { label: `gemini-2.5-pro ${dim("(capable)")}`, value: "google/gemini-2.5-pro" });
-            }
-            return models;
-        });
-        if (modelOptions.length > 0) {
-            process.stderr.write(`  ${bold("Pick a default model for coding threads:")}\n\n`);
-            for (let i = 0; i < modelOptions.length; i++) {
-                const opt = modelOptions[i];
-                const rec = opt.recommended ? ` ${coral("(recommended)")}` : "";
-                process.stderr.write(`    ${cyan(String(i + 1))}  ${opt.label}${rec}\n`);
-            }
-            process.stderr.write("\n");
-            const prompt = createPrompt();
-            const modelChoice = await prompt.ask(`  ${coral(symbols.arrow)} Choice [1]: `);
-            prompt.close();
-            const idx = parseInt(modelChoice, 10);
-            if (idx >= 1 && idx <= modelOptions.length) {
-                chosenModel = modelOptions[idx - 1].value;
-            }
-            else {
-                chosenModel = modelOptions[0].value;
+    if (!usesOllama && !usesOpenRouter) {
+        const configuredProviders = PROVIDERS.filter((p) => apiKeys.has(p.envVar));
+        if (configuredProviders.length > 0) {
+            sectionHeader("Default Model", w);
+            const modelOptions = configuredProviders.flatMap((p) => {
+                const models = [];
+                if (p.envVar === "ANTHROPIC_API_KEY") {
+                    models.push({
+                        label: `claude-sonnet-4-6 ${dim("(fast, capable)")}`,
+                        value: "anthropic/claude-sonnet-4-6",
+                        recommended: true,
+                    }, {
+                        label: `claude-opus-4-6 ${dim("(most capable)")}`,
+                        value: "anthropic/claude-opus-4-6",
+                    });
+                }
+                else if (p.envVar === "OPENAI_API_KEY") {
+                    models.push({ label: `gpt-4o ${dim("(fast, versatile)")}`, value: "openai/gpt-4o" }, { label: `o3 ${dim("(reasoning)")}`, value: "openai/o3" });
+                }
+                else if (p.envVar === "GEMINI_API_KEY") {
+                    models.push({
+                        label: `gemini-2.5-flash ${dim("(fast, cheap)")}`,
+                        value: "google/gemini-2.5-flash",
+                    }, { label: `gemini-2.5-pro ${dim("(capable)")}`, value: "google/gemini-2.5-pro" });
+                }
+                return models;
+            });
+            if (modelOptions.length > 0) {
+                process.stderr.write(`  ${bold("Pick a default model for coding threads:")}\n\n`);
+                for (let i = 0; i < modelOptions.length; i++) {
+                    const opt = modelOptions[i];
+                    const rec = opt.recommended ? ` ${coral("(recommended)")}` : "";
+                    process.stderr.write(`    ${cyan(String(i + 1))}  ${opt.label}${rec}\n`);
+                }
+                process.stderr.write("\n");
+                const prompt = createPrompt();
+                const modelChoice = await prompt.ask(`  ${coral(symbols.arrow)} Choice [1]: `);
+                prompt.close();
+                const idx = parseInt(modelChoice, 10);
+                if (idx >= 1 && idx <= modelOptions.length) {
+                    chosenModel = modelOptions[idx - 1].value;
+                }
+                else {
+                    chosenModel = modelOptions[0].value;
+                }
+                process.stderr.write(`  ${green(symbols.check)} Default model: ${bold(chosenModel)}\n`);
             }
-            process.stderr.write(`  ${green(symbols.check)} Default model: ${bold(chosenModel)}\n`);
         }
     }
     // ── Step 4: Save config ──────────────────────────────────────────────
@@ -491,22 +726,29 @@ export async function runOnboarding() {
     sectionHeader("Ready", w);
     process.stderr.write(`  ${green(symbols.check)} Agent:  ${bold(chosenAgent)}\n`);
     process.stderr.write(`  ${green(symbols.check)} Model:  ${bold(chosenModel)}\n`);
-    const keyNames = [...apiKeys.keys()].map((k) => {
-        const p = PROVIDERS.find((pr) => pr.envVar === k);
-        return p?.name ?? k;
-    });
-    if (keyNames.length > 0) {
-        process.stderr.write(`  ${green(symbols.check)} Keys:   ${bold(keyNames.join(", "))}\n`);
+    if (usesOllama) {
+        process.stderr.write(`  ${green(symbols.check)} Backend: ${bold("Ollama")} ${dim("(local)")}\n`);
+    }
+    else if (usesOpenRouter) {
+        process.stderr.write(`  ${green(symbols.check)} Backend: ${bold("OpenRouter")}\n`);
+    }
+    else {
+        const keyNames = [...apiKeys.keys()].map((k) => {
+            const p = PROVIDERS.find((pr) => pr.envVar === k);
+            return p?.name ?? k;
+        });
+        if (keyNames.length > 0) {
+            process.stderr.write(`  ${green(symbols.check)} Keys:   ${bold(keyNames.join(", "))}\n`);
+        }
     }
     process.stderr.write(`  ${green(symbols.check)} Config: ${dim("~/.swarm/config.yaml")}\n`);
-    process.stderr.write(`\n  ${dim("Run")} ${yellow('swarm --dir ./project "your task"')} ${dim("to get started.")}\n`);
-    process.stderr.write(`  ${dim("Edit")} ${cyan("~/.swarm/config.yaml")} ${dim("to change these settings anytime.")}\n`);
+    process.stderr.write("\n");
     // If still missing critical deps, show warnings
     if (!gitVer) {
-        process.stderr.write(`\n  ${red(symbols.cross)} ${bold("git is required.")} Install it before using swarm.\n`);
+        process.stderr.write(`  ${red(symbols.cross)} ${bold("git is required.")} Install it before using swarm.\n`);
     }
-    if (apiKeys.size === 0) {
-        process.stderr.write(`\n  ${yellow(symbols.warn)} ${bold("No API keys configured.")}\n`);
+    if (apiKeys.size === 0 && !usesOllama && !usesOpenRouter) {
+        process.stderr.write(`  ${yellow(symbols.warn)} ${bold("No API keys configured.")}\n`);
         process.stderr.write(`  ${dim("Add keys to")} ${cyan("~/.swarm/credentials")} ${dim("or")} ${cyan(".env")}${dim(":")}\n`);
         process.stderr.write(`    ${dim("ANTHROPIC_API_KEY=sk-ant-...")}\n`);
         process.stderr.write(`    ${dim("OPENAI_API_KEY=sk-...")}\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarm-code",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Open-source swarm-native coding agent orchestrator — spawns parallel coding agents in isolated git worktrees, built on RLM (arXiv:2512.24601)",
   "type": "module",
   "bin": {