pilotswarm 0.5.25 → 0.5.27

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pilotswarm",
-    "version": "0.5.25",
+    "version": "0.5.27",
     "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

@@ -1070,6 +1070,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 +2305,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 +6156,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() {

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,46 @@ 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,
+        ];
+        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];
@@ -5320,7 +5366,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`;