pilotswarm 0.5.36 → 0.5.38

package/ui/core/src/history.js

@@ -1,4 +1,5 @@
 import { formatHumanDurationSeconds, formatTimestamp, shortSessionId, stripTerminalMarkupTags, summarizeJson } from "./formatting.js";
+import { isCanvasActionContent, parseCanvasActionContent } from "./canvas-actions.js";
 import { formatCompactionActivityRuns } from "./context-usage.js";
 import { canonicalSystemTitle } from "./system-titles.js";
 
@@ -30,6 +31,9 @@ export const CHAT_HISTORY_EVENT_TYPES = [
     // silently never flipped. Observed live — two attempts died on
     // ARTIFACT_TOO_LARGE with nothing shown in the transcript.
     "session.regenerate_failed",
+    // Canvas revisions — kept in backward chat paging so the TUI's artifact
+    // link line survives history loads (the portal skips the line either way).
+    "session.canvas_updated",
 ];
 
 // Build the inline transcript divider marking a session-regeneration epoch
@@ -379,6 +383,13 @@ function sharesClientMessageId(left, right) {
 function areMessagesEquivalent(left, right) {
     if (!left || !right) return false;
     if (left.role !== right.role) return false;
+    // Canvas revision lines are platform-minted, exactly-once (one durable
+    // event per rev), and share identical text by design (the artifact://
+    // link) — the redelivery time-window below would eat rev N-1 on every
+    // reload, making the transcript disagree with what live append showed.
+    if (left.kind === "canvas-update" || right.kind === "canvas-update") {
+        return left.kind === right.kind && left.id === right.id;
+    }
 
     const leftText = comparableMessageText(left);
     const rightText = comparableMessageText(right);
@@ -458,6 +469,33 @@ function buildChatMessage(event, role) {
     const sessionMessageCard = buildSessionMessageChatCard(event, rawText);
     if (sessionMessageCard) return sessionMessageCard;
 
+    // A structured canvas response — the browser sent it on the viewer's
+    // behalf after validating it against the drawn contract. One item shape
+    // from ONE builder, so bulk load and live append cannot disagree. The
+    // portal chat hides it (the redraw is the visible half of the loop);
+    // the TUI shows a compact line.
+    if (role === "user" && isCanvasActionContent(rawText)) {
+        const parsed = parseCanvasActionContent(rawText);
+        if (parsed) {
+            return {
+                id: `${event.sessionId}:${event.seq}`,
+                kind: "canvas-action",
+                role: "user",
+                action: parsed.action,
+                data: parsed.data,
+                text: rawText,
+                time: formatTimestamp(event.createdAt),
+                createdAt: event.createdAt instanceof Date ? event.createdAt.getTime() : new Date(event.createdAt).getTime(),
+                // Without the ids, the distinct-ids rule can never fire and two
+                // genuine same-payload submissions within 10s collapse to one
+                // falsely-"redelivered" bubble while the activity feed shows two.
+                ...(Array.isArray(event?.data?.clientMessageIds) && event.data.clientMessageIds.length > 0
+                    ? { clientMessageIds: event.data.clientMessageIds }
+                    : {}),
+            };
+        }
+    }
+
     const text = stripLeadingSenderMarker(extractVisibleChatText(rawText, role));
     if (!hasVisibleMessageText(text)) return null;
     const clientMessageIds = Array.isArray(event?.data?.clientMessageIds)
@@ -711,6 +749,31 @@ function formatActivity(event) {
             break;
         }
 
+        case "session.canvas_updated": {
+            const data = (event?.data ?? {}) || {};
+            const rev = Number(data.rev) || 0;
+            const note = typeof data.note === "string" && data.note.trim() ? ` — ${data.note.trim()}` : "";
+            // Server-side artifact draws record their source; surfacing it here
+            // distinguishes "rendered the stored app" from an inline redraw the
+            // same honest way ticks are distinguished from draws.
+            const sourceName = typeof data.source?.filename === "string" && data.source.filename.trim()
+                ? ` from ${data.source.filename.trim()}`
+                : "";
+            runs = buildLabeledActivityRuns(time, "[canvas]", "cyan", `rev ${rev}${sourceName}${note}`, "white");
+            break;
+        }
+
+        case "session.canvas_data": {
+            // A data TICK, deliberately distinct from a full redraw: the page
+            // patched itself in place; no document was replaced.
+            const data = (event?.data ?? {}) || {};
+            const dataRev = Number(data.dataRev) || 0;
+            const kb = Number.isFinite(Number(data.sizeBytes)) ? ` (${(Number(data.sizeBytes) / 1024).toFixed(1)} KB)` : "";
+            const note = typeof data.note === "string" && data.note.trim() ? ` — ${data.note.trim()}` : "";
+            runs = buildLabeledActivityRuns(time, "[canvas]", "cyan", `data tick ${dataRev}${kb}${note}`, "white");
+            break;
+        }
+
         case "tool.execution_start":
             runs = formatToolActivityRuns(time, event, "start");
             break;
@@ -934,6 +997,43 @@ export function getNextHistoryEventLimit(currentLimit = DEFAULT_HISTORY_EVENT_LI
     return nextLimit || Math.min(100_000, safeCurrent * 2);
 }
 
+/**
+ * The canvas event's chat item, shared verbatim by the bulk loader and the
+ * live append path — a reload must not change the transcript. `text` carries
+ * the bare artifact URI because the TUI's press-a picker extracts
+ * `artifact://` links from message text; the rendered line builds its own
+ * runs and never shows this string.
+ */
+function buildCanvasChatItem(event) {
+    const sessionId = event.sessionId || null;
+    return {
+        id: `${event.sessionId || ""}:${event.seq}:canvas`,
+        kind: "canvas-update",
+        role: "canvas-update",
+        sessionId,
+        rev: Number(event?.data?.rev) || 0,
+        note: typeof event?.data?.note === "string" ? event.data.note : "",
+        text: sessionId ? `artifact://${sessionId}/canvas.html` : "",
+        createdAt: event.createdAt instanceof Date ? event.createdAt.getTime() : new Date(event.createdAt).getTime(),
+    };
+}
+
+/** The diagnostic feed line for a validated canvas response. */
+function buildCanvasActionActivity(event, item) {
+    const time = formatTimestamp(event.createdAt);
+    const detail = `action ${item.action}${Object.keys(item.data || {}).length ? " " + summarizeJson(item.data) : ""}`;
+    const runs = buildLabeledActivityRuns(time, "[canvas]", "cyan", detail, "white");
+    return {
+        id: `${event.sessionId}:${event.seq}:canvas-action`,
+        eventType: event.eventType,
+        time,
+        seq: Number.isFinite(Number(event?.seq)) ? Number(event.seq) : 0,
+        createdAt: event.createdAt instanceof Date ? event.createdAt.getTime() : new Date(event.createdAt).getTime(),
+        text: flattenRunsText(runs),
+        line: runs,
+    };
+}
+
 export function buildHistoryModel(events = [], options = {}) {
     const requestedLimit = Math.max(
         DEFAULT_HISTORY_EVENT_LIMIT,
@@ -949,6 +1049,23 @@ export function buildHistoryModel(events = [], options = {}) {
             activity.push(...buildEmbeddedSystemNoticeActivityItems(event, "user"));
             const message = buildChatMessage(event, "user");
             if (message) chat.push(message);
+            if (message?.kind === "canvas-action") {
+                const actionActivity = buildCanvasActionActivity(event, message);
+                if (actionActivity) activity.push(actionActivity);
+            }
+            continue;
+        }
+        if (event.eventType === "session.canvas_updated") {
+            // A flagged chat item, not a plain message: the PORTAL chat skips
+            // it entirely (the canvas pane updating is the signal there),
+            // while the TUI — which cannot render the canvas — shows it as an
+            // ordinary artifact link. Shared data, host-chosen affordance,
+            // same precedent as the download hint. `text` carries the bare
+            // artifact URI for the TUI's press-a picker, which extracts
+            // `artifact://` links from message text.
+            chat.push(buildCanvasChatItem(event));
+            const activityItem = formatActivity(event);
+            if (activityItem) activity.push(activityItem);
             continue;
         }
         if (event.eventType === "assistant.message") {
@@ -1038,8 +1155,12 @@ export function appendEventToHistory(history, event) {
 
     if (event.eventType === "user.message") {
         next.activity.push(...buildEmbeddedSystemNoticeActivityItems(event, "user"));
-        next.activity = clampHistoryItems(next.activity, loadedEventLimit);
         const message = buildChatMessage(event, "user");
+        if (message?.kind === "canvas-action") {
+            const actionActivity = buildCanvasActionActivity(event, message);
+            if (actionActivity) next.activity.push(actionActivity);
+        }
+        next.activity = clampHistoryItems(next.activity, loadedEventLimit);
         if (!message) return next;
         // Prospective flag: covers a bulk load where the stop event arrived
         // before this message in the reduce order.
@@ -1052,6 +1173,18 @@ export function appendEventToHistory(history, event) {
         next.chat = clampHistoryItems(dedupeChatMessages(next.chat), loadedEventLimit);
         return next;
     }
+    if (event.eventType === "session.canvas_updated") {
+        // Same flagged chat item the bulk loader builds — the live path and
+        // the history path must agree or a reload would change the transcript.
+        next.chat.push(buildCanvasChatItem(event));
+        next.chat = clampHistoryItems(next.chat, loadedEventLimit);
+        const canvasActivity = formatActivity(event);
+        if (canvasActivity) {
+            next.activity.push(canvasActivity);
+            next.activity = clampHistoryItems(next.activity, loadedEventLimit);
+        }
+        return next;
+    }
     if (event.eventType === "assistant.message") {
         next.activity.push(...buildEmbeddedSystemNoticeActivityItems(event, "assistant"));
         next.activity = clampHistoryItems(next.activity, loadedEventLimit);

package/ui/core/src/index.js

@@ -13,3 +13,4 @@ export * from "./selectors.js";
 export * from "./controller.js";
 export { isThemeLight } from "./themes/helpers.js";
 export * from "./themes/index.js";
+export { validateCanvasAction, formatCanvasActionPrompt, parseCanvasActionContent, isCanvasActionContent, createCanvasActionLimiter, CANVAS_ACTION_PREFIX } from "./canvas-actions.js";

package/ui/core/src/reducer.js

@@ -8,7 +8,11 @@ import {
     normalizeArtifactEntries,
     normalizeSessionOwnerFilter,
     normalizeStoredActiveSessionId,
+    normalizeStoredCanvasPrefs,
+    canvasKey,
+    parseCanvasKey,
     normalizeStoredCollapsedSessionIds,
+    normalizeStoredDesktopPanes,
     normalizeStoredLayoutAdjustments,
     normalizeStoredPinnedSessionIds,
     normalizeStoredSessionOrder,
@@ -87,6 +91,44 @@ function prunePinnedIds(ids, byId) {
     return out;
 }
 
+/**
+ * Fold a freshly applied profile's canvasPrefs over the local map. Two rules:
+ *
+ * - `lastViewedRev` merges by MAX. A poll snapshotted before a local view and
+ *   applied after must not regress what this window has already seen — same
+ *   monotonicity the revision counter itself keeps.
+ * - Entries prune like pins: absent-from-listing proves nothing (the listing
+ *   is paged), but a session PRESENT as a child or group can never have a
+ *   canvas, and a default-valued entry ({optedOut:false, lastViewedRev:0})
+ *   says nothing worth storing. Both drop, which is what keeps the map from
+ *   growing one dead key per session forever.
+ */
+function mergeCanvasPrefs(local, stored, byId) {
+    const out = {};
+    const keys = new Set([...Object.keys(stored || {}), ...Object.keys(local || {})]);
+    for (const sessionId of keys) {
+        const storedEntry = (stored || {})[sessionId];
+        const localEntry = (local || {})[sessionId];
+        const merged = {
+            // A local-only entry (viewed since the poll was snapshotted) must
+            // survive the apply — dropping it un-views what this window saw.
+            optedOut: storedEntry ? storedEntry.optedOut : Boolean(localEntry?.optedOut),
+            lastViewedRev: Math.max(storedEntry?.lastViewedRev || 0, localEntry?.lastViewedRev || 0),
+            lastViewedDataRev: Math.max(storedEntry?.lastViewedDataRev || 0, localEntry?.lastViewedDataRev || 0),
+            // Latest write wins is unknowable here; the local value is the one
+            // this window just dragged, so it outranks the poll.
+            ...((localEntry?.zenRailPx || storedEntry?.zenRailPx)
+                ? { zenRailPx: localEntry?.zenRailPx || storedEntry?.zenRailPx }
+                : {}),
+        };
+        if (!merged.optedOut && merged.lastViewedRev === 0 && merged.lastViewedDataRev === 0 && !merged.zenRailPx) continue;
+        const session = byId?.[parseCanvasKey(sessionId).sessionId];
+        if (session && session.isGroup) continue;
+        out[sessionId] = merged;
+    }
+    return out;
+}
+
 
 /**
  * Keep a collapse flag unless the session is genuinely gone.
@@ -772,8 +814,20 @@ export function appReducer(state, action) {
             // say "rich" fall through to the transcript below.
             const hasTouchScale = Object.prototype.hasOwnProperty.call(settings, "touchScale")
                 && typeof settings.touchScale === "boolean";
-            const hasChatViewMode = Object.prototype.hasOwnProperty.call(settings, "chatViewMode")
-                && (settings.chatViewMode === "summary" || settings.chatViewMode === "transcript");
+            const hasRightPaneMode = Object.prototype.hasOwnProperty.call(settings, "rightPaneMode")
+                && (settings.rightPaneMode === "canvas" || settings.rightPaneMode === "panes");
+            // The two independent columns. A profile written by a build that
+            // predates them carries only rightPaneMode, so fall back to
+            // migrating that — see normalizeStoredDesktopPanes.
+            const hasDesktopPanes = Object.prototype.hasOwnProperty.call(settings, "desktopPanes")
+                && settings.desktopPanes && typeof settings.desktopPanes === "object";
+            const nextDesktopPanes = (hasDesktopPanes || hasRightPaneMode)
+                ? normalizeStoredDesktopPanes(
+                    hasDesktopPanes ? settings.desktopPanes : null,
+                    hasRightPaneMode ? settings.rightPaneMode : null,
+                )
+                : null;
+            const hasCanvasPrefs = Object.prototype.hasOwnProperty.call(settings, "canvasPrefs");
             const hasPins = Object.prototype.hasOwnProperty.call(settings, "pinnedSessionIds");
             const hasCollapsed = Object.prototype.hasOwnProperty.call(settings, "collapsedSessionIds");
             const hasSessionOrder = Object.prototype.hasOwnProperty.call(settings, "sessionOrder");
@@ -836,28 +890,18 @@ export function appReducer(state, action) {
                     ...selection.ui,
                     themeId: hasTheme ? settings.themeId.trim() : selection.ui.themeId,
                     touchScale: hasTouchScale ? settings.touchScale : selection.ui.touchScale,
-                    chatViewMode: hasChatViewMode ? settings.chatViewMode : selection.ui.chatViewMode,
+                    rightPaneMode: hasRightPaneMode ? settings.rightPaneMode : selection.ui.rightPaneMode,
+                    ...(nextDesktopPanes
+                        ? { canvasOpen: nextDesktopPanes.canvasOpen, diagnosticsOpen: nextDesktopPanes.diagnosticsOpen, canvasZen: nextDesktopPanes.zen === true }
+                        : {}),
                     layout: nextLayout,
                 },
+                canvas: hasCanvasPrefs
+                    ? { ...state.canvas, prefs: mergeCanvasPrefs(state.canvas.prefs, normalizeStoredCanvasPrefs(settings.canvasPrefs), hasLoadedSessions ? state.sessions.byId : null) }
+                    : state.canvas,
             };
         }
 
-        case "ui/chatViewMode":
-            if (action.mode !== "summary" && action.mode !== "transcript") {
-                return state;
-            }
-            return {
-                ...state,
-                ui: {
-                    ...state.ui,
-                    chatViewMode: action.mode,
-                    scroll: {
-                        ...state.ui.scroll,
-                        chat: 0,
-                    },
-                },
-            };
-
         case "ui/modal":
             return {
                 ...state,
@@ -924,6 +968,46 @@ export function appReducer(state, action) {
                 },
             };
 
+        // Where the canvas/diagnostics seam sits when both columns are open.
+        // A pixel delta from an even split of the right side, like the other
+        // adjusts. Closing a column is a separate action — see
+        // CanvasDiagnosticsResizeHandle, which decides that on release.
+        case "ui/canvasPaneAdjust":
+            return {
+                ...state,
+                ui: {
+                    ...state.ui,
+                    layout: {
+                        ...(state.ui.layout || {}),
+                        canvasPaneAdjust: Number(action.canvasPaneAdjust) || 0,
+                    },
+                },
+            };
+
+        case "ui/diagnosticsSplitAdjust":
+            return {
+                ...state,
+                ui: {
+                    ...state.ui,
+                    layout: {
+                        ...(state.ui.layout || {}),
+                        diagnosticsSplitAdjust: Number(action.diagnosticsSplitAdjust) || 0,
+                    },
+                },
+            };
+
+        case "ui/diagnosticsPaneAdjust":
+            return {
+                ...state,
+                ui: {
+                    ...state.ui,
+                    layout: {
+                        ...(state.ui.layout || {}),
+                        diagnosticsPaneAdjust: Number(action.diagnosticsPaneAdjust) || 0,
+                    },
+                },
+            };
+
         case "ui/activityPaneAdjust":
             return {
                 ...state,
@@ -2587,6 +2671,310 @@ export function appReducer(state, action) {
                 },
             };
 
+        // ── Canvas ──────────────────────────────────────────────────────
+        // The right column's mode plus the per-session attention state that
+        // decides flip-vs-badge. Viewed-marking deliberately does NOT live in
+        // these mode transitions: only the rendering surface knows what is
+        // actually on screen, so `canvas/viewed` is dispatched by the canvas
+        // pane when a revision really displays. Inferring "viewed" from mode
+        // changes marked revs seen on a phone whose layout never showed the
+        // pane, and left session-switches-while-in-canvas-mode unviewed.
+        //   - entering canvas mode is always a user gesture → clears opt-out
+        //   - a MANUAL switch away records the opt-out (future draws badge)
+        //   - `canvas/flip` is the agent-driven variant: same mode change,
+        //     plus a flipSeq tick that hosts with their own pane state (the
+        //     phone's tab strip) listen to
+        case "ui/rightPaneMode": {
+            const mode = action.mode === "canvas" ? "canvas" : "panes";
+            const sessionId = action.sessionId || state.sessions.activeSessionId || null;
+            let prefs = state.canvas.prefs;
+            if (sessionId) {
+                const prev = prefs[sessionId] || { optedOut: false, lastViewedRev: 0 };
+                if (mode === "canvas" && prev.optedOut) {
+                    // Coming back by hand un-opts-out: the user has shown the
+                    // canvas is welcome again, so future draws may flip.
+                    prefs = { ...prefs, [sessionId]: { ...prev, optedOut: false } };
+                } else if (mode === "panes" && action.manual && !prev.optedOut) {
+                    prefs = { ...prefs, [sessionId]: { ...prev, optedOut: true } };
+                }
+            }
+            return {
+                ...state,
+                ui: { ...state.ui, rightPaneMode: mode, canvasOpen: mode === "canvas" },
+                canvas: { ...state.canvas, prefs },
+            };
+        }
+
+        // Canvas as a column of its own. Same opt-out bookkeeping as the old
+        // mode switch above — closing by hand still says "do not flip me back",
+        // opening by hand still withdraws that — but closing the canvas no
+        // longer implies showing anything else, because Diagnostics is now a
+        // separate column with its own toggle.
+        //
+        // `open` may be omitted to mean "toggle".
+        case "ui/canvasOpen": {
+            const open = typeof action.open === "boolean" ? action.open : !state.ui.canvasOpen;
+            const sessionId = action.sessionId || state.sessions.activeSessionId || null;
+            let prefs = state.canvas.prefs;
+            if (sessionId) {
+                const prev = prefs[sessionId] || { optedOut: false, lastViewedRev: 0 };
+                if (open && prev.optedOut) {
+                    prefs = { ...prefs, [sessionId]: { ...prev, optedOut: false } };
+                } else if (!open && action.manual && !prev.optedOut) {
+                    prefs = { ...prefs, [sessionId]: { ...prev, optedOut: true } };
+                }
+            }
+            return {
+                ...state,
+                // rightPaneMode is kept in step for anything still reading it.
+                // Closing always drops full screen: otherwise the next open
+                // comes back covering the workspace with no warning.
+                ui: {
+                    ...state.ui,
+                    canvasOpen: open,
+                    rightPaneMode: open ? "canvas" : "panes",
+                    ...(open ? {} : { canvasMaximized: false, canvasZen: false }),
+                },
+                canvas: { ...state.canvas, prefs },
+            };
+        }
+
+        // Diagnostics — today's Inspector + Activity, travelling as one column.
+        // No canvas bookkeeping: it has nothing to do with the canvas, which is
+        // the whole point of splitting the old enum in two.
+        // Zen: sessions hidden, chat a narrow rail, canvas the workbench.
+        // Turning it on opens the canvas; it means nothing without one.
+        case "ui/canvasZen": {
+            const on = typeof action.on === "boolean" ? action.on : !state.ui.canvasZen;
+            if (on === Boolean(state.ui.canvasZen)) return state;
+            return {
+                ...state,
+                ui: { ...state.ui, canvasZen: on, ...(on ? { canvasOpen: true, rightPaneMode: "canvas" } : {}) },
+            };
+        }
+
+        // The zen chat-rail width for one session. Clamped so a wild drag can
+        // never wedge the rail off screen or crush the canvas.
+        case "canvas/zenRail": {
+            const sessionId = String(action.sessionId || "").trim();
+            const px = Number(action.px);
+            if (!sessionId || !Number.isFinite(px)) return state;
+            const prev = state.canvas.prefs[sessionId] || { optedOut: false, lastViewedRev: 0 };
+            const clamped = Math.max(260, Math.min(720, Math.round(px)));
+            return {
+                ...state,
+                canvas: { ...state.canvas, prefs: { ...state.canvas.prefs, [sessionId]: { ...prev, zenRailPx: clamped } } },
+            };
+        }
+
+        // Full-screen canvas. The header stays put and the canvas covers the
+        // workspace below it, so there is always a way back.
+        case "ui/canvasMaximized": {
+            const on = typeof action.on === "boolean" ? action.on : !state.ui.canvasMaximized;
+            if (on === Boolean(state.ui.canvasMaximized)) return state;
+            return { ...state, ui: { ...state.ui, canvasMaximized: on } };
+        }
+
+        case "ui/diagnosticsOpen": {
+            const open = typeof action.open === "boolean" ? action.open : !state.ui.diagnosticsOpen;
+            if (open === state.ui.diagnosticsOpen) return state;
+            return { ...state, ui: { ...state.ui, diagnosticsOpen: open } };
+        }
+
+        // The agent-driven flip. The guards (active session, freshness,
+        // opt-out) live in the controller; by the time this dispatches the
+        // flip is decided. flipSeq ticks even when the mode is already
+        // "canvas" — a phone can be off the canvas tab while the persisted
+        // mode still says canvas, and the tick is what brings its tab back.
+        case "canvas/flip": {
+            const slot = Number.isInteger(Number(action.slot)) && Number(action.slot) >= 1 && Number(action.slot) <= 5
+                ? Number(action.slot) : 1;
+            return {
+                ...state,
+                // Opens the canvas column ON THE SLOT THAT DREW; leaves
+                // Diagnostics exactly as the user left it. An agent drawing
+                // must not close their panels.
+                ui: { ...state.ui, rightPaneMode: "canvas", canvasOpen: true, canvasSlot: slot },
+                canvas: { ...state.canvas, flipSeq: (state.canvas.flipSeq || 0) + 1 },
+            };
+        }
+
+        // Which of the active session's canvases the pane shows. In-memory
+        // only: a reload lands on slot 1 (or wherever the next flip points).
+        case "ui/canvasSlot": {
+            const slot = Number.isInteger(Number(action.slot)) && Number(action.slot) >= 1 && Number(action.slot) <= 5
+                ? Number(action.slot) : 1;
+            if (slot === (state.ui.canvasSlot || 1)) return state;
+            return { ...state, ui: { ...state.ui, canvasSlot: slot } };
+        }
+
+        // The surface's receipt: revision `rev` (a draw) and/or `dataRev` (a
+        // tick) actually rendered on screen. Both feed the unseen badge.
+        case "canvas/viewed": {
+            const sessionId = String(action.sessionId || "").trim();
+            if (!sessionId) return state;
+            const rev = Number(action.rev);
+            const dataRev = Number(action.dataRev);
+            const key = canvasKey(sessionId, action.slot);
+            const prev = state.canvas.prefs[key] || { optedOut: false, lastViewedRev: 0, lastViewedDataRev: 0 };
+            const nextRev = Number.isFinite(rev) && rev > (prev.lastViewedRev || 0) ? rev : (prev.lastViewedRev || 0);
+            const nextDataRev = Number.isFinite(dataRev) && dataRev > (prev.lastViewedDataRev || 0) ? dataRev : (prev.lastViewedDataRev || 0);
+            if (nextRev === (prev.lastViewedRev || 0) && nextDataRev === (prev.lastViewedDataRev || 0)) return state;
+            return {
+                ...state,
+                canvas: {
+                    ...state.canvas,
+                    prefs: { ...state.canvas.prefs, [key]: { ...prev, lastViewedRev: nextRev, lastViewedDataRev: nextDataRev } },
+                },
+            };
+        }
+
+        // The sessions-list seed: rev+name per slot from session_canvases,
+        // merged under the live entries. Never regresses a rev a live event
+        // already delivered, never sets snapshotLoaded (the full snapshot —
+        // note, contract, data replay — still loads on selection).
+        case "canvas/seed": {
+            const entries = Array.isArray(action.entries) ? action.entries : [];
+            if (!entries.length) return state;
+            let next = null;
+            for (const e of entries) {
+                const sessionId = String(e?.sessionId || "").trim();
+                const rev = Number(e?.latestRev);
+                const slotN = Number(e?.slot);
+                if (!sessionId || !Number.isFinite(rev) || rev <= 0) continue;
+                if (!Number.isInteger(slotN) || slotN < 1 || slotN > 5) continue;
+                const key = canvasKey(sessionId, slotN);
+                const existing = (next || state.canvas.bySessionId)[key] || {};
+                if ((existing.latestRev || 0) >= rev && existing.name !== undefined) continue;
+                next = next || { ...state.canvas.bySessionId };
+                next[key] = {
+                    ...existing,
+                    slot: slotN,
+                    latestRev: Math.max(existing.latestRev || 0, rev),
+                    ...(typeof e.name === "string" && existing.name === undefined ? { name: e.name } : {}),
+                    ...(existing.sizeBytes === undefined && e.sizeBytes !== undefined ? { sizeBytes: e.sizeBytes } : {}),
+                };
+            }
+            if (!next) return state;
+            return { ...state, canvas: { ...state.canvas, bySessionId: next } };
+        }
+
+        case "canvas/updated": {
+            const sessionId = String(action.sessionId || "").trim();
+            const rev = Number(action.rev);
+            if (!sessionId || !Number.isFinite(rev) || rev <= 0) return state;
+            const slot = Number.isInteger(Number(action.slot)) && Number(action.slot) >= 1 && Number(action.slot) <= 5
+                ? Number(action.slot) : 1;
+            const key = canvasKey(sessionId, slot);
+            const existing = state.canvas.bySessionId[key] || {};
+            // Monotonic: replays and out-of-order merges must never regress
+            // the known revision (freshness gates the FLIP, never the data).
+            if ((existing.latestRev || 0) >= rev) return state;
+            return {
+                ...state,
+                canvas: {
+                    ...state.canvas,
+                    bySessionId: {
+                        ...state.canvas.bySessionId,
+                        [key]: {
+                            ...existing,
+                            slot,
+                            ...(typeof action.name === "string" ? { name: action.name } : {}),
+                            latestRev: rev,
+                            note: typeof action.note === "string" ? action.note : "",
+                            sizeBytes: Number.isFinite(Number(action.sizeBytes)) ? Number(action.sizeBytes) : null,
+                            // The contract belongs to the revision: a draw
+                            // without one REVOKES interactivity (default
+                            // closed), so no carry-over from the previous rev.
+                            responseContract: action.responseContract && typeof action.responseContract === "object"
+                                ? action.responseContract
+                                : null,
+                        },
+                    },
+                },
+            };
+        }
+
+        // A data tick: content for the page, in place. Never flips (ticks do
+        // not interrupt) — but it DOES count toward the unseen badge via
+        // latestDataRev vs lastViewedDataRev. Monotonic like the draw rev.
+        case "canvas/data": {
+            const sessionId = String(action.sessionId || "").trim();
+            const slot = Number.isInteger(Number(action.slot)) && Number(action.slot) >= 1 && Number(action.slot) <= 5
+                ? Number(action.slot) : 1;
+            const key = canvasKey(sessionId, slot);
+            const dataRev = Number(action.dataRev);
+            if (!sessionId || !Number.isFinite(dataRev) || dataRev <= 0) return state;
+            const existing = state.canvas.bySessionId[key] || {};
+            if ((existing.latestDataRev || 0) >= dataRev) return state;
+            return {
+                ...state,
+                canvas: {
+                    ...state.canvas,
+                    bySessionId: {
+                        ...state.canvas.bySessionId,
+                        [key]: {
+                            ...existing,
+                            latestDataRev: dataRev,
+                            dataPayload: action.payload && typeof action.payload === "object" ? action.payload : null,
+                        },
+                    },
+                },
+            };
+        }
+
+        case "canvas/snapshot": {
+            const sessionId = String(action.sessionId || "").trim();
+            if (!sessionId) return state;
+            const slot = Number.isInteger(Number(action.slot)) && Number(action.slot) >= 1 && Number(action.slot) <= 5
+                ? Number(action.slot) : 1;
+            const key = canvasKey(sessionId, slot);
+            const existing = state.canvas.bySessionId[key] || {};
+            const rev = Number(action.rev) || 0;
+            return {
+                ...state,
+                canvas: {
+                    ...state.canvas,
+                    bySessionId: {
+                        ...state.canvas.bySessionId,
+                        [key]: {
+                            ...existing,
+                            slot,
+                            ...(typeof action.name === "string" && ((existing.latestRev || 0) <= rev) ? { name: action.name } : {}),
+                            // Events may have beaten the snapshot; never regress.
+                            latestRev: Math.max(existing.latestRev || 0, rev),
+                            note: (existing.latestRev || 0) > rev ? existing.note : (typeof action.note === "string" ? action.note : existing.note || ""),
+                            sizeBytes: (existing.latestRev || 0) > rev ? existing.sizeBytes : (Number.isFinite(Number(action.sizeBytes)) ? Number(action.sizeBytes) : existing.sizeBytes ?? null),
+                            responseContract: (existing.latestRev || 0) > rev
+                                ? (existing.responseContract ?? null)
+                                : (action.responseContract && typeof action.responseContract === "object" ? action.responseContract : null),
+                            snapshotLoaded: true,
+                        },
+                    },
+                },
+            };
+        }
+
+        // Continuity break (windowed bulk reload replaced gap-free replay):
+        // the memoized snapshot can no longer be trusted — re-take on next need.
+        case "canvas/snapshotInvalidate": {
+            const sessionId = String(action.sessionId || "").trim();
+            const existing = state.canvas.bySessionId[sessionId];
+            if (!sessionId || !existing?.snapshotLoaded) return state;
+            // Slots 2-5 of the same session invalidate with slot 1: the flag
+            // that gates re-take lives on the slot-1 entry.
+            return {
+                ...state,
+                canvas: {
+                    ...state.canvas,
+                    bySessionId: {
+                        ...state.canvas.bySessionId,
+                        [sessionId]: { ...existing, snapshotLoaded: false },
+                    },
+                },
+            };
+        }
+
         case "files/htmlViewMode":
             return {
                 ...state,