pilotswarm 0.5.55 → 0.5.57

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pilotswarm",
-    "version": "0.5.55",
+    "version": "0.5.57",
     "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.55",
+        "pilotswarm-sdk": "0.5.57",
         "react": "^19.2.4",
         "react-dom": "^19.2.4",
         "ws": "^8.18.2"

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: {

package/ui/core/src/selectors.js

@@ -383,13 +383,13 @@ function sessionStatusIcon(session, mode = "local") {
     }
 }
 
-function ownerKeyForOwner(owner) {
+export function ownerKeyForOwner(owner) {
     const provider = String(owner?.provider || "").trim();
     const subject = String(owner?.subject || "").trim();
     return provider && subject ? `${provider}\u0001${subject}` : null;
 }
 
-function ownerDisplayName(owner, fallback = "unknown user") {
+export function ownerDisplayName(owner, fallback = "unknown user") {
     return String(owner?.displayName || owner?.email || "").trim() || fallback;
 }
 
@@ -398,7 +398,7 @@ function ownerDisplayName(owner, fallback = "unknown user") {
 // deletable) — but they belong to the same "System" bucket as the real system
 // agents, so the single System filter entry covers both. Computed via the same
 // join helper so it stays byte-identical to real owner keys.
-const SYSTEM_OWNER_KEY = ownerKeyForOwner({ provider: "system", subject: "system" });
+export const SYSTEM_OWNER_KEY = ownerKeyForOwner({ provider: "system", subject: "system" });
 
 function initialsFromText(value) {
     const text = String(value || "").trim();
@@ -1457,6 +1457,17 @@ export function selectNavigationError(state) {
  * linked session is being shown despite the current filters excluding it.
  */
 export function selectSessionFilterExceptionNotice(state) {
+    // A linked session whose owner was added to the filter so it is listed.
+    // Durable (the filter itself changed and persists); the notice is what
+    // is transient, cleared on the next manual navigation or filter change.
+    const admitted = state.sessions?.ownerFilterAutoAdmitted || null;
+    const stillAdmitted = admitted?.ownerKey
+        && Array.isArray(state.sessions?.ownerFilter?.ownerKeys)
+        && state.sessions.ownerFilter.ownerKeys.includes(admitted.ownerKey);
+    if (admitted?.sessionId && stillAdmitted && state.sessions?.byId?.[admitted.sessionId]) {
+        const owner = state.sessions.byId[admitted.sessionId]?.owner;
+        return `Added ${ownerDisplayName(owner, "its owner")} to your session filters so the linked session is listed.`;
+    }
     const exceptionId = state.sessions?.filterExceptionId || null;
     if (!exceptionId || !state.sessions?.byId?.[exceptionId]) return null;
     return "Showing linked session outside your current filters.";
@@ -1471,7 +1482,26 @@ export function canStopSessionTurn(session) {
     return (session.status || "") === "running";
 }
 
-function buildPendingQuestionMessage(session) {
+// The moment an event of one of these types was recorded, in ms, or null.
+// Product cards (Question, Warning) take their timestamp from the event that
+// raised them. They used to stamp session.updatedAt, which moves on EVERY
+// poll and status tick — so the card's clock jumped forward with each update
+// and read as flicker.
+function latestEventCreatedAtMs(events = [], eventTypes = []) {
+    const wanted = new Set(eventTypes);
+    for (let index = (events || []).length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (!event || !wanted.has(event.eventType)) continue;
+        const createdAt = event.createdAt;
+        const ms = createdAt instanceof Date
+            ? createdAt.getTime()
+            : typeof createdAt === "number" ? createdAt : new Date(createdAt || 0).getTime();
+        return Number.isFinite(ms) && ms > 0 ? ms : null;
+    }
+    return null;
+}
+
+function buildPendingQuestionMessage(session, events = []) {
     const pendingQuestion = session?.pendingQuestion;
     if (!pendingQuestion?.question) return null;
 
@@ -1500,7 +1530,7 @@ function buildPendingQuestionMessage(session) {
         role: "system",
         text: body.join("\n"),
         time: "",
-        createdAt: session.updatedAt || Date.now(),
+        createdAt: latestEventCreatedAtMs(events, ["session.input_required_started"]),
         cardTitle: "Question",
         cardTitleColor: "cyan",
         cardBorderColor: "cyan",
@@ -1558,7 +1588,7 @@ function chatAlreadyContainsPendingQuestion(chat, question) {
     });
 }
 
-function buildSessionErrorMessage(session) {
+function buildSessionErrorMessage(session, events = []) {
     const errorText = String(session?.error || "").trim();
     if (!errorText) return null;
 
@@ -1575,7 +1605,10 @@ function buildSessionErrorMessage(session) {
         role: "system",
         text: body,
         time: "",
-        createdAt: session.updatedAt || Date.now(),
+        // The error event when one was recorded, else the end of the turn
+        // that produced the error; never the session's rolling updatedAt.
+        createdAt: latestEventCreatedAtMs(events, ["session.error"])
+            ?? latestEventCreatedAtMs(events, ["session.turn_completed", "assistant.turn_end"]),
         cardTitle: isFailed ? "Error" : "Warning",
         cardTitleColor: isFailed ? "red" : "yellow",
         cardBorderColor: isFailed ? "red" : "yellow",
@@ -1801,12 +1834,13 @@ export function selectActiveChat(state) {
     }
     const history = state.history.bySessionId.get(sessionId);
     const chat = history?.chat || [];
+    const events = history?.events || [];
     const pendingQuestionMessage = session?.pendingQuestion?.question
         && !chatAlreadyContainsPendingQuestion(chat, session.pendingQuestion.question)
-        ? buildPendingQuestionMessage(session)
+        ? buildPendingQuestionMessage(session, events)
         : null;
     const answeredQuestionMessage = buildAnsweredPendingQuestionMessage(session, chat);
-    const sessionErrorMessage = buildSessionErrorMessage(session);
+    const sessionErrorMessage = buildSessionErrorMessage(session, events);
 
     if ((!history || chat.length === 0) && !pendingQuestionMessage && !answeredQuestionMessage && !sessionErrorMessage) {
         return createSplashCard(state.branding, session);
@@ -2949,7 +2983,39 @@ export function sessionCanvasMark(state, sessionId) {
     return mark;
 }
 
+// Memoized on its five inputs. The view carries a fresh `slots` array, so
+// without this every shallow-equal subscriber (the app root, the toolbar)
+// saw a "change" on EVERY dispatch — a keystroke, a poll, a live event —
+// and re-rendered the whole tree under it. Measured on a phone viewport
+// with a 600-turn transcript: ~10 component renders per keystroke, down to
+// the composer alone once the identity held.
+let canvasViewCache = null;
 export function selectCanvasView(state) {
+    const sessionId = state?.sessions?.activeSessionId || null;
+    const bySessionId = state?.canvas?.bySessionId;
+    const prefs = state?.canvas?.prefs;
+    const canvasSlot = state?.ui?.canvasSlot;
+    const canvasOpen = state?.ui?.canvasOpen;
+    // flipSeq is the agent-driven "open the canvas now" tick. It changes
+    // without any other key moving (a redraw of the already-open slot), and
+    // the phone opens its canvas tab off it — so it MUST be a cache key.
+    const flipSeq = state?.canvas?.flipSeq;
+    const cached = canvasViewCache;
+    if (cached
+        && cached.sessionId === sessionId
+        && cached.bySessionId === bySessionId
+        && cached.prefs === prefs
+        && cached.canvasSlot === canvasSlot
+        && cached.canvasOpen === canvasOpen
+        && cached.flipSeq === flipSeq) {
+        return cached.result;
+    }
+    const result = computeCanvasView(state);
+    canvasViewCache = { sessionId, bySessionId, prefs, canvasSlot, canvasOpen, flipSeq, result };
+    return result;
+}
+
+function computeCanvasView(state) {
     const sessionId = state?.sessions?.activeSessionId || null;
     // The pane shows ONE slot at a time. An out-of-range or never-drawn slot
     // falls back to 1 so a stale selection can never strand the pane.

package/ui/core/src/state.js

@@ -169,6 +169,62 @@ export function normalizeStoredRightPaneMode(value) {
  *   "panes"  -> both off. "panes" was the default value rather than a choice,
  *               and the new default is a clean two-column workspace.
  */
+// ── Per-session desktop views ─────────────────────────────────────────────
+// How a person set up the workspace for ONE session: which optional columns
+// are open and how the right side is sized. Keyed by session id, then by
+// device slot ("desktop" today; a "mobile" slot is reserved, not written).
+// Absent = the default workspace: sessions and chat, no other pane.
+export const SESSION_VIEW_LAYOUT_KEYS = Object.freeze([
+    "paneAdjust", "activityPaneAdjust", "canvasPaneAdjust", "diagnosticsPaneAdjust", "diagnosticsSplitAdjust",
+]);
+export const SESSION_VIEW_DEVICES = Object.freeze(["desktop", "mobile"]);
+// Bound on the profile document: the newest entries win.
+export const SESSION_VIEWS_MAX = 300;
+
+export function defaultSessionView() {
+    const layout = {};
+    for (const key of SESSION_VIEW_LAYOUT_KEYS) layout[key] = 0;
+    return { canvasOpen: false, diagnosticsOpen: false, zen: false, layout, at: 0 };
+}
+
+function normalizeStoredSessionView(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+    const view = defaultSessionView();
+    view.canvasOpen = value.canvasOpen === true;
+    view.diagnosticsOpen = value.diagnosticsOpen === true;
+    view.zen = view.canvasOpen && value.zen === true;
+    const layout = value.layout && typeof value.layout === "object" ? value.layout : {};
+    for (const key of SESSION_VIEW_LAYOUT_KEYS) {
+        const n = Number(layout[key]);
+        view.layout[key] = Number.isFinite(n) ? Math.trunc(n) : 0;
+    }
+    const at = Number(value.at);
+    view.at = Number.isFinite(at) && at > 0 ? Math.trunc(at) : 0;
+    return view;
+}
+
+export function normalizeStoredSessionViews(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+    const entries = [];
+    for (const [sessionId, slots] of Object.entries(value)) {
+        const id = String(sessionId || "").trim();
+        if (!id || !slots || typeof slots !== "object" || Array.isArray(slots)) continue;
+        const entry = {};
+        let newest = 0;
+        for (const device of SESSION_VIEW_DEVICES) {
+            const view = normalizeStoredSessionView(slots[device]);
+            if (!view) continue;
+            entry[device] = view;
+            newest = Math.max(newest, view.at);
+        }
+        if (Object.keys(entry).length > 0) entries.push([id, entry, newest]);
+    }
+    entries.sort((a, b) => b[2] - a[2]);
+    const out = {};
+    for (const [id, entry] of entries.slice(0, SESSION_VIEWS_MAX)) out[id] = entry;
+    return out;
+}
+
 export function normalizeStoredDesktopPanes(value, legacyRightPaneMode) {
     const candidate = value && typeof value === "object" ? value : null;
     if (candidate && (typeof candidate.canvasOpen === "boolean" || typeof candidate.diagnosticsOpen === "boolean")) {
@@ -345,6 +401,14 @@ export function createInitialState({ mode = "local", branding = null, docs = nul
             // a "look at this now" gesture, and returning to a portal with no
             // chat and no session list would read as a broken app.
             canvasMaximized: false,
+            // Per-session desktop views (see normalizeStoredSessionViews).
+            // Applied when the active session changes, recorded when the
+            // columns or the right-side sizes change — desktop only, and only
+            // once the profile has been read (so a fresh tab does not record
+            // the defaults over a stored view before it has seen it).
+            sessionViews: {},
+            sessionViewsLoaded: false,
+            sessionViewDevice: null,
             statsViewMode: "session",
             prompt: "",
             promptCursor: 0,
@@ -430,6 +494,7 @@ export function createInitialState({ mode = "local", branding = null, docs = nul
             ownerFilter: normalizeSessionOwnerFilter(sessionOwnerFilter),
             navigationIntent: null,
             filterExceptionId: null,
+            ownerFilterAutoAdmitted: null,
         },
         history: {
             bySessionId: new Map(),