pmx-canvas 0.7.3 → 0.8.2

package/src/client/nodes/use-workbench-asset.ts

@@ -0,0 +1,26 @@
+import { useEffect, useState } from 'preact/hooks';
+import { isHostedWorkbench, workbenchFetch } from '../state/workbench-transport';
+
+/** Asset bytes travel through the host, not a localhost URL in the user's browser. */
+export function useWorkbenchAsset(path: string): string | undefined {
+  const hosted = isHostedWorkbench() && path.startsWith('/');
+  const [asset, setAsset] = useState<{ path: string; url: string } | null>(null);
+  useEffect(() => {
+    if (!hosted) return;
+    let cancelled = false;
+    void workbenchFetch(path)
+      .then(async (response) => {
+        if (!response.ok) throw new Error(`Asset read failed: ${response.status}`);
+        const reader = new FileReader();
+        reader.onload = () => {
+          if (!cancelled && typeof reader.result === 'string') setAsset({ path, url: reader.result });
+        };
+        reader.readAsDataURL(await response.blob());
+      })
+      .catch((error: unknown) => console.error('[workbench-asset]', error));
+    return () => {
+      cancelled = true;
+    };
+  }, [path, hosted]);
+  return hosted ? (asset?.path === path ? asset.url : undefined) : path;
+}

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

