pilotswarm 0.5.39 → 0.5.40

package/package.json

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

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

@@ -2111,6 +2111,31 @@ export class NodeSdkTransport {
         return this.mgmt.getSessionEventsBefore(sessionId, beforeSeq, limit, eventTypes);
     }
 
+    async getCanvasLive(sessionId) {
+        if (typeof this.mgmt.getCanvasLive !== "function") return [];
+        return this.mgmt.getCanvasLive(sessionId);
+    }
+
+    async getCanvasShareLink(sessionId, slot) {
+        if (typeof this.mgmt.getCanvasShareLink !== "function") return { exists: false };
+        return this.mgmt.getCanvasShareLink(sessionId, slot);
+    }
+
+    async resetCanvasShareLink(sessionId, slot, createdBy) {
+        if (typeof this.mgmt.resetCanvasShareLink !== "function") throw new Error("canvas share links unavailable");
+        return this.mgmt.resetCanvasShareLink(sessionId, slot, createdBy);
+    }
+
+    async resolveCanvasShareTokenHash(tokenHash) {
+        if (typeof this.mgmt.resolveCanvasShareTokenHash !== "function") return null;
+        return this.mgmt.resolveCanvasShareTokenHash(tokenHash);
+    }
+
+    async removeCanvasShareLink(sessionId, slot) {
+        if (typeof this.mgmt.removeCanvasShareLink !== "function") return { removed: false };
+        return this.mgmt.removeCanvasShareLink(sessionId, slot);
+    }
+
     emitLogEntry(entry) {
         if (!this._logBatch) this._logBatch = [];
         this._logBatch.push(entry);

package/ui/core/src/controller.js

@@ -4499,8 +4499,41 @@ export class PilotSwarmUiController {
         return true;
     }
 
+    applyCanvasDataEvent(sessionId, event) {
+        this.dispatch({
+            type: "canvas/data",
+            sessionId,
+            slot: Number(event?.data?.slot) || 1,
+            dataRev: Number(event?.data?.dataRev),
+            payload: event?.data?.payload,
+            // Plane-fed ticks (the canvas data plane's live mirror) carry
+            // their own seq lineage and the patch that produced them — the
+            // reducer orders plane ticks by planeSeq and hands the patch to
+            // pages that opt into targeted updates.
+            ...(Number.isFinite(Number(event?.data?.planeSeq)) ? { planeSeq: Number(event.data.planeSeq) } : {}),
+            ...(event?.data?.patch && typeof event.data.patch === "object" ? { patch: event.data.patch } : {}),
+            note: typeof event?.data?.note === "string" ? event.data.note : "",
+        });
+    }
+
     mergeSessionEvent(sessionId, event) {
         if (!sessionId || !event) return false;
+        // Plane-synthesized canvas events are TRANSIENT: they update canvas
+        // state and nothing else. They carry no seq — letting them into
+        // history would corrupt the replay cursor — and they must never
+        // appear in the transcript.
+        if (event.transient === true) {
+            if (event.eventType === "session.canvas_data") {
+                this.applyCanvasDataEvent(sessionId, event);
+            }
+            if (event.eventType === "session.canvas_plane_released") {
+                // The plane died for this session (server error/rollback).
+                // Clear the reducer's takeover so legacy durable ticks — the
+                // fallback path — apply again instead of being dropped.
+                this.dispatch({ type: "canvas/planeReleased", sessionId });
+            }
+            return false;
+        }
         const state = this.getState();
         const existing = state.history.bySessionId.get(sessionId) || { chat: [], activity: [], lastSeq: 0 };
         if (event.seq <= (existing.lastSeq || 0)) return false;
@@ -4561,14 +4594,7 @@ export class PilotSwarmUiController {
             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 : "",
-            });
+            this.applyCanvasDataEvent(sessionId, event);
         }
         this.reconcileOutboxAgainstEvent(sessionId, event);
         const derivedModel = extractSessionModelFromEvent(event);

package/ui/core/src/history.js

