pilotswarm 0.5.26 → 0.5.28

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pilotswarm",
-    "version": "0.5.26",
+    "version": "0.5.28",
     "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([
@@ -1070,6 +1075,19 @@ function normalizePreviewPayload(filename, rawContent, contentType = "", metadat
 
 /** How long a fetched artifact list is trusted before a refetch. */
 const FILES_LIST_TTL_MS = 10_000;
+// How long keyboard navigation must rest on a session before it is fetched.
+// Long enough that scrolling past a row costs nothing, short enough that
+// landing on one feels immediate.
+const SESSION_NAV_SETTLE_MS = 140;
+// Ceiling on the window a session re-opens with, in events (5 history pages).
+//
+// `loadedEventLimit` is sticky: scrolling back through a long session escalates
+// it 300 -> 1000 -> 3000 -> 10000, and ensureSessionHistory then re-requested
+// that expanded size on EVERY switch-in, for the life of the tab. So one trip
+// through the history of a busy session made it permanently expensive to open —
+// 10k events re-fetched, re-derived and re-laid-out each time. Paging back
+// still expands freely while you are in the session; re-entering starts bounded.
+const HISTORY_REENTRY_MAX_EVENTS = 1_500;
 
 export class PilotSwarmUiController {
     constructor({ store, transport }) {
@@ -2292,9 +2310,12 @@ export class PilotSwarmUiController {
     async ensureSessionHistory(sessionId, { force = false } = {}) {
         if (!sessionId) return null;
         const existingHistory = this.getState().history.bySessionId.get(sessionId);
-        const requestedLimit = Math.max(
-            DEFAULT_HISTORY_EVENT_LIMIT,
-            Number(existingHistory?.loadedEventLimit ?? DEFAULT_HISTORY_EVENT_LIMIT) || DEFAULT_HISTORY_EVENT_LIMIT,
+        const requestedLimit = Math.min(
+            HISTORY_REENTRY_MAX_EVENTS,
+            Math.max(
+                DEFAULT_HISTORY_EVENT_LIMIT,
+                Number(existingHistory?.loadedEventLimit ?? DEFAULT_HISTORY_EVENT_LIMIT) || DEFAULT_HISTORY_EVENT_LIMIT,
+            ),
         );
         if (!force && existingHistory?.events) {
             return existingHistory;
@@ -6140,7 +6161,36 @@ export class PilotSwarmUiController {
         const currentIndex = Math.max(0, rows.findIndex((row) => row.sessionId === currentId));
         const nextIndex = Math.max(0, Math.min(rows.length - 1, currentIndex + delta));
         const nextId = rows[nextIndex].sessionId;
-        await this.loadSession(nextId);
+        this.navigateToSession(nextId);
+    }
+
+    /**
+     * Move the selection now; fetch the session once the movement settles.
+     *
+     * `loadSession` force-refetches history, syncs detail, re-attaches the live
+     * event stream and refreshes the inspector — four round trips. Driving that
+     * from every keypress meant scrolling a list of sessions fired a request
+     * pair per row, and against a remote deployment the UI ran behind the
+     * cursor by however long the network took. The highlight is local state and
+     * moves immediately; only the fetching waits for the user to stop.
+     *
+     * A CLICK still loads immediately — that is a deliberate choice of one
+     * session, not a scroll through many.
+     */
+    navigateToSession(sessionId) {
+        if (!sessionId) return;
+        if (this.getState().sessions.activeSessionId !== sessionId) {
+            this.dispatch({ type: "sessions/selected", sessionId });
+            // Same per-session reset loadSession does, so the sequence tab does
+            // not show another session's turn while the fetch is pending.
+            this.dispatch({ type: "ui/sequenceExpandedTurns", turns: [] });
+            this.dispatch({ type: "ui/sequenceSelectedTurn", turn: null });
+        }
+        if (this.sessionNavSettleTimer) clearTimeout(this.sessionNavSettleTimer);
+        this.sessionNavSettleTimer = setTimeout(() => {
+            this.sessionNavSettleTimer = null;
+            this.loadSession(sessionId).catch(() => {});
+        }, SESSION_NAV_SETTLE_MS);
     }
 
     getSessionPageSize() {
@@ -6283,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/selectors.js

@@ -509,7 +509,7 @@ function getCollapseBadge(sessionId, entry, totalDescendantCounts, visibleDescen
     return { text: `[+${badgeCount}]`, color: "cyan" };
 }
 
-function formatCronTimestampForClient(value) {
+export function formatCronTimestampForClient(value) {
     if (!value) return "scheduled";
     const date = value instanceof Date ? value : new Date(value);
     if (Number.isNaN(date.getTime())) return "scheduled";
@@ -771,6 +771,14 @@ function buildSessionRowView(entry, session, state, totalDescendantCounts, visib
         badgeRuns: [],
         selectedMetaRuns: detailRuns,
         detailRuns,
+        // Total descendants, for renderers that want the real number rather
+        // than the collapse badge (which counts only HIDDEN children, so it is
+        // null whenever the subtree is expanded).
+        // NOTE: `detailRuns` above computes its own childCount by indexing this
+        // Map with brackets, which always yields undefined — so its "N children"
+        // segment has never rendered. Left alone deliberately: fixing it would
+        // change TUI and mobile output.
+        childCount: totalDescendantCounts?.get?.(session?.sessionId) || 0,
         // 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
@@ -840,6 +848,23 @@ function collectFilterExceptionIds(sessions) {
     return ids;
 }
 
+// Per-row memo, keyed by the `flat` list so it survives selection changes but
+// resets whenever the tree itself is rebuilt.
+//
+// WHY: moving the selection re-runs this selector (once from moveSession, once
+// from the portal's useMemo) and used to rebuild EVERY row — including
+// flattenRunsText over each row's runs — to change one boolean on two of them.
+// At fleet scale that is the cost of a keypress. Now only rows whose inputs
+// actually moved are rebuilt, and the rest keep their previous object
+// identity, which also lets the renderer skip them.
+const sessionRowMemo = new WeakMap();
+
+function sameRowDeps(a, b) {
+    if (!a || a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i += 1) if (a[i] !== b[i]) return false;
+    return true;
+}
+
 export function selectSessionRows(state) {
     const totalDescendantCounts = getTotalDescendantCounts(state.sessions.byId);
     const visibleDescendantCounts = getVisibleDescendantCounts(state.sessions.flat, state.sessions.byId);
@@ -850,25 +875,52 @@ export function selectSessionRows(state) {
     const selectedSet = new Set(Array.isArray(state.sessions?.selectedIds) ? state.sessions.selectedIds : []);
     const filterExceptionIds = collectFilterExceptionIds(state.sessions);
 
+    let memo = sessionRowMemo.get(state.sessions.flat);
+    if (!memo) {
+        memo = new Map();
+        sessionRowMemo.set(state.sessions.flat, memo);
+    }
+
     return state.sessions.flat.map((entry) => {
         const session = state.sessions.byId[entry.sessionId];
+        const active = entry.sessionId === state.sessions.activeSessionId;
+        const pinned = pinnedSet.has(entry.sessionId);
+        const selected = selectedSet.has(entry.sessionId);
+        // Every input the row below is derived from. Identity comparison is
+        // enough: the reducer replaces these objects rather than mutating them.
+        const deps = [
+            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;
+
         const rowView = buildSessionRowView(entry, session, state, totalDescendantCounts, visibleDescendantCounts);
-        return {
+        const row = {
             sessionId: entry.sessionId,
             text: flattenRunsText(rowView.runs),
             ...rowView,
             depth: entry.depth,
             status: session?.status,
             statusColor: sessionStatusColor(session, state.connection?.mode || "local"),
-            active: entry.sessionId === state.sessions.activeSessionId,
+            active,
             isSystem: Boolean(session?.isSystem),
             isGroup: Boolean(session?.isGroup),
             hasChildren: entry.hasChildren,
             collapsed: entry.collapsed,
-            pinned: pinnedSet.has(entry.sessionId),
-            selected: selectedSet.has(entry.sessionId),
+            pinned,
+            selected,
             canPin: canPinSessionRow(session),
         };
+        memo.set(entry.sessionId, { deps, row });
+        return row;
     }).filter((row) => {
         if (filterExceptionIds?.has(row.sessionId)) return true;
         const session = state.sessions.byId[row.sessionId];
@@ -2356,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
@@ -2403,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)
@@ -2440,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 [];
@@ -2461,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;
@@ -2474,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,
@@ -2486,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
@@ -5320,7 +5572,7 @@ export function selectArtifactPickerModal(state, maxWidth = 88) {
 
 // ── Stats Inspector Pane ────────────────────────────────────────────
 
-function formatCompactNumber(n) {
+export function formatCompactNumber(n) {
     if (n == null || !Number.isFinite(n)) return "0";
     if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
     if (n >= 10_000) return `${(n / 1_000).toFixed(1)}K`;