swarm-code 0.1.22 → 0.1.24

package/dist/agents/opencode.js

@@ -13,10 +13,38 @@
  * lazily and shutting them down when the session ends.
  */
 import { spawn } from "node:child_process";
+import * as fs from "node:fs";
 import * as http from "node:http";
 import * as os from "node:os";
+import * as path from "node:path";
 import { registerAgent } from "./provider.js";
 // ── Helpers ──────────────────────────────────────────────────────────────────
+/**
+ * Ensure model string is in `provider/model` format as required by OpenCode.
+ * If no provider prefix is present, infer it from the model name.
+ */
+function normalizeModelForOpenCode(model) {
+    if (model.includes("/"))
+        return model;
+    // Infer provider from model name prefix patterns
+    if (model.startsWith("gpt-") || model.startsWith("o1") || model.startsWith("o3") || model.startsWith("o4")) {
+        return `openai/${model}`;
+    }
+    if (model.startsWith("claude-")) {
+        return `anthropic/${model}`;
+    }
+    if (model.startsWith("gemini-")) {
+        return `google/${model}`;
+    }
+    if (model.startsWith("deepseek-")) {
+        return `deepseek/${model}`;
+    }
+    if (model.startsWith("llama-") || model.startsWith("codellama-")) {
+        return `ollama/${model}`;
+    }
+    // Can't infer — return as-is and let OpenCode handle it
+    return model;
+}
 async function commandExists(cmd) {
     return new Promise((resolve) => {
         const proc = spawn("which", [cmd], { stdio: "pipe" });
@@ -87,6 +115,15 @@ function extractFromParsed(parsed) {
 /** Whitelist of env vars safe to pass to agent subprocess. */
 function buildAgentEnv() {
     const homeDir = os.homedir();
+    // Isolate OpenCode's data dir to prevent stale auth tokens (e.g. expired
+    // OAuth) from causing "Model not found" errors on startup.
+    const agentDataDir = path.join(homeDir, ".swarm", "agent-data");
+    try {
+        fs.mkdirSync(agentDataDir, { recursive: true });
+    }
+    catch {
+        // Non-fatal
+    }
     return {
         PATH: process.env.PATH,
         HOME: homeDir,
@@ -94,9 +131,12 @@ function buildAgentEnv() {
         SHELL: process.env.SHELL,
         TERM: process.env.TERM,
         LANG: process.env.LANG,
+        TMPDIR: process.env.TMPDIR,
+        XDG_DATA_HOME: agentDataDir,
         ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
         OPENAI_API_KEY: process.env.OPENAI_API_KEY,
         GEMINI_API_KEY: process.env.GEMINI_API_KEY,
+        OPENROUTER_API_KEY: process.env.OPENROUTER_API_KEY,
         GIT_AUTHOR_NAME: process.env.GIT_AUTHOR_NAME,
         GIT_AUTHOR_EMAIL: process.env.GIT_AUTHOR_EMAIL,
         GIT_COMMITTER_NAME: process.env.GIT_COMMITTER_NAME,
@@ -290,7 +330,7 @@ async function runViaHttpApi(serverUrl, task, model, signal) {
             parts: [{ type: "text", text: task }],
         };
         if (model)
-            msgBody.model = model;
+            msgBody.model = normalizeModelForOpenCode(model);
         const msgRes = await httpPost(`${serverUrl}/session/${sessionId}/message`, msgBody, signal);
         if (!msgRes)
             return null;
@@ -401,7 +441,7 @@ function runViaAttach(serverUrl, task, workDir, model, signal, onOutput) {
     const startTime = Date.now();
     const args = ["run", "--attach", serverUrl, "--format", "json"];
     if (model)
-        args.push("--model", model);
+        args.push("--model", normalizeModelForOpenCode(model));
     args.push(task);
     return runSubprocess(args, workDir, startTime, signal, onOutput);
 }
@@ -414,7 +454,7 @@ function runViaSubprocess(task, workDir, model, signal, onOutput) {
     const startTime = Date.now();
     const args = ["run", "--format", "json"];
     if (model)
-        args.push("--model", model);
+        args.push("--model", normalizeModelForOpenCode(model));
     args.push(task);
     return runSubprocess(args, workDir, startTime, signal, onOutput);
 }

package/dist/core/rlm.js

@@ -171,6 +171,7 @@ export async function runRlmLoop(options) {
     const { context, query, model, repl, signal, onProgress, onSubQueryStart, onSubQuery, systemPrompt, threadHandler, mergeHandler, } = options;
     let totalSubQueries = 0;
     let iterationSubQueries = 0;
+    let mergedAlready = false;
     const llmQueryHandler = async (subContext, instruction) => {
         if (signal?.aborted)
             throw new Error("Aborted");
@@ -217,7 +218,10 @@ export async function runRlmLoop(options) {
             repl.setThreadHandler(threadHandler);
         }
         if (mergeHandler) {
-            repl.setMergeHandler(mergeHandler);
+            repl.setMergeHandler(async () => {
+                mergedAlready = true;
+                return mergeHandler();
+            });
         }
     }
     await initRepl();
@@ -374,7 +378,7 @@ export async function runRlmLoop(options) {
         });
         if (execResult.hasFinal && execResult.finalValue !== null) {
             // Auto-merge any unmerged thread branches before returning
-            if (mergeHandler) {
+            if (mergeHandler && !mergedAlready) {
                 try {
                     await mergeHandler();
                 }
@@ -422,7 +426,7 @@ export async function runRlmLoop(options) {
         });
     }
     // Auto-merge any remaining thread branches even though FINAL was never called
-    if (mergeHandler) {
+    if (mergeHandler && !mergedAlready) {
         try {
             await mergeHandler();
         }

package/dist/interactive-swarm.js

@@ -44,6 +44,7 @@ import { runOnboarding } from "./ui/onboarding.js";
 import { RunLogger } from "./ui/run-log.js";
 // UI system
 import { Spinner } from "./ui/spinner.js";
+import { StreamingFeed } from "./ui/streaming-feed.js";
 import { bold, coral, cyan, dim, green, isTTY, red, symbols, termWidth, truncate, yellow } from "./ui/theme.js";
 import { mergeAllThreads, mergeThreadBranch } from "./worktree/merge.js";
 function parseInteractiveArgs(args) {
@@ -757,8 +758,11 @@ export async function runInteractiveSwarm(rawArgs) {
         logError(`Directory "${args.dir}" does not exist`);
         process.exit(1);
     }
-    // First-run onboarding
+    // First-run onboarding (may create ~/.swarm/config.yaml with user's chosen model)
     await runOnboarding();
+    // Reload config to pick up any changes from onboarding
+    // (onboarding writes ~/.swarm/config.yaml but loadConfig() already ran before it)
+    Object.assign(config, loadConfig());
     // Override config with CLI args
     if (args.agent)
         config.default_agent = args.agent;
@@ -805,13 +809,17 @@ export async function runInteractiveSwarm(rawArgs) {
     const repl = new PythonRepl();
     const sessionAc = new AbortController();
     const dashboard = new ThreadDashboard();
+    const streamingFeed = new StreamingFeed();
     spinner.setDashboard(dashboard);
+    spinner.setStreamingFeed(streamingFeed);
     const threadProgress = (threadId, phase, detail) => {
         if (phase === "completed" || phase === "failed" || phase === "cancelled") {
             dashboard.complete(threadId, phase, detail);
+            streamingFeed.completeThread(threadId, phase, detail);
         }
         else {
             dashboard.update(threadId, phase, detail);
+            streamingFeed.updateThread(threadId, phase, detail);
         }
     };
     // Enable OpenCode server mode
@@ -821,6 +829,9 @@ export async function runInteractiveSwarm(rawArgs) {
     }
     // Initialize thread manager
     const threadManager = new ThreadManager(args.dir, config, threadProgress, sessionAc.signal);
+    threadManager.setThreadOutputCallback((threadId, chunk) => {
+        streamingFeed.appendOutput(threadId, chunk);
+    });
     await threadManager.init();
     if (episodicMemory) {
         threadManager.setEpisodicMemory(episodicMemory);
@@ -870,6 +881,7 @@ export async function runInteractiveSwarm(rawArgs) {
         cleanupCalled = true;
         spinner.stop();
         dashboard.clear();
+        streamingFeed.clear();
         sessionAc.abort();
         repl.shutdown();
         await threadManager.cleanup();
@@ -960,6 +972,22 @@ export async function runInteractiveSwarm(rawArgs) {
         else if (merged > 0) {
             logSuccess(`Merged ${merged} branches`);
         }
+        // Clean up merged worktrees
+        if (config.auto_cleanup_worktrees) {
+            for (const r of results) {
+                if (r.success) {
+                    const thread = threads.find((t) => t.branchName === r.branch);
+                    if (thread) {
+                        try {
+                            await threadManager.destroyWorktree(thread.id);
+                        }
+                        catch {
+                            // Non-fatal
+                        }
+                    }
+                }
+            }
+        }
         const summary = results
             .map((r) => (r.success ? `Merged ${r.branch}: ${r.message}` : `FAILED ${r.branch}: ${r.message}`))
             .join("\n");

package/dist/swarm.js

@@ -38,6 +38,7 @@ import { isJsonMode, logAnswer, logError, logRouter, logSuccess, logVerbose, log
 import { runOnboarding } from "./ui/onboarding.js";
 // UI system
 import { Spinner } from "./ui/spinner.js";
+import { StreamingFeed } from "./ui/streaming-feed.js";
 import { renderSummary } from "./ui/summary.js";
 import { mergeAllThreads } from "./worktree/merge.js";
 function parseSwarmArgs(args) {
@@ -286,16 +287,20 @@ export async function runSwarmMode(rawArgs) {
     // Start REPL
     const repl = new PythonRepl();
     const ac = new AbortController();
-    // Thread dashboard for live status
+    // Thread dashboard and streaming feed for live status
     const dashboard = new ThreadDashboard();
+    const streamingFeed = new StreamingFeed();
     spinner.setDashboard(dashboard);
+    spinner.setStreamingFeed(streamingFeed);
     // Progress callback for thread events
     const threadProgress = (threadId, phase, detail) => {
         if (phase === "completed" || phase === "failed" || phase === "cancelled") {
             dashboard.complete(threadId, phase, detail);
+            streamingFeed.completeThread(threadId, phase, detail);
         }
         else {
             dashboard.update(threadId, phase, detail);
+            streamingFeed.updateThread(threadId, phase, detail);
         }
     };
     // Enable OpenCode server mode for persistent connections (reduces cold-start)
@@ -305,6 +310,9 @@ export async function runSwarmMode(rawArgs) {
     }
     // Initialize thread manager
     const threadManager = new ThreadManager(args.dir, config, threadProgress, ac.signal);
+    threadManager.setThreadOutputCallback((threadId, chunk) => {
+        streamingFeed.appendOutput(threadId, chunk);
+    });
     await threadManager.init();
     if (episodicMemory) {
         threadManager.setEpisodicMemory(episodicMemory);
@@ -375,12 +383,17 @@ export async function runSwarmMode(rawArgs) {
                 logRouter(`${route.reason} [slot: ${route.slot}]`);
             }
             const threadId = randomBytes(6).toString("hex");
-            // Update dashboard with task info
+            // Update dashboard and streaming feed with task info
             dashboard.update(threadId, "queued", undefined, {
                 task,
                 agent: resolvedAgent,
                 model: resolvedModel,
             });
+            streamingFeed.updateThread(threadId, "queued", undefined, {
+                task,
+                agent: resolvedAgent,
+                model: resolvedModel,
+            });
             const result = await threadManager.spawnThread({
                 id: threadId,
                 task,
@@ -520,6 +533,7 @@ export async function runSwarmMode(rawArgs) {
     finally {
         spinner.stop();
         dashboard.clear();
+        streamingFeed.clear();
         process.removeListener("SIGINT", abortAndExit);
         process.removeListener("SIGTERM", abortAndExit);
         repl.shutdown();

package/dist/threads/manager.d.ts

@@ -29,6 +29,7 @@ export declare class AsyncSemaphore {
     get waitingCount(): number;
 }
 export type ThreadProgressCallback = (threadId: string, phase: ThreadProgressPhase, detail?: string) => void;
+export type ThreadOutputCallback = (threadId: string, chunk: string) => void;
 export declare class ThreadManager {
     private threads;
     private totalSpawned;
@@ -39,9 +40,12 @@ export declare class ThreadManager {
     private threadCache;
     private episodicMemory?;
     private onThreadProgress?;
+    private onThreadOutput?;
     private sessionAbort?;
     private threadAbortControllers;
     constructor(repoRoot: string, config: SwarmConfig, onThreadProgress?: ThreadProgressCallback, sessionAbort?: AbortSignal);
+    /** Set the output streaming callback for live agent output. */
+    setThreadOutputCallback(cb: ThreadOutputCallback): void;
     /** Set the episodic memory store for recording thread outcomes. */
     setEpisodicMemory(memory: EpisodicMemory): void;
     init(): Promise<void>;
@@ -80,6 +84,7 @@ export declare class ThreadManager {
     };
     /** Cleanup all worktrees. */
     cleanup(): Promise<void>;
-    private cleanupWorktree;
+    /** Destroy a specific thread's worktree and branch. */
+    destroyWorktree(threadId: string): Promise<void>;
     private failResult;
 }

package/dist/threads/manager.js

@@ -260,6 +260,7 @@ export class ThreadManager {
     threadCache;
     episodicMemory;
     onThreadProgress;
+    onThreadOutput;
     sessionAbort;
     threadAbortControllers = new Map();
     constructor(repoRoot, config, onThreadProgress, sessionAbort) {
@@ -271,6 +272,10 @@ export class ThreadManager {
         this.onThreadProgress = onThreadProgress;
         this.sessionAbort = sessionAbort;
     }
+    /** Set the output streaming callback for live agent output. */
+    setThreadOutputCallback(cb) {
+        this.onThreadOutput = cb;
+    }
     /** Set the episodic memory store for recording thread outcomes. */
     setEpisodicMemory(memory) {
         this.episodicMemory = memory;
@@ -476,6 +481,7 @@ export class ThreadManager {
                     model: threadConfig.agent.model || this.config.default_model,
                     files: threadConfig.files,
                     signal: combinedAc.signal,
+                    onOutput: this.onThreadOutput ? (chunk) => this.onThreadOutput(threadId, chunk) : undefined,
                 });
             }
             finally {
@@ -486,7 +492,7 @@ export class ThreadManager {
                 state.status = "cancelled";
                 state.phase = "cancelled";
                 state.completedAt = Date.now();
-                await this.cleanupWorktree(threadId);
+                await this.destroyWorktree(threadId);
                 return this.failResult(state, "Thread cancelled during execution");
             }
             // Capture diff
@@ -570,7 +576,7 @@ export class ThreadManager {
             const { cost } = this.budget.recordCost(threadId, errModel);
             state.estimatedCostUsd = cost;
             // Cleanup worktree on failure
-            await this.cleanupWorktree(threadId);
+            await this.destroyWorktree(threadId);
             return this.failResult(state, errorMsg);
         }
         finally {
@@ -637,7 +643,8 @@ export class ThreadManager {
             await this.worktreeManager.destroyAll();
         }
     }
-    async cleanupWorktree(threadId) {
+    /** Destroy a specific thread's worktree and branch. */
+    async destroyWorktree(threadId) {
         try {
             await this.worktreeManager.destroy(threadId, true);
         }

package/dist/ui/index.d.ts

@@ -6,5 +6,6 @@ export * from "./dashboard.js";
 export * from "./log.js";
 export * from "./onboarding.js";
 export * from "./spinner.js";
+export * from "./streaming-feed.js";
 export * from "./summary.js";
 export * from "./theme.js";

package/dist/ui/index.js

@@ -6,6 +6,7 @@ export * from "./dashboard.js";
 export * from "./log.js";
 export * from "./onboarding.js";
 export * from "./spinner.js";
+export * from "./streaming-feed.js";
 export * from "./summary.js";
 export * from "./theme.js";
 //# sourceMappingURL=index.js.map

package/dist/ui/spinner.d.ts

@@ -4,10 +4,12 @@
  * Runs on an isolated 80ms animation loop separated from other output.
  * Displays a coral-colored spinner glyph + a rotating verb + optional detail.
  *
- * Coordinates with ThreadDashboard — the spinner owns the render cycle:
- * spinner line first, then dashboard lines below. This prevents interleaving.
+ * Coordinates with ThreadDashboard or StreamingFeed — the spinner owns the
+ * render cycle: spinner line first, then extra lines below. This prevents
+ * interleaving.
  */
 import type { ThreadDashboard } from "./dashboard.js";
+import type { StreamingFeed } from "./streaming-feed.js";
 export declare class Spinner {
     private static _exitHandlerRegistered;
     private intervalId;
@@ -18,10 +20,13 @@ export declare class Spinner {
     private startTime;
     private running;
     private dashboard;
+    private streamingFeed;
     /** How many lines we wrote below the spinner (dashboard) */
     private extraLines;
     /** Link a dashboard so the spinner owns its render cycle. */
     setDashboard(d: ThreadDashboard): void;
+    /** Link a streaming feed so the spinner owns its render cycle. */
+    setStreamingFeed(f: StreamingFeed): void;
     /** Start the spinner. */
     start(detail?: string): void;
     /** Update the detail text without restarting. */

package/dist/ui/spinner.js

@@ -4,8 +4,9 @@
  * Runs on an isolated 80ms animation loop separated from other output.
  * Displays a coral-colored spinner glyph + a rotating verb + optional detail.
  *
- * Coordinates with ThreadDashboard — the spinner owns the render cycle:
- * spinner line first, then dashboard lines below. This prevents interleaving.
+ * Coordinates with ThreadDashboard or StreamingFeed — the spinner owns the
+ * render cycle: spinner line first, then extra lines below. This prevents
+ * interleaving.
  */
 import { coral, dim, isTTY, termWidth } from "./theme.js";
 /** Playful verbs shown while the spinner is active. */
@@ -50,12 +51,17 @@ export class Spinner {
     startTime = 0;
     running = false;
     dashboard = null;
+    streamingFeed = null;
     /** How many lines we wrote below the spinner (dashboard) */
     extraLines = 0;
     /** Link a dashboard so the spinner owns its render cycle. */
     setDashboard(d) {
         this.dashboard = d;
     }
+    /** Link a streaming feed so the spinner owns its render cycle. */
+    setStreamingFeed(f) {
+        this.streamingFeed = f;
+    }
     /** Start the spinner. */
     start(detail) {
         if (!isTTY || this.running)
@@ -119,13 +125,15 @@ export class Spinner {
         const verb = VERBS[this.verbIdx];
         const time = dim(`${elapsed}s`);
         const maxW = termWidth();
+        // When streaming feed is active, use its status detail automatically
+        const activeDetail = this.streamingFeed ? this.streamingFeed.getStatusDetail() || this.detail : this.detail;
         // Build detail string, truncating if needed (ANSI-safe)
         let detailStr = "";
-        if (this.detail) {
+        if (activeDetail) {
             const prefix = `  X ${verb}...  ${elapsed}s`;
             const available = maxW - prefix.length - 1;
             if (available > 5) {
-                const raw = this.detail;
+                const raw = activeDetail;
                 detailStr = raw.length > available ? dim(` ${raw.slice(0, available - 2)}\u2026`) : dim(` ${raw}`);
             }
         }
@@ -141,13 +149,14 @@ export class Spinner {
         }
         // Write spinner line (we're on the spinner line now)
         process.stderr.write(`\r\x1b[2K${line}`);
-        // Write dashboard lines below if we have a linked dashboard
-        if (this.dashboard) {
-            const dashLines = this.dashboard.getLines();
-            if (dashLines.length > 0) {
+        // Write extra lines below — streaming feed takes priority over dashboard
+        const provider = this.streamingFeed || this.dashboard;
+        if (provider) {
+            const extraLines = provider.getLines();
+            if (extraLines.length > 0) {
                 process.stderr.write("\n");
-                process.stderr.write(dashLines.join("\n"));
-                this.extraLines = dashLines.length;
+                process.stderr.write(extraLines.join("\n"));
+                this.extraLines = extraLines.length;
                 // Move cursor back up to the spinner line
                 if (this.extraLines > 0) {
                     process.stderr.write(`\x1b[${this.extraLines}A`);

package/dist/ui/streaming-feed.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Streaming feed — live grouped-waves view of swarm thread activity.
+ *
+ * Layout (top to bottom):
+ *   1. Completed summary   (single line, hidden when 0)
+ *   2. Failed summary      (single line, hidden when 0)
+ *   3. Retried summary     (single line, hidden when 0)
+ *   4. Running section      (interleaved feed, capped at MAX_FEED_LINES)
+ *   5. Queued summary       (single line, hidden when 0)
+ *   6. Wave marker          (single line, hidden when no waves)
+ *
+ * Rendering is owned by the Spinner — this component builds lines but does
+ * NOT write to stderr directly.
+ */
+export type ThreadOutputCallback = (threadId: string, chunk: string) => void;
+export declare class StreamingFeed {
+    private threads;
+    private feedLines;
+    private waves;
+    private labelIndex;
+    private enabled;
+    /** Tracks the highest completed count at each wave boundary. */
+    private completedAtLastSpawn;
+    private currentWave;
+    /** Cumulative stats for the session summary. */
+    private totalCompleted;
+    private totalFailed;
+    private totalFilesChanged;
+    private totalCostUsd;
+    constructor();
+    /** Called when a thread's phase changes. */
+    updateThread(id: string, phase: string, detail?: string, extra?: {
+        task?: string;
+        agent?: string;
+        model?: string;
+        filesChanged?: number;
+        costUsd?: number;
+    }): void;
+    /** Called when a thread completes, fails, or is cancelled. */
+    completeThread(id: string, phase: string, detail?: string): void;
+    /** Append a chunk of agent output for a thread. */
+    appendOutput(threadId: string, chunk: string): void;
+    private detectWave;
+    /** Get the status bar text (used by Spinner as its detail). */
+    getStatusDetail(): string;
+    /** Build all display lines (called by Spinner on each render tick). */
+    getLines(): string[];
+    /** Clear all state. */
+    clear(): void;
+    /** Get session summary stats. */
+    getSessionStats(): {
+        totalThreads: number;
+        completed: number;
+        failed: number;
+        totalFiles: number;
+        totalCost: number;
+        waves: number;
+    };
+    private buildCompletedLine;
+    private buildFailedLine;
+    private buildRunningSection;
+    private buildQueuedLine;
+    private buildWaveLine;
+    private assignLabel;
+    private subscript;
+    private shortTask;
+    private countByPhase;
+    private getThreadsByPhase;
+    private avgDuration;
+    private formatPhaseShort;
+    private truncateLine;
+}

package/dist/ui/streaming-feed.js

@@ -0,0 +1,382 @@
+/**
+ * Streaming feed — live grouped-waves view of swarm thread activity.
+ *
+ * Layout (top to bottom):
+ *   1. Completed summary   (single line, hidden when 0)
+ *   2. Failed summary      (single line, hidden when 0)
+ *   3. Retried summary     (single line, hidden when 0)
+ *   4. Running section      (interleaved feed, capped at MAX_FEED_LINES)
+ *   5. Queued summary       (single line, hidden when 0)
+ *   6. Wave marker          (single line, hidden when no waves)
+ *
+ * Rendering is owned by the Spinner — this component builds lines but does
+ * NOT write to stderr directly.
+ */
+import { getLogLevel, isJsonMode } from "./log.js";
+import { coral, cyan, dim, green, isTTY, red, stripAnsi, symbols, termWidth, truncate } from "./theme.js";
+// ── Constants ────────────────────────────────────────────────────────────────
+/** Max visible feed lines in the running section. */
+const MAX_FEED_LINES = 8;
+/** Max completed/failed thread names shown individually before collapsing. */
+const COLLAPSE_THRESHOLD = 5;
+/** Greek labels for low thread counts. */
+const GREEK = [
+    "α",
+    "β",
+    "γ",
+    "δ",
+    "ε",
+    "ζ",
+    "η",
+    "θ",
+    "ι",
+    "κ",
+    "λ",
+    "μ",
+    "ν",
+    "ξ",
+    "ο",
+    "π",
+    "ρ",
+    "σ",
+    "τ",
+    "υ",
+    "φ",
+    "χ",
+    "ψ",
+    "ω",
+];
+export class StreamingFeed {
+    threads = new Map();
+    feedLines = [];
+    waves = [];
+    labelIndex = 0;
+    enabled;
+    /** Tracks the highest completed count at each wave boundary. */
+    completedAtLastSpawn = 0;
+    currentWave = 1;
+    /** Cumulative stats for the session summary. */
+    totalCompleted = 0;
+    totalFailed = 0;
+    totalFilesChanged = 0;
+    totalCostUsd = 0;
+    constructor() {
+        this.enabled = isTTY && !isJsonMode() && getLogLevel() !== "quiet";
+    }
+    // ── Thread lifecycle ───────────────────────────────────────────────────
+    /** Called when a thread's phase changes. */
+    updateThread(id, phase, detail, extra) {
+        const existing = this.threads.get(id);
+        if (existing) {
+            existing.phase = phase;
+            if (detail !== undefined)
+                existing.detail = detail;
+            if (extra?.filesChanged !== undefined)
+                existing.filesChanged = extra.filesChanged;
+            if (extra?.costUsd !== undefined)
+                existing.costUsd = extra.costUsd;
+        }
+        else {
+            // New thread — assign label and detect wave
+            const label = this.assignLabel();
+            this.threads.set(id, {
+                id,
+                label,
+                task: extra?.task || "",
+                phase,
+                startedAt: Date.now(),
+                detail,
+            });
+            this.detectWave();
+        }
+    }
+    /** Called when a thread completes, fails, or is cancelled. */
+    completeThread(id, phase, detail) {
+        const existing = this.threads.get(id);
+        if (!existing)
+            return;
+        existing.phase = phase;
+        existing.completedAt = Date.now();
+        existing.durationSec = Math.round((existing.completedAt - existing.startedAt) / 1000);
+        if (detail)
+            existing.detail = detail;
+        // Parse detail for file count and cost (format: "3 files, $0.04 (1500+800 tokens)")
+        if (detail && phase === "completed") {
+            const filesMatch = detail.match(/(\d+)\s+files?/);
+            if (filesMatch) {
+                existing.filesChanged = Number.parseInt(filesMatch[1], 10);
+                this.totalFilesChanged += existing.filesChanged;
+            }
+            const costMatch = detail.match(/\$([0-9.]+)/);
+            if (costMatch) {
+                existing.costUsd = Number.parseFloat(costMatch[1]);
+                this.totalCostUsd += existing.costUsd;
+            }
+            this.totalCompleted++;
+        }
+        else if (phase === "failed") {
+            existing.error = detail;
+            this.totalFailed++;
+        }
+    }
+    // ── Agent output streaming ─────────────────────────────────────────────
+    /** Append a chunk of agent output for a thread. */
+    appendOutput(threadId, chunk) {
+        const thread = this.threads.get(threadId);
+        if (!thread)
+            return;
+        // Split into lines, ignore empty
+        const lines = chunk.split("\n").filter((l) => l.trim().length > 0);
+        for (const line of lines) {
+            this.feedLines.push({
+                threadId,
+                label: thread.label,
+                text: line.trim(),
+                timestamp: Date.now(),
+            });
+        }
+        // Cap total feed lines to prevent unbounded memory growth
+        if (this.feedLines.length > 500) {
+            this.feedLines = this.feedLines.slice(-300);
+        }
+    }
+    // ── Wave tracking ──────────────────────────────────────────────────────
+    detectWave() {
+        const completed = this.countByPhase("completed") + this.countByPhase("failed");
+        if (completed > this.completedAtLastSpawn && this.threads.size > 1) {
+            this.currentWave++;
+            const runningCount = this.countByPhase("agent_running") + this.countByPhase("creating_worktree") + this.countByPhase("queued");
+            this.waves.push({
+                waveNumber: this.currentWave,
+                threadCount: runningCount,
+                timestamp: Date.now(),
+            });
+            this.completedAtLastSpawn = completed;
+        }
+    }
+    // ── Rendering ──────────────────────────────────────────────────────────
+    /** Get the status bar text (used by Spinner as its detail). */
+    getStatusDetail() {
+        const running = this.countByPhase("agent_running") + this.countByPhase("creating_worktree");
+        const queued = this.countByPhase("queued");
+        const completed = this.totalCompleted;
+        const failed = this.totalFailed;
+        const total = this.threads.size;
+        const parts = [];
+        if (total > 0)
+            parts.push(`${total} threads`);
+        if (running > 0)
+            parts.push(`${running} running`);
+        if (completed > 0)
+            parts.push(`${completed} done`);
+        if (queued > 0)
+            parts.push(`${queued} queued`);
+        if (failed > 0)
+            parts.push(`${failed} failed`);
+        return parts.join(" · ");
+    }
+    /** Build all display lines (called by Spinner on each render tick). */
+    getLines() {
+        if (!this.enabled || this.threads.size === 0)
+            return [];
+        const w = Math.min(termWidth(), 100);
+        const lines = [];
+        // Completed summary
+        const completedLines = this.buildCompletedLine(w);
+        if (completedLines)
+            lines.push(completedLines);
+        // Failed summary
+        const failedLine = this.buildFailedLine(w);
+        if (failedLine)
+            lines.push(failedLine);
+        // Running section
+        const runningLines = this.buildRunningSection(w);
+        lines.push(...runningLines);
+        // Queued summary
+        const queuedLine = this.buildQueuedLine(w);
+        if (queuedLine)
+            lines.push(queuedLine);
+        // Wave marker
+        const waveLine = this.buildWaveLine();
+        if (waveLine)
+            lines.push(waveLine);
+        return lines;
+    }
+    /** Clear all state. */
+    clear() {
+        this.threads.clear();
+        this.feedLines = [];
+        this.waves = [];
+        this.labelIndex = 0;
+    }
+    /** Get session summary stats. */
+    getSessionStats() {
+        return {
+            totalThreads: this.threads.size,
+            completed: this.totalCompleted,
+            failed: this.totalFailed,
+            totalFiles: this.totalFilesChanged,
+            totalCost: this.totalCostUsd,
+            waves: this.currentWave,
+        };
+    }
+    // ── Private rendering helpers ──────────────────────────────────────────
+    buildCompletedLine(w) {
+        const completed = this.getThreadsByPhase("completed");
+        if (completed.length === 0)
+            return null;
+        if (completed.length <= COLLAPSE_THRESHOLD) {
+            // Show individual thread names
+            const names = completed
+                .map((t) => {
+                const dur = t.durationSec ? `${t.durationSec}s` : "";
+                return `${t.label} ${truncate(this.shortTask(t.task), 12)} ${dur}`;
+            })
+                .join(dim(" · "));
+            const files = this.totalFilesChanged > 0 ? dim(` · ${this.totalFilesChanged} files`) : "";
+            return this.truncateLine(`  ${green(symbols.check)} ${green("completed")} ${dim(`(${completed.length})`)}  ${dim(names)}${files}`, w);
+        }
+        // Collapsed — aggregate stats
+        const avgDur = this.avgDuration(completed);
+        const avgCost = this.totalCostUsd > 0 ? ` · $${(this.totalCostUsd / completed.length).toFixed(2)} each` : "";
+        return this.truncateLine(`  ${green(symbols.check)} ${green("completed")} ${dim(`(${completed.length})`)}  ${dim(`avg ${avgDur}s${avgCost} · ${this.totalFilesChanged} files`)}`, w);
+    }
+    buildFailedLine(w) {
+        const failed = this.getThreadsByPhase("failed");
+        if (failed.length === 0)
+            return null;
+        if (failed.length <= COLLAPSE_THRESHOLD) {
+            const names = failed
+                .map((t) => {
+                const err = t.error || t.detail || "error";
+                return `${t.label} ${truncate(err, 20)}`;
+            })
+                .join(dim(" · "));
+            return this.truncateLine(`  ${red(symbols.cross)} ${red("failed")} ${dim(`(${failed.length})`)}  ${dim(names)}`, w);
+        }
+        return this.truncateLine(`  ${red(symbols.cross)} ${red("failed")} ${dim(`(${failed.length})`)}`, w);
+    }
+    buildRunningSection(w) {
+        const running = this.getThreadsByPhase("agent_running", "creating_worktree", "capturing_diff", "compressing");
+        if (running.length === 0)
+            return [];
+        const lines = [];
+        // Section header
+        const showingNote = running.length > MAX_FEED_LINES ? dim(`  showing ${Math.min(running.length, 4)} most active`) : "";
+        lines.push(`  ${coral("▸")} ${coral("running")} ${dim(`(${running.length})`)}${showingNote}`);
+        // Feed lines — show recent output from active threads
+        const activeIds = new Set(running.map((t) => t.id));
+        const relevantLines = this.feedLines.filter((fl) => activeIds.has(fl.threadId));
+        const recentLines = relevantLines.slice(-MAX_FEED_LINES);
+        if (recentLines.length > 0) {
+            for (const fl of recentLines) {
+                const label = coral(fl.label);
+                const text = truncate(fl.text, w - 10);
+                lines.push(`    ${label} ${dim(symbols.vertLine)} ${text}`);
+            }
+            // Add cursor on last line of most active thread
+            const lastLine = recentLines[recentLines.length - 1];
+            if (lastLine) {
+                const thread = this.threads.get(lastLine.threadId);
+                if (thread && (thread.phase === "agent_running" || thread.phase === "creating_worktree")) {
+                    // Replace the last line to add cursor
+                    const idx = lines.length - 1;
+                    lines[idx] = `${lines[idx]} ${dim("▌")}`;
+                }
+            }
+        }
+        else {
+            // No output yet — show phase info for each running thread
+            for (const t of running.slice(0, MAX_FEED_LINES)) {
+                const label = coral(t.label);
+                const phase = this.formatPhaseShort(t.phase);
+                const task = t.task ? dim(truncate(this.shortTask(t.task), w - 20)) : "";
+                lines.push(`    ${label} ${dim(symbols.vertLine)} ${phase} ${task}`);
+            }
+        }
+        return lines;
+    }
+    buildQueuedLine(w) {
+        const queued = this.getThreadsByPhase("queued");
+        if (queued.length === 0)
+            return null;
+        if (queued.length <= COLLAPSE_THRESHOLD) {
+            const names = queued.map((t) => t.label).join(" ");
+            return this.truncateLine(`  ${dim("·")} ${dim("queued")} ${dim(`(${queued.length})`)}  ${dim(names)}`, w);
+        }
+        return this.truncateLine(`  ${dim("·")} ${dim("queued")} ${dim(`(${queued.length})`)}`, w);
+    }
+    buildWaveLine() {
+        if (this.waves.length === 0)
+            return null;
+        const latest = this.waves[this.waves.length - 1];
+        return `  ${dim("↳")} ${dim(`wave ${latest.waveNumber} — ${latest.threadCount} threads spawned from previous results`)}`;
+    }
+    // ── Utility ────────────────────────────────────────────────────────────
+    assignLabel() {
+        const idx = this.labelIndex++;
+        if (idx < GREEK.length)
+            return GREEK[idx];
+        // Beyond 24 threads: use indexed labels like τ₂₅
+        const base = GREEK[idx % GREEK.length];
+        const num = idx + 1;
+        return `${base}${this.subscript(num)}`;
+    }
+    subscript(n) {
+        const SUBSCRIPT_DIGITS = "₀₁₂₃₄₅₆₇₈₉";
+        return String(n)
+            .split("")
+            .map((d) => SUBSCRIPT_DIGITS[Number.parseInt(d, 10)])
+            .join("");
+    }
+    shortTask(task) {
+        // Extract a short label from the task description
+        const firstLine = task.split("\n")[0];
+        // Remove common prefixes
+        return firstLine.replace(/^(fix|add|update|create|implement|refactor|write|remove|delete)\s+/i, "").trim();
+    }
+    countByPhase(...phases) {
+        let count = 0;
+        for (const [, t] of this.threads) {
+            if (phases.includes(t.phase))
+                count++;
+        }
+        return count;
+    }
+    getThreadsByPhase(...phases) {
+        const result = [];
+        for (const [, t] of this.threads) {
+            if (phases.includes(t.phase))
+                result.push(t);
+        }
+        return result;
+    }
+    avgDuration(threads) {
+        if (threads.length === 0)
+            return 0;
+        const total = threads.reduce((sum, t) => sum + (t.durationSec || 0), 0);
+        return Math.round(total / threads.length);
+    }
+    formatPhaseShort(phase) {
+        switch (phase) {
+            case "agent_running":
+                return coral("running");
+            case "creating_worktree":
+                return cyan("creating worktree");
+            case "capturing_diff":
+                return cyan("capturing diff");
+            case "compressing":
+                return dim("compressing");
+            default:
+                return dim(phase);
+        }
+    }
+    truncateLine(line, maxWidth) {
+        const visible = stripAnsi(line);
+        if (visible.length <= maxWidth)
+            return line;
+        const ansiOverhead = line.length - visible.length;
+        return `${line.slice(0, maxWidth - 1 + ansiOverhead)}\x1b[0m`;
+    }
+}
+//# sourceMappingURL=streaming-feed.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarm-code",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "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": {