@@ -11,7 +11,6 @@ import {
 import {
   pushAttentionHistory,
   resetAttentionState,
-  setAttentionFocus,
   setAttentionPulse,
   setAttentionToast,
   type AttentionEntry,
@@ -242,11 +241,6 @@ function entryFromEvent(event: SemanticWatchEvent): AttentionEntry | null {
   }
 }
 
-function applyAttentionSnapshot(): void {
-  const snapshot = reducer.getAttentionSnapshot();
-  setAttentionFocus(snapshot.primaryFocusNodeIds, snapshot.secondaryFocusNodeIds, snapshot.regions);
-}
-
 function flushToastQueue(): void {
   if (toastTimer !== null) return;
   const next = toastQueue.shift() ?? null;
@@ -322,8 +316,6 @@ export function syncAttentionFromSse(message: SseMessage): void {
     .map((event) => entryFromEvent(event))
     .filter((entry): entry is AttentionEntry => entry !== null);
 
-  applyAttentionSnapshot();
-
   for (const entry of entries) {
     if (shouldSuppressEntry(entry)) continue;
     pushAttentionHistory(entry);

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

@@ -1,5 +1,4 @@
 import { signal } from '@preact/signals';
-import type { SemanticAttentionRegion } from '../../shared/semantic-attention.js';
 
 export type AttentionTone = 'context' | 'relationship' | 'group' | 'cluster' | 'neighborhood' | 'remove';
 
@@ -14,9 +13,6 @@ export interface AttentionEntry {
 
 export const attentionToast = signal<AttentionEntry | null>(null);
 export const attentionHistory = signal<AttentionEntry[]>([]);
-export const attentionPrimaryNodeIds = signal<Set<string>>(new Set());
-export const attentionSecondaryNodeIds = signal<Set<string>>(new Set());
-export const attentionRegions = signal<SemanticAttentionRegion[]>([]);
 export const attentionPulseNodeIds = signal<Set<string>>(new Set());
 export const attentionHistoryOpen = signal<boolean>(false);
 export const attentionHistoryUnread = signal<number>(0);
@@ -24,9 +20,6 @@ export const attentionHistoryUnread = signal<number>(0);
 export function resetAttentionState(): void {
   attentionToast.value = null;
   attentionHistory.value = [];
-  attentionPrimaryNodeIds.value = new Set();
-  attentionSecondaryNodeIds.value = new Set();
-  attentionRegions.value = [];
   attentionPulseNodeIds.value = new Set();
   attentionHistoryOpen.value = false;
   attentionHistoryUnread.value = 0;
@@ -41,16 +34,6 @@ export function closeAttentionHistory(): void {
   attentionHistoryOpen.value = false;
 }
 
-export function setAttentionFocus(
-  primaryNodeIds: string[],
-  secondaryNodeIds: string[],
-  regions: SemanticAttentionRegion[],
-): void {
-  attentionPrimaryNodeIds.value = new Set(primaryNodeIds);
-  attentionSecondaryNodeIds.value = new Set(secondaryNodeIds);
-  attentionRegions.value = regions;
-}
-
 export function setAttentionToast(entry: AttentionEntry | null): void {
   attentionToast.value = entry;
 }

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

@@ -11,6 +11,7 @@ import {
 import { computeAutoArrange } from '../../shared/auto-arrange';
 import { canvasArea, canvasAreaCenter, canvasFitInsets } from '../canvas/canvas-area';
 import { pushCanvasUpdate, requestBestEffort, requestOk, updateViewportFromClient } from './intent-bridge';
+import { isHostedWorkbench } from './workbench-transport';
 
 function logCanvasStoreError(action: string, error: unknown): void {
   console.error(`[canvas-store] ${action} failed`, error);
@@ -39,7 +40,7 @@ export const reconnectAttempt = signal<number>(0);
 export const reconnectDelay = signal<number>(0);
 export const sessionId = signal<string>('');
 export const traceEnabled = signal<boolean>(false);
-export const canvasTheme = signal<string>('dark');
+export const canvasTheme = signal<string>('harbor');
 export const hasInitialServerLayout = signal<boolean>(false);
 // Compact AX state snapshot (work items, focus, …) mirrored from the server and
 // pushed into AX-enabled surfaces so authored boards can render the live queue.
@@ -775,7 +776,8 @@ export function persistLayout(options: { recordHistory?: boolean } = {}): void {
       })),
       contextPinnedNodeIds: Array.from(contextPinnedNodeIds.value),
     };
-    localStorage.setItem(STORAGE_KEY, JSON.stringify(layout));
+    // Opaque MCP App frames have no localStorage; the daemon persists layout.
+    if (!isHostedWorkbench()) localStorage.setItem(STORAGE_KEY, JSON.stringify(layout));
     void pushCanvasUpdate(nodeUpdates, options);
   } catch (error) {
     logCanvasStoreError('persistLayout', error);

package/src/client/state/context-status-store.ts

@@ -0,0 +1,66 @@
+import { signal } from '@preact/signals';
+import { activeBoardId } from './boards-store';
+import { requestJson } from './intent-bridge';
+
+/**
+ * What agents did with the board's context (docs/design/AgentContext.dc.html):
+ * per node, the latest agent read of its content and the revision it read;
+ * per pin, who pinned it, when and why. Server truth from
+ * `GET /api/canvas/ax/context-status`, refetched when a read lands
+ * (`context-status-changed`), when pins change, and on (re)connect.
+ */
+
+export interface NodeReadStatus {
+  nodeId: string;
+  lastReadAt: string;
+  lastReadBy: string;
+  readRevision: number;
+  readCount: number;
+}
+
+export interface ContextPinMeta {
+  pinnedBy: { actor: 'human' | 'agent' | 'system' | 'unknown'; source: string; agentId?: string };
+  pinnedAt: string;
+  reason?: string;
+}
+
+interface ContextStatusResponse {
+  ok?: boolean;
+  boardId?: string | null;
+  nodes?: NodeReadStatus[];
+  pins?: Record<string, ContextPinMeta>;
+}
+
+export const nodeReadStatus = signal<Map<string, NodeReadStatus>>(new Map());
+export const contextPinMeta = signal<Record<string, ContextPinMeta>>({});
+
+export function applyContextStatus(response: ContextStatusResponse): void {
+  nodeReadStatus.value = new Map((response.nodes ?? []).map((entry) => [entry.nodeId, entry]));
+  contextPinMeta.value = response.pins ?? {};
+}
+
+export async function refreshContextStatus(): Promise<void> {
+  const response = await requestJson<ContextStatusResponse>('fetchContextStatus', '/api/canvas/ax/context-status', {});
+  // A late answer for a board you have since left must not mark this one.
+  if (response.ok && response.boardId === activeBoardId.value) applyContextStatus(response);
+}
+
+/** How an agent's context relates to one pinned node — the mark its header shows. */
+export type PinnedReadState =
+  | { kind: 'not-read' }
+  | { kind: 'read'; by: string; at: string; count: number }
+  | { kind: 'changed'; by: string; at: string };
+
+export function pinnedReadState(nodeId: string, currentRevision: number): PinnedReadState {
+  const read = nodeReadStatus.value.get(nodeId);
+  const pinnedAt = contextPinMeta.value[nodeId]?.pinnedAt;
+  // Pinned after the latest read: the agent has not loaded it since you pinned it.
+  if (!read || (pinnedAt && read.lastReadAt < pinnedAt)) return { kind: 'not-read' };
+  if (currentRevision > read.readRevision) return { kind: 'changed', by: read.lastReadBy, at: read.lastReadAt };
+  return { kind: 'read', by: read.lastReadBy, at: read.lastReadAt, count: read.readCount };
+}
+
+/** Display name for an attributed writer: its agent id, else its transport label. */
+export function writerName(actor: { source: string; agentId?: string }): string {
+  return actor.agentId?.trim() || actor.source;
+}

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

@@ -6,6 +6,7 @@ import {
 } from '../../shared/human-presence.js';
 import { requestBestEffort, vetoGhostIntent } from './intent-bridge';
 import { intents, removeIntent } from './intent-store';
+import { isHostedWorkbench } from './workbench-transport';
 
 /**
  * Human collaborator presence (rail-chrome-v2 phase 8). This tab reports its
@@ -64,6 +65,7 @@ let lastSentAt = 0;
 let pending: ReturnType<typeof setTimeout> | null = null;
 
 function post(body: Record<string, unknown>): void {
+  if (isHostedWorkbench()) return;
   void requestBestEffort('humanPresence', '/api/canvas/human-presence', {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },

package/src/client/state/iframe-mode.ts

@@ -23,6 +23,7 @@
  */
 import { signal } from '@preact/signals';
 import { IFRAME_PROBE_MESSAGE_SOURCE } from '../../shared/iframe-probe.js';
+import { isHostedWorkbench } from './workbench-transport';
 
 export type IframeMode = 'src' | 'srcdoc';
 
@@ -105,6 +106,10 @@ function isAmpOrbHost(): boolean {
 export function resolveIframeMode(
   opts: { embedded?: boolean; ampOrb?: boolean; probeTimeoutMs?: number } = {},
 ): Promise<IframeMode> {
+  if (isHostedWorkbench()) {
+    iframeMode.value = 'srcdoc';
+    return Promise.resolve('srcdoc');
+  }
   if (iframeMode.value) return Promise.resolve(iframeMode.value);
   if (pending) return pending;
   const forced = forcedIframeMode();

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

@@ -1,8 +1,10 @@
 import { canvasArea } from '../canvas/canvas-area';
 import { showToast } from './attention-bridge';
+import { isHostedWorkbench, workbenchFetch } from './workbench-transport';
 import type { AgentPresenceSnapshot } from '../../shared/agent-presence.js';
 import type { CanvasEdge } from '../types';
 import { addEdge, canvasInteractionEpoch, nodes } from './canvas-store';
+import { boardsLoaded } from './boards-store';
 function logRequestError(action: string, error: unknown): void {
   console.error(`[intent-bridge] ${action} failed`, error);
 }
@@ -29,6 +31,7 @@ export const tabAgentKey: string | null = (() => {
  * opened with `?agent=<key>` identifies as that agent instead.
  */
 function withWorkbenchMarker(init?: RequestInit): RequestInit {
+  if (isHostedWorkbench()) return init ?? {};
   const headers = { ...(init?.headers as Record<string, string> | undefined) };
   if (tabAgentKey) {
     headers['x-pmx-source'] = tabAgentKey;
@@ -61,7 +64,7 @@ async function readJsonBody(res: Response): Promise<unknown> {
 
 export async function requestJson<T>(action: string, url: string, fallback: T, init?: RequestInit): Promise<T> {
   try {
-    const res = await fetch(url, withWorkbenchMarker(init));
+    const res = await workbenchFetch(url, withWorkbenchMarker(init));
     const body = await readJsonBody(res);
     reportRefusedWrite(res, init, body);
     if (body === null) throw new Error(`${res.status} response had no JSON body`);
@@ -74,7 +77,7 @@ export async function requestJson<T>(action: string, url: string, fallback: T, i
 
 export async function requestOk(action: string, url: string, init?: RequestInit): Promise<{ ok: boolean }> {
   try {
-    const res = await fetch(url, withWorkbenchMarker(init));
+    const res = await workbenchFetch(url, withWorkbenchMarker(init));
     if (!res.ok) reportRefusedWrite(res, init, await readJsonBody(res));
     return { ok: res.ok };
   } catch (error) {
@@ -85,7 +88,7 @@ export async function requestOk(action: string, url: string, init?: RequestInit)
 
 export async function requestBestEffort(action: string, url: string, init?: RequestInit): Promise<void> {
   try {
-    const res = await fetch(url, withWorkbenchMarker(init));
+    const res = await workbenchFetch(url, withWorkbenchMarker(init));
     if (!res.ok) reportRefusedWrite(res, init, await readJsonBody(res));
   } catch (error) {
     logRequestError(action, error);
@@ -328,8 +331,10 @@ export async function updateNodeFromClient(
     data?: Record<string, unknown>;
     /** Groups: replace the membership list (positions preserved). */
     children?: string[];
+    expectedContentRevision?: number;
+    expectedBoardId?: string | null;
   },
-): Promise<{ ok: boolean; id?: string }> {
+): Promise<{ ok: boolean; id?: string; contentRevision?: number }> {
   return requestJson(
     'updateNodeFromClient',
     `/api/canvas/node/${encodeURIComponent(id)}`,
@@ -477,6 +482,7 @@ function clientWindowSize(): { clientWidth: number; clientHeight: number } | Rec
  * window size before the human ever pans or zooms.
  */
 export async function reportClientViewportSize(): Promise<void> {
+  if (isHostedWorkbench() && !boardsLoaded.value) return;
   const size = clientWindowSize();
   if (!('clientWidth' in size)) return;
   await requestBestEffort('reportClientViewportSize', '/api/canvas/viewport', {

package/src/client/state/near-pin-store.ts

@@ -0,0 +1,53 @@
+import { computed } from '@preact/signals';
+import { findNeighborhoods } from '../../server/spatial-analysis.js';
+import { contextPinnedNodeIds, nodes } from './canvas-store';
+
+/**
+ * Near a pin (docs/design/NearPin.dc.html): each pinned node pulls up to five
+ * unpinned nodes within 600 px into the agent's brief as title + short
+ * summary. Same rule as the server's brief (`findNeighborhoods`), so the mark
+ * claims exactly what the agent receives.
+ */
+export interface NearPin {
+  pinNodeId: string;
+  pinTitle: string;
+}
+
+let lastKey = '';
+let lastNear = new Map<string, NearPin[]>();
+
+/**
+ * Unpinned node id → the pins it is near, nearest first. Every drag frame
+ * moves a node, so the result keeps its identity while no node's set of pins
+ * changes: the chips subscribed to it re-render only when a neighbourhood does.
+ */
+export const nearPins = computed<Map<string, NearPin[]>>(() => {
+  const pins = contextPinnedNodeIds.value;
+  const near = new Map<string, NearPin[]>();
+  if (pins.size > 0) {
+    const nearest = new Map<string, Array<NearPin & { distance: number }>>();
+    for (const neighborhood of findNeighborhoods([...nodes.value.values()], pins)) {
+      const pinTitle = neighborhood.pinnedNodeTitle ?? neighborhood.pinnedNodeId;
+      for (const neighbor of neighborhood.neighbors) {
+        const list = nearest.get(neighbor.id) ?? [];
+        list.push({ pinNodeId: neighborhood.pinnedNodeId, pinTitle, distance: neighbor.distance });
+        nearest.set(neighbor.id, list);
+      }
+    }
+    for (const [id, list] of nearest) {
+      list.sort((a, b) => a.distance - b.distance);
+      near.set(
+        id,
+        list.map(({ pinNodeId, pinTitle }) => ({ pinNodeId, pinTitle })),
+      );
+    }
+  }
+  const key = [...near]
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([id, list]) => `${id}:${list.map((pin) => `${pin.pinNodeId}=${pin.pinTitle}`).join(',')}`)
+    .join('|');
+  if (key === lastKey) return lastNear;
+  lastKey = key;
+  lastNear = near;
+  return near;
+});

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

@@ -32,18 +32,13 @@ export const writersSheetOpen = signal(false);
 export const activityFilter = signal<string | null>(null);
 
 /**
- * Per-writer identity colors from the accent set, agent-violet first,
- * assigned in order of first appearance and stable for the page's life — a
- * writer that fades and returns keeps its color.
+ * A writer's colour says what it is, not who: agents take the agent violet,
+ * subagents (fleet workers) the subagent fuchsia. Writers are told apart by
+ * name and initial (docs/design.md, "Kinds carry no colour").
  */
-const WRITER_PALETTE = ['var(--c-purple)', 'var(--c-accent)', 'var(--c-ok)', 'var(--c-warn)', 'var(--c-danger)'];
-const writerColors = new Map<string, string>();
 export function writerColor(sessionId: string): string {
-  const known = writerColors.get(sessionId);
-  if (known) return known;
-  const color = WRITER_PALETTE[writerColors.size % WRITER_PALETTE.length]!;
-  writerColors.set(sessionId, color);
-  return color;
+  const presence = agentPresences.value.find((entry) => entry.sessionId === sessionId);
+  return presence?.parentAgentId ? 'var(--c-subagent)' : 'var(--c-agent)';
 }
 
 /** Avatar initial: first letter of the label, upper-cased. */

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