swarm-code 0.1.16 → 0.1.18

package/dist/core/rlm.js

@@ -373,6 +373,15 @@ export async function runRlmLoop(options) {
             stderr: execResult.stderr,
         });
         if (execResult.hasFinal && execResult.finalValue !== null) {
+            // Auto-merge any unmerged thread branches before returning
+            if (mergeHandler) {
+                try {
+                    await mergeHandler();
+                }
+                catch {
+                    // Non-fatal — merge may have already been done by the LLM
+                }
+            }
             return {
                 answer: execResult.finalValue,
                 iterations: iteration,
@@ -392,13 +401,35 @@ export async function runRlmLoop(options) {
             parts.push("(No output produced. The code ran without printing anything.)");
         }
         parts.push(`\nIteration ${iteration}/${config.max_iterations}. Sub-queries used: ${totalSubQueries}/${config.max_sub_queries}.`);
-        parts.push("Continue processing or call FINAL() when you have the answer.");
+        const remaining = config.max_iterations - iteration;
+        if (remaining <= 2) {
+            parts.push("⚠️ CRITICAL: Only " +
+                remaining +
+                " iteration(s) remaining! Call merge_threads() then FINAL() NOW with your best result. Any unmerged work will be lost.");
+        }
+        else if (remaining <= Math.ceil(config.max_iterations * 0.25)) {
+            parts.push("⚠️ WARNING: " +
+                remaining +
+                " iterations remaining. Wrap up: merge_threads() → FINAL(). Don't start new threads.");
+        }
+        else {
+            parts.push("Continue processing or call FINAL() when you have the answer.");
+        }
         conversationHistory.push({
             role: "user",
             content: parts.join("\n\n"),
             timestamp: Date.now(),
         });
     }
+    // Auto-merge any remaining thread branches even though FINAL was never called
+    if (mergeHandler) {
+        try {
+            await mergeHandler();
+        }
+        catch {
+            // Non-fatal
+        }
+    }
     return {
         answer: "[Maximum iterations reached without calling FINAL]",
         iterations: config.max_iterations,

package/dist/interactive-swarm.js

@@ -40,6 +40,7 @@ import { ThreadManager } from "./threads/manager.js";
 import { ThreadDashboard } from "./ui/dashboard.js";
 import { logError, logRouter, logSuccess, logVerbose, logWarn, setLogLevel } from "./ui/log.js";
 import { runOnboarding } from "./ui/onboarding.js";
+import { RunLogger } from "./ui/run-log.js";
 // UI system
 import { Spinner } from "./ui/spinner.js";
 import { bold, coral, cyan, dim, green, isTTY, red, symbols, termWidth, truncate, yellow } from "./ui/theme.js";
@@ -784,6 +785,7 @@ export async function runInteractiveSwarm(rawArgs) {
     const repl = new PythonRepl();
     const sessionAc = new AbortController();
     const dashboard = new ThreadDashboard();
+    spinner.setDashboard(dashboard);
     const threadProgress = (threadId, phase, detail) => {
         if (phase === "completed" || phase === "failed" || phase === "cancelled") {
             dashboard.complete(threadId, phase, detail);
@@ -943,6 +945,7 @@ export async function runInteractiveSwarm(rawArgs) {
         sessionAc.signal.addEventListener("abort", onSessionAbort, { once: true });
         spinner.start();
         const startTime = Date.now();
+        const runLog = new RunLogger(query, resolved.model.id, config.default_agent, args.dir, config.max_iterations || 20);
         try {
             // Update episodic memory hints per-task
             let taskSystemPrompt = systemPrompt;
@@ -970,7 +973,7 @@ export async function runInteractiveSwarm(rawArgs) {
                 mergeHandler,
                 onProgress: (info) => {
                     spinner.update(`iteration ${info.iteration}/${info.maxIterations}` +
-                        (info.subQueries > 0 ? ` · ${info.subQueries} queries` : ""));
+                        (info.subQueries > 0 ? ` \u00B7 ${info.subQueries} queries` : ""));
                     logVerbose(`Iteration ${info.iteration}/${info.maxIterations} | ` +
                         `Sub-queries: ${info.subQueries} | Phase: ${info.phase}`);
                 },
@@ -978,6 +981,9 @@ export async function runInteractiveSwarm(rawArgs) {
             spinner.stop();
             dashboard.clear();
             const elapsed = (Date.now() - startTime) / 1000;
+            // Log the run
+            runLog.complete({ completed: result.completed, iterations: result.iterations, answer: result.answer }, Date.now() - startTime);
+            const logPath = runLog.save();
             // Show concise result
             process.stderr.write("\n");
             const status = result.completed ? green("completed") : yellow("incomplete");
@@ -985,22 +991,27 @@ export async function runInteractiveSwarm(rawArgs) {
             // Show answer
             if (result.answer) {
                 process.stderr.write("\n");
-                const lines = result.answer.split("\n");
-                for (const line of lines) {
+                const answerLines = result.answer.split("\n");
+                for (const line of answerLines) {
                     process.stderr.write(`  ${line}\n`);
                 }
             }
+            if (logPath) {
+                process.stderr.write(`  ${dim(`log: ${logPath}`)}\n`);
+            }
             process.stderr.write("\n");
         }
         catch (err) {
             spinner.stop();
             dashboard.clear();
+            const errMsg = err instanceof Error ? err.message : String(err);
+            runLog.complete({ completed: false, iterations: 0, error: errMsg }, Date.now() - startTime);
+            runLog.save();
             if (currentTaskAc?.signal.aborted) {
                 logWarn("Task cancelled");
             }
             else {
-                const msg = err instanceof Error ? err.message : String(err);
-                logError(`Task failed: ${msg}`);
+                logError(`Task failed: ${errMsg}`);
             }
         }
         finally {

package/dist/prompts/orchestrator.js

@@ -77,9 +77,10 @@ ${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. Always run verification after merge.
+7. After merging, try to run a quick verification thread if iterations allow. But don't endlessly loop on verification — one attempt is enough.
 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
+9. The REPL persists state — variables survive across iterations
+10. **Watch your iteration count.** If you're past 75% of max iterations, call \`merge_threads()\` then \`FINAL()\` with your best result. Don't waste iterations on repeated verification cycles.
 
 ## Examples
 

package/dist/swarm.js

@@ -288,6 +288,7 @@ export async function runSwarmMode(rawArgs) {
     const ac = new AbortController();
     // Thread dashboard for live status
     const dashboard = new ThreadDashboard();
+    spinner.setDashboard(dashboard);
     // Progress callback for thread events
     const threadProgress = (threadId, phase, detail) => {
         if (phase === "completed" || phase === "failed" || phase === "cancelled") {

package/dist/ui/dashboard.d.ts

@@ -1,18 +1,18 @@
 /**
  * Live thread status dashboard — shows running/queued/completed threads.
  *
- * Inspired by Claude Code's collapsed tool results: shows concise status
- * per thread, color-coded by phase, with elapsed time and file counts.
- * Uses in-place terminal updates for a live-updating display.
+ * Rendering is owned by the Spinner — the dashboard builds lines but does NOT
+ * write directly to stderr. This prevents interleaving between the spinner's
+ * 80ms animation loop and async thread progress callbacks.
  */
 /**
- * Thread dashboard — manages a live-updating display of thread states.
- * Renders below the spinner line using ANSI cursor movement.
+ * Thread dashboard — manages thread state and builds status lines.
+ * Does NOT write to stderr directly — the Spinner calls getLines()
+ * on each render tick to include dashboard output atomically.
  */
 export declare class ThreadDashboard {
     private threads;
     private pendingTimers;
-    private lastLineCount;
     private enabled;
     constructor();
     /** Update a thread's status. */
@@ -22,12 +22,12 @@ export declare class ThreadDashboard {
         model?: string;
         filesChanged?: number;
     }): void;
-    /** Remove a thread from the dashboard (when done). */
+    /** Mark a thread as done. Auto-removes after 1.5s. */
     complete(id: string, phase: string, detail?: string): void;
-    /** Clear all dashboard output and cancel pending timers. */
+    /** Clear all state and cancel pending timers. */
     clear(): void;
-    private render;
-    private clearLines;
+    /** Get the current dashboard lines (called by Spinner.render). */
+    getLines(): string[];
     private buildLines;
     private formatPhase;
 }

package/dist/ui/dashboard.js

@@ -1,20 +1,20 @@
 /**
  * Live thread status dashboard — shows running/queued/completed threads.
  *
- * Inspired by Claude Code's collapsed tool results: shows concise status
- * per thread, color-coded by phase, with elapsed time and file counts.
- * Uses in-place terminal updates for a live-updating display.
+ * Rendering is owned by the Spinner — the dashboard builds lines but does NOT
+ * write directly to stderr. This prevents interleaving between the spinner's
+ * 80ms animation loop and async thread progress callbacks.
  */
 import { getLogLevel, isJsonMode } from "./log.js";
 import { coral, cyan, dim, green, isTTY, red, stripAnsi, symbols, termWidth, truncate, yellow } from "./theme.js";
 /**
- * Thread dashboard — manages a live-updating display of thread states.
- * Renders below the spinner line using ANSI cursor movement.
+ * Thread dashboard — manages thread state and builds status lines.
+ * Does NOT write to stderr directly — the Spinner calls getLines()
+ * on each render tick to include dashboard output atomically.
  */
 export class ThreadDashboard {
     threads = new Map();
     pendingTimers = new Set();
-    lastLineCount = 0;
     enabled;
     constructor() {
         this.enabled = isTTY && !isJsonMode() && getLogLevel() !== "quiet";
@@ -41,9 +41,9 @@ export class ThreadDashboard {
                 detail,
             });
         }
-        this.render();
+        // No direct render — spinner picks up changes on next tick
     }
-    /** Remove a thread from the dashboard (when done). */
+    /** Mark a thread as done. Auto-removes after 1.5s. */
     complete(id, phase, detail) {
         const existing = this.threads.get(id);
         if (existing) {
@@ -51,47 +51,24 @@ export class ThreadDashboard {
             if (detail)
                 existing.detail = detail;
         }
-        this.render();
-        // Remove completed/failed threads after a brief display
         const timer = setTimeout(() => {
             this.pendingTimers.delete(timer);
             this.threads.delete(id);
-            this.render();
         }, 1500);
         this.pendingTimers.add(timer);
     }
-    /** Clear all dashboard output and cancel pending timers. */
+    /** Clear all state and cancel pending timers. */
     clear() {
         for (const timer of this.pendingTimers)
             clearTimeout(timer);
         this.pendingTimers.clear();
-        if (!this.enabled)
-            return;
-        this.clearLines();
         this.threads.clear();
-        this.lastLineCount = 0;
     }
-    render() {
-        if (!this.enabled)
-            return;
-        // Clear previous output
-        this.clearLines();
-        const lines = this.buildLines();
-        if (lines.length === 0) {
-            this.lastLineCount = 0;
-            return;
-        }
-        // Write new lines
-        process.stderr.write(`${lines.join("\n")}\n`);
-        this.lastLineCount = lines.length;
-    }
-    clearLines() {
-        if (this.lastLineCount <= 0)
-            return;
-        // Move up and clear each line
-        for (let i = 0; i < this.lastLineCount; i++) {
-            process.stderr.write("\x1b[1A\x1b[K");
-        }
+    /** Get the current dashboard lines (called by Spinner.render). */
+    getLines() {
+        if (!this.enabled || this.threads.size === 0)
+            return [];
+        return this.buildLines();
     }
     buildLines() {
         const w = Math.min(termWidth(), 80);
@@ -115,9 +92,12 @@ export class ThreadDashboard {
             else {
                 line = `    ${tag}  ${phase}  ${time}  ${dim(task)}`;
             }
-            // Truncate to terminal width
-            if (stripAnsi(line).length > w) {
-                line = line.slice(0, w + (line.length - stripAnsi(line).length) - 1);
+            // ANSI-safe truncation — count visible chars, not raw string length
+            const visible = stripAnsi(line);
+            if (visible.length > w) {
+                // Rebuild truncated: just trim the last visible portion
+                const ansiOverhead = line.length - visible.length;
+                line = `${line.slice(0, w - 1 + ansiOverhead)}\x1b[0m`;
             }
             lines.push(line);
         }

package/dist/ui/run-log.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Run logger — writes structured logs for each swarm run to ~/.swarm/logs/.
+ *
+ * Each run creates a timestamped JSON log file with:
+ *   - Task, model, agent, config
+ *   - Iterations, sub-queries, thread spawns
+ *   - Timing, token usage, costs
+ *   - Thread details (task, agent, model, result, duration)
+ *   - Final answer and completion status
+ *
+ * Logs are kept for dev iteration — view with `ls ~/.swarm/logs/` or parse as JSON.
+ */
+export interface ThreadLogEntry {
+    id: string;
+    task: string;
+    agent: string;
+    model: string;
+    success: boolean;
+    durationMs: number;
+    filesChanged: string[];
+    error?: string;
+}
+export interface RunLogEntry {
+    timestamp: string;
+    task: string;
+    orchestratorModel: string;
+    agent: string;
+    dir: string;
+    completed: boolean;
+    iterations: number;
+    maxIterations: number;
+    durationMs: number;
+    threads: ThreadLogEntry[];
+    answer?: string;
+    error?: string;
+}
+export declare class RunLogger {
+    private entry;
+    private threads;
+    constructor(task: string, orchestratorModel: string, agent: string, dir: string, maxIterations: number);
+    addThread(thread: ThreadLogEntry): void;
+    complete(result: {
+        completed: boolean;
+        iterations: number;
+        answer?: string;
+        error?: string;
+    }, durationMs: number): void;
+    /** Write the log file. Call after complete(). */
+    save(): string | null;
+}

package/dist/ui/run-log.js

@@ -0,0 +1,60 @@
+/**
+ * Run logger — writes structured logs for each swarm run to ~/.swarm/logs/.
+ *
+ * Each run creates a timestamped JSON log file with:
+ *   - Task, model, agent, config
+ *   - Iterations, sub-queries, thread spawns
+ *   - Timing, token usage, costs
+ *   - Thread details (task, agent, model, result, duration)
+ *   - Final answer and completion status
+ *
+ * Logs are kept for dev iteration — view with `ls ~/.swarm/logs/` or parse as JSON.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+const LOG_DIR = path.join(os.homedir(), ".swarm", "logs");
+export class RunLogger {
+    entry;
+    threads = [];
+    constructor(task, orchestratorModel, agent, dir, maxIterations) {
+        this.entry = {
+            timestamp: new Date().toISOString(),
+            task,
+            orchestratorModel,
+            agent,
+            dir,
+            completed: false,
+            iterations: 0,
+            maxIterations,
+            durationMs: 0,
+            threads: [],
+        };
+    }
+    addThread(thread) {
+        this.threads.push(thread);
+    }
+    complete(result, durationMs) {
+        this.entry.completed = result.completed;
+        this.entry.iterations = result.iterations;
+        this.entry.answer = result.answer;
+        this.entry.error = result.error;
+        this.entry.durationMs = durationMs;
+        this.entry.threads = this.threads;
+    }
+    /** Write the log file. Call after complete(). */
+    save() {
+        try {
+            fs.mkdirSync(LOG_DIR, { recursive: true });
+            const ts = this.entry.timestamp.replace(/[:.]/g, "-").slice(0, 19);
+            const filename = `run-${ts}.json`;
+            const filepath = path.join(LOG_DIR, filename);
+            fs.writeFileSync(filepath, JSON.stringify(this.entry, null, 2), "utf-8");
+            return filepath;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=run-log.js.map

package/dist/ui/spinner.d.ts

@@ -3,7 +3,11 @@
  *
  * 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.
  */
+import type { ThreadDashboard } from "./dashboard.js";
 export declare class Spinner {
     private static _exitHandlerRegistered;
     private intervalId;
@@ -13,13 +17,20 @@ export declare class Spinner {
     private detail;
     private startTime;
     private running;
+    private dashboard;
+    /** 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;
     /** Start the spinner. */
     start(detail?: string): void;
     /** Update the detail text without restarting. */
     update(detail: string): void;
-    /** Stop the spinner and clear the line. */
+    /** Stop the spinner and clear everything (spinner + dashboard lines). */
     stop(): void;
     /** Whether the spinner is currently active. */
     get isActive(): boolean;
+    /** Called by the dashboard when it wants to re-render. */
+    requestDashboardRender(): void;
     private render;
 }

package/dist/ui/spinner.js

@@ -3,8 +3,11 @@
  *
  * 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.
  */
-import { coral, dim, isTTY, stripAnsi, termWidth } from "./theme.js";
+import { coral, dim, isTTY, termWidth } from "./theme.js";
 /** Playful verbs shown while the spinner is active. */
 const VERBS = [
     "Orchestrating",
@@ -46,6 +49,13 @@ export class Spinner {
     detail = "";
     startTime = 0;
     running = false;
+    dashboard = 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;
+    }
     /** Start the spinner. */
     start(detail) {
         if (!isTTY || this.running)
@@ -55,6 +65,7 @@ export class Spinner {
         this.startTime = Date.now();
         this.frameIdx = 0;
         this.totalFrames = 0;
+        this.extraLines = 0;
         this.verbIdx = Math.floor(Math.random() * VERBS.length);
         // Hide cursor + register exit handler to restore it
         process.stderr.write("\x1b[?25l");
@@ -80,7 +91,7 @@ export class Spinner {
     update(detail) {
         this.detail = detail;
     }
-    /** Stop the spinner and clear the line. */
+    /** Stop the spinner and clear everything (spinner + dashboard lines). */
     stop() {
         if (!this.running)
             return;
@@ -89,25 +100,64 @@ export class Spinner {
             clearInterval(this.intervalId);
             this.intervalId = null;
         }
-        // Clear spinner line and show cursor
-        process.stderr.write("\r\x1b[K\x1b[?25h");
+        // Clear spinner line + all dashboard lines below using "erase to end of screen"
+        process.stderr.write(`\r\x1b[K\x1b[J\x1b[?25h`);
+        this.extraLines = 0;
     }
     /** Whether the spinner is currently active. */
     get isActive() {
         return this.running;
     }
+    /** Called by the dashboard when it wants to re-render. */
+    requestDashboardRender() {
+        // Dashboard render happens on next spinner tick — no immediate write.
+        // This prevents interleaving.
+    }
     render() {
         const elapsed = ((Date.now() - this.startTime) / 1000).toFixed(1);
         const char = coral(SPINNER_CHARS[this.frameIdx]);
         const verb = VERBS[this.verbIdx];
         const time = dim(`${elapsed}s`);
-        const detail = this.detail ? dim(` ${this.detail}`) : "";
-        const line = `  ${char} ${verb}...${detail}  ${time}`;
         const maxW = termWidth();
-        const stripped = stripAnsi(line);
-        // Truncate if wider than terminal
-        const output = stripped.length > maxW ? line.slice(0, maxW - 1) : line;
-        process.stderr.write(`\r\x1b[K${output}`);
+        // Build detail string, truncating if needed (ANSI-safe)
+        let detailStr = "";
+        if (this.detail) {
+            const prefix = `  X ${verb}...  ${elapsed}s`;
+            const available = maxW - prefix.length - 1;
+            if (available > 5) {
+                const raw = this.detail;
+                detailStr = raw.length > available ? dim(` ${raw.slice(0, available - 2)}\u2026`) : dim(` ${raw}`);
+            }
+        }
+        const line = `  ${char} ${verb}...${detailStr}  ${time}`;
+        // Clear previous extra lines (dashboard) — move up from current position
+        // Current cursor is on spinner line after last render
+        if (this.extraLines > 0) {
+            // Move down to the last dashboard line, then clear upward
+            process.stderr.write(`\x1b[${this.extraLines}B`); // move down past dashboard
+            for (let i = 0; i < this.extraLines; i++) {
+                process.stderr.write("\x1b[1A\x1b[2K"); // move up + clear line
+            }
+        }
+        // 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) {
+                process.stderr.write("\n");
+                process.stderr.write(dashLines.join("\n"));
+                this.extraLines = dashLines.length;
+                // Move cursor back up to the spinner line
+                if (this.extraLines > 0) {
+                    process.stderr.write(`\x1b[${this.extraLines}A`);
+                }
+                process.stderr.write("\r");
+            }
+            else {
+                this.extraLines = 0;
+            }
+        }
     }
 }
 //# sourceMappingURL=spinner.js.map

package/package.json

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