pilotswarm 0.5.56 → 0.5.58

package/package.json

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

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

@@ -1976,6 +1976,11 @@ export class NodeSdkTransport {
         return this.mgmt.getCanvasLive(sessionId);
     }
 
+    async getLive(sessionId, topics) {
+        if (typeof this.mgmt.getLive !== "function") return [];
+        return this.mgmt.getLive(sessionId, topics);
+    }
+
     // The canvas KV store. The portal runtime hands a resolved principal
     // (door 1); the native TUI has no canvas surface and never calls these.
     async readCanvasKv(sessionId, slot, principal, query = {}) {

package/ui/core/src/controller.js

@@ -4,8 +4,10 @@ import { parseAgentSourceLink } from "./repo-links.js";
 import { importPackageFilesFromLink, readImportedPackageName } from "./repo-import.js";
 import {
     appendEventToHistory,
+    applyLiveTurnToHistory,
     buildHistoryModel,
     CHAT_HISTORY_EVENT_TYPES,
+    clearLiveTurnFromHistory,
     DEFAULT_HISTORY_EVENT_LIMIT,
     dedupeChatMessages,
     getNextHistoryEventLimit,
@@ -2503,6 +2505,8 @@ export class PilotSwarmUiController {
     }
 
     async stop() {
+        for (const timer of this._liveTurnIdleTimers?.values() || []) clearTimeout(timer);
+        this._liveTurnIdleTimers?.clear();
         if (this.catalogTimer) clearInterval(this.catalogTimer);
         this.catalogTimer = null;
         if (this.activeSessionDetailTimer) clearTimeout(this.activeSessionDetailTimer);
@@ -2518,6 +2522,16 @@ export class PilotSwarmUiController {
     }
 
     detachActiveSession() {
+        // Timers belong to the subscription, not to a future visit to this session.
+        const sessionId = this.activeSessionSubscriptionId;
+        if (sessionId) {
+            clearTimeout(this._liveTurnIdleTimers?.get(sessionId));
+            this._liveTurnIdleTimers?.delete(sessionId);
+            const history = this.getState().history.bySessionId.get(sessionId);
+            if (history) this.dispatch({ type: "history/set", sessionId, history: {
+                ...history, chat: history.chat.filter((item) => !item.liveTurn),
+            } });
+        }
         if (this.activeSessionUnsub) {
             this.activeSessionUnsub();
             this.activeSessionUnsub = null;
@@ -2866,8 +2880,9 @@ export class PilotSwarmUiController {
         if (newEvents.length === 0) {
             return existingHistory;
         }
-        let history = existingHistory;
+        let history = this.getState().history.bySessionId.get(sessionId) || existingHistory;
         for (const event of newEvents) {
+            if (event.seq <= (history.lastSeq || 0)) continue;
             history = appendEventToHistory(history, event);
         }
         history = {
@@ -2937,10 +2952,37 @@ export class PilotSwarmUiController {
                 }
                 throw error;
             }
-            const history = {
-                ...buildHistoryModel(events, { requestedLimit }),
-                lastSeq: events[events.length - 1]?.seq || 0,
+            const current = this.getState().history.bySessionId.get(sessionId);
+            // Durable events and previews can arrive while REST is pending.
+            // Merge that newer truth before replacing the loaded window.
+            const mergedEvents = [...new Map([...(events || []), ...(current?.events || [])]
+                .map((event) => [event.seq, event])).values()].sort((a, b) => a.seq - b.seq);
+            let history = {
+                ...buildHistoryModel(mergedEvents, { requestedLimit }),
+                lastSeq: mergedEvents.at(-1)?.seq || 0,
             };
+            history.closedLiveKeys = current?.closedLiveKeys || [];
+            history.closedLiveStreams = current?.closedLiveStreams || [];
+            const newTerminal = mergedEvents.some((event) => event.seq > (current?.lastSeq || 0)
+                && ["session.turn_completed", "session.turn_stopped"].includes(event.eventType));
+            for (const item of current?.chat || []) {
+                if (item.streamSettling) {
+                    history.chat = history.chat.map((message) => message.messageId === item.messageId
+                        ? { ...item, ...message } : message);
+                } else if (item.liveTurn && !newTerminal) {
+                    // Reuse the item itself: its key, reveal clock and memoized
+                    // rendering belong to this visit, not the REST response.
+                    if (!history.chat.some((message) => message.messageId && message.messageId === item.messageId)) {
+                        history.chat.push(item);
+                    } else {
+                        const finalEvent = mergedEvents.find((event) => event.eventType === "assistant.message" && event.data?.messageId === item.messageId);
+                        if (finalEvent) {
+                            const reconciled = appendEventToHistory({ chat: [item], events: [], activity: [], lastSeq: 0 }, finalEvent).chat[0];
+                            history.chat = history.chat.map((message) => message.messageId === item.messageId ? { ...reconciled, ...message } : message);
+                        }
+                    }
+                }
+            }
             this.dispatch({
                 type: "history/set",
                 sessionId,
@@ -5708,6 +5750,71 @@ export class PilotSwarmUiController {
         // history would corrupt the replay cursor — and they must never
         // appear in the transcript.
         if (event.transient === true) {
+            if (event.eventType === "assistant.live_tick") {
+                // A worker can die leaving a reasoning-only retained row.
+                // On re-entry its message ID cannot match a durable final;
+                // use database timestamps to reject snapshots older than an
+                // already-loaded terminal event. Never use client wall time.
+                const snapshotTime = event.liveUpdatedAt ? new Date(event.liveUpdatedAt).getTime() : NaN;
+                if (event.data?.phase === "live" && Number.isFinite(snapshotTime)) {
+                    const history = this.getState().history.bySessionId.get(sessionId);
+                    if (history?.events?.some((entry) => ["session.turn_completed", "session.turn_stopped"].includes(entry.eventType)
+                        && new Date(entry.createdAt).getTime() > snapshotTime)) return false;
+                }
+                if (!this._liveTurnIdleTimers) this._liveTurnIdleTimers = new Map();
+                const pendingIdle = this._liveTurnIdleTimers.get(sessionId);
+                if (pendingIdle && event.data?.phase === "idle") {
+                    clearTimeout(pendingIdle);
+                    this._liveTurnIdleTimers.delete(sessionId);
+                }
+                // The live plane and durable event stream are independent.
+                // An idle tick commonly wins the race by a few milliseconds;
+                // tearing down immediately makes the live answer flash out
+                // before its durable replacement lands. Give reconciliation a
+                // bounded grace window, then clear only if it is still live.
+                if (event.data?.phase === "idle") {
+                    const ended = this.getState().history.bySessionId.get(sessionId);
+                    if (!ended) return true;
+                    const streamId = event.data?.streamId || null;
+                    const endedKeys = new Set(ended.chat.filter((item) => item.liveTurn && (
+                        !streamId || item.streamId === streamId
+                        || (ended.closedLiveStreams || []).includes(item.streamId)
+                        || (ended.closedLiveKeys || []).includes(item.liveKey)
+                    )).map((item) => item.liveKey));
+                    // Never reveal a preview that has already finished. Keep
+                    // only previews that crossed the reveal threshold, and
+                    // close their keys now so late packets cannot revive them.
+                    this.dispatch({ type: "history/set", sessionId, history: {
+                        ...clearLiveTurnFromHistory(ended, null, streamId),
+                        chat: ended.chat.filter((item) => !item.liveTurn || !endedKeys.has(item.liveKey) || Date.now() - item.liveStartedAt >= 200),
+                    } });
+                    const timer = setTimeout(() => {
+                        this._liveTurnIdleTimers?.delete(sessionId);
+                        const current = this.getState().history.bySessionId.get(sessionId);
+                        if (!current) return;
+                        const chat = current.chat.filter((item) => !item.liveTurn || !endedKeys.has(item.liveKey));
+                        const cleared = chat.length === current.chat.length ? current : { ...current, chat };
+                        if (cleared !== current) {
+                            this.dispatch({ type: "history/set", sessionId, history: cleared });
+                        }
+                    }, 1_200);
+                    timer.unref?.();
+                    this._liveTurnIdleTimers.set(sessionId, timer);
+                    return true;
+                }
+                const existing = this.getState().history.bySessionId.get(sessionId)
+                    || { chat: [], activity: [], events: [], lastSeq: 0 };
+                this.dispatch({
+                    type: "history/set",
+                    sessionId,
+                    history: applyLiveTurnToHistory(existing, event.data, {
+                        sessionId,
+                        seq: event.liveSeq,
+                        createdAt: Date.now(),
+                    }),
+                });
+                return true;
+            }
             if (event.eventType === "session.canvas_data") {
                 this.applyCanvasDataEvent(sessionId, event);
             }
@@ -5730,6 +5837,12 @@ export class PilotSwarmUiController {
             }
             return false;
         }
+        if (this._liveTurnIdleTimers?.has(sessionId)
+            && (event.eventType === "session.turn_completed"
+                || event.eventType === "session.turn_stopped")) {
+            clearTimeout(this._liveTurnIdleTimers.get(sessionId));
+            this._liveTurnIdleTimers.delete(sessionId);
+        }
         const state = this.getState();
         const existing = state.history.bySessionId.get(sessionId) || { chat: [], activity: [], lastSeq: 0 };
         if (event.seq <= (existing.lastSeq || 0)) return false;

package/ui/core/src/history.js

@@ -530,6 +530,9 @@ function buildChatMessage(event, role) {
     const attachments = Array.isArray(event?.data?.attachments)
         ? event.data.attachments.filter((a) => a && typeof a.filename === "string" && a.filename)
         : [];
+    const messageId = typeof event?.data?.messageId === "string" && event.data.messageId
+        ? event.data.messageId
+        : null;
     return {
         id: `${event.sessionId}:${event.seq}`,
         role: deriveChatRole(event, role, text),
@@ -539,9 +542,76 @@ function buildChatMessage(event, role) {
         ...(clientMessageIds.length > 0 ? { clientMessageIds } : {}),
         ...(sender ? { sender } : {}),
         ...(attachments.length > 0 ? { attachments } : {}),
+        ...(messageId ? { messageId } : {}),
     };
 }
 
+/** Apply one transient `turn` topic snapshot without touching durable events/seq. */
+export function applyLiveTurnToHistory(history, payload, meta = {}) {
+    if (!payload) return history;
+    if (payload.phase === "idle") return clearLiveTurnFromHistory(history, null, payload.streamId || null);
+    if (payload.phase !== "live") return history;
+    const messageId = typeof payload.messageId === "string" && payload.messageId ? payload.messageId : null;
+    const reasoningId = typeof payload.reasoningId === "string" && payload.reasoningId ? payload.reasoningId : null;
+    const liveKey = messageId || (reasoningId ? `reasoning:${reasoningId}` : "active-turn");
+    const createdAt = Number(meta.createdAt) || Date.now();
+    const current = history || { chat: [], activity: [], events: [], lastSeq: 0 };
+    const oldChat = current.chat || [];
+    // Durable truth wins even when a delayed retained snapshot arrives later.
+    if ((messageId && oldChat.some((item) => !item.liveTurn && item.messageId === messageId))
+        || (current.closedLiveKeys || []).includes(liveKey)
+        || (payload.streamId && (current.closedLiveStreams || []).includes(payload.streamId))) return current;
+    const matches = (item) => item?.liveTurn === true && (
+        item?.liveKey === liveKey
+        || (messageId && item?.messageId === messageId)
+        || (reasoningId && item?.reasoningId === reasoningId && (!item.messageId || !messageId))
+    );
+    const firstMatch = oldChat.findIndex(matches);
+    const previous = firstMatch >= 0 ? oldChat[firstMatch] : null;
+    const chat = oldChat.filter((item) => !matches(item));
+    const reasoningText = typeof payload.reasoningText === "string" ? payload.reasoningText : "";
+    const text = typeof payload.text === "string" ? payload.text : "";
+    const liveStartedAt = Number(previous?.liveStartedAt || previous?.createdAt) || createdAt;
+    // Reasoning and answer text are one visual turn, not two independently
+    // mounted transcript rows. Keeping them in one keyed item lets the browser
+    // collapse reasoning above the answer and lets the durable final settle
+    // into the exact same React component instead of flashing between nodes.
+    const replacement = (reasoningText || text) ? [{
+        id: previous?.id || `live:${meta.sessionId || ""}:${liveKey}`,
+        role: "assistant",
+        ...(messageId ? { messageId } : {}),
+        ...(reasoningId ? { reasoningId } : {}),
+        liveKey: previous?.liveKey || liveKey,
+        liveTurn: true,
+        streamId: payload.streamId || previous?.streamId || null,
+        streaming: true,
+        truncated: payload.truncated === true,
+        text,
+        reasoningText,
+        liveStartedAt,
+        createdAt: liveStartedAt,
+        time: "",
+    }] : [];
+    chat.splice(firstMatch < 0 ? chat.length : Math.min(firstMatch, chat.length), 0, ...replacement);
+    return { ...current, chat };
+}
+
+export function clearLiveTurnFromHistory(history, messageId = null, streamId = null) {
+    if (!history?.chat) return history;
+    const chat = history.chat.filter((item) => !(
+        item?.liveTurn === true && (!messageId || item?.messageId === messageId) && (!streamId || item?.streamId === streamId)
+    ));
+    const retired = history.chat.filter((item) => item.liveTurn && (!messageId || item.messageId === messageId) && (!streamId || item.streamId === streamId));
+    const closedLiveKeys = [...new Set([...(history.closedLiveKeys || []),
+        ...retired.flatMap((item) => [item.liveKey, item.messageId, item.reasoningId && `reasoning:${item.reasoningId}`].filter(Boolean)),
+    ])].slice(-256);
+    const closedLiveStreams = [...new Set([...(history.closedLiveStreams || []),
+        ...(!messageId ? retired.map((item) => item.streamId).filter(Boolean) : []),
+        ...(streamId ? [streamId] : []),
+    ])].slice(-256);
+    return chat.length === history.chat.length && !streamId ? history : { ...history, chat, closedLiveKeys, closedLiveStreams };
+}
+
 // The Copilot SDK echoes the system prompt as a system.message on EVERY
 // turn, and the worker keeps only a 120-char snippet of it (session-proxy.ts,
 // "Full content omitted from CMS"). For one release (0.5.47) each echo also
@@ -765,6 +835,12 @@ function formatActivity(event) {
         case "assistant.streaming_progress":
             return null;
 
+        case "model.call_start": {
+            const model = String(event?.data?.model || event?.data?.modelId || "model").split(":").pop();
+            runs = buildLabeledActivityRuns(time, "[model]", "cyan", `calling ${model}`, "white");
+            break;
+        }
+
         case "session.artifact_presented": {
             const data = (event?.data ?? {}) || {};
             const filename = String(data.filename || "artifact");
@@ -1167,6 +1243,8 @@ export function appendEventToHistory(history, event) {
         ? existingEvents
         : [...existingEvents, event].slice(-loadedEventLimit);
     const next = {
+        closedLiveKeys: history?.closedLiveKeys || [],
+        closedLiveStreams: history?.closedLiveStreams || [],
         chat: clampHistoryItems(history?.chat || [], loadedEventLimit),
         activity: clampHistoryItems(history?.activity || [], loadedEventLimit),
         events: nextEvents,
@@ -1201,6 +1279,7 @@ export function appendEventToHistory(history, event) {
                     : m
             ));
         }
+        Object.assign(next, clearLiveTurnFromHistory(next));
         return next;
     }
 
@@ -1241,10 +1320,42 @@ export function appendEventToHistory(history, event) {
         next.activity = clampHistoryItems(next.activity, loadedEventLimit);
         const message = buildChatMessage(event, "assistant");
         if (!message) return next;
-        next.chat.push(message);
+        const liveIndex = message.messageId
+            ? next.chat.findIndex((item) => item?.liveTurn === true && item?.messageId === message.messageId)
+            : -1;
+        const liveItem = liveIndex >= 0 ? next.chat[liveIndex] : null;
+        Object.assign(next, clearLiveTurnFromHistory(next, message.messageId || null));
+        // Preserve the model-call slot when several assistant messages are
+        // interleaved: the durable final replaces its own live bubble in
+        // place instead of jumping behind a later streaming message.
+        if (liveIndex >= 0) {
+            const settledAt = Date.now();
+            const liveStartedAt = Number(liveItem?.liveStartedAt || liveItem?.createdAt) || settledAt;
+            const liveAgeMs = Math.max(0, settledAt - liveStartedAt);
+            // A live surface that never crossed the reveal threshold remains
+            // invisible and the durable answer renders normally. Once it was
+            // eligible to be seen, preserve the key and reasoning long enough
+            // for the browser to morph it smoothly into committed transcript.
+            if (liveAgeMs >= 200) {
+                const streamSettleDelayMs = Math.max(0, 900 - liveAgeMs);
+                Object.assign(message, {
+                    streamSettling: true,
+                    liveKey: liveItem?.liveKey || message.messageId,
+                    liveStartedAt,
+                    liveReasoningText: liveItem?.reasoningText || "",
+                    streamSettleDelayMs,
+                    streamSettleAt: settledAt + streamSettleDelayMs + 180,
+                });
+            }
+            next.chat.splice(Math.min(liveIndex, next.chat.length), 0, message);
+        }
+        else next.chat.push(message);
         next.chat = clampHistoryItems(dedupeChatMessages(next.chat), loadedEventLimit);
         return next;
     }
+    if (event.eventType === "session.turn_completed" || event.eventType === "session.turn_stopped") {
+        Object.assign(next, clearLiveTurnFromHistory(next));
+    }
     if (event.eventType === "system.message") {
         if (shouldRenderSystemMessageAsActivity(event)) {
             const activityItem = formatActivity(event);

package/ui/core/src/reducer.js

@@ -2,7 +2,7 @@ import { buildSessionTree, isManuallyOrderableSession } from "./session-tree.js"
 import { FOCUS_REGIONS } from "./commands.js";
 import { DEFAULT_HISTORY_EVENT_LIMIT, dedupeChatMessages } from "./history.js";
 import { getPromptInputRows } from "./layout.js";
-import { selectSessionRows } from "./selectors.js";
+import { SYSTEM_OWNER_KEY, ownerKeyForOwner, selectSessionRows } from "./selectors.js";
 import { systemSessionSortOrder } from "./system-titles.js";
 import {
     normalizeArtifactEntries,
@@ -20,6 +20,9 @@ import {
     BUDGET_SERIES_DAYS,
     BUDGET_SERIES_RANGES,
     createInitialState,
+    SESSION_VIEW_LAYOUT_KEYS,
+    defaultSessionView,
+    normalizeStoredSessionViews,
 } from "./state.js";
 
 /**
@@ -635,6 +638,38 @@ function updateUiForSessionSelection(state, nextActiveSessionId) {
     };
 }
 
+// Add the linked session's owner to the owner filter when that is what hides
+// it. Returns the next sessions slice, or null when the owner filter is not
+// the reason (an `all` filter, a system or unowned session, an owner the
+// filter already admits) so the caller falls back to the transient exception.
+function admitLinkedSessionOwner(state, sessions, targetId) {
+    const target = sessions.byId?.[targetId];
+    if (!target || target.isGroup || target.isSystem) return null;
+    const filter = normalizeSessionOwnerFilter(sessions.ownerFilter);
+    if (filter.all === true) return null;
+    const ownerKey = ownerKeyForOwner(target.owner);
+    if (!ownerKey || ownerKey === SYSTEM_OWNER_KEY) return null;
+    const viewerKey = ownerKeyForOwner(state.auth?.principal);
+    if (viewerKey && ownerKey === viewerKey) return null;
+    if (filter.includeShared || filter.ownerKeys.includes(ownerKey)) return null;
+    const candidate = {
+        ...sessions,
+        ownerFilterExplicit: true,
+        ownerFilter: { ...filter, ownerKeys: [...filter.ownerKeys, ownerKey] },
+        ownerFilterAutoAdmitted: { sessionId: targetId, ownerKey },
+    };
+    // Prove it worked: a session hidden by something else as well (a text
+    // filter, a collapsed ancestor) must not change the filter for nothing.
+    const rows = selectSessionRows({ ...state, sessions: candidate });
+    return rows.some((row) => row.sessionId === targetId) ? candidate : null;
+}
+
+function keepAdmittedOwner(filter, admitted) {
+    const ownerKey = admitted?.ownerKey;
+    if (!ownerKey || filter.all === true || filter.includeShared || filter.ownerKeys.includes(ownerKey)) return filter;
+    return { ...filter, ownerKeys: [...filter.ownerKeys, ownerKey] };
+}
+
 function applyVisibleSessionSelection(state, nextSessions) {
     let sessions = nextSessions;
 
@@ -671,16 +706,27 @@ function applyVisibleSessionSelection(state, nextSessions) {
         }
     }
 
-    // A resolved intent target excluded by the current filters gets a
-    // transient exception so the linked session is shown anyway. Never
-    // persisted; cleared on manual navigation or filter change.
-    if (intentTargetId && sessions.filterExceptionId !== intentTargetId) {
+    // A resolved intent target excluded by the current filters. First choice:
+    // when the only thing hiding it is that its owner is not in the owner
+    // filter, ADD that owner to the filter. The filter persists with the
+    // profile, so the linked session — and that person's other shared
+    // sessions — stay listed after the link is gone. Without this the link
+    // opened the chat but the row never appeared in the list. Fallback (no
+    // human owner, or hidden for another reason): the transient exception,
+    // never persisted, cleared on manual navigation or filter change.
+    if (intentTargetId && sessions.filterExceptionId !== intentTargetId
+        && sessions.ownerFilterAutoAdmitted?.sessionId !== intentTargetId) {
         const probeRows = selectSessionRows({ ...state, sessions });
         if (!probeRows.some((row) => row.sessionId === intentTargetId)) {
-            sessions = {
-                ...sessions,
-                filterExceptionId: intentTargetId,
-            };
+            const admitted = admitLinkedSessionOwner(state, sessions, intentTargetId);
+            if (admitted) {
+                sessions = admitted;
+            } else {
+                sessions = {
+                    ...sessions,
+                    filterExceptionId: intentTargetId,
+                };
+            }
         }
     }
 
@@ -771,6 +817,103 @@ function normalizePromptAttachments(prompt, attachments) {
 }
 
 export function appReducer(state, action) {
+    const next = baseReducer(state, action);
+    if (next === state) return next;
+    return reconcileSessionView(state, next, action);
+}
+
+// Per-session desktop views, kept in step with the ui slice.
+//
+//   active session changed  → apply that session's stored view (or the
+//                             default: no columns, even sizes)
+//   profile settings applied → re-apply the active session's view, so the
+//                             global desktopPanes/layoutAdjustments a poll
+//                             carries never override a per-session choice
+//   anything else changed a column toggle or a right-side size while the
+//   session stayed the same → record it for that session
+//
+// Desktop only (the phone has no columns; its layout is untouched), and only
+// once the profile has been read, so the defaults cannot be recorded over a
+// stored view the tab has not seen yet.
+function reconcileSessionView(prev, next, action) {
+    const ui = next.ui;
+    if (ui.sessionViewDevice !== "desktop") return next;
+    const active = next.sessions.activeSessionId || null;
+    if (!active || next.sessions.byId?.[active]?.isGroup) return next;
+    const prevActive = prev.sessions.activeSessionId || null;
+    // A profile read (the first one included) re-applies the active
+    // session's view from the merged map. Local edits made before the read
+    // were recorded below and win the merge, so a column opened while the
+    // profile was still loading is not shut by the answer.
+    if (action.type === "profileSettings/apply") {
+        return { ...next, ui: applySessionViewToUi(ui, ui.sessionViews?.[active]?.desktop || defaultSessionView()) };
+    }
+    if (active !== prevActive) {
+        // Before the read there is nothing to apply on a switch; the stored
+        // view lands with the read.
+        if (!ui.sessionViewsLoaded) return next;
+        return { ...next, ui: applySessionViewToUi(ui, ui.sessionViews?.[active]?.desktop || defaultSessionView()) };
+    }
+    const current = sessionViewFromUi(ui);
+    const before = sessionViewFromUi(prev.ui);
+    if (sessionViewsEqual(current, before)) return next;
+    const entry = { ...(ui.sessionViews?.[active] || {}), desktop: { ...current, at: Date.now() } };
+    return {
+        ...next,
+        ui: {
+            ...ui,
+            sessionViews: { ...(ui.sessionViews || {}), [active]: entry },
+        },
+    };
+}
+
+function sessionViewFromUi(ui) {
+    const layout = {};
+    for (const key of SESSION_VIEW_LAYOUT_KEYS) layout[key] = Number(ui.layout?.[key]) || 0;
+    return {
+        canvasOpen: ui.canvasOpen === true,
+        diagnosticsOpen: ui.diagnosticsOpen === true,
+        zen: ui.canvasOpen === true && ui.canvasZen === true,
+        layout,
+    };
+}
+
+function sessionViewsEqual(a, b) {
+    if (a.canvasOpen !== b.canvasOpen || a.diagnosticsOpen !== b.diagnosticsOpen || a.zen !== b.zen) return false;
+    for (const key of SESSION_VIEW_LAYOUT_KEYS) if (a.layout[key] !== b.layout[key]) return false;
+    return true;
+}
+
+function applySessionViewToUi(ui, view) {
+    const current = sessionViewFromUi(ui);
+    const wanted = { canvasOpen: view.canvasOpen === true, diagnosticsOpen: view.diagnosticsOpen === true, zen: view.canvasOpen === true && view.zen === true, layout: view.layout || {} };
+    if (sessionViewsEqual(current, { ...wanted, layout: { ...current.layout, ...wanted.layout } })) return ui;
+    return {
+        ...ui,
+        canvasOpen: wanted.canvasOpen,
+        diagnosticsOpen: wanted.diagnosticsOpen,
+        canvasZen: wanted.zen,
+        rightPaneMode: wanted.canvasOpen ? "canvas" : "panes",
+        ...(wanted.canvasOpen ? {} : { canvasMaximized: false }),
+        layout: { ...(ui.layout || {}), ...wanted.layout },
+    };
+}
+
+// Newest wins, per session: every record carries the time it was made, so a
+// local edit newer than the stored one survives the poll, and another
+// desktop's later edit replaces this tab's older one. No "touched" set —
+// one that never cleared made two desktops fight over the same session.
+function mergeSessionViews(remote, local) {
+    const out = { ...(remote || {}) };
+    for (const [id, entry] of Object.entries(local || {})) {
+        const localAt = Number(entry?.desktop?.at) || 0;
+        const remoteAt = Number(out[id]?.desktop?.at) || 0;
+        if (!out[id] || localAt > remoteAt) out[id] = entry;
+    }
+    return out;
+}
+
+function baseReducer(state, action) {
     switch (action.type) {
         case "connection/ready":
             return {
@@ -828,6 +971,12 @@ export function appReducer(state, action) {
                 },
             };
 
+        case "ui/sessionViewDevice": {
+            const device = action.device === "desktop" || action.device === "mobile" ? action.device : null;
+            if (device === state.ui.sessionViewDevice) return state;
+            return { ...state, ui: { ...state.ui, sessionViewDevice: device } };
+        }
+
         case "ui/touchScale":
             if (Boolean(action.enabled) === Boolean(state.ui.touchScale)) return state;
             return { ...state, ui: { ...state.ui, touchScale: Boolean(action.enabled) } };
@@ -868,6 +1017,11 @@ export function appReducer(state, action) {
             // migrating that — see normalizeStoredDesktopPanes.
             const hasDesktopPanes = Object.prototype.hasOwnProperty.call(settings, "desktopPanes")
                 && settings.desktopPanes && typeof settings.desktopPanes === "object";
+            const hasSessionViews = Object.prototype.hasOwnProperty.call(settings, "sessionViews")
+                && settings.sessionViews && typeof settings.sessionViews === "object";
+            const nextSessionViews = hasSessionViews
+                ? mergeSessionViews(normalizeStoredSessionViews(settings.sessionViews), state.ui.sessionViews)
+                : state.ui.sessionViews;
             const nextDesktopPanes = (hasDesktopPanes || hasRightPaneMode)
                 ? normalizeStoredDesktopPanes(
                     hasDesktopPanes ? settings.desktopPanes : null,
@@ -914,7 +1068,13 @@ export function appReducer(state, action) {
                 ...state.sessions,
                 ...(hasOwnerFilter
                     ? {
-                        ownerFilter: normalizeSessionOwnerFilter(settings.sessionOwnerFilter),
+                        // A stored filter that predates a just-admitted owner
+                        // (the first poll racing the deep link, or another
+                        // device's save) must not drop that owner again.
+                        ownerFilter: keepAdmittedOwner(
+                            normalizeSessionOwnerFilter(settings.sessionOwnerFilter),
+                            state.sessions.ownerFilterAutoAdmitted,
+                        ),
                         ownerFilterExplicit: true,
                     }
                     : {}),
@@ -948,6 +1108,9 @@ export function appReducer(state, action) {
                         ? { canvasOpen: nextDesktopPanes.canvasOpen, diagnosticsOpen: nextDesktopPanes.diagnosticsOpen, canvasZen: nextDesktopPanes.zen === true }
                         : {}),
                     layout: nextLayout,
+                    sessionViews: nextSessionViews,
+                    // Read once is enough: from here on this tab records.
+                    sessionViewsLoaded: true,
                 },
                 canvas: hasCanvasPrefs
                     ? { ...state.canvas, prefs: mergeCanvasPrefs(state.canvas.prefs, normalizeStoredCanvasPrefs(settings.canvasPrefs), hasLoadedSessions ? state.sessions.byId : null) }
@@ -1184,6 +1347,7 @@ export function appReducer(state, action) {
                     // the deep-link latch and its transient filter exception.
                     navigationIntent: null,
                     filterExceptionId: null,
+                ownerFilterAutoAdmitted: null,
                 };
                 const selection = applyVisibleSessionSelection(state, nextSessions);
                 return {
@@ -1201,6 +1365,7 @@ export function appReducer(state, action) {
                     ownerFilter: normalizeSessionOwnerFilter(action.filter),
                     navigationIntent: null,
                     filterExceptionId: null,
+                ownerFilterAutoAdmitted: null,
                 };
                 const selection = applyVisibleSessionSelection(state, nextSessions);
                 return {
@@ -1221,6 +1386,7 @@ export function appReducer(state, action) {
                 listDeselected: false,
                 navigationIntent: { sessionId, status: "pending" },
                 filterExceptionId: null,
+                ownerFilterAutoAdmitted: null,
             };
             const selection = applyVisibleSessionSelection(state, nextSessions);
             return {
@@ -1719,7 +1885,7 @@ export function appReducer(state, action) {
                     ...state.sessions,
                     activeSessionId: action.sessionId,
                     ...(releasesNavigationLatch
-                        ? { navigationIntent: null, filterExceptionId: null }
+                        ? { navigationIntent: null, filterExceptionId: null, ownerFilterAutoAdmitted: null }
                         : {}),
                 },
                 ui: {