pilotswarm 0.5.27 → 0.5.29

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pilotswarm",
-    "version": "0.5.27",
+    "version": "0.5.29",
     "description": "PilotSwarm application package: terminal UI, browser portal + Web API server, and MCP server \u2014 one install, three bins.",
     "type": "module",
     "license": "MIT",

package/ui/core/src/controller.js

@@ -935,7 +935,12 @@ function movePromptCursorVertically(prompt, cursor, direction) {
     return getPromptCursorIndex(prompt, targetLine, position.column);
 }
 
-const AUTO_HISTORY_EVENT_SOFT_CAP = 3_000;
+// Automatic scroll-up expansion stops here; past it the user must ask for more
+// explicitly. Exported so a surface can SHOW that control — the portal had no
+// way to trigger EXPAND_HISTORY at all, so on a busy session (tens of thousands
+// of events) scrolling up simply died with a status line telling the user to
+// press a key that only exists in the TUI.
+export const AUTO_HISTORY_EVENT_SOFT_CAP = 3_000;
 const INSPECTOR_BOTTOM_ANCHORED_TABS = new Set(["logs", "sequence"]);
 const FILE_PREVIEW_CHAR_LIMIT = 200_000;
 const MARKDOWN_FILE_EXTENSIONS = new Set([
@@ -6328,7 +6333,17 @@ export class PilotSwarmUiController {
 
         await this.maybeAutoExpandActiveHistory(requestedScrollOffset, {
             pages: AUTO_HISTORY_SCROLL_PAGE_COUNT,
-            force: Boolean(options.force),
+            // Always bypass the offset gate. Every caller of this method fires
+            // only when the DOM scroller is already AT the top — a direct
+            // measurement. The gate is a second, weaker guess that compares a
+            // DOM-derived offset against `selectChatLines` metrics, i.e. the
+            // TERMINAL wrapped-line count, which the rich renderer does not
+            // use. On a session whose messages are long (tables, code blocks)
+            // the terminal line count balloons far past the rich DOM's scroll
+            // extent, so the gate could never open and older history was
+            // unreachable — while a session of short messages worked fine.
+            // The arm/fire handshake above still debounces the wheel path.
+            force: true,
         });
     }
 

package/ui/core/src/formatting.js

@@ -100,6 +100,58 @@ export function shortModelName(model) {
     return value.includes(":") ? value.split(":").slice(1).join(":") : value;
 }
 
+/*
+ * `date.toLocaleTimeString(locale, opts)` builds a fresh Intl.DateTimeFormat on
+ * EVERY call. Constructing the formatter is the expensive part — the formatting
+ * itself is cheap — and these timestamps are re-derived for every row on every
+ * render, so a pane resize paid for thousands of throwaway formatters per drag.
+ * Measured on the chk portal: this one function was 5,332ms of self time in a
+ * 5,800ms drag profile (91.8%), with nothing else above 60ms.
+ *
+ * Built lazily rather than at module load: callers that never format a
+ * timestamp (the CLI paths) should not pay ICU initialisation on import.
+ *
+ * Passing `undefined` as the locale keeps the user's own locale, matching what
+ * toLocaleTimeString did. The "en-GB" ones are deliberately fixed — the compact
+ * form is a fixed-width column and a locale-dependent month name would break it.
+ */
+let hourMinuteFormatter = null;
+let hourMinuteSecondFormatter = null;
+let monthShortFormatter = null;
+let monthDayFormatter = null;
+
+function hourMinuteFormat() {
+    if (!hourMinuteFormatter) {
+        hourMinuteFormatter = new Intl.DateTimeFormat(undefined, {
+            hour: "2-digit", minute: "2-digit", hour12: false,
+        });
+    }
+    return hourMinuteFormatter;
+}
+
+function hourMinuteSecondFormat() {
+    if (!hourMinuteSecondFormatter) {
+        hourMinuteSecondFormatter = new Intl.DateTimeFormat(undefined, {
+            hour: "2-digit", minute: "2-digit", second: "2-digit", hour12: false,
+        });
+    }
+    return hourMinuteSecondFormatter;
+}
+
+function monthShortFormat() {
+    if (!monthShortFormatter) {
+        monthShortFormatter = new Intl.DateTimeFormat("en-GB", { month: "short" });
+    }
+    return monthShortFormatter;
+}
+
+function monthDayFormat() {
+    if (!monthDayFormatter) {
+        monthDayFormatter = new Intl.DateTimeFormat("en-GB", { month: "short", day: "numeric" });
+    }
+    return monthDayFormatter;
+}
+
 /**
  * Compact timestamp for fixed-width columns (the sequence pane).
  *
@@ -114,19 +166,16 @@ export function formatTimestampCompact(value, now = new Date()) {
     try {
         const date = value instanceof Date ? value : new Date(value);
         if (Number.isNaN(date.getTime())) return "";
-        const hhmm = date.toLocaleTimeString(undefined, {
-            hour: "2-digit", minute: "2-digit", hour12: false,
-        });
         const sameLocalDay = date.getFullYear() === now.getFullYear()
             && date.getMonth() === now.getMonth()
             && date.getDate() === now.getDate();
-        if (sameLocalDay) {
-            return date.toLocaleTimeString(undefined, {
-                hour: "2-digit", minute: "2-digit", second: "2-digit", hour12: false,
-            });
-        }
+        // Same-day returns a DIFFERENT string (it carries seconds), so
+        // computing hhmm before this branch built a formatted time only to
+        // throw it away — on the most common row in the list.
+        if (sameLocalDay) return hourMinuteSecondFormat().format(date);
+        const hhmm = hourMinuteFormat().format(date);
         const day = String(date.getDate());
-        const month = date.toLocaleDateString("en-GB", { month: "short" });
+        const month = monthShortFormat().format(date);
         // Year only when it differs — a two-digit suffix, since the column is
         // shared with same-day rows and every extra char costs lane width.
         const year = date.getFullYear() === now.getFullYear()
@@ -142,19 +191,14 @@ export function formatTimestamp(value, now = new Date()) {
     if (!value) return "";
     try {
         const date = value instanceof Date ? value : new Date(value);
-        const time = date.toLocaleTimeString(undefined, {
-            hour: "2-digit",
-            minute: "2-digit",
-            second: "2-digit",
-            hour12: false,
-        });
+        const time = hourMinuteSecondFormat().format(date);
         // Same-day messages show time only; anything older carries its date
         // so a transcript spanning days stays unambiguous.
         const sameLocalDay = date.getFullYear() === now.getFullYear()
             && date.getMonth() === now.getMonth()
             && date.getDate() === now.getDate();
         if (sameLocalDay) return time;
-        const day = date.toLocaleDateString("en-GB", { month: "short", day: "numeric" });
+        const day = monthDayFormat().format(date);
         const year = date.getFullYear() === now.getFullYear() ? "" : ` ${date.getFullYear()}`;
         return `${day}${year} ${time}`;
     } catch {

package/ui/core/src/selectors.js

@@ -892,6 +892,12 @@ export function selectSessionRows(state) {
             entry, session, active, pinned, selected, query, ownerFilter, auth,
             state.connection?.mode, state.sessions.selectMode,
             totalDescendantCounts, visibleDescendantCounts,
+            // The root system row renders as the branding title, and this
+            // selector is called with two different state shapes (the portal
+            // builds a synthetic one). Without this the cache could hand a row
+            // built under one branding to a caller using another, and the root
+            // session's name would flip between them.
+            state.branding?.title,
         ];
         const cached = memo.get(entry.sessionId);
         if (cached && sameRowDeps(cached.deps, deps)) return cached.row;
@@ -2402,10 +2408,75 @@ export function selectLiveActivityLines(state, options = {}) {
     return [fitRuns(runs, maxWidth)];
 }
 
+// Recent selectChatLines results, compared by the IDENTITY of every input.
+//
+// This wraps the entire transcript to terminal lines, and it runs from
+// scrollPane / scrollPaneTo / the visual-offset helpers — i.e. on every scroll
+// action, to answer nothing more than "how many lines are there". Measured
+// 1.6ms at 300 messages and 5.1ms at 1500, per scroll.
+//
+// Keyed on identities rather than fields on purpose: selectActiveChat is NOT a
+// pure function of the chat array — it also appends a pending-question message,
+// an answered-question message and a session-error message, and branches on
+// ui.chatViewMode and branding. Anything derived from `session` therefore has
+// to invalidate when `session` does, which identity comparison gives for free.
+//
+// `byId` is in the key for two reasons found by adversarial review, both of
+// which produced visibly wrong output:
+//
+//   1. For a GROUP session, selectActiveChat ignores the group's own history
+//      entirely and builds a Members table by scanning every OTHER session in
+//      byId (title / status / shortSummary). Renaming a member changes none of
+//      the group row's own aggregate counters, and the reducer PRESERVES a
+//      session object's identity when nothing on it moved — so without byId the
+//      table froze on the old titles indefinitely. (An earlier version of this
+//      comment claimed the poll rebuilds the session object every time. It does
+//      not, and that wrong assumption is what made the bug possible.)
+//   2. This memo is module-level and shared by callers that pass DIFFERENT
+//      state shapes: the TUI's ChatPane passes a synthetic single-session byId
+//      while the controller's scroll math passes the real full state. Every
+//      other key field can match between them, so whichever missed first
+//      populated one entry for both, and the member list flipped depending on
+//      call order. Distinct byId objects now key them apart.
+const CHAT_LINES_MEMO_MAX = 4;
+let chatLinesMemo = [];
+
 export function selectChatLines(state, maxWidth = 80, options = {}) {
+    const memoSessionId = state?.sessions?.activeSessionId ?? null;
+    const memoKey = {
+        sessionId: memoSessionId,
+        session: memoSessionId ? state?.sessions?.byId?.[memoSessionId] ?? null : null,
+        byId: state?.sessions?.byId ?? null,
+        chat: state?.history?.bySessionId?.get?.(memoSessionId)?.chat ?? null,
+        viewMode: state?.ui?.chatViewMode ?? null,
+        branding: state?.branding ?? null,
+        principal: state?.auth?.principal ?? null,
+        maxWidth,
+        tableMode: options?.tableMode ?? null,
+    };
+    for (const entry of chatLinesMemo) {
+        if (entry.sessionId === memoKey.sessionId
+            && entry.session === memoKey.session
+            && entry.byId === memoKey.byId
+            && entry.chat === memoKey.chat
+            && entry.viewMode === memoKey.viewMode
+            && entry.branding === memoKey.branding
+            && entry.principal === memoKey.principal
+            && Object.is(entry.maxWidth, memoKey.maxWidth)
+            && entry.tableMode === memoKey.tableMode) {
+            return entry.lines;
+        }
+    }
+
+    const memoize = (lines) => {
+        chatLinesMemo.unshift({ ...memoKey, lines });
+        if (chatLinesMemo.length > CHAT_LINES_MEMO_MAX) chatLinesMemo.length = CHAT_LINES_MEMO_MAX;
+        return lines;
+    };
+
     const messages = selectActiveChat(state);
     if (!messages || messages.length === 0) {
-        return [{ text: "No messages yet.", color: "gray" }];
+        return memoize([{ text: "No messages yet.", color: "gray" }]);
     }
 
     // The current viewer's identity key — a user.message whose sender differs
@@ -2449,7 +2520,7 @@ export function selectChatLines(state, maxWidth = 80, options = {}) {
             lines.push(createBlankLine());
         }
     }
-    return lines.length > 0 ? lines : [{ text: "No messages yet.", color: "gray" }];
+    return memoize(lines.length > 0 ? lines : [{ text: "No messages yet.", color: "gray" }]);
 }
 
 // True when a chat message is plain user/assistant prose the rich (block)
@@ -2486,6 +2557,10 @@ function isRichRenderableChatMessage(message) {
  *
  * The TUI never calls this; selectChatLines remains the terminal path.
  */
+// Rich message blocks, cached on the message object. Keyed weakly so entries
+// die with the transcript they came from.
+const chatMessageBlockCache = new WeakMap();
+
 export function selectChatBlocks(state, maxWidth = 80, options = {}) {
     const messages = selectActiveChat(state);
     if (!messages || messages.length === 0) return [];
@@ -2507,6 +2582,41 @@ export function selectChatBlocks(state, maxWidth = 80, options = {}) {
 
     const blocks = [];
     for (const message of messages) {
+        // Fast path FIRST. Classifying a message as rich-renderable scans its
+        // text (asked-and-answered parsing, system-notice splitting), and that
+        // ran for every message on every call — so a pane-splitter drag paid
+        // it across the whole transcript per width step. A cache entry only
+        // exists for a message already classified rich, and `kind` is part of
+        // what is compared, so a hit is safe to take before classifying.
+        // Object.is, NOT ===: `createdAt` is NaN whenever the source event had
+        // no parseable timestamp, and NaN === NaN is false, so a plain equality
+        // check could never hit for those messages — the cache would silently
+        // do nothing while still costing a lookup. Same trap as comparing
+        // Infinity by subtraction.
+        const cached = message ? chatMessageBlockCache.get(message) : null;
+        if (cached
+            && Object.is(cached.text, message.text)
+            && Object.is(cached.kind, message.kind)
+            && Object.is(cached.role, message.role)
+            && Object.is(cached.id, message.id)
+            && Object.is(cached.pendingPhase, message.pendingPhase)
+            && Object.is(cached.stopped, message.stopped)
+            // The header is derived from these, and the chips from attachments.
+            // Messages are mutated in place (pendingPhase provably is), so every
+            // field the block is built from has to be compared — not just the
+            // obvious ones.
+            && Object.is(cached.createdAt, message.createdAt)
+            && Object.is(cached.time, message.time)
+            && Object.is(cached.sender, message.sender)
+            && Object.is(cached.attachments, message.attachments)
+            && Object.is(cached.tableMode, buildOptions.tableMode)
+            && Object.is(cached.viewerKey, buildOptions.viewerKey)
+            && Object.is(cached.ownerKey, buildOptions.ownerKey)
+            && Object.is(cached.sharedContext, buildOptions.sharedContext)) {
+            blocks.push(cached.block);
+            continue;
+        }
+
         if (message?.kind === "epoch-divider") {
             blocks.push({ kind: "lines", variant: "divider", lines: [buildEpochDividerLine(message, maxWidth)] });
             continue;
@@ -2520,9 +2630,15 @@ export function selectChatBlocks(state, maxWidth = 80, options = {}) {
             continue;
         }
         if (isRichRenderableChatMessage(message)) {
+            // A rich message block does NOT depend on maxWidth — the browser
+            // wraps this text with CSS; only the terminal needs a column count.
+            // Rebuilding it on every width step meant dragging a pane splitter
+            // re-parsed artifact links and re-derived headers for the entire
+            // loaded transcript to produce byte-identical output. Cache on the
+            // message itself, keyed by the inputs that CAN change it.
             const attachmentLines = buildAttachmentChipLines(message, { tableMode: "sentinel" });
             const attachmentSentinel = attachmentLines.find((line) => line?.kind === "imageAttachments") || null;
-            blocks.push({
+            const block = {
                 kind: "message",
                 id: message?.id ?? null,
                 role: message.role,
@@ -2532,17 +2648,107 @@ export function selectChatBlocks(state, maxWidth = 80, options = {}) {
                 attachments: attachmentSentinel
                     ? { sessionId: attachmentSentinel.sessionId, attachments: attachmentSentinel.attachments }
                     : null,
+            };
+            chatMessageBlockCache.set(message, {
+                block,
+                text: message.text,
+                kind: message.kind,
+                createdAt: message.createdAt,
+                time: message.time,
+                sender: message.sender,
+                attachments: message.attachments,
+                role: message.role,
+                id: message.id,
+                pendingPhase: message.pendingPhase,
+                stopped: message.stopped,
+                tableMode: buildOptions.tableMode,
+                viewerKey: buildOptions.viewerKey,
+                ownerKey: buildOptions.ownerKey,
+                sharedContext: buildOptions.sharedContext,
             });
+            blocks.push(block);
             continue;
         }
-        const lines = buildChatMessageLines(message, maxWidth, buildOptions);
-        if (lines.length > 0) {
-            blocks.push({ kind: "lines", variant: "event", lines });
-        }
+        const lineBlock = cachedLineBlock(message, maxWidth, buildOptions);
+        if (lineBlock) blocks.push(lineBlock);
     }
     return blocks;
 }
 
+/**
+ * Non-message blocks (thinking cards, system cards, splash, chrome-less
+ * summaries) go through the terminal line builders, which DO depend on width —
+ * so unlike message blocks these cannot be made width-independent. What they
+ * can avoid is being rebuilt when the width has not moved, which is every poll:
+ * the poll replaces `session`, the portal's useMemo sees a new selectorState,
+ * and the whole transcript is re-derived. Measured at 1500 messages with 10%
+ * line blocks that was 1.17ms a time, and 5.26ms at 50%.
+ *
+ * Only the LAST width is kept per message. A drag sweeps widths and will miss
+ * on every step — that work is genuinely required, since these lines are
+ * wrapped to a column count.
+ *
+ * The compared fields were enumerated from buildChatMessageLines and the
+ * builders it delegates to (message/thinking/system-notice cards). `stopped` is
+ * included because history.js sets it IN PLACE on an existing message.
+ */
+const chatLineBlockCache = new WeakMap();
+
+function cachedLineBlock(message, maxWidth, buildOptions) {
+    if (!message || typeof message !== "object") {
+        const lines = buildChatMessageLines(message, maxWidth, buildOptions);
+        return lines.length > 0 ? { kind: "lines", variant: "event", lines } : null;
+    }
+    const cached = chatLineBlockCache.get(message);
+    if (cached
+        && Object.is(cached.maxWidth, maxWidth)
+        && Object.is(cached.text, message.text)
+        && Object.is(cached.mobileText, message.mobileText)
+        && Object.is(cached.role, message.role)
+        && Object.is(cached.time, message.time)
+        && Object.is(cached.createdAt, message.createdAt)
+        && Object.is(cached.splash, message.splash)
+        && Object.is(cached.thinking, message.thinking)
+        && Object.is(cached.thinkingLabel, message.thinkingLabel)
+        && Object.is(cached.progressKind, message.progressKind)
+        && Object.is(cached.noChrome, message.noChrome)
+        && Object.is(cached.cardTitle, message.cardTitle)
+        && Object.is(cached.cardTitleColor, message.cardTitleColor)
+        && Object.is(cached.cardBorderColor, message.cardBorderColor)
+        && Object.is(cached.stopped, message.stopped)
+        && Object.is(cached.tableMode, buildOptions.tableMode)
+        && Object.is(cached.viewerKey, buildOptions.viewerKey)
+        && Object.is(cached.ownerKey, buildOptions.ownerKey)
+        && Object.is(cached.sharedContext, buildOptions.sharedContext)) {
+        return cached.block;
+    }
+    const lines = buildChatMessageLines(message, maxWidth, buildOptions);
+    const block = lines.length > 0 ? { kind: "lines", variant: "event", lines } : null;
+    chatLineBlockCache.set(message, {
+        block,
+        maxWidth,
+        text: message.text,
+        mobileText: message.mobileText,
+        role: message.role,
+        time: message.time,
+        createdAt: message.createdAt,
+        splash: message.splash,
+        thinking: message.thinking,
+        thinkingLabel: message.thinkingLabel,
+        progressKind: message.progressKind,
+        noChrome: message.noChrome,
+        cardTitle: message.cardTitle,
+        cardTitleColor: message.cardTitleColor,
+        cardBorderColor: message.cardBorderColor,
+        stopped: message.stopped,
+        tableMode: buildOptions.tableMode,
+        viewerKey: buildOptions.viewerKey,
+        ownerKey: buildOptions.ownerKey,
+        sharedContext: buildOptions.sharedContext,
+    });
+    return block;
+}
+
 // 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/react/src/web-app.js

@@ -12,6 +12,7 @@ import {
     computeLegacyLayout,
     createInitialState,
     createStore,
+    AUTO_HISTORY_EVENT_SOFT_CAP,
     formatCompactNumber,
     formatCronTimestampForClient,
     formatHumanDurationSeconds,
@@ -2488,30 +2489,29 @@ function StructuredChatBlocks({ lines, theme, controller = null }) {
 // every other block (splash, thinking cards, system cards, epoch dividers)
 // reuses the structured line renderer so the terminal-era special cases
 // keep exactly one implementation.
-function RichChatBlocks({ blocks, theme, controller = null }) {
-    return React.createElement("div", { className: "ps-rich-chat" },
-        (blocks || []).map((block, index) => {
-            if (block.kind === "message") {
-                const header = block.header || {};
-                const roleClass = block.role === "user" ? " is-user" : " is-assistant";
-                const pendingClass = block.pendingPhase ? ` is-${block.pendingPhase}` : "";
-                const text = String(block.text || "");
-                // A speaker label only earns its place when it disambiguates:
-                // another human in a shared session. The viewer's own turns
-                // and the agent's are obvious from side and styling.
-                const showLabel = block.role === "user" && header.fromOtherPerson;
-                // Consecutive turns from the same speaker read as one
-                // continuous passage — no repeated header, tighter spacing.
-                const previous = blocks[index - 1];
-                const continued = previous
-                    && previous.kind === "message"
-                    && previous.role === block.role
-                    && !(previous.header && previous.header.fromOtherPerson)
-                    && !showLabel;
-                return React.createElement("article", {
-                    key: block.id != null ? `msg:${block.id}` : `msg:${index}`,
-                    className: `ps-rich-msg${roleClass}${pendingClass}${continued ? " is-continued" : ""}`,
-                },
+/**
+ * One rich message, memoized.
+ *
+ * The body runs markdown through MarkdownPreviewContent — the single most
+ * expensive thing in the transcript — and a pane resize used to re-run it for
+ * every loaded message. `selectChatBlocks` now returns identity-stable blocks,
+ * so this bails out instead. Every prop must stay referentially stable for
+ * that to hold: `theme` comes from a Map, `controller` is a singleton, and
+ * `continued` is hoisted to a boolean because it depends on the PREVIOUS block
+ * and would otherwise have to be recomputed inside.
+ */
+const RichChatMessage = React.memo(function RichChatMessage({ block, theme, controller, continued }) {
+    const header = block.header || {};
+    const roleClass = block.role === "user" ? " is-user" : " is-assistant";
+    const pendingClass = block.pendingPhase ? ` is-${block.pendingPhase}` : "";
+    const text = String(block.text || "");
+    // A speaker label only earns its place when it disambiguates: another human
+    // in a shared session. The viewer's own turns and the agent's are obvious
+    // from side and styling.
+    const showLabel = block.role === "user" && header.fromOtherPerson;
+    return React.createElement("article", {
+        className: `ps-rich-msg${roleClass}${pendingClass}${continued ? " is-continued" : ""}`,
+    },
                     React.createElement("header", { className: "ps-rich-msg-head" },
                         showLabel
                             ? React.createElement("span", {
@@ -2536,22 +2536,53 @@ function RichChatBlocks({ blocks, theme, controller = null }) {
                         ? React.createElement("div", { className: "ps-rich-msg-body" },
                             React.createElement(MarkdownPreviewContent, { content: text, theme }))
                         : null,
-                    block.attachments
-                        ? React.createElement(ArtifactImageStrip, {
-                            controller,
-                            sessionId: block.attachments.sessionId,
-                            attachments: block.attachments.attachments,
-                        })
-                        : null);
+        block.attachments
+            ? React.createElement(ArtifactImageStrip, {
+                controller,
+                sessionId: block.attachments.sessionId,
+                attachments: block.attachments.attachments,
+            })
+            : null);
+});
+
+/** A non-message block (splash, system card, divider), memoized the same way. */
+const RichChatLineBlock = React.memo(function RichChatLineBlock({ block, theme, controller }) {
+    const lines = React.useMemo(() => normalizeLines(block.lines || []), [block.lines]);
+    return React.createElement("div", {
+        className: `ps-rich-lineblock is-${block.variant || "event"}`,
+    }, React.createElement(StructuredChatBlocks, { lines, theme, controller }));
+});
+
+function RichChatBlocks({ blocks, theme, controller = null }) {
+    return React.createElement("div", { className: "ps-rich-chat" },
+        (blocks || []).map((block, index) => {
+            if (block.kind === "message") {
+                // Consecutive turns from the same speaker read as one
+                // continuous passage — no repeated header, tighter spacing.
+                // Computed here because it reads the previous block; passing it
+                // down as a boolean is what keeps the child memoizable.
+                const previous = blocks[index - 1];
+                const header = block.header || {};
+                const showLabel = block.role === "user" && header.fromOtherPerson;
+                const continued = Boolean(previous
+                    && previous.kind === "message"
+                    && previous.role === block.role
+                    && !(previous.header && previous.header.fromOtherPerson)
+                    && !showLabel);
+                return React.createElement(RichChatMessage, {
+                    key: block.id != null ? `msg:${block.id}` : `msg:${index}`,
+                    block,
+                    theme,
+                    controller,
+                    continued,
+                });
             }
-            return React.createElement("div", {
+            return React.createElement(RichChatLineBlock, {
                 key: `lines:${index}`,
-                className: `ps-rich-lineblock is-${block.variant || "event"}`,
-            }, React.createElement(StructuredChatBlocks, {
-                lines: normalizeLines(block.lines || []),
+                block,
                 theme,
                 controller,
-            }));
+            });
         }));
 }
 
@@ -3100,6 +3131,10 @@ function SessionDetailBox({ session, childCount = 0 }) {
         : (childCount > 0 ? String(childCount) : null);
 
     return React.createElement("div", { className: "ps-session-detail-box" },
+        // The row above ellipsizes to one line, so this is the only place the
+        // whole name is legible. Two lines are RESERVED whether or not they are
+        // used, so the box height still cannot move with the selection.
+        field("Title", session?.title, "is-title"),
         field("ID", session?.sessionId, "is-id"),
         field("Model", model),
         field("Context", context, percent != null && percent >= 85 ? "is-hot" : percent != null && percent >= 70 ? "is-warm" : ""),
@@ -3273,6 +3308,7 @@ function SessionPane({ controller, actions = null, panelClassName = "", structur
     const theme = getTheme(themeId);
     const sessionButtonRefs = React.useRef(new Map());
     const viewState = useControllerSelector(controller, (state) => ({
+        branding: state.branding,
         activeSessionId: state.sessions.activeSessionId,
         sessionsById: state.sessions.byId,
         sessionsFlat: state.sessions.flat,
@@ -3306,7 +3342,12 @@ function SessionPane({ controller, actions = null, panelClassName = "", structur
         connection: {
             mode: viewState.connectionMode,
         },
-    }), [viewState.activeSessionId, viewState.auth, viewState.connectionMode, viewState.filterQuery, viewState.ownerFilter, viewState.pinnedIds, viewState.selectedIds, viewState.selectMode, viewState.sessionsById, viewState.sessionsFlat]);
+        // The root system session renders as the deployment's branding title.
+        // Omitting this made the list fall back to "PilotSwarm" on a branded
+        // deployment, while the controller's own calls (which pass real state)
+        // produced the branded name.
+        branding: viewState.branding,
+    }), [viewState.activeSessionId, viewState.auth, viewState.branding, viewState.connectionMode, viewState.filterQuery, viewState.ownerFilter, viewState.pinnedIds, viewState.selectedIds, viewState.selectMode, viewState.sessionsById, viewState.sessionsFlat]);
     // Hold the previous rows when a poll produced identical output.
     const rows = useStableValue(computedRows);
     const activeSession = viewState.activeSessionId
@@ -4044,6 +4085,15 @@ function ChatPane({ controller, mobile = false, fullWidth = false, showComposer
         [animatedDots, chrome.animateTitleRight, chrome.titleRight],
     );
     const richMode = viewState.chatViewMode === "rich" && !viewState.activeSessionIsGroup;
+    const [loadingOlder, setLoadingOlder] = React.useState(false);
+    // Scroll-up expands the transcript automatically until the soft cap, then
+    // refuses — and the portal had no control to ask for more, so a busy
+    // session's history became unreachable from the browser. Surface the
+    // control exactly when the automatic path has given up.
+    const showLoadOlder = Boolean(
+        viewState.activeHistory?.hasOlderEvents
+        && Number(viewState.activeHistory?.loadedEventCount || 0) >= AUTO_HISTORY_EVENT_SOFT_CAP,
+    );
     const richBlocks = React.useMemo(
         () => (richMode ? selectChatBlocks(selectorState, viewState.contentWidth, { tableMode: "sentinel" }) : null),
         [richMode, selectorState, viewState.contentWidth],
@@ -4147,6 +4197,20 @@ function ChatPane({ controller, mobile = false, fullWidth = false, showComposer
         className: richMode ? "is-wrapped is-rich" : "is-wrapped",
         panelClassName: richMode ? "ps-chat-panel is-rich" : "ps-chat-panel",
         bottomContent: composer,
+        topContent: showLoadOlder
+            ? React.createElement("div", { className: "ps-load-older-bar" },
+                React.createElement("button", {
+                    type: "button",
+                    className: "ps-load-older-button",
+                    disabled: loadingOlder,
+                    onClick: () => {
+                        setLoadingOlder(true);
+                        controller.handleCommand(UI_COMMANDS.EXPAND_HISTORY)
+                            .catch(() => {})
+                            .finally(() => setLoadingOlder(false));
+                    },
+                }, loadingOlder ? "Loading older messages…" : "↑ Load older messages"))
+            : null,
         structuredBlocks: true,
         renderBody: richBlocks
             ? (_bodyLines, bodyTheme) => React.createElement(RichChatBlocks, {

package/web/dist/assets/{abnfDiagram-VRR7QNED-DOZGtiQC.js → abnfDiagram-VRR7QNED-oWxPJ_GQ.js}

@@ -1 +1 @@
-import{g as p,r as u,d as a}from"./chunk-MOJQB5TN-B-bgmTfa.js";import{p as f}from"./chunk-JWPE2WC7-D5reV4oK.js";import{_ as n,l as o}from"./mermaid.core-OUiCmXKB.js";import{M as c,b as d}from"./cynefin-VYW2F7L2-COwlV5eq.js";import"./pilotswarm-CU6jtK4w.js";var v=d().RailroadAbnf.parser.LangiumParser,i=n(e=>{const r=e.alternatives.map(g);return r.length===1?r[0]:{type:"choice",alternatives:r}},"transformAlternation"),g=n(e=>{const r=e.elements.map(y);return r.length===1?r[0]:{type:"sequence",elements:r}},"transformConcatenation"),b=n(e=>{if(e.includes("*")){const[t,s]=e.split("*"),l=t?parseInt(t,10):0,m=s?parseInt(s,10):1/0;return{min:l,max:m}}const r=parseInt(e,10);return{min:r,max:r}},"parseRepeat"),y=n(e=>{const r=A(e.primary);if(!e.repeat)return r;const{min:t,max:s}=b(e.repeat);return t===0&&s===1?{type:"optional",element:r}:{type:"repetition",element:r,min:t,max:s}},"transformElement"),A=n(e=>{switch(e.$type){case"AbnfStringLiteral":return{type:"terminal",value:e.value};case"AbnfNumVal":return{type:"terminal",value:e.value};case"AbnfRuleName":return{type:"nonterminal",name:e.name};case"AbnfGroup":return i(e.element);case"AbnfOptionalGroup":return{type:"optional",element:i(e.element)};default:throw new Error(`Unsupported ABNF primary node: ${e.$type}`)}},"transformPrimary"),P=n(e=>({name:e.name,definition:i(e.definition)}),"transformRule"),h=n(e=>{f(e,a),e.title&&a.setTitle(e.title),e.rules.map(r=>a.addRule(P(r)))},"populateDb"),R={parse:n(e=>{a.clear(),o.debug("[ABNF Parser] Starting Langium parse");const r=v.parse(e);if(r.lexerErrors.length>0||r.parserErrors.length>0)throw new c(r);const t=r.value;o.debug("[ABNF Parser] Parsed rules:",t.rules.length),h(t),o.debug("[ABNF Parser] Parse complete")},"parse"),parser:{yy:a}},B={parser:R,db:a,renderer:u,styles:p};export{B as diagram};
+import{g as p,r as u,d as a}from"./chunk-MOJQB5TN-D-6WLgUh.js";import{p as f}from"./chunk-JWPE2WC7-BuP_EUE9.js";import{_ as n,l as o}from"./mermaid.core-Dl9SNFGg.js";import{M as c,b as d}from"./cynefin-VYW2F7L2-7QQpYsvS.js";import"./pilotswarm-Bu5uSolS.js";var v=d().RailroadAbnf.parser.LangiumParser,i=n(e=>{const r=e.alternatives.map(g);return r.length===1?r[0]:{type:"choice",alternatives:r}},"transformAlternation"),g=n(e=>{const r=e.elements.map(y);return r.length===1?r[0]:{type:"sequence",elements:r}},"transformConcatenation"),b=n(e=>{if(e.includes("*")){const[t,s]=e.split("*"),l=t?parseInt(t,10):0,m=s?parseInt(s,10):1/0;return{min:l,max:m}}const r=parseInt(e,10);return{min:r,max:r}},"parseRepeat"),y=n(e=>{const r=A(e.primary);if(!e.repeat)return r;const{min:t,max:s}=b(e.repeat);return t===0&&s===1?{type:"optional",element:r}:{type:"repetition",element:r,min:t,max:s}},"transformElement"),A=n(e=>{switch(e.$type){case"AbnfStringLiteral":return{type:"terminal",value:e.value};case"AbnfNumVal":return{type:"terminal",value:e.value};case"AbnfRuleName":return{type:"nonterminal",name:e.name};case"AbnfGroup":return i(e.element);case"AbnfOptionalGroup":return{type:"optional",element:i(e.element)};default:throw new Error(`Unsupported ABNF primary node: ${e.$type}`)}},"transformPrimary"),P=n(e=>({name:e.name,definition:i(e.definition)}),"transformRule"),h=n(e=>{f(e,a),e.title&&a.setTitle(e.title),e.rules.map(r=>a.addRule(P(r)))},"populateDb"),R={parse:n(e=>{a.clear(),o.debug("[ABNF Parser] Starting Langium parse");const r=v.parse(e);if(r.lexerErrors.length>0||r.parserErrors.length>0)throw new c(r);const t=r.value;o.debug("[ABNF Parser] Parsed rules:",t.rules.length),h(t),o.debug("[ABNF Parser] Parse complete")},"parse"),parser:{yy:a}},B={parser:R,db:a,renderer:u,styles:p};export{B as diagram};