pilotswarm-cli 0.1.6 → 0.1.7

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);
@@ -2907,12 +2959,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 +3020,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 +3221,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);
@@ -5128,12 +5218,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 +5619,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") {
@@ -6396,33 +6481,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.7",
   "description": "Terminal UI for pilotswarm — interactive durable agent orchestration.",
   "type": "module",
   "bin": {