pilotswarm 0.5.37 → 0.5.39

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,
@@ -3644,9 +3724,29 @@ export function selectAdminConsole(state) {
         distinctPackageOwners.add(key);
     }
     const decoratePackageOwners = distinctPackageOwners.size > 1;
+    // Copy-identity helpers: one NAME can be two packages (scope shadowing),
+    // so row selection and highlighting key on (name, scope, owner) — never
+    // the bare name.
+    const packageCopyKey = (name, scope, owner) =>
+        `${name}\u0001${scope === "shared" ? "shared" : "user"}\u0001${scope === "shared" ? "" : (owner?.subject ?? "")}`;
+    const selectedCopyKey = pkgState.selectedName
+        ? packageCopyKey(
+            pkgState.selectedName,
+            pkgState.selectedSelector?.scope ?? null,
+            pkgState.selectedSelector?.owner ?? principal ?? null,
+        )
+        : null;
+    const rowMatchesSelection = (pkg) => {
+        if (admin.section !== "packages" || pkgState.selectedName !== pkg.name) return false;
+        // Legacy selection with no selector: fall back to name-only so an
+        // in-flight selection from an older host still highlights something.
+        if (!pkgState.selectedSelector?.scope) return true;
+        return packageCopyKey(pkg.name, pkg.scope, pkg.owner) === selectedCopyKey;
+    };
     const packageRow = (pkg) => ({
         name: pkg.name,
         scope: pkg.scope === "shared" ? "shared" : "user",
+        owner: pkg.owner ?? null,
         enabled: Boolean(pkg.enabled),
         semver: pkg.active?.semver || null,
         sha7: pkg.active?.sha256 ? String(pkg.active.sha256).slice(0, 7) : null,
@@ -3662,7 +3762,7 @@ export function selectAdminConsole(state) {
             : ownerBadgeFor(resolvePackageOwner(pkg, ownerDirectory)),
         // Highlight only while the Agents section is active — otherwise the
         // GitHub Keys screen shows a double selection.
-        selected: admin.section === "packages" && pkgState.selectedName === pkg.name,
+        selected: rowMatchesSelection(pkg),
     });
     // Admins are served every user-scope package, but another person's private
     // agents are not part of YOUR workspace — keep them out of the main tree
@@ -3707,13 +3807,13 @@ export function selectAdminConsole(state) {
         { id: "ghcp", kind: "section", depth: 0, label: "GitHub Keys", selected: section === "ghcp" },
         { id: "agents", kind: "section", depth: 0, label: "Agents", selected: section === "packages" && !pkgState.selectedName },
         { id: "group:shared", kind: "group", depth: 1, label: "Shared", count: sharedRows.length },
-        ...sharedRows.map((row) => ({ id: `pkg:${row.name}`, kind: "package", depth: 2, label: row.name, ...row })),
+        ...sharedRows.map((row) => ({ id: `pkg:shared:${row.name}`, kind: "package", depth: 2, label: row.name, ...row })),
         { id: "group:user", kind: "group", depth: 1, label: "User", count: userRows.length },
-        ...userRows.map((row) => ({ id: `pkg:${row.name}`, kind: "package", depth: 2, label: row.name, ...row })),
+        ...userRows.map((row) => ({ id: `pkg:user:${row.name}`, kind: "package", depth: 2, label: row.name, ...row })),
         ...(otherUserRows.length > 0
             ? [
                 { id: "group:others", kind: "group", depth: 1, label: "Other users", count: otherUserRows.length },
-                ...otherUserRows.map((row) => ({ id: `pkg:${row.name}`, kind: "package", depth: 2, label: row.name, ...row })),
+                ...otherUserRows.map((row) => ({ id: `pkg:user:${row.owner?.subject ?? "?"}:${row.name}`, kind: "package", depth: 2, label: row.name, ...row })),
             ]
             : []),
         // The worker registry is a hard-gated admin read; hide the section
@@ -3725,7 +3825,10 @@ export function selectAdminConsole(state) {
     const detail = pkgState.detail || null;
     let packageDetail = null;
     if (pkgState.selectedName) {
-        const summary = pkgList.find((pkg) => pkg.name === pkgState.selectedName) || null;
+        const sameName = pkgList.filter((pkg) => pkg.name === pkgState.selectedName);
+        const summary = (pkgState.selectedSelector?.scope
+            ? sameName.find((pkg) => packageCopyKey(pkg.name, pkg.scope, pkg.owner) === selectedCopyKey)
+            : sameName[0]) ?? sameName[0] ?? null;
         const activeVersion = detail?.versions?.find((v) => v.versionId === detail.activeVersionId) || null;
         const manifest = activeVersion?.manifest || summary?.active?.manifest || {};
         // Workers are ephemeral pods: rows for retired pod names linger until
@@ -3739,9 +3842,22 @@ export function selectAdminConsole(state) {
                 return !Number.isNaN(at.getTime()) && at.getTime() >= liveCutoff;
             });
         const fleetTotal = workerRows.length;
+        // Workers report installed state by bare name — except when two
+        // same-named copies are installed at once, where each row gets a
+        // qualified key (name#scope[:owner8]) so the collision stays visible.
+        // Read whichever key this copy answers to.
+        const installedRowFor = (worker) => {
+            const installed = worker.installed || {};
+            const scope = detail?.scope || summary?.scope || pkgState.selectedSelector?.scope || null;
+            const ownerSubject = (detail?.owner?.subject || summary?.owner?.subject || pkgState.selectedSelector?.owner?.subject || "");
+            const qualified = scope === "user"
+                ? `${pkgState.selectedName}#user${ownerSubject ? `:${ownerSubject.slice(0, 8)}` : ""}`
+                : `${pkgState.selectedName}#shared`;
+            return installed[qualified] ?? installed[pkgState.selectedName];
+        };
         const fleetCurrent = activeVersion
-            ? workerRows.filter((worker) => worker.installed?.[pkgState.selectedName]?.semver === activeVersion.semver
-                && worker.installed?.[pkgState.selectedName]?.status === "ok").length
+            ? workerRows.filter((worker) => installedRowFor(worker)?.semver === activeVersion.semver
+                && installedRowFor(worker)?.status === "ok").length
             : 0;
         const canManage = detail ? ownsPackage(detail) : (summary ? ownsPackage(summary) : false);
         packageDetail = {
@@ -3776,6 +3892,12 @@ export function selectAdminConsole(state) {
                 : null,
             actionPending: pkgState.action?.pending || null,
             actionError: pkgState.action?.error || null,
+            // Which same-named copies exist, for the republish affordance and
+            // the shadowing note. Counterparts the caller can SEE only —
+            // exactly what the list already enforces.
+            hasSharedCounterpart: sameName.some((pkg) => pkg.scope === "shared"),
+            hasOwnUserCounterpart: sameName.some((pkg) => pkg.scope !== "shared" && isMinePackage(pkg)),
+            copyCount: sameName.length,
         };
     }
 

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";