pilotswarm 0.5.37 → 0.5.39

package/ui/core/src/controller.js

@@ -1,4 +1,5 @@
 import { UI_COMMANDS, FOCUS_REGIONS, INSPECTOR_TABS, cycleValue } from "./commands.js";
+import { canvasKey as canvasPrefKey } from "./state.js";
 import { parseAgentSourceLink } from "./repo-links.js";
 import { importPackageFilesFromLink, readImportedPackageName } from "./repo-import.js";
 import {
@@ -50,6 +51,22 @@ import {
 import { findArtifactEntry } from "./state.js";
 import { getTheme, listThemes } from "./themes/index.js";
 
+/**
+ * The copy selector for a package LIST row: which same-named copy it is.
+ * Scope shadowing means one name can be a shared package AND a user copy at
+ * once; the row's scope (+ owner, for admins looking at someone else's user
+ * copy) is what disambiguates every read and action on it.
+ */
+export function packageRowSelector(row) {
+    if (!row) return null;
+    return {
+        ...(row.scope === "shared" || row.scope === "user" ? { scope: row.scope } : {}),
+        ...(row.scope === "user" && row.owner?.provider && row.owner?.subject
+            ? { owner: { provider: row.owner.provider, subject: row.owner.subject } }
+            : {}),
+    };
+}
+
 const ORCHESTRATION_STATS_REFRESH_MS = 20_000;
 const SESSION_STATS_REFRESH_MS = 20_000;
 const FLEET_STATS_REFRESH_MS = 30_000;
@@ -2414,6 +2431,17 @@ export class PilotSwarmUiController {
         if (pendingGroupRows) {
             this.dispatch({ type: "sessions/groupsLoaded", groups: pendingGroupRows, sessions });
         }
+        // Canvas summaries ride the list rows (session_canvases join) — seed
+        // the store so rows mark on cold load, before any session is selected
+        // or any live event arrives. Never regresses what live events already
+        // know; see the canvas/seed reducer.
+        const canvasSeed = [];
+        for (const row of sessions) {
+            for (const c of Array.isArray(row?.canvases) ? row.canvases : []) {
+                canvasSeed.push({ sessionId: row.sessionId, slot: c.slot, name: c.name, latestRev: c.latestRev, sizeBytes: c.sizeBytes });
+            }
+        }
+        if (canvasSeed.length) this.dispatch({ type: "canvas/seed", entries: canvasSeed });
         this.dispatch({ type: "sessions/loaded", sessions });
         this.refreshOpenSessionOwnerFilterModal();
         const selected = this.getState().sessions.activeSessionId;
@@ -3050,27 +3078,39 @@ export class PilotSwarmUiController {
         }
     }
 
-    /** Select a package: loads its detail and workspace tree. */
-    async selectAdminPackage(name) {
-        this.dispatch({ type: "admin/packages/select", name });
+    /**
+     * Select a package: loads its detail and workspace tree.
+     *
+     * `selector` = { scope, owner? } from the clicked ROW. One name can be
+     * two packages at once (scope shadowing: a shared copy plus a user
+     * copy), and without the selector every read here resolved "own copy
+     * first" — both rows showed the same history, and actions could land on
+     * the copy the user was not looking at.
+     */
+    async selectAdminPackage(name, selector = null) {
+        this.dispatch({ type: "admin/packages/select", name, selector });
         if (!name) return;
+        // Selection token minted by the reducer just now; every response from
+        // this selection carries it so a slow response for another COPY of
+        // the same name (scope shadowing) can never land on this one.
+        const seq = this.getState().admin?.packages?.selectionSeq ?? 0;
         await Promise.all([
             (async () => {
                 try {
-                    const detail = await this.transport.getAgentPackage(name);
+                    const detail = await this.transport.getAgentPackage(name, selector);
                     if (!detail) throw new Error(`package "${name}" not found`);
-                    this.dispatch({ type: "admin/packages/detail/loaded", name, detail });
+                    this.dispatch({ type: "admin/packages/detail/loaded", name, seq, detail });
                 } catch (error) {
-                    this.dispatch({ type: "admin/packages/detail/loadFailed", name, error: error?.message || String(error) });
+                    this.dispatch({ type: "admin/packages/detail/loadFailed", name, seq, error: error?.message || String(error) });
                 }
             })(),
             (async () => {
                 try {
-                    const tree = await this.transport.getAgentPackageTree(name);
+                    const tree = await this.transport.getAgentPackageTree(name, null, selector);
                     // A slower tree for a PREVIOUS selection must not clobber
                     // the current package's workspace (stale-response race).
-                    if (this.getState().admin?.packages?.selectedName !== name) return;
-                    this.dispatch({ type: "admin/packages/tree/loaded", name, tree });
+                    if ((this.getState().admin?.packages?.selectionSeq ?? 0) !== seq) return;
+                    this.dispatch({ type: "admin/packages/tree/loaded", name, seq, tree });
                     // The package's own CHANGELOG, when it ships one. Loaded
                     // alongside the tree rather than on demand because it is
                     // the first thing a reviewer wants: what changed, why, and
@@ -3079,11 +3119,12 @@ export class PilotSwarmUiController {
                     if (hasChangelog && typeof this.transport.getAgentPackageFile === "function") {
                         void (async () => {
                             try {
-                                const file = await this.transport.getAgentPackageFile(name, null, "CHANGELOG.md");
-                                if (this.getState().admin?.packages?.selectedName !== name) return;
+                                const file = await this.transport.getAgentPackageFile(name, null, "CHANGELOG.md", selector);
+                                if ((this.getState().admin?.packages?.selectionSeq ?? 0) !== seq) return;
                                 this.dispatch({
                                     type: "admin/packages/changelog/loaded",
                                     name,
+                                    seq,
                                     content: typeof file === "string" ? file : (file?.content ?? file?.text ?? ""),
                                 });
                             } catch {
@@ -3092,13 +3133,13 @@ export class PilotSwarmUiController {
                             }
                         })();
                     } else {
-                        this.dispatch({ type: "admin/packages/changelog/loaded", name, content: null });
+                        this.dispatch({ type: "admin/packages/changelog/loaded", name, seq, content: null });
                     }
                     // Default preview: plugin.json (always present in a valid package).
                     const first = tree?.files?.find((f) => f.path === "plugin.json") ?? tree?.files?.[0];
                     if (first) void this.selectAdminPackageFile(first.path);
                 } catch (error) {
-                    this.dispatch({ type: "admin/packages/tree/loadFailed", name, error: error?.message || String(error) });
+                    this.dispatch({ type: "admin/packages/tree/loadFailed", name, seq, error: error?.message || String(error) });
                 }
             })(),
         ]);
@@ -3109,14 +3150,22 @@ export class PilotSwarmUiController {
         const pkgs = this.getState().admin?.packages;
         if (!pkgs?.list?.length) return;
         // Same shared→user projection the settings tree renders, so j/k walks
-        // the list in VISUAL order regardless of transport ordering.
-        const names = [
+        // the list in VISUAL order regardless of transport ordering. Rows are
+        // COPIES, not names: a shadowed name appears once per scope.
+        const rows = [
             ...pkgs.list.filter((p) => p.scope === "shared"),
             ...pkgs.list.filter((p) => p.scope !== "shared"),
-        ].map((p) => p.name);
-        const index = names.indexOf(pkgs.selectedName);
-        const next = names[Math.min(names.length - 1, Math.max(0, (index < 0 ? (delta > 0 ? -1 : 0) : index) + delta))];
-        if (next && next !== pkgs.selectedName) await this.selectAdminPackage(next);
+        ];
+        const keyOf = (row) => `${row.name}\u0001${row.scope ?? ""}\u0001${row.owner?.subject ?? ""}`;
+        const selectedKey = pkgs.selectedName
+            ? `${pkgs.selectedName}\u0001${pkgs.selectedSelector?.scope ?? ""}\u0001${pkgs.selectedSelector?.owner?.subject ?? ""}`
+            : null;
+        let index = rows.findIndex((row) => keyOf(row) === selectedKey);
+        if (index < 0) index = rows.findIndex((row) => row.name === pkgs.selectedName);
+        const next = rows[Math.min(rows.length - 1, Math.max(0, (index < 0 ? (delta > 0 ? -1 : 0) : index) + delta))];
+        if (next && (next.name !== pkgs.selectedName || keyOf(next) !== selectedKey)) {
+            await this.selectAdminPackage(next.name, packageRowSelector(next));
+        }
     }
 
     toggleAdminPackageDir(dir) {
@@ -3127,12 +3176,17 @@ export class PilotSwarmUiController {
         const pkgs = this.getState().admin?.packages;
         const name = pkgs?.selectedName;
         if (!name || !filePath) return;
+        // Tag the preview with the current selection token so a slow file for
+        // one copy can't render under another copy of the same name (their
+        // file paths are identical — both ship plugin.json).
+        const seq = pkgs?.selectionSeq ?? 0;
+        const selector = pkgs?.selectedSelector ?? null;
         this.dispatch({ type: "admin/packages/file/loading", path: filePath });
         try {
-            const file = await this.transport.getAgentPackageFile(name, null, filePath);
-            this.dispatch({ type: "admin/packages/file/loaded", file });
+            const file = await this.transport.getAgentPackageFile(name, null, filePath, selector);
+            this.dispatch({ type: "admin/packages/file/loaded", seq, file });
         } catch (error) {
-            this.dispatch({ type: "admin/packages/file/loadFailed", path: filePath, error: error?.message || String(error) });
+            this.dispatch({ type: "admin/packages/file/loadFailed", seq, path: filePath, error: error?.message || String(error) });
         }
     }
 
@@ -3145,32 +3199,53 @@ export class PilotSwarmUiController {
     async runAdminPackageAction(kind, arg = null) {
         const pkgs = this.getState().admin?.packages;
         const name = pkgs?.selectedName;
+        const selector = pkgs?.selectedSelector ?? null;
         if (!name) return;
         this.dispatch({ type: "admin/packages/action/pending", action: kind });
         try {
             switch (kind) {
                 case "promote":
-                    await this.transport.setAgentPackageScope(name, "shared");
+                    await this.transport.setAgentPackageScope(name, "shared", selector);
                     break;
                 case "demote":
-                    await this.transport.setAgentPackageScope(name, "user");
+                    await this.transport.setAgentPackageScope(name, "user", selector);
+                    break;
+                // Publish the selected copy's version (arg, default active)
+                // into the same-named package in the OTHER scope. THE update
+                // path when the shared name already exists — promote can only
+                // move a row to an unused name.
+                case "republish":
+                    await this.transport.republishAgentPackageVersion(
+                        name, arg, selector?.scope === "shared" ? "user" : "shared",
+                    );
                     break;
                 case "pin":
-                    await this.transport.pinAgentPackageVersion(name, arg);
+                    await this.transport.pinAgentPackageVersion(name, arg, selector);
                     break;
                 case "enable":
                 case "disable":
-                    await this.transport.setAgentPackageEnabled(name, kind === "enable");
+                    await this.transport.setAgentPackageEnabled(name, kind === "enable", selector);
                     break;
                 case "delete":
-                    await this.transport.deleteAgentPackage(name);
+                    await this.transport.deleteAgentPackage(name, selector);
                     break;
                 default:
                     throw new Error(`unknown package action: ${kind}`);
             }
             this.dispatch({ type: "admin/packages/action/done" });
             await this.refreshAdminAgentPackages();
-            if (kind !== "delete") await this.selectAdminPackage(name);
+            // Re-select the copy that still exists. promote/demote MOVE the row
+            // to the other scope, so the pre-action selector now points at a
+            // copy that is gone — re-selecting it would error the pane with
+            // "package not found". Every other action leaves the copy in place.
+            if (kind !== "delete") {
+                const nextSelector = kind === "promote"
+                    ? { scope: "shared", ...(selector?.owner ? { owner: selector.owner } : {}) }
+                    : kind === "demote"
+                        ? { scope: "user", ...(selector?.owner ? { owner: selector.owner } : {}) }
+                        : selector;
+                await this.selectAdminPackage(name, nextSelector);
+            }
         } catch (error) {
             this.dispatch({ type: "admin/packages/action/failed", error: error?.message || String(error) });
         }
@@ -4254,9 +4329,13 @@ export class PilotSwarmUiController {
     applyCanvasUpdate(sessionId, event) {
         const rev = Number(event?.data?.rev);
         if (!sessionId || !Number.isFinite(rev) || rev <= 0) return false;
+        const rawSlot = Number(event?.data?.slot);
+        const slot = Number.isInteger(rawSlot) && rawSlot >= 1 && rawSlot <= 5 ? rawSlot : 1;
         this.dispatch({
             type: "canvas/updated",
             sessionId,
+            slot,
+            ...(typeof event?.data?.name === "string" ? { name: event.data.name } : {}),
             rev,
             note: typeof event?.data?.note === "string" ? event.data.note : "",
             sizeBytes: event?.data?.sizeBytes,
@@ -4265,7 +4344,9 @@ export class PilotSwarmUiController {
 
         const state = this.getState();
         if (sessionId !== state.sessions.activeSessionId) return true;
-        if (state.canvas.prefs[sessionId]?.optedOut) return true;
+        // The opt-out is PER SLOT: leaving one canvas by hand must not
+        // silence a different canvas's first draw.
+        if (state.canvas.prefs[canvasPrefKey(sessionId, slot)]?.optedOut) return true;
         const createdAt = event?.createdAt ? Date.parse(event.createdAt) : Number.NaN;
         if (Number.isFinite(createdAt) && Date.now() - createdAt > PRESENTED_ARTIFACT_FRESHNESS_MS) {
             return true;
@@ -4274,7 +4355,7 @@ export class PilotSwarmUiController {
         // when the mode is already "canvas", because a phone can be off its
         // canvas tab while the mode state still says canvas — the tick is
         // what brings the tab back. On desktop the repeat dispatch is a no-op.
-        this.dispatch({ type: "canvas/flip", sessionId });
+        this.dispatch({ type: "canvas/flip", sessionId, slot });
         return true;
     }
 
@@ -4337,29 +4418,55 @@ export class PilotSwarmUiController {
             return;
         }
         try {
+            // A 30-event window, not 1: five interleaved slots mean the top
+            // event only describes the most recently drawn slot. Latest per
+            // slot wins; every drawn slot gets its snapshot.
             const rows = await this.transport.getSessionEventsBefore(
-                sessionId, Number.MAX_SAFE_INTEGER, 1, ["session.canvas_updated"],
+                sessionId, Number.MAX_SAFE_INTEGER, 30, ["session.canvas_updated"],
             );
-            const top = Array.isArray(rows) ? rows[0] : null;
-            this.dispatch({
-                type: "canvas/snapshot",
-                sessionId,
-                rev: Number(top?.data?.rev) || 0,
-                note: typeof top?.data?.note === "string" ? top.data.note : "",
-                sizeBytes: top?.data?.sizeBytes,
-                responseContract: top?.data?.responseContract,
-            });
-            // The latest data tick is the page's cold-load state — replay it
-            // so a freshly loaded shell can reconstruct without the agent.
-            if ((Number(top?.data?.rev) || 0) > 0) {
+            const bySlot = new Map();
+            for (const row of Array.isArray(rows) ? rows : []) {
+                const slot = Number(row?.data?.slot) || 1;
+                const rev = Number(row?.data?.rev) || 0;
+                if (!bySlot.has(slot) || rev > (Number(bySlot.get(slot)?.data?.rev) || 0)) bySlot.set(slot, row);
+            }
+            // Always at least a slot-1 snapshot (rev 0 marks snapshotLoaded
+            // so this does not respin).
+            if (!bySlot.has(1)) bySlot.set(1, null);
+            let anyDrawn = false;
+            for (const [slot, top] of bySlot) {
+                const rev = Number(top?.data?.rev) || 0;
+                if (rev > 0) anyDrawn = true;
+                this.dispatch({
+                    type: "canvas/snapshot",
+                    sessionId,
+                    slot,
+                    rev,
+                    ...(typeof top?.data?.name === "string" ? { name: top.data.name } : {}),
+                    note: typeof top?.data?.note === "string" ? top.data.note : "",
+                    sizeBytes: top?.data?.sizeBytes,
+                    responseContract: top?.data?.responseContract,
+                });
+            }
+            // The latest data tick per slot is that page's cold-load state —
+            // replay it so a freshly loaded shell reconstructs without the
+            // agent.
+            if (anyDrawn) {
                 const dataRows = await this.transport.getSessionEventsBefore(
-                    sessionId, Number.MAX_SAFE_INTEGER, 1, ["session.canvas_data"],
+                    sessionId, Number.MAX_SAFE_INTEGER, 30, ["session.canvas_data"],
                 ).catch(() => []);
-                const tick = Array.isArray(dataRows) ? dataRows[0] : null;
-                if (tick?.data?.dataRev) {
+                const tickBySlot = new Map();
+                for (const row of Array.isArray(dataRows) ? dataRows : []) {
+                    const slot = Number(row?.data?.slot) || 1;
+                    const dr = Number(row?.data?.dataRev) || 0;
+                    if (!tickBySlot.has(slot) || dr > (Number(tickBySlot.get(slot)?.data?.dataRev) || 0)) tickBySlot.set(slot, row);
+                }
+                for (const [slot, tick] of tickBySlot) {
+                    if (!tick?.data?.dataRev) continue;
                     this.dispatch({
                         type: "canvas/data",
                         sessionId,
+                        slot,
                         dataRev: Number(tick.data.dataRev),
                         payload: tick.data.payload,
                         note: typeof tick.data.note === "string" ? tick.data.note : "",
@@ -4371,6 +4478,27 @@ export class PilotSwarmUiController {
         }
     }
 
+    /**
+     * An agent asked to PRESENT an already-drawn canvas — no bytes, no rev,
+     * nothing marked unseen. Same guards as a draw's auto-flip: only the
+     * active session, only a fresh event (a reconnect replay must not yank
+     * the view), and the user's manual dismissal of that slot still wins.
+     */
+    applyCanvasPresented(sessionId, event) {
+        const rawSlot = Number(event?.data?.slot);
+        const slot = Number.isInteger(rawSlot) && rawSlot >= 1 && rawSlot <= 5 ? rawSlot : 1;
+        if (!sessionId) return false;
+        const state = this.getState();
+        if (sessionId !== state.sessions.activeSessionId) return false;
+        if (state.canvas.prefs[canvasPrefKey(sessionId, slot)]?.optedOut) return false;
+        const createdAt = event?.createdAt ? Date.parse(event.createdAt) : Number.NaN;
+        if (Number.isFinite(createdAt) && Date.now() - createdAt > PRESENTED_ARTIFACT_FRESHNESS_MS) {
+            return false;
+        }
+        this.dispatch({ type: "canvas/flip", sessionId, slot });
+        return true;
+    }
+
     mergeSessionEvent(sessionId, event) {
         if (!sessionId || !event) return false;
         const state = this.getState();
@@ -4429,10 +4557,14 @@ export class PilotSwarmUiController {
         if (event.eventType === "session.canvas_updated") {
             this.applyCanvasUpdate(sessionId, event);
         }
+        if (event.eventType === "session.canvas_presented") {
+            this.applyCanvasPresented(sessionId, event);
+        }
         if (event.eventType === "session.canvas_data") {
             this.dispatch({
                 type: "canvas/data",
                 sessionId,
+                slot: Number(event?.data?.slot) || 1,
                 dataRev: Number(event?.data?.dataRev),
                 payload: event?.data?.payload,
                 note: typeof event?.data?.note === "string" ? event.data.note : "",
@@ -7156,7 +7288,14 @@ export class PilotSwarmUiController {
     }
 
     setFocus(focusRegion) {
-        this.dispatch({ type: "ui/focus", focusRegion: normalizeFocusRegion(focusRegion, this.getCurrentLayout()) });
+        // Carry the raw request alongside the normalized region: on a phone a
+        // workspace region (sessions/chat) normalizes to inspector, and the
+        // mobile follow-focus effect must not read that as "open diagnostics".
+        this.dispatch({
+            type: "ui/focus",
+            focusRegion: normalizeFocusRegion(focusRegion, this.getCurrentLayout()),
+            requestedFocusRegion: focusRegion,
+        });
     }
 
     focusNext() {
@@ -7449,7 +7588,15 @@ export class PilotSwarmUiController {
 
     applyPaneVisualScrollOffset(pane, offset, options = {}, state = this.getState()) {
         const maxOffset = this.getPaneMaxScrollOffset(pane, state);
-        const nextOffset = Math.max(0, Math.min(Number(offset) || 0, maxOffset));
+        // fromViewport: the offset was measured off the real DOM (scrollTop /
+        // row height), which the browser has already bounded. Clamping it
+        // against the CONTROLLER's max — counted in TUI render-metric rows, a
+        // different unit — teleported the pane on the first wheel tick: one
+        // 100px notch re-applied as metric-max × 16px, thousands of pixels
+        // away. The two row spaces must never clamp each other.
+        const nextOffset = options.fromViewport
+            ? Math.max(0, Number(offset) || 0)
+            : Math.max(0, Math.min(Number(offset) || 0, maxOffset));
         if (this.paneUsesStickyBottomFollow(pane, state)) {
             const followBottom = options.followBottom !== undefined
                 ? Boolean(options.followBottom)
@@ -7468,7 +7615,7 @@ export class PilotSwarmUiController {
     updatePaneScrollFromViewport(pane, offset, options = {}) {
         const state = this.getState();
         if (this.paneUsesStickyBottomFollow(pane, state)) {
-            this.applyPaneVisualScrollOffset(pane, offset, options, state);
+            this.applyPaneVisualScrollOffset(pane, offset, { ...options, fromViewport: true }, state);
             return;
         }
         this.scrollPaneTo(pane, offset);

package/ui/core/src/layout.js

@@ -57,6 +57,16 @@ export function getMaxSessionPaneHeight(totalHeight, bodyHeight) {
     return Math.max(MIN_SESSION_PANE_HEIGHT, Math.min(maxByChatMinimum, maxByWindow));
 }
 
+export function getDiagnosticsSplitAdjustBounds(columnHeight, dividerHeight) {
+    const height = Math.max(0, Number(columnHeight) || 0);
+    const divider = clamp(Math.max(0, Number(dividerHeight) || 0), 0, height);
+    const minAdjust = -(height / 2);
+    return {
+        minAdjust,
+        maxAdjust: Math.max(minAdjust, (height / 2) - divider),
+    };
+}
+
 export function computeLegacyLayout(viewport, paneAdjust = 0, promptRows = 1, sessionPaneAdjust = 0, activityPaneAdjust = 0, fullscreenPane = null) {
     const safeViewport = normalizeViewport(viewport);
     const totalWidth = safeViewport.width;