pilotswarm 0.5.21 → 0.5.23

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pilotswarm",
-    "version": "0.5.21",
+    "version": "0.5.23",
     "description": "PilotSwarm application package: terminal UI, browser portal + Web API server, and MCP server — one install, three bins.",
     "type": "module",
     "license": "MIT",
@@ -78,6 +78,7 @@
         "hono": "^4.12.10",
         "ink": "^6.8.0",
         "jose": "^6.2.2",
+        "mermaid": "^11.16.0",
         "pilotswarm-sdk": "^0.5.20",
         "react": "^19.2.4",
         "react-dom": "^19.2.4",

package/tui/src/node-sdk-transport.js

@@ -1690,8 +1690,13 @@ export class NodeSdkTransport {
                         const payload = JSON.parse(body || "{}");
                         const items = Array.isArray(payload?.items) ? payload.items : [];
                         resolve(items
-                            .map((item) => String(item?.metadata?.name || "").trim())
-                            .filter(Boolean));
+                            .map((item) => ({
+                                name: String(item?.metadata?.name || "").trim(),
+                                containers: (Array.isArray(item?.spec?.containers) ? item.spec.containers : [])
+                                    .map((container) => String(container?.name || "").trim())
+                                    .filter(Boolean),
+                            }))
+                            .filter((pod) => pod.name));
                     } catch (error) {
                         reject(error);
                     }
@@ -1709,6 +1714,9 @@ export class NodeSdkTransport {
             timestamps: "true",
             tailLines: String(options.tailLines ?? 500),
         });