@@ -1123,7 +1123,11 @@ export function appendEventToHistory(history, event) {
         chat: clampHistoryItems(history?.chat || [], loadedEventLimit),
         activity: clampHistoryItems(history?.activity || [], loadedEventLimit),
         events: nextEvents,
-        lastSeq: event.seq,
+        // The replay cursor. A seq-less event (plane-synthesized canvas
+        // ticks are transient and carry none) must never poison it —
+        // lastSeq=undefined reads as afterSeq 0 on the next sync and the
+        // whole transcript re-merges, duplicated.
+        lastSeq: Number.isFinite(Number(event.seq)) ? event.seq : (history?.lastSeq || 0),
         loadedEventLimit,
         loadedEventCount: Math.max(Number(history?.loadedEventCount || 0), nextEvents.length),
         hasOlderEvents: Boolean(history?.hasOlderEvents),

package/ui/core/src/index.js

@@ -8,6 +8,7 @@ export * from "./repo-import.js";
 export * from "./session-tree.js";
 export * from "./state.js";
 export * from "./reducer.js";
+export * from "./portal-links.js";
 export * from "./store.js";
 export * from "./selectors.js";
 export * from "./controller.js";

package/ui/core/src/portal-links.js

@@ -0,0 +1,46 @@
+/**
+ * Multi-origin portal links.
+ *
+ * A deployment can be reachable through several entry points at once — a
+ * public edge and a private/VPN hostname, say — and a link built from the
+ * sender's window.location.origin only works for recipients on the SAME
+ * network path. When the portal is configured with named link origins,
+ * every link-producing surface offers one variant per origin, labeled.
+ *
+ * This replaces waldemort's deploy-time monkey patch
+ * (patch-pilotswarm-dual-session-links.mjs), which anchor-matched the
+ * minified bundle and broke on every release. The plug-in surface is one
+ * env var on the portal server: PORTAL_LINK_ORIGINS.
+ */
+
+/**
+ * Rebase one produced URL onto each configured origin.
+ * @param {string} url - a full URL produced against the current origin
+ * @param {Array<{label: string, origin: string}>} linkOrigins
+ * @returns {Array<{label: string|null, url: string}>} one entry per origin;
+ *   with no (or one) configured origin, a single unlabeled entry with the
+ *   original URL — zero behavior change for plain deployments.
+ */
+export function buildPortalLinks(url, linkOrigins) {
+    const origins = Array.isArray(linkOrigins) ? linkOrigins.filter((o) => o?.origin && o?.label) : [];
+    if (origins.length < 2) return [{ label: null, url: String(url || "") }];
+    let suffix;
+    try {
+        const parsed = new URL(String(url || ""));
+        suffix = `${parsed.pathname}${parsed.search}${parsed.hash}`;
+    } catch {
+        return [{ label: null, url: String(url || "") }];
+    }
+    return origins.map((o) => ({ label: String(o.label), url: `${o.origin}${suffix}` }));
+}
+
+/**
+ * Clipboard shape: a bare URL for the single-origin case; one labeled line
+ * per origin otherwise, so the sender pastes both and the recipient picks
+ * the one their network can reach.
+ */
+export function formatPortalLinksForCopy(links) {
+    const list = Array.isArray(links) ? links : [];
+    if (list.length <= 1) return String(list[0]?.url || "");
+    return list.map((l) => `${l.label}: ${l.url}`).join("\n");
+}

package/ui/core/src/reducer.js

@@ -1570,6 +1570,39 @@ export function appReducer(state, action) {
             if (previousActiveId && previousActiveId !== action.sessionId) {
                 savedChatScroll[previousActiveId] = Number(state.ui.scroll?.chat) || 0;
             }
+            // Per-session prompt drafts: a half-written message belongs to the
+            // session it was written in. Stash the outgoing draft (text +
+            // staged attachments) and restore the incoming one, exactly like
+            // the chat-scroll memory above. Exception: while editing a pending
+            // outbox message the composer text lives in that outbox item, not
+            // in a draft — leave the item alone, drop the edit latch, and give
+            // the incoming session its own draft back.
+            const switchingSession = previousActiveId !== action.sessionId;
+            const savedDrafts = { ...(state.ui.promptDraftBySession || {}) };
+            let nextPrompt = state.ui.prompt;
+            let nextPromptCursor = state.ui.promptCursor;
+            let nextPromptAttachments = state.ui.promptAttachments;
+            let nextPromptEdit = state.ui.promptEdit ?? null;
+            if (switchingSession) {
+                const editingPending = Boolean(state.ui.promptEdit);
+                if (!editingPending && previousActiveId) {
+                    const outgoing = {
+                        prompt: String(state.ui.prompt || ""),
+                        attachments: Array.isArray(state.ui.promptAttachments) ? state.ui.promptAttachments : [],
+                    };
+                    if (outgoing.prompt || outgoing.attachments.length > 0) {
+                        savedDrafts[previousActiveId] = outgoing;
+                    } else {
+                        delete savedDrafts[previousActiveId];
+                    }
+                }
+                const incoming = action.sessionId ? savedDrafts[action.sessionId] : null;
+                delete savedDrafts[action.sessionId];
+                nextPrompt = incoming?.prompt || "";
+                nextPromptCursor = nextPrompt.length;
+                nextPromptAttachments = Array.isArray(incoming?.attachments) ? incoming.attachments : [];
+                nextPromptEdit = null;
+            }
             // Manual navigation to a different session releases the deep-link
             // latch and its transient filter exception.
             const releasesNavigationLatch = Boolean(
@@ -1588,6 +1621,12 @@ export function appReducer(state, action) {
                 ui: {
                     ...state.ui,
                     chatScrollBySession: savedChatScroll,
+                    promptDraftBySession: savedDrafts,
+                    prompt: nextPrompt,
+                    promptCursor: nextPromptCursor,
+                    promptRows: getPromptInputRows(nextPrompt),
+                    promptAttachments: nextPromptAttachments,
+                    promptEdit: nextPromptEdit,
                     // Status notices are per-moment, usually per-session (send
                     // refusals, access hints) — a stale one must not follow the
                     // user to the next session.
@@ -1861,6 +1900,8 @@ export function appReducer(state, action) {
             for (const id of ids) delete nextOutbox[id];
             const nextChatScroll = { ...(state.ui.chatScrollBySession || {}) };
             for (const id of ids) delete nextChatScroll[id];
+            const nextDrafts = { ...(state.ui.promptDraftBySession || {}) };
+            for (const id of ids) delete nextDrafts[id];
             return {
                 ...state,
                 history: {
@@ -1874,6 +1915,7 @@ export function appReducer(state, action) {
                 ui: {
                     ...state.ui,
                     chatScrollBySession: nextChatScroll,
+                    promptDraftBySession: nextDrafts,
                 },
             };
         }
@@ -2953,7 +2995,20 @@ export function appReducer(state, action) {
             const dataRev = Number(action.dataRev);
             if (!sessionId || !Number.isFinite(dataRev) || dataRev <= 0) return state;
             const existing = state.canvas.bySessionId[key] || {};
-            if ((existing.latestDataRev || 0) >= dataRev) return state;
+            const planeSeq = Number(action.planeSeq);
+            const isPlane = Number.isFinite(planeSeq) && planeSeq > 0;
+            // Plane takeover: once a slot has seen ONE plane-fed tick, that
+            // lineage owns the slot. Plane ticks order by planeSeq (their
+            // numbering restarts relative to legacy dataRev, so the numeric
+            // guard below would wrongly starve them); legacy dual-written
+            // events for a plane-owned slot are strictly staler copies of
+            // state the plane already delivered — drop them.
+            if (isPlane) {
+                if ((existing.planeSeq || 0) >= planeSeq) return state;
+            } else {
+                if (existing.planeSeq) return state;
+                if ((existing.latestDataRev || 0) >= dataRev) return state;
+            }
             return {
                 ...state,
                 canvas: {
@@ -2962,14 +3017,45 @@ export function appReducer(state, action) {
                         ...state.canvas.bySessionId,
                         [key]: {
                             ...existing,
-                            latestDataRev: dataRev,
+                            // The DISPLAYED tick number stays monotonic across
+                            // the takeover: viewed-marking and badges compare
+                            // against it, and a smaller number would replay
+                            // as "already seen".
+                            latestDataRev: Math.max(dataRev, existing.latestDataRev || 0),
+                            ...(isPlane ? { planeSeq } : {}),
                             dataPayload: action.payload && typeof action.payload === "object" ? action.payload : null,
+                            // The patch that produced this state, for pages
+                            // that opt into targeted updates. Whole-state
+                            // ticks clear it — there is no delta to hand out.
+                            dataPatch: isPlane && action.patch && typeof action.patch === "object" ? action.patch : null,
                         },
                     },
                 },
             };
         }
 
+        case "canvas/planeReleased": {
+            // The plane died for this session: release the takeover on every
+            // slot so legacy durable ticks resume applying. Displayed tick
+            // numbers (latestDataRev) survive, so stale legacy dupes still
+            // drop by ordinary ordering while fresh ones flow.
+            const sessionId = String(action.sessionId || "").trim();
+            if (!sessionId) return state;
+            let changed = false;
+            const nextBySession = { ...state.canvas.bySessionId };
+            for (let slot = 1; slot <= 5; slot++) {
+                const key = canvasKey(sessionId, slot);
+                const entry = nextBySession[key];
+                if (entry && entry.planeSeq) {
+                    const { planeSeq: _released, ...rest } = entry;
+                    nextBySession[key] = rest;
+                    changed = true;
+                }
+            }
+            if (!changed) return state;
+            return { ...state, canvas: { ...state.canvas, bySessionId: nextBySession } };
+        }
+
         case "canvas/snapshot": {
             const sessionId = String(action.sessionId || "").trim();
             if (!sessionId) return state;

package/ui/core/src/selectors.js

@@ -2769,6 +2769,8 @@ export function selectCanvasView(state) {
         latestDataRev,
         lastViewedDataRev,
         dataPayload: entry?.dataPayload || null,
+        dataPatch: entry?.dataPatch || null,
+        planeSeq: entry?.planeSeq || 0,
         unseen: exists && (latestRev > lastViewedRev || latestDataRev > lastViewedDataRev) && mode !== "canvas",
     };
 }