swarm-code 0.1.21 → 0.1.23

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

@@ -757,8 +757,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;
@@ -960,6 +963,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/threads/manager.d.ts

@@ -80,6 +80,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

@@ -486,7 +486,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 +570,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 +637,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/text-input.js

@@ -44,51 +44,93 @@ export function readTextInput(_prompt) {
         process.stdin.setRawMode(true);
         process.stdin.resume();
         process.stdin.setEncoding("utf-8");
-        // How many rows below the top border the cursor sits after drawBox()
+        // Tracks cursor position relative to top border after each drawBox()
         let cursorRowFromTop = 0;
-        let hasDrawn = false;
-        function drawBox() {
-            const out = process.stderr;
-            const promptVisibleLen = 2; // "❯ "
-            if (hasDrawn) {
-                // Move cursor from its current position back to the top border row
-                if (cursorRowFromTop > 0) {
-                    out.write(`\x1b[${cursorRowFromTop}A`);
-                }
-                out.write("\x1b[0G"); // go to column 0
-                out.write("\x1b[J"); // erase from cursor to end of screen
-            }
-            hasDrawn = true;
-            // Top border — thin dim line
-            const topLine = `${BORDER_COLOR}${"─".repeat(w)}${RESET}`;
-            out.write(`${topLine}\n`);
-            // Content rows — dark background, full width
+        let prevTotalRows = 0;
+        function buildRows() {
+            const promptVisibleLen = 2;
+            const rows = [];
+            // Top border
+            rows.push(`${BORDER_COLOR}${"─".repeat(w)}${RESET}`);
+            // Content rows
             const promptChar = `${ACCENT_COLOR}❯${RESET} `;
             for (let i = 0; i < linesBuf.length; i++) {
                 const lineText = linesBuf[i];
                 const prefix = i === 0 ? promptChar : `${dim("·")} `;
-                // How much space for text content
                 const contentWidth = w - promptVisibleLen;
-                // Truncate display if line is too long
                 const displayText = lineText.length > contentWidth ? lineText.slice(0, contentWidth - 1) + "…" : lineText;
                 const padding = Math.max(0, contentWidth - displayText.length);
-                out.write(`${BG_DARK}${prefix}${displayText}${" ".repeat(padding)}${RESET}\n`);
+                rows.push(`${BG_DARK}${prefix}${displayText}${" ".repeat(padding)}${RESET}`);
+            }
+            // Bottom border
+            rows.push(`${ACCENT_COLOR}${"─".repeat(w)}${RESET}`);
+            // Hints — pad to full width so it fully overwrites old content
+            const hintsText = "  enter submit  esc exit";
+            const hintsPad = Math.max(0, w - hintsText.length);
+            rows.push(`${dim(hintsText)}${" ".repeat(hintsPad)}`);
+            return rows;
+        }
+        function drawBox() {
+            const out = process.stderr;
+            const promptVisibleLen = 2;
+            const rows = buildRows();
+            const totalRows = rows.length;
+            if (prevTotalRows > 0) {
+                // ── Redraw: overwrite rows in place (no \n, no scrolling) ──
+                // Move cursor to top border row
+                if (cursorRowFromTop > 0) {
+                    out.write(`\x1b[${cursorRowFromTop}A`);
+                }
+                out.write("\r");
+                // Overwrite each row in place
+                const commonRows = Math.min(totalRows, prevTotalRows);
+                for (let i = 0; i < commonRows; i++) {
+                    out.write(`\x1b[2K${rows[i]}`);
+                    if (i < commonRows - 1) {
+                        out.write("\x1b[1B\r"); // cursor down 1 (no scroll), start of line
+                    }
+                }
+                if (totalRows > prevTotalRows) {
+                    // More rows than before (multi-line paste) — append with \n
+                    for (let i = commonRows; i < totalRows; i++) {
+                        out.write(`\n\x1b[2K${rows[i]}`);
+                    }
+                }
+                else if (prevTotalRows > totalRows) {
+                    // Fewer rows than before — erase leftover old rows
+                    for (let i = totalRows; i < prevTotalRows; i++) {
+                        out.write("\x1b[1B\r\x1b[2K");
+                    }
+                    // Move back to last new row
+                    const extra = prevTotalRows - totalRows;
+                    if (extra > 0)
+                        out.write(`\x1b[${extra}A`);
+                }
+                // Cursor is now on the last row (hints).
+            }
+            else {
+                // ── Initial draw: use \n between rows, no trailing \n ──
+                for (let i = 0; i < totalRows; i++) {
+                    if (i > 0)
+                        out.write("\n");
+                    out.write(rows[i]);
+                }
+                // Cursor is on the hints line (last row).
             }
-            // Bottom border — accent colored
-            const bottomLine = `${ACCENT_COLOR}${"─".repeat(w)}${RESET}`;
-            out.write(`${bottomLine}\n`);
-            // Hints
-            out.write(`${dim("  enter submit  esc exit")}\n`);
-            // Position cursor inside the text area
-            // We're at the bottom (after hints). Move up to the correct content row.
-            const currentLineIdx = linesBuf.length - 1; // cursor is always on last line
-            const rowsFromBottom = 2 + (linesBuf.length - 1 - currentLineIdx); // hints + bottom border + lines below cursor
-            out.write(`\x1b[${rowsFromBottom}A`);
-            // Move to correct column: prefix width + cursor position
+            prevTotalRows = totalRows;
+            // Position cursor at the active content row
+            // Cursor is currently on the hints line (last row = index totalRows-1).
+            // Content cursor is on row (1 + currentLineIdx).
+            const currentLineIdx = linesBuf.length - 1;
+            const targetRow = 1 + currentLineIdx;
+            const hintsRow = totalRows - 1;
+            const rowsUp = hintsRow - targetRow;
+            if (rowsUp > 0)
+                out.write(`\x1b[${rowsUp}A`);
+            // Set column
             const col = promptVisibleLen + cursorPos + 1;
             out.write(`\x1b[${col}G`);
-            // Track where cursor ended up (row 0 = top border)
-            cursorRowFromTop = 1 + currentLineIdx;
+            cursorRowFromTop = targetRow;
         }
         // Initial draw
         process.stderr.write(HIDE_CURSOR);
@@ -203,12 +245,11 @@ export function readTextInput(_prompt) {
             if (origRawMode !== undefined) {
                 process.stdin.setRawMode(origRawMode);
             }
-            // Move cursor to top of box and clear everything
+            // Move cursor to top of box
             if (cursorRowFromTop > 0) {
                 process.stderr.write(`\x1b[${cursorRowFromTop}A`);
             }
-            process.stderr.write("\x1b[0G");
-            process.stderr.write("\x1b[J"); // erase to end of screen
+            process.stderr.write("\r\x1b[J"); // erase from here to end of screen
             // Write the submitted text as a clean line (so it's visible in scrollback)
             const fullText = linesBuf.join("\n").trim();
             if (fullText) {

package/package.json

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