+        // Multi-container pods (sidecars, init containers) reject log reads
+        // that don't name a container (400 BadRequest).
+        if (options.container) params.set("container", options.container);
         const pathName = `/api/v1/namespaces/${encodeURIComponent(config.namespace)}/pods/${encodeURIComponent(podName)}/log?${params.toString()}`;
 
         return new Promise((resolve, reject) => {
@@ -1810,9 +1818,9 @@ export class NodeSdkTransport {
         this.logTailHandle = handle;
 
         this.listPodsFromKubeApi(config, labelSelector)
-            .then(async (podNames) => {
+            .then(async (pods) => {
                 if (handle.stopped || this.logTailHandle !== handle) return;
-                if (podNames.length === 0) {
+                if (pods.length === 0) {
                     this.emitSyntheticLogMessage(
                         `No pods matched label selector ${JSON.stringify(labelSelector)} in namespace ${config.namespace}.`,
                         "warn",
@@ -1820,8 +1828,17 @@ export class NodeSdkTransport {
                     return;
                 }
 
+                // Container selection per pod: explicit K8S_LOG_CONTAINER wins,
+                // else the conventional "worker" container when present, else
+                // the pod's first container. Single-container pods work either
+                // way; multi-container pods 400 without an explicit name.
+                const configuredContainer = String(process.env.K8S_LOG_CONTAINER || "").trim();
                 const results = await Promise.allSettled(
-                    podNames.map((podName) => this.streamPodLogsFromKubeApi(config, podName, handle)),
+                    pods.map((pod) => {
+                        const container = configuredContainer
+                            || (pod.containers.includes("worker") ? "worker" : pod.containers[0]);
+                        return this.streamPodLogsFromKubeApi(config, pod.name, handle, container ? { container } : {});
+                    }),
                 );
 
                 if (handle.stopped || this.logTailHandle !== handle) return;

package/ui/core/src/controller.js

@@ -3870,7 +3870,7 @@ export class PilotSwarmUiController {
     }
 
     setChatViewMode(mode) {
-        if (mode !== "summary" && mode !== "transcript") return;
+        if (mode !== "summary" && mode !== "transcript" && mode !== "rich") return;
         if (this.getActiveSession()?.isGroup) return;
         this.dispatch({ type: "ui/chatViewMode", mode });
     }

package/ui/core/src/reducer.js

@@ -637,7 +637,8 @@ export function appReducer(state, action) {
             const hasOwnerFilter = Object.prototype.hasOwnProperty.call(settings, "sessionOwnerFilter");
             const hasLayout = Object.prototype.hasOwnProperty.call(settings, "layoutAdjustments");
             const hasChatViewMode = Object.prototype.hasOwnProperty.call(settings, "chatViewMode")
-                && (settings.chatViewMode === "summary" || settings.chatViewMode === "transcript");
+                && (settings.chatViewMode === "summary" || settings.chatViewMode === "transcript"
+                    || settings.chatViewMode === "rich");
             const hasPins = Object.prototype.hasOwnProperty.call(settings, "pinnedSessionIds");
             const hasCollapsed = Object.prototype.hasOwnProperty.call(settings, "collapsedSessionIds");
             // A pending/resolved deep-link intent outranks the profile's
@@ -701,7 +702,7 @@ export function appReducer(state, action) {
         }
 
         case "ui/chatViewMode":
-            if (action.mode !== "summary" && action.mode !== "transcript") {
+            if (action.mode !== "summary" && action.mode !== "transcript" && action.mode !== "rich") {
                 return state;
             }
             return {

package/ui/core/src/selectors.js

@@ -229,7 +229,15 @@ function shouldDecorateSessionOwners(state) {
     // distinct human owner — otherwise the owner chip is pure noise on every
     // row (you are always "you"). A narrowed owner filter is an explicit
     // multi-user context, so honor that too.
-    if (state.sessions?.ownerFilter && state.sessions.ownerFilter.all !== true) return true;
+    // A narrowed filter counts as an explicit multi-user context ONLY when it
+    // names specific owners. The DEFAULT signed-in filter already sets
+    // `all: false` AND `includeShared: true` (see
+    // defaultOwnerFilterForPrincipal), so testing either of those tagged every
+    // row in a single-user deployment with a pointless "you are you" chip.
+    // Everything else falls through to counting DISTINCT owners below, which
+    // is what the chip actually communicates.
+    const ownerFilter = state.sessions?.ownerFilter;
+    if (Array.isArray(ownerFilter?.ownerKeys) && ownerFilter.ownerKeys.length > 0) return true;
     const owners = new Set();
     for (const session of Object.values(state.sessions?.byId || {})) {
         if (!session || session.isSystem || session.isGroup) continue;
@@ -731,6 +739,37 @@ function buildSessionRowView(entry, session, state, totalDescendantCounts, visib
         badgeRuns: [],
         selectedMetaRuns: detailRuns,
         detailRuns,
+        // Structured row description for renderers that draw real chrome
+        // instead of terminal runs (the portal's rich session list): status
+        // becomes a dot, depth becomes indentation, the owner/child/cron
+        // badges become chips. Purely additive — `runs`/`titleRuns` above
+        // stay the terminal's source of truth and the TUI ignores this.
+        chrome: {
+            kind: session?.isGroup ? "group"
+                : session?.isSystem ? "system"
+                : session?.serviceKind ? "service"
+                : "session",
+            title: hasRealTitle ? rawTitle : shortId,
+            untitled: !hasRealTitle,
+            statusColor: sessionStatusColor(session, mode),
+            accentColor: mainColor,
+            pinned: isPinned,
+            selectMode,
+            checked: isSelected,
+            owner: shouldDecorateSessionOwners(state) && !session?.isSystem && !session?.isGroup
+                ? {
+                    initials: effectiveOwner ? ownerInitials(effectiveOwner) : "?",
+                    isMine: Boolean(ownerKeyForOwner(state?.auth?.principal)
+                        && ownerKeyForOwner(effectiveOwner) === ownerKeyForOwner(state?.auth?.principal)),
+                }
+                : null,
+            childBadge: collapseBadge ? { text: collapseBadge.text, color: collapseBadge.color } : null,
+            cron: Boolean(cronBadge),
+            age: relTime || null,
+            model: modelLabel || null,
+            shortId,
+            ctx: ctxRuns.length > 0 ? { text: ctxRuns[0].text, color: ctxRuns[0].color } : null,
+        },
     };
 }
 
@@ -1374,7 +1413,12 @@ function prefixRuns(text, color = "gray", options = {}) {
     }];
 }
 
-function buildChatMessagePrefix(message, options = {}) {
+// Header facts for one chat message — speaker label, label color, delivery
+// glyph, and timestamp — extracted from buildChatMessagePrefix so the rich
+// (block) chat renderer can consume the same labeling rules without the
+// terminal run/prefix shape. Returns { time, glyph, glyphColor, roleLabel,
+// roleColor }.
+function describeChatMessageHeader(message, options = {}) {
     const time = formatTimestamp(message?.createdAt || message?.time);
     // A user.message is labeled from the CURRENT VIEWER's perspective: "You"
     // for the viewer's own messages, the sender's name for anyone else. When
@@ -1459,6 +1503,15 @@ function buildChatMessagePrefix(message, options = {}) {
             : message?.role === "system"
                 ? "yellow"
                 : "white";
+    // `fromOtherPerson` lets renderers drop the speaker label for the
+    // viewer's own messages and the agent's (a 1:1 chat needs no "You:" /
+    // "Agent:" on every turn) while still naming OTHER humans in a shared
+    // session, where attribution is the whole point.
+    return { time, glyph, glyphColor, roleLabel, roleColor, fromOtherPerson };
+}
+
+function buildChatMessagePrefix(message, options = {}) {
+    const { time, glyph, glyphColor, roleLabel, roleColor } = describeChatMessageHeader(message, options);
     const prefix = time ? `[${time}] ` : "";
     const runs = [...prefixRuns(prefix, "gray")];
     if (glyph) {
@@ -2319,6 +2372,93 @@ export function selectChatLines(state, maxWidth = 80, options = {}) {
     return lines.length > 0 ? lines : [{ text: "No messages yet.", color: "gray" }];
 }
 
+// True when a chat message is plain user/assistant prose the rich (block)
+// renderer can format as markdown directly. Everything with terminal-era
+// special handling — splash art, thinking cards, chrome-less summaries,
+// system/PilotSwarm cards, asked-and-answered exchanges, embedded
+// [SYSTEM: …] notice segments — stays on the line renderer, which already
+// knows every edge case.
+function isRichRenderableChatMessage(message) {
+    if (!message) return false;
+    if (message.kind === "epoch-divider" || message.kind === "regen-refused") return false;
+    if (message.splash || message.thinking || message.noChrome) return false;
+    if (message.role !== "user" && message.role !== "assistant") return false;
+    if (message.role === "user" && parseAskedAndAnsweredExchange(message?.text || "")) return false;
+    const segments = splitSystemNoticeSegments(message?.text || "");
+    if (segments.some((segment) => segment.kind === "system")) return false;
+    return true;
+}
+
+/**
+ * Message-level view of the active chat for the rich (desktop-style) web
+ * renderer. Returns an ordered array of blocks:
+ *
+ *   { kind: "message", id, role, header, text, pendingPhase, attachments }
+ *     — plain user/assistant prose. `header` is describeChatMessageHeader()
+ *       output; `text` is the artifact-link-decorated markdown source the
+ *       renderer formats itself; `attachments` is { sessionId, attachments }
+ *       (the sentinel shape) or null.
+ *
+ *   { kind: "lines", variant, lines }
+ *     — everything else (splash, thinking cards, system cards, dividers),
+ *       pre-rendered through the exact same line builders the terminal
+ *       transcript uses, so no edge case has two implementations.
+ *
+ * The TUI never calls this; selectChatLines remains the terminal path.
+ */
+export function selectChatBlocks(state, maxWidth = 80, options = {}) {
+    const messages = selectActiveChat(state);
+    if (!messages || messages.length === 0) return [];
+
+    const viewerKey = ownerKeyForOwner(state?.auth?.principal);
+    const activeSessionId = state?.sessions?.activeSessionId;
+    const activeSession = activeSessionId ? state?.sessions?.byId?.[activeSessionId] : null;
+    const ownerKey = ownerKeyForOwner(activeSession?.owner);
+    const sharedContext = Boolean(activeSession && (
+        (activeSession.visibility && activeSession.visibility !== "private")
+        || (ownerKey && viewerKey && ownerKey !== viewerKey)
+    ));
+    const buildOptions = {
+        ...(options?.tableMode ? { tableMode: options.tableMode } : {}),
+        ...(viewerKey ? { viewerKey } : {}),
+        ...(ownerKey ? { ownerKey } : {}),
+        ...(sharedContext ? { sharedContext: true } : {}),
+    };
+
+    const blocks = [];
+    for (const message of messages) {
+        if (message?.kind === "epoch-divider") {
+            blocks.push({ kind: "lines", variant: "divider", lines: [buildEpochDividerLine(message, maxWidth)] });
+            continue;
+        }
+        if (message?.kind === "regen-refused") {
+            blocks.push({ kind: "lines", variant: "divider", lines: [buildRegenRefusedLine(message, maxWidth)] });
+            continue;
+        }
+        if (isRichRenderableChatMessage(message)) {
+            const attachmentLines = buildAttachmentChipLines(message, { tableMode: "sentinel" });
+            const attachmentSentinel = attachmentLines.find((line) => line?.kind === "imageAttachments") || null;
+            blocks.push({
+                kind: "message",
+                id: message?.id ?? null,
+                role: message.role,
+                header: describeChatMessageHeader(message, buildOptions),
+                text: decorateArtifactLinksForChat(message?.text || ""),
+                pendingPhase: message?.pendingPhase || null,
+                attachments: attachmentSentinel
+                    ? { sessionId: attachmentSentinel.sessionId, attachments: attachmentSentinel.attachments }
+                    : null,
+            });
+            continue;
+        }
+        const lines = buildChatMessageLines(message, maxWidth, buildOptions);
+        if (lines.length > 0) {
+            blocks.push({ kind: "lines", variant: "event", lines });
+        }
+    }
+    return blocks;
+}
+
 // A centered inline rule ("──── label ────") for transcript markers. The dash
 // runs are CAPPED (not stretched to maxWidth): the web portal wraps by pixel
 // width, and a maxWidth-long "─" run overflows a narrower pane and wraps the

package/ui/core/src/state.js

@@ -129,7 +129,7 @@ export function createInitialState({ mode = "local", branding = null, themeId =
             inspectorTab: INSPECTOR_TABS[0],
             sequenceExpandedTurns: [],
             sequenceSelectedTurn: null,
-            chatViewMode: chatViewMode === "summary" ? "summary" : "transcript",
+            chatViewMode: (chatViewMode === "summary" || chatViewMode === "rich") ? chatViewMode : "transcript",
             statsViewMode: "session",
             prompt: "",
             promptCursor: 0,