pmx-canvas 0.7.3 → 0.8.0

package/src/client/state/session-store.ts

@@ -1,3 +1,5 @@
+import { isHostedWorkbench } from './workbench-transport';
+import { showToast } from './attention-bridge';
 import { computed, signal } from '@preact/signals';
 import type { AxApprovalStatus, AxEventKind, AxWorkItemStatus } from '../../shared/ax-kinds.js';
 import { HUMAN_STARTED_SESSION_LABEL } from '../../shared/agent-presence.js';
@@ -207,7 +209,7 @@ export function mergeTimeline(
       // Activity entries are already attributed server-side — the sessionId is
       // the identity key (hue-stable across chrome), the label its display name.
       who: write.sessionId ?? null,
-      ...(top?.actor === 'agent' && newestWrite?.id === write.id ? { undoable: true } : {}),
+      ...(!isHostedWorkbench() && top?.actor === 'agent' && newestWrite?.id === write.id ? { undoable: true } : {}),
     })),
     ...timeline.events.map((event) => ({
       id: `event-${event.id}`,
@@ -298,6 +300,10 @@ export async function undoAgentEdit(entry: TimelineEntry): Promise<boolean> {
 
 /** Ctrl+Z / Ctrl+Shift+Z: whichever op is top of the shared stack, agent or human. */
 export async function undoFromKeyboard(redo = false): Promise<boolean> {
+  if (isHostedWorkbench()) {
+    showToast('remove', 'Undo / redo unavailable', 'Open the local PMX workbench to use shared history.');
+    return false;
+  }
   const result = await requestOk(redo ? 'redo' : 'undo', redo ? '/api/canvas/redo' : '/api/canvas/undo', {
     method: 'POST',
   });
@@ -371,37 +377,117 @@ export async function endSession(session: { source: string; agentId: string | nu
 }
 
 export interface SessionReceipt {
-  label: string;
+  /** Distinct labels of the sessions on this card (one unless merged). */
+  labels: string[];
+  /** Endings folded into this card (see applySessionReceipt). */
+  sessions: number;
   endedAt: string;
   /** Why it ended — the receipt should answer this, not leave the human asking. */
   endedBy?: 'human' | 'agent' | 'idle-timeout';
-  /** The session changed nothing on the board (its pre-session snapshot was dropped). */
-  unchanged?: boolean;
   /** Cancelled (withdrawn items), rejected (human's explicit no on a gate), and
    * held (TTL expired unanswered) are three different outcomes — never one
    * "vetoed" pile. */
   counts: { items: number; done: number; cancelled: number; rejected: number; held: number };
+  /** The pre-session snapshot; null when the board was empty at attach, or on a
+   * merged receipt (each session's snapshot is in History). */
   snapshot: { id: string; name: string } | null;
+  /** What the session did with context (docs/design/AgentContext.dc.html receipt). */
+  context: SessionContextActivity;
+}
+
+export interface ReceiptNode {
+  id: string;
+  title: string;
+  reason?: string;
+}
+
+export interface SessionContextActivity {
+  read: ReceiptNode[];
+  pinned: ReceiptNode[];
+  created: ReceiptNode[];
+  edited: ReceiptNode[];
+  changedSinceRead: ReceiptNode[];
+}
+
+function receiptNodes(value: unknown): ReceiptNode[] {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry) => {
+    if (!entry || typeof entry !== 'object') return [];
+    const record = entry as Record<string, unknown>;
+    if (typeof record.id !== 'string' || typeof record.title !== 'string') return [];
+    return [
+      { id: record.id, title: record.title, ...(typeof record.reason === 'string' ? { reason: record.reason } : {}) },
+    ];
+  });
+}
+
+/**
+ * The agent-activity lens: while on, nodes the last session did not touch
+ * (read, pin, create, edit) are dimmed. Null when off.
+ */
+export const activityLensNodeIds = signal<Set<string> | null>(null);
+
+export function setActivityLens(on: boolean): void {
+  const context = sessionReceipt.value?.context;
+  activityLensNodeIds.value =
+    on && context
+      ? new Set([...context.read, ...context.pinned, ...context.created, ...context.edited].map((node) => node.id))
+      : null;
 }
 
 /** The last ended session's receipt (design item 2); client-side, cleared on dismiss. */
 export const sessionReceipt = signal<SessionReceipt | null>(null);
 
+function unionNodes(a: ReceiptNode[], b: ReceiptNode[]): ReceiptNode[] {
+  const seen = new Set(a.map((node) => node.id));
+  return [...a, ...b.filter((node) => !seen.has(node.id))];
+}
+
+/**
+ * Endings that arrive while a receipt is still up fold into it, so a burst of
+ * sessions shows one card. A merged card carries no single snapshot — no one
+ * snapshot undoes overlapping sessions — and points at History instead.
+ */
+function mergeReceipts(open: SessionReceipt, next: SessionReceipt): SessionReceipt {
+  return {
+    labels: [...new Set([...open.labels, ...next.labels])],
+    sessions: open.sessions + 1,
+    endedAt: next.endedAt,
+    endedBy: open.endedBy === next.endedBy ? next.endedBy : undefined,
+    // Board-wide counts: the latest frame is the current board.
+    counts: next.counts,
+    snapshot: null,
+    context: {
+      read: unionNodes(open.context.read, next.context.read),
+      pinned: unionNodes(open.context.pinned, next.context.pinned),
+      created: unionNodes(open.context.created, next.context.created),
+      edited: unionNodes(open.context.edited, next.context.edited),
+      changedSinceRead: unionNodes(open.context.changedSinceRead, next.context.changedSinceRead),
+    },
+  };
+}
+
+/**
+ * The receipt rule: a pop-up only for a top-level session that changed the
+ * board or read/pinned context. `unchanged` endings and worker endings
+ * (`parentAgentId` set — their orchestrator's receipt covers the board since
+ * it attached) stay in the timeline and History only, and never replace or
+ * extend an open receipt. Qualifying endings while one is up merge into it.
+ */
 export function applySessionReceipt(data: Record<string, unknown>): void {
   const counts = data.counts as Partial<SessionReceipt['counts']> | undefined;
   const snapshot = data.snapshot as SessionReceipt['snapshot'] | undefined;
+  const context = data.context as Record<string, unknown> | undefined;
   if (typeof data.label !== 'string' || typeof data.endedAt !== 'string') return;
-  // Keep history/timeline intact, but only interrupt for a changed top-level
-  // session. Quiet endings must not replace an existing useful receipt.
   if (data.unchanged === true || typeof data.parentAgentId === 'string') return;
-  sessionReceipt.value = {
-    label: data.label,
+  const next: SessionReceipt = {
+    labels: [data.label],
+    sessions: 1,
     endedAt: data.endedAt,
     endedBy:
       data.endedBy === 'human' || data.endedBy === 'agent' || data.endedBy === 'idle-timeout'
         ? data.endedBy
         : undefined,
-    unchanged: data.unchanged === true,
     counts: {
       items: Number(counts?.items ?? 0) || 0,
       done: Number(counts?.done ?? 0) || 0,
@@ -411,11 +497,22 @@ export function applySessionReceipt(data: Record<string, unknown>): void {
     },
     snapshot:
       snapshot && typeof snapshot.id === 'string' ? { id: snapshot.id, name: String(snapshot.name ?? '') } : null,
+    context: {
+      read: receiptNodes(context?.read),
+      pinned: receiptNodes(context?.pinned),
+      created: receiptNodes(context?.created),
+      edited: receiptNodes(context?.edited),
+      changedSinceRead: receiptNodes(context?.changedSinceRead),
+    },
   };
+  const open = sessionReceipt.value;
+  sessionReceipt.value = open ? mergeReceipts(open, next) : next;
+  if (open && activityLensNodeIds.value) setActivityLens(true);
 }
 
 export function dismissSessionReceipt(): void {
   sessionReceipt.value = null;
+  activityLensNodeIds.value = null;
 }
 
 export function resetSessionStore(): void {

package/src/client/state/sse-bridge.ts

@@ -1,7 +1,8 @@
 import { findOpenCanvasPosition } from '../utils/placement.js';
 import { ownsCamera } from './presentation';
+import { isHostedWorkbench, workbenchFetch } from './workbench-transport';
 import { normalizeExtAppToolResult } from '../utils/ext-app-tool-result.js';
-import type { CanvasAnnotation, CanvasEdge, CanvasNodeState } from '../types';
+import type { CanvasAnnotation, CanvasEdge, CanvasNodeState, NodeActor } from '../types';
 import {
   activeNodeId,
   addEdge,
@@ -30,6 +31,7 @@ import {
   resetCanvasInteractionState,
 } from './canvas-store';
 import { applyBoards, loadBoards, setBoardSwitchHandler } from './boards-store';
+import { applyContextStatus, refreshContextStatus } from './context-status-store';
 import {
   fetchAgentPresence,
   fetchAxSurfaceState,
@@ -75,6 +77,7 @@ let pollGeneration = 0;
 let sseFirstEventWatchdog: ReturnType<typeof setTimeout> | null = null;
 
 export function forcedTransport(): 'poll' | 'sse' | null {
+  if (isHostedWorkbench()) return 'poll';
   if (typeof location === 'undefined' || typeof window === 'undefined') return null;
   const value = new URLSearchParams(location.search).get('transport');
   if (value === 'poll' || value === 'sse') return value;
@@ -365,10 +368,19 @@ function parseCanvasNode(raw: Record<string, unknown>): CanvasNodeState | null {
     zIndex: typeof raw.zIndex === 'number' ? raw.zIndex : 1,
     collapsed: raw.collapsed === true,
     pinned: raw.pinned === true,
+    contentRevision: typeof raw.contentRevision === 'number' ? raw.contentRevision : 0,
+    ...(isActor(raw.createdBy) ? { createdBy: raw.createdBy } : {}),
+    ...(isActor(raw.lastEditedBy) ? { lastEditedBy: raw.lastEditedBy } : {}),
     data,
   };
 }
 
+function isActor(value: unknown): value is NodeActor {
+  if (!value || typeof value !== 'object') return false;
+  const record = value as Record<string, unknown>;
+  return typeof record.actor === 'string' && typeof record.source === 'string';
+}
+
 function parseCanvasEdge(raw: Record<string, unknown>): CanvasEdge | null {
   if (typeof raw.id !== 'string' || !raw.id) return null;
   if (typeof raw.from !== 'string' || !raw.from) return null;
@@ -481,6 +493,7 @@ function resyncForBoardSwitch(): void {
   resetCanvasInteractionState();
   resetAttentionBridge();
   dismissSessionReceipt();
+  applyContextStatus({});
   axSurfaceState.value = null;
   void refreshAxSurface();
   const layoutAtRequest = layoutRevision;
@@ -499,21 +512,21 @@ setBoardSwitchHandler(resyncForBoardSwitch);
 function handleConnected(data: Record<string, unknown>): void {
   sessionId.value = (data.sessionId as string) || '';
   connectionStatus.value = 'connected';
-  void loadBoards();
+  // Hosted writes capture the active board. Load its identity before reporting
+  // the viewport, rather than sending a spurious Home precondition on boot.
+  void loadBoards().then(reportClientViewportSize);
   // Reconnect marker for holders of server-minted URLs (Finding S).
   workbenchConnectionEpoch.value += 1;
   reloadIfServerUpgraded(data.version, data.bundleStamp);
-  // Tell the server how big this window actually is, so an agent `fit` sizes
-  // the board to the human's window (0.4.6 orb feedback #2).
-  void reportClientViewportSize();
   // Agent presence: read the snapshot on (re)connect; `agent-presence` frames
   // keep it live from here on.
   void fetchAgentPresence().then(applyPresenceSnapshot);
+  void refreshContextStatus();
   // Human collaborators (phase 8): announce this tab and read who else is here.
   // An `?agent=<key>` tab is an AGENT's view — it must not heartbeat a human
   // guest cursor (its writes already book as the agent).
   stopHumanPresence?.();
-  if (!tabAgentKey) stopHumanPresence = startHumanPresence();
+  if (!tabAgentKey && !isHostedWorkbench()) stopHumanPresence = startHumanPresence();
   void requestJson<Partial<HumanPresenceSnapshot> | null>(
     'fetchHumanPresence',
     '/api/canvas/human-presence',
@@ -1033,6 +1046,11 @@ function handleContextPinsChanged(data: Record<string, unknown>): void {
   const nodeIds = Array.isArray(data.nodeIds) ? data.nodeIds.filter((id): id is string => typeof id === 'string') : [];
   replaceContextPinsFromServer(nodeIds);
   syncAttentionFromSse({ event: 'context-pins-changed', data });
+  void refreshContextStatus();
+}
+
+function handleContextStatusChanged(): void {
+  void refreshContextStatus();
 }
 
 // AX state changes arrive as per-primitive deltas; rather than reduce them, treat
@@ -1109,6 +1127,7 @@ export const EVENT_HANDLERS: Record<string, (data: Record<string, unknown>) => v
   'ext-app-update': handleExtAppUpdate,
   'ext-app-result': handleExtAppResult,
   'context-pins-changed': handleContextPinsChanged,
+  'context-status-changed': handleContextStatusChanged,
   'boards-changed': applyBoards,
   'canvas-layout-update': handleCanvasLayoutUpdate,
   'canvas-focus-node': handleCanvasFocusNode,
@@ -1170,7 +1189,7 @@ function startPollingTransport(): () => void {
       const sid = sessionId.value;
       if (sid) params.set('session', sid);
       const query = params.toString();
-      const response = await fetch(`/api/workbench/poll${query ? `?${query}` : ''}`);
+      const response = await workbenchFetch(`/api/workbench/poll${query ? `?${query}` : ''}`);
       if (generation !== pollGeneration) return;
       if (!response.ok) throw new Error(`poll failed with HTTP ${response.status}`);
       const body = (await response.json()) as {

package/src/client/state/theme-override.ts

@@ -76,7 +76,7 @@ export function initSessionThemeOverride(apply: (theme: CanvasThemeName) => void
   }
   schemeQuery = window.matchMedia('(prefers-color-scheme: light)');
   schemeListener = () => {
-    if (active && schemeQuery) apply(schemeQuery.matches ? 'light' : 'dark');
+    if (active && schemeQuery) apply(schemeQuery.matches ? 'daylight' : 'harbor');
   };
   schemeListener();
   schemeQuery.addEventListener('change', schemeListener);

package/src/client/state/workbench-transport.ts

@@ -0,0 +1,36 @@
+/** The normal workbench uses HTTP; an MCP App installs its host transport before mounting. */
+type WorkbenchFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+let hostFetch: WorkbenchFetch | undefined;
+
+export function installWorkbenchTransport(transport: WorkbenchFetch | undefined): void {
+  hostFetch = transport;
+}
+
+export function isHostedWorkbench(): boolean {
+  return hostFetch !== undefined;
+}
+
+export const workbenchFetch: WorkbenchFetch = (input, init) =>
+  hostFetch ? hostFetch(input, init) : globalThis.fetch(input, init);
+
+type WorkbenchDownload = (file: { name: string; mimeType: string; text: string }) => Promise<{ isError?: boolean }>;
+let hostDownload: WorkbenchDownload | undefined;
+
+export function installWorkbenchDownload(download: WorkbenchDownload | undefined): void {
+  hostDownload = download;
+}
+
+/** Export files live on PMX, not on the embedded frame's sandbox origin. */
+export async function downloadWorkbenchExport(path: string): Promise<void> {
+  if (!hostDownload)
+    throw new Error('This host does not support downloads. The export is saved in the local PMX workspace.');
+  if (!/^\/api\/canvas\/exports\/[^/?#]+$/.test(path)) throw new Error('Invalid export path.');
+  const response = await workbenchFetch(path);
+  if (!response.ok) throw new Error('Could not read the export. Try again.');
+  const result = await hostDownload({
+    name: decodeURIComponent(path.slice(path.lastIndexOf('/') + 1)),
+    mimeType: 'text/html',
+    text: await response.text(),
+  });
+  if (result.isError) throw new Error('The download was cancelled or declined by the host.');
+}