pilotswarm-cli 0.1.6 → 0.1.8

package/cli/tui.js

@@ -1099,6 +1099,58 @@ function appendActivity(text, orchId) {
     }
 }
 
+function formatToolArgValue(value) {
+    if (typeof value === "string") return JSON.stringify(value);
+    if (typeof value === "number" || typeof value === "boolean") return String(value);
+    if (value === null) return "null";
+    if (Array.isArray(value)) return `[${value.map(formatToolArgValue).join(", ")}]`;
+    try {
+        return JSON.stringify(value);
+    } catch {
+        return String(value);
+    }
+}
+
+function formatToolArgsSummary(toolName, args) {
+    if (!args || typeof args !== "object") return "";
+    if (toolName === "wait") {
+        const seconds = args.seconds != null ? `${args.seconds}s` : "?";
+        const preserve = args.preserveWorkerAffinity === true ? " preserve=true" : "";
+        const reason = typeof args.reason === "string" && args.reason
+            ? ` reason=${JSON.stringify(args.reason)}`
+            : "";
+        return ` ${seconds}${preserve}${reason}`;
+    }
+
+    const entries = Object.entries(args)
+        .slice(0, 4)
+        .map(([key, value]) => `${key}=${formatToolArgValue(value)}`);
+    if (entries.length === 0) return "";
+    const suffix = Object.keys(args).length > entries.length ? ", ..." : "";
+    return ` ${entries.join(", ")}${suffix}`;
+}
+
+function formatToolActivityLine(timeStr, evt, phase = "start") {
+    const toolName = evt.data?.toolName || evt.data?.name || "tool";
+    const args = evt.data?.arguments || evt.data?.args;
+    const dsid = evt.data?.durableSessionId ? ` {gray-fg}[${shortId(evt.data.durableSessionId)}]{/gray-fg}` : "";
+    const summary = formatToolArgsSummary(toolName, args);
+    if (phase === "start") {
+        return `{white-fg}[${timeStr}]{/white-fg} {yellow-fg}▶ ${toolName}${summary}{/yellow-fg}${dsid}`;
+    }
+    return `{white-fg}[${timeStr}]{/white-fg} {green-fg}✓ ${toolName}{/green-fg}${dsid}`;
+}
+
+function summarizeActivityPreview(text, maxLen = 100) {
+    const compact = String(text || "")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!compact) return "(no content)";
+    return compact.length > maxLen
+        ? `${compact.slice(0, maxLen - 1)}...`
+        : compact;
+}
+
 function ensureSessionSplashBuffer(orchId) {
     const existing = sessionChatBuffers.get(orchId) || [];
     const splashText = systemSplashText.get(orchId);
@@ -2631,6 +2683,7 @@ function recolorWorkerPanes() {
 
 function showCopilotMessage(raw, orchId) {
     const _ph = perfStart("showCopilotMessage");
+    stopChatSpinner(orchId);
 
     appendActivity(`{green-fg}[obs] showCopilotMessage called for ${orchId === activeOrchId ? "ACTIVE" : "background"} session, len=${raw?.length || 0}{/green-fg}`, orchId);
 
@@ -2907,12 +2960,9 @@ async function loadCmsHistory(orchId, options = {}) {
                         lines.push("");
                     }
                 } else if (type === "tool.execution_start") {
-                    const toolName = evt.data?.toolName || "tool";
-                    const dsid = evt.data?.durableSessionId ? ` {gray-fg}[${shortId(evt.data.durableSessionId)}]{/gray-fg}` : "";
-                    activityLines.push(`{white-fg}[${timeStr}]{/white-fg} {yellow-fg}▶ ${toolName}{/yellow-fg}${dsid}`);
+                    activityLines.push(formatToolActivityLine(timeStr, evt, "start"));
                 } else if (type === "tool.execution_complete") {
-                    const toolName = evt.data?.toolName || "tool";
-                    activityLines.push(`{white-fg}[${timeStr}]{/white-fg} {green-fg}✓ ${toolName}{/green-fg}`);
+                    activityLines.push(formatToolActivityLine(timeStr, evt, "complete"));
                 } else if (type === "abort" || type === "session.info" || type === "session.idle"
                     || type === "session.usage_info" || type === "pending_messages.modified"
                     || type === "assistant.usage") {
@@ -2971,7 +3021,45 @@ async function loadCmsHistory(orchId, options = {}) {
             }
 
             const maxRenderedSeq = (events || []).reduce((max, evt) => Math.max(max, evt.seq || 0), 0);
-            sessionChatBuffers.set(orchId, lines);
+
+            // Append pending question so it survives the history buffer swap.
+            // The observer may have written it into the old buffer, but this
+            // replacement would nuke it without this check.
+            const pendingQ = sessionPendingQuestions.get(orchId);
+            if (pendingQ) {
+                lines.push(`{cyan-fg}{bold}Copilot:{/bold}{/cyan-fg}`);
+                const renderedQ = renderMarkdown(pendingQ);
+                for (const line of renderedQ.split("\n")) {
+                    lines.push(line);
+                }
+                lines.push("");
+            }
+
+            // If CMS history produced no chat-visible lines (only the footer),
+            // but the observer previously wrote real content into the buffer,
+            // keep the existing buffer. This handles the case where assistant
+            // response text comes via the observer (customStatus streaming) but
+            // hasn't been persisted as CMS assistant.message events yet.
+            const chatContentLines = lines.filter(l =>
+                l && !/^{(?:white|gray)-fg}──/.test(l) && l.trim() !== "",
+            );
+            const existing = sessionChatBuffers.get(orchId);
+            const existingHasContent = existing && existing.length > 1
+                && existing.some(l => l && !/Loading/.test(l) && !/no recent/.test(l));
+
+            if (chatContentLines.length === 0 && existingHasContent) {
+                // CMS has no chat-worthy content but observer buffer does —
+                // append the footer to the existing buffer instead of replacing.
+                if (eventCount > 0) {
+                    const footerIdx = lines.findIndex(l => /recent history loaded/.test(l));
+                    if (footerIdx >= 0) {
+                        existing.push(lines[footerIdx]);
+                        existing.push("");
+                    }
+                }
+            } else {
+                sessionChatBuffers.set(orchId, lines);
+            }
             sessionActivityBuffers.set(orchId, activityLines);
             sessionHistoryLoadedAt.set(orchId, Date.now());
             sessionRenderedCmsSeq.set(orchId, maxRenderedSeq);
@@ -3134,8 +3222,11 @@ if (!isRemote) {
             ...(workerModuleConfig.mcpServers && { mcpServers: workerModuleConfig.mcpServers }),
         });
         // Register custom tools from worker module
-        if (workerModuleConfig.tools?.length) {
-            w.registerTools(workerModuleConfig.tools);
+        const workerTools = typeof workerModuleConfig.createTools === "function"
+            ? await workerModuleConfig.createTools({ workerNodeId: `local-rt-${i}`, workerIndex: i })
+            : workerModuleConfig.tools;
+        if (workerTools?.length) {
+            w.registerTools(workerTools);
         }
         await w.start();
         workers.push(w);
@@ -3453,6 +3544,60 @@ const sessionRecoveredTurnResult = new Map(); // orchId → normalized completed
 const sessionObservers = new Map(); // orchId → AbortController
 const sessionLiveStatus = new Map(); // orchId → "idle"|"running"|"waiting"|"input_required"
 const sessionPendingTurns = new Set(); // orchIds with a locally-sent turn awaiting first live status
+
+// ─── Inline chat spinner ─────────────────────────────────────────
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const sessionSpinnerIndex = new Map(); // orchId → buffer line index where spinner lives
+let _spinnerFrame = 0;
+let _spinnerTimer = null;
+
+function startChatSpinner(orchId) {
+    const buf = sessionChatBuffers.get(orchId);
+    if (!buf) return;
+    // Remove existing spinner if any
+    stopChatSpinner(orchId);
+    const line = `{gray-fg}${SPINNER_FRAMES[0]} Thinking…{/gray-fg}`;
+    buf.push("");
+    buf.push(line);
+    sessionSpinnerIndex.set(orchId, buf.length - 1);
+    if (orchId === activeOrchId) invalidateChat("bottom");
+    // Start global animation timer if not running
+    if (!_spinnerTimer) {
+        _spinnerTimer = setInterval(() => {
+            _spinnerFrame = (_spinnerFrame + 1) % SPINNER_FRAMES.length;
+            let anyActive = false;
+            for (const [sid, idx] of sessionSpinnerIndex) {
+                const b = sessionChatBuffers.get(sid);
+                if (b && idx < b.length) {
+                    b[idx] = `{gray-fg}${SPINNER_FRAMES[_spinnerFrame]} Thinking…{/gray-fg}`;
+                    if (sid === activeOrchId) { invalidateChat(); anyActive = true; }
+                }
+            }
+            if (!anyActive && sessionSpinnerIndex.size === 0) {
+                clearInterval(_spinnerTimer);
+                _spinnerTimer = null;
+            }
+        }, 80);
+    }
+}
+
+function stopChatSpinner(orchId) {
+    const idx = sessionSpinnerIndex.get(orchId);
+    if (idx == null) return;
+    const buf = sessionChatBuffers.get(orchId);
+    if (buf && idx < buf.length) {
+        // Remove spinner line and the blank line before it
+        const startIdx = (idx > 0 && buf[idx - 1] === "") ? idx - 1 : idx;
+        buf.splice(startIdx, idx - startIdx + 1);
+    }
+    sessionSpinnerIndex.delete(orchId);
+    if (orchId === activeOrchId) invalidateChat();
+    // Stop global timer if no spinners remain
+    if (sessionSpinnerIndex.size === 0 && _spinnerTimer) {
+        clearInterval(_spinnerTimer);
+        _spinnerTimer = null;
+    }
+}
 const sessionPendingQuestions = new Map(); // orchId → latest input-required question awaiting a user answer
 const sessionLastSeenResponseVersion = new Map(); // orchId → latest KV-backed response version rendered
 const sessionLastSeenCommandVersion = new Map(); // orchId → latest KV-backed command response version rendered
@@ -3666,6 +3811,33 @@ function handleDbRecovered() {
     if (_dbOffline) {
         appendLog(`{green-fg}Database connection restored.{/green-fg}`);
         setStatus("Database connection restored.");
+
+        // The orchestration list poll uses its own management client pool, but
+        // the active session's CMS event stream and reconstructed history may
+        // still be stale after a DB outage. Re-prime the active session view so
+        // chat/activity panes resume updating without requiring a manual switch.
+        const recoveredOrchId = activeOrchId;
+        if (recoveredOrchId) {
+            stopCmsPoller();
+            loadCmsHistory(recoveredOrchId, { force: true })
+                .then(() => {
+                    if (recoveredOrchId === activeOrchId) {
+                        startCmsPoller(recoveredOrchId);
+                        invalidateChat();
+                        invalidateActivity();
+                        redrawActiveViews();
+                        scheduleLightRefresh("dbRecovered", recoveredOrchId);
+                    }
+                })
+                .catch(() => {
+                    if (recoveredOrchId === activeOrchId) {
+                        startCmsPoller(recoveredOrchId);
+                        invalidateChat();
+                        invalidateActivity();
+                        redrawActiveViews();
+                    }
+                });
+        }
     }
     _dbOffline = false;
     _dbNextRetryAt = 0;
@@ -5115,6 +5287,7 @@ function startObserver(orchId) {
 
     function renderResponsePayload(response, cs, source) {
         if (!response) return;
+        stopChatSpinner(orchId);
         if (response.type === "completed" && response.content) {
             appendActivity(`{green-fg}[obs] ✓ SHOWING ${source}: version=${response.version} type=completed content=${response.content.slice(0, 80)}{/green-fg}`, orchId);
             renderCompletedContent(response.content);
@@ -5128,12 +5301,8 @@ function startObserver(orchId) {
         }
         if (response.type === "wait" && response.content) {
             appendActivity(`{green-fg}[obs] ✓ SHOWING ${source}: version=${response.version} type=wait content=${response.content.slice(0, 80)}{/green-fg}`, orchId);
-            const prefix = `{white-fg}[${ts()}]{/white-fg} {gray-fg}[intermediate]{/gray-fg}`;
-            appendActivity(prefix, orchId);
-            const rendered = renderMarkdown(response.content);
-            for (const line of rendered.split("\n")) {
-                appendActivity(line, orchId);
-            }
+            const preview = summarizeActivityPreview(response.content);
+            appendActivity(`{white-fg}[${ts()}]{/white-fg} {gray-fg}[intermediate]{/gray-fg} ${preview}`, orchId);
             promoteIntermediateContent(response.content, orchId);
             setStatusIfActive(`Waiting (${cs.waitReason || response.waitReason || "timer"})…`);
             return;
@@ -5533,13 +5702,12 @@ function startCmsPoller(orchId) {
 
             if (type === "tool.execution_start") {
                 const toolName = evt.data?.toolName || "tool";
-                const dsid = evt.data?.durableSessionId ? ` {gray-fg}[${shortId(evt.data.durableSessionId)}]{/gray-fg}` : "";
                 // Track last tool name so we can show it on completion too
                 sess._lastToolName = toolName;
-                appendActivity(`{white-fg}[${t}]{/white-fg} {yellow-fg}▶ ${toolName}{/yellow-fg}${dsid}`, orchId);
+                appendActivity(formatToolActivityLine(t, evt, "start"), orchId);
             } else if (type === "tool.execution_complete") {
                 const toolName = evt.data?.toolName || sess._lastToolName || "tool";
-                appendActivity(`{white-fg}[${t}]{/white-fg} {green-fg}✓ ${toolName}{/green-fg}`, orchId);
+                appendActivity(formatToolActivityLine(t, { ...evt, data: { ...(evt.data || {}), toolName } }, "complete"), orchId);
             } else if (type === "assistant.reasoning") {
                 appendActivity(`{white-fg}[${t}]{/white-fg} {gray-fg}[reasoning]{/gray-fg}`, orchId);
             } else if (type === "assistant.turn_start") {
@@ -6036,6 +6204,7 @@ async function handleInput(text) {
     }
 
     appendChatRaw(`{white-fg}[${ts()}]{/white-fg} {white-fg}{bold}You:{/bold} ${trimmed}{/white-fg}`, targetOrchId);
+    startChatSpinner(targetOrchId);
     inputBar.clearValue();
     focusInput();
     setSessionPendingTurn(targetOrchId, true);
@@ -6396,33 +6565,43 @@ screen.on("keypress", (ch, key) => {
         picker.key(["escape", "q", "a"], closePicker);
 
         picker.on("select", async (_el, idx) => {
-            closePicker();
             const art = artifacts[idx];
             if (!art) return;
 
-            setStatus(`Downloading ${art.filename}...`);
-            screen.render();
-            const localPath = await downloadArtifact(art.sessionId, art.filename);
-            if (localPath) {
-                art.downloaded = true;
-                art.localPath = localPath;
-
-                // Open markdown viewer with this file selected
+            if (art.downloaded) {
+                // Already downloaded — close picker and open viewer
+                closePicker();
                 mdViewActive = true;
                 refreshMarkdownViewer();
-
-                // Find and select the downloaded file in the viewer
                 const files = scanExportFiles();
-                const matchIdx = files.findIndex(f => f.localPath === localPath);
+                const matchIdx = files.findIndex(f => f.localPath === art.localPath);
                 if (matchIdx >= 0) {
                     mdViewerSelectedIdx = matchIdx;
                     mdFileListPane.select(matchIdx);
                     refreshMarkdownViewer();
                 }
-
                 screen.realloc();
                 relayoutAll();
                 setStatus("Markdown Viewer (v to exit)");
+                screen.render();
+                return;
+            }
+
+            setStatus(`Downloading ${art.filename}...`);
+            screen.render();
+            const localPath = await downloadArtifact(art.sessionId, art.filename);
+            if (localPath) {
+                art.downloaded = true;
+                art.localPath = localPath;
+
+                // Update picker item to show downloaded state
+                const updatedItems = artifacts.map((a) => {
+                    const icon = a.downloaded ? "✓" : "↓";
+                    return ` ${icon} ${a.filename}`;
+                });
+                picker.setItems(updatedItems);
+                picker.select(idx);
+                setStatus(`Downloaded ${art.filename}`);
             } else {
                 setStatus("Download failed — check logs");
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pilotswarm-cli",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Terminal UI for pilotswarm — interactive durable agent orchestration.",
   "type": "module",
   "bin": {