pilotswarm 0.5.37 → 0.5.38

package/ui/core/src/selectors.js

@@ -1,4 +1,5 @@
 import { INSPECTOR_TABS, FOCUS_REGIONS } from "./commands.js";
+import { canvasKey as canvasSlotKey, parseCanvasKey } from "./state.js";
 import { isManuallyOrderableSession } from "./session-tree.js";
 import {
     createSplashCard,
@@ -1125,6 +1126,10 @@ export function selectSessionRows(state) {
             // built under one branding to a caller using another, and the root
             // session's name would flip between them.
             state.branding?.title,
+            // The canvas marker below reads these. Without them the memo hands
+            // back a row built before the draw and the marker never appears.
+            state.canvas?.bySessionId?.[entry.sessionId],
+            state.canvas?.prefs?.[entry.sessionId],
         ];
         const cached = memo.get(entry.sessionId);
         if (cached && sameRowDeps(cached.deps, deps)) return cached.row;
@@ -1160,6 +1165,15 @@ export function selectSessionRows(state) {
                 : null,
             orderable: isManuallyOrderableSession(session),
             orderContainer: manualOrderContainerKey(session, pinned),
+            // Canvas state for THIS row. The toolbar badge answers the same
+            // question for the active session only; the list has to answer it
+            // for every session at once, which is the point — a canvas drawn
+            // in a session you are not looking at is otherwise invisible.
+            //
+            //   null      no canvas, or one that was cleared
+            //   "canvas"  a canvas exists and nothing is new
+            //   "unseen"  it changed since this user last looked at it
+            canvasMark: sessionCanvasMark(state, entry.sessionId),
         };
         memo.set(entry.sessionId, { deps, row });
         return row;
@@ -2661,21 +2675,87 @@ export function selectChatLines(state, maxWidth = 80, options = {}) {
  * whether the yellow unseen-changes badge should light
  * (latestRev > lastViewedRev, and only while the canvas is not on screen).
  */
+/**
+ * The canvas marker for one session row.
+ *
+ * Same rules selectCanvasView applies to the active session, minus the
+ * on-screen check: a row's marker describes the SESSION, not the layout, so it
+ * does not care which column happens to be open.
+ *
+ * A cleared canvas (draw_canvas("") -> sizeBytes 0) no longer exists. Unknown
+ * size (null, from a degraded snapshot) is presumed drawn — a marker that is
+ * occasionally early beats one that silently never shows.
+ */
+export function sessionCanvasMark(state, sessionId) {
+    if (!sessionId) return null;
+    // Aggregate across the session's slots: ANY unseen slot lights the dot;
+    // any drawn slot at all marks the row. Slot 1 is the bare id key.
+    let mark = null;
+    for (let slot = 1; slot <= 5; slot += 1) {
+        const key = canvasSlotKey(sessionId, slot);
+        const entry = state?.canvas?.bySessionId?.[key];
+        const prefs = state?.canvas?.prefs?.[key];
+        if (!entry) {
+            // No live state loaded (cold page). canvasPrefs persist per user,
+            // so a slot this user has ever VIEWED still marks — plain, never
+            // "unseen": whether it changed since is unknowable client-side.
+            if ((prefs?.lastViewedRev || 0) > 0) mark = mark || "canvas";
+            continue;
+        }
+        const latestRev = entry.latestRev || 0;
+        if (latestRev <= 0 || entry.sizeBytes === 0) continue;
+        const unseen = latestRev > (prefs?.lastViewedRev || 0)
+            || (entry.latestDataRev || 0) > (prefs?.lastViewedDataRev || 0);
+        if (unseen) return "unseen";
+        mark = "canvas";
+    }
+    return mark;
+}
+
 export function selectCanvasView(state) {
     const sessionId = state?.sessions?.activeSessionId || null;
-    const entry = sessionId ? state?.canvas?.bySessionId?.[sessionId] : null;
-    const prefs = sessionId ? state?.canvas?.prefs?.[sessionId] : 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.
+    const wantedSlot = Number(state?.ui?.canvasSlot) || 1;
+    const bySessionId = state?.canvas?.bySessionId || {};
+    // Every drawn slot of the active session, for the selector and arrows.
+    const slots = [];
+    if (sessionId) {
+        for (let slot = 1; slot <= 5; slot += 1) {
+            const e = bySessionId[canvasSlotKey(sessionId, slot)];
+            if (!e || (e.latestRev || 0) <= 0 || e.sizeBytes === 0) continue;
+            const p = state?.canvas?.prefs?.[canvasSlotKey(sessionId, slot)];
+            slots.push({
+                slot,
+                name: typeof e.name === "string" ? e.name : "",
+                latestRev: e.latestRev || 0,
+                unseen: (e.latestRev || 0) > (p?.lastViewedRev || 0)
+                    || (e.latestDataRev || 0) > (p?.lastViewedDataRev || 0),
+            });
+        }
+    }
+    const slot = slots.some((s2) => s2.slot === wantedSlot) ? wantedSlot : 1;
+    const key = sessionId ? canvasSlotKey(sessionId, slot) : null;
+    const entry = key ? bySessionId[key] : null;
+    const prefs = key ? state?.canvas?.prefs?.[key] : null;
     const latestRev = entry?.latestRev || 0;
     const lastViewedRev = prefs?.lastViewedRev || 0;
     const latestDataRev = entry?.latestDataRev || 0;
     const lastViewedDataRev = prefs?.lastViewedDataRev || 0;
-    const mode = state?.ui?.rightPaneMode === "canvas" ? "canvas" : "panes";
+    // Read from canvasOpen, not the retired rightPaneMode enum. Diagnostics
+    // moving to its own column means "not canvas" no longer implies "panes",
+    // and this drives the unseen badge, which must light whenever the canvas
+    // is off screen.
+    const mode = state?.ui?.canvasOpen ? "canvas" : "panes";
     // A cleared canvas (draw_canvas("") → sizeBytes 0) no longer exists for
     // affordance purposes: no phone tab, no badge, blank teaching state.
     // Unknown size (null — snapshot degrade) is presumed drawn.
     const exists = latestRev > 0 && entry?.sizeBytes !== 0;
     return {
         sessionId,
+        slot,
+        slots,
+        name: typeof entry?.name === "string" ? entry.name : "",
         mode,
         exists,
         latestRev,

package/ui/core/src/state.js

@@ -73,11 +73,23 @@ export function normalizeStoredLayoutAdjustments(layoutAdjustments) {
     const sessionPaneAdjust = Number(candidate.sessionPaneAdjust);
     const portalSessionColumnAdjust = Number(candidate.portalSessionColumnAdjust);
     const activityPaneAdjust = Number(candidate.activityPaneAdjust);
+    // Canvas is a column of its own now rather than a face the right column
+    // wears, so it needs its own remembered width. Same mechanism as the rest:
+    // a pixel delta from the computed base, persisted per user.
+    const canvasPaneAdjust = Number(candidate.canvasPaneAdjust);
+    const diagnosticsPaneAdjust = Number(candidate.diagnosticsPaneAdjust);
+    const diagnosticsSplitAdjust = Number(candidate.diagnosticsSplitAdjust);
     return {
         paneAdjust: Number.isFinite(paneAdjust) ? Math.trunc(paneAdjust) : 0,
         sessionPaneAdjust: Number.isFinite(sessionPaneAdjust) ? Math.trunc(sessionPaneAdjust) : 0,
         portalSessionColumnAdjust: Number.isFinite(portalSessionColumnAdjust) ? Math.trunc(portalSessionColumnAdjust) : 0,
         activityPaneAdjust: Number.isFinite(activityPaneAdjust) ? Math.trunc(activityPaneAdjust) : 0,
+        canvasPaneAdjust: Number.isFinite(canvasPaneAdjust) ? Math.trunc(canvasPaneAdjust) : 0,
+        diagnosticsPaneAdjust: Number.isFinite(diagnosticsPaneAdjust) ? Math.trunc(diagnosticsPaneAdjust) : 0,
+        // The inspector/activity seam inside Diagnostics, in PIXELS from an
+        // even split. The old row-quantized TUI adjust made browser drags
+        // jump in ~20px notches.
+        diagnosticsSplitAdjust: Number.isFinite(diagnosticsSplitAdjust) ? Math.trunc(diagnosticsSplitAdjust) : 0,
     };
 }
 
@@ -132,11 +144,66 @@ export function normalizeStoredCollapsedSessionIds(value) {
  * Right-column mode: the inspector/activity split, or the session canvas.
  * Anything unrecognized falls back to panes — a stored value from a newer
  * build must not strand an older portal in a mode it cannot render.
+ *
+ * @deprecated Superseded by the independent `canvasOpen` / `diagnosticsOpen`
+ * booleans. Kept only to migrate a value written by an older build — see
+ * normalizeStoredDesktopPanes.
  */
 export function normalizeStoredRightPaneMode(value) {
     return value === "canvas" ? "canvas" : "panes";
 }
 
+/**
+ * Which of the two optional desktop columns are on screen.
+ *
+ * Canvas and Diagnostics used to be one enum (`rightPaneMode`), so the right
+ * column could only ever wear one face. They are independent now: either, both,
+ * or neither. Diagnostics is the old inspector/activity split, moved out of the
+ * chat pane and travelling as one unit.
+ *
+ * Both default to OFF. A pane that is off has no width and no resizer — it is
+ * absent, not collapsed to nothing.
+ *
+ * Migrating a stored `rightPaneMode`:
+ *   "canvas" -> canvas on. That was a deliberate choice, so it is honored.
+ *   "panes"  -> both off. "panes" was the default value rather than a choice,
+ *               and the new default is a clean two-column workspace.
+ */
+export function normalizeStoredDesktopPanes(value, legacyRightPaneMode) {
+    const candidate = value && typeof value === "object" ? value : null;
+    if (candidate && (typeof candidate.canvasOpen === "boolean" || typeof candidate.diagnosticsOpen === "boolean")) {
+        return {
+            canvasOpen: candidate.canvasOpen === true,
+            diagnosticsOpen: candidate.diagnosticsOpen === true,
+            // Zen: chat as a narrow rail, canvas as the workbench. Only
+            // meaningful with the canvas open.
+            zen: candidate.zen === true && candidate.canvasOpen === true,
+        };
+    }
+    return {
+        canvasOpen: legacyRightPaneMode === "canvas",
+        diagnosticsOpen: false,
+        zen: false,
+    };
+}
+
+/**
+ * The store key for one canvas surface. Slot 1 keeps the bare session id so
+ * every reader written before slots existed keeps working untouched; slots
+ * 2-5 append "#<slot>". Used for canvas.bySessionId AND canvas.prefs.
+ */
+export function canvasKey(sessionId, slot) {
+    const id = String(sessionId || "");
+    const n = Number(slot);
+    return Number.isInteger(n) && n >= 2 && n <= 5 ? `${id}#${n}` : id;
+}
+
+/** The inverse: `sessionId#3` -> { sessionId, slot: 3 }; bare id -> slot 1. */
+export function parseCanvasKey(key) {
+    const m = /^(.*)#([2-5])$/.exec(String(key || ""));
+    return m ? { sessionId: m[1], slot: Number(m[2]) } : { sessionId: String(key || ""), slot: 1 };
+}
+
 /**
  * Per-session canvas preferences: what this user has chosen and seen.
  *
@@ -154,10 +221,13 @@ export function normalizeStoredCanvasPrefs(value) {
         if (!id || !entry || typeof entry !== "object") continue;
         const lastViewedRev = Number(entry.lastViewedRev);
         const lastViewedDataRev = Number(entry.lastViewedDataRev);
+        const zenRailPx = Number(entry.zenRailPx);
         out[id] = {
             optedOut: entry.optedOut === true,
             lastViewedRev: Number.isFinite(lastViewedRev) && lastViewedRev > 0 ? Math.floor(lastViewedRev) : 0,
             lastViewedDataRev: Number.isFinite(lastViewedDataRev) && lastViewedDataRev > 0 ? Math.floor(lastViewedDataRev) : 0,
+            // Zen chat-rail width, remembered for THIS session only.
+            ...(Number.isFinite(zenRailPx) && zenRailPx > 0 ? { zenRailPx: Math.floor(zenRailPx) } : {}),
         };
     }
     return out;
@@ -169,7 +239,11 @@ export function normalizeStoredActiveSessionId(value) {
     return id ? id : null;
 }
 
-export function createInitialState({ mode = "local", branding = null, docs = null, themeId = null, sessionOwnerFilter = null, layoutAdjustments = null, pinnedSessionIds = null, collapsedSessionIds = null, activeSessionId = null, sessionOrder = null, rightPaneMode = null, canvasPrefs = null } = {}) {
+export function createInitialState({ mode = "local", branding = null, docs = null, themeId = null, sessionOwnerFilter = null, layoutAdjustments = null, pinnedSessionIds = null, collapsedSessionIds = null, activeSessionId = null, sessionOrder = null, rightPaneMode = null, desktopPanes: storedDesktopPanes = null, canvasPrefs = null } = {}) {
+    const desktopPanes = normalizeStoredDesktopPanes(
+        storedDesktopPanes,
+        normalizeStoredRightPaneMode(rightPaneMode),
+    );
     const hasStoredSessionOwnerFilter = sessionOwnerFilter != null;
     const hasStoredCollapsedSessionIds = collapsedSessionIds != null;
     const initialLayoutAdjustments = normalizeStoredLayoutAdjustments(layoutAdjustments);
@@ -201,7 +275,21 @@ export function createInitialState({ mode = "local", branding = null, docs = nul
             // through to the transcript.
             // Which face the right column wears: the inspector/activity panes
             // or the session canvas. Persisted.
-            rightPaneMode: normalizeStoredRightPaneMode(rightPaneMode),
+            //
+            // @deprecated Read by nothing that decides layout any more — the
+            // two booleans below do that. Still derived so a build that rolls
+            // back, and anything still reading the old key, sees a sane value.
+            rightPaneMode: desktopPanes.canvasOpen ? "canvas" : "panes",
+            // The two optional desktop columns, independent of each other.
+            // Both off is the default workspace: sessions and chat only.
+            canvasOpen: desktopPanes.canvasOpen,
+            diagnosticsOpen: desktopPanes.diagnosticsOpen,
+            // Chat-rail + canvas-workbench mode. Persisted with the columns.
+            canvasZen: desktopPanes.zen,
+            // Canvas filling the workspace. Deliberately NOT persisted: it is
+            // 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,
             statsViewMode: "session",
             prompt: "",
             promptCursor: 0,

package/ui/core/src/themes/index.js

@@ -61,7 +61,7 @@ const THEMES = Object.freeze([
 
 const THEME_MAP = new Map(THEMES.map((theme) => [theme.id, theme]));
 
-export const DEFAULT_THEME_ID = noctisObscuroTheme.id;
+export const DEFAULT_THEME_ID = workspaceDarkTheme.id;
 
 export { THEME_GROUP_ORDER } from "./helpers.js";