pmx-canvas 0.4.7 → 0.5.0

package/src/server/scope-fence.ts

@@ -0,0 +1,207 @@
+/**
+ * Scope fence enforcement (rail-chrome-v2 phase 4, design item 4).
+ *
+ * When the AX policy carries a scope fence, an attached agent may only WRITE
+ * inside it: existing-node writes must target fenced nodes, new nodes must
+ * land inside the fence's bounding box (fenced nodes + padding), and
+ * board-wide writes (arrange, clear, restore) are refused. Reads are never
+ * fenced, and neither are the human's own workbench writes — the fence is the
+ * human's tool, not a cage for the human.
+ *
+ * One core check (`checkFenceTarget`) serves two describers: the operation
+ * registry (`checkScopeFence`, every HTTP/MCP/CLI write) and the sync SDK,
+ * whose methods bypass the registry and describe their own targets.
+ *
+ * Safe default: a mutating op this module does not know how to scope is
+ * refused while a fence is set, rather than silently allowed. Likewise a
+ * write this module cannot resolve (an edge given by search, a missing id)
+ * is refused — fail closed, never a bypass.
+ *
+ * Trust note: the workbench marker is a self-reported header. Under the
+ * local single-workspace model that is by design (any local process may
+ * write; the safety model is human veto plus this fence), so the fence holds
+ * cooperating agents to the region the human granted — it is not an
+ * authentication boundary.
+ */
+import { type FenceRect, fenceRectFromNodes } from '../shared/scope-fence.js';
+import { canvasState } from './canvas-state.js';
+import type { Operation } from './operations/types.js';
+
+/** Bounding box of the fenced nodes plus padding; null when none of them exist. */
+export function scopeFenceRect(fence: { nodeIds: string[]; padding: number }): FenceRect | null {
+  const nodes = fence.nodeIds
+    .map((id) => canvasState.getNode(id))
+    .filter((node): node is NonNullable<typeof node> => node !== undefined);
+  return fenceRectFromNodes(nodes, fence.padding);
+}
+
+/** What a write touches, in fence terms. */
+export interface FenceTarget {
+  /** Existing nodes the write targets — every one must be fenced. */
+  nodeIds?: string[];
+  /** World points a write introduces (a new node, annotation points) — all must be inside the box. */
+  points?: Array<{ x: number; y: number }>;
+  /** A new node with no position: refused (it cannot be placed inside the fence). */
+  unplacedCreate?: boolean;
+  /** Rewrites the whole board — never allowed under a fence. */
+  boardWide?: boolean;
+  /** The op is not fence-aware — refused while a fence is set. */
+  unknown?: string;
+}
+
+function inside(rect: FenceRect, x: number, y: number): boolean {
+  return x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height;
+}
+
+/** Returns a human-readable refusal, or null when the target is inside the fence. */
+export function checkFenceTarget(target: FenceTarget, opName: string, writerKey?: string): string | null {
+  const policy = canvasState.getPolicy();
+  // Per-agent territory (fleet orchestration) overrides the global fence for
+  // that writer; writers without a territory fall under the global fence.
+  const territory = writerKey ? policy.agentScopes[writerKey] : undefined;
+  const fence = territory ?? policy.scope;
+  if (!fence) return null;
+  const describe = territory
+    ? `your assigned territory (${fence.nodeIds.length} node${fence.nodeIds.length === 1 ? '' : 's'}); reads are allowed — ask the orchestrator or the human to widen it`
+    : `the agent scope fence (${fence.nodeIds.length} node${fence.nodeIds.length === 1 ? '' : 's'}); reads are allowed — ask the human to widen the fence`;
+  if (target.boardWide) return `"${opName}" rewrites the whole board, which is outside ${describe}.`;
+  if (target.unknown) return `"${target.unknown}" is not fence-aware and was refused under ${describe}.`;
+  const fenced = new Set(fence.nodeIds);
+  for (const id of target.nodeIds ?? []) {
+    if (!fenced.has(id)) return `node "${id}" is outside ${describe}.`;
+  }
+  if (target.unplacedCreate) return `new nodes need an explicit x/y inside ${describe}.`;
+  if (target.points && target.points.length > 0) {
+    const rect = scopeFenceRect(fence);
+    if (!rect) return `no fenced node exists to place new content near — outside ${describe}.`;
+    for (const point of target.points) {
+      if (!Number.isFinite(point.x) || !Number.isFinite(point.y) || !inside(rect, point.x, point.y)) {
+        return `position (${point.x}, ${point.y}) is outside ${describe}.`;
+      }
+    }
+  }
+  return null;
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
+}
+
+function stringList(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === 'string') : [];
+}
+
+function str(value: unknown): string {
+  return typeof value === 'string' ? value : '';
+}
+
+/** Group membership as `node.add` / `node.update` accept it (mirrors `pickGroupChildIds`). */
+function groupChildren(input: Record<string, unknown>): string[] {
+  if ('children' in input) return stringList(input.children);
+  if ('childIds' in input) return stringList(input.childIds);
+  const data = asRecord(input.data);
+  return 'children' in data ? stringList(data.children) : [];
+}
+
+function createTarget(input: Record<string, unknown>, extraNodeIds: string[] = []): FenceTarget {
+  const x = Number(input.x);
+  const y = Number(input.y);
+  if (!Number.isFinite(x) || !Number.isFinite(y)) return { unplacedCreate: true, nodeIds: extraNodeIds };
+  return { points: [{ x, y }], nodeIds: extraNodeIds };
+}
+
+/** Ops that rewrite the whole board — never allowed under a fence. */
+const BOARD_WIDE_OPS = new Set(['arrange', 'canvas.clear', 'snapshot.restore', 'render.workboard']);
+
+/** Describe what a registry op would write, in fence terms. */
+export function describeOpTarget(op: Operation, rawInput: unknown): FenceTarget {
+  const input = asRecord(rawInput);
+  if (BOARD_WIDE_OPS.has(op.name)) return { boardWide: true };
+  switch (op.name) {
+    case 'node.update': {
+      // A group's membership change reparents (and may reposition) its children.
+      const nodeIds = [str(input.id), ...groupChildren(input)];
+      // A move's DESTINATION must also land inside the fence — otherwise an
+      // agent relocates a fenced node outward, and since the fence rect is
+      // derived from live node positions, that grows its own writable region
+      // past the human-seeded region.
+      const x = Number(input.x);
+      const y = Number(input.y);
+      if (Number.isFinite(x) && Number.isFinite(y)) return { points: [{ x, y }], nodeIds };
+      return { nodeIds };
+    }
+    case 'node.remove':
+      return { nodeIds: [str(input.id)] };
+    case 'node.add':
+      return createTarget(input, input.type === 'group' ? groupChildren(input) : []);
+    case 'jsonrender.add':
+    case 'graph.add':
+      return createTarget(input);
+    case 'jsonrender.stream':
+      // Appends to an existing node by `nodeId`, or creates one at x/y.
+      return typeof input.nodeId === 'string' ? { nodeIds: [input.nodeId] } : createTarget(input);
+    case 'edge.add':
+      // Search-resolved endpoints (`fromSearch`/`toSearch`) cannot be checked
+      // before resolution and so read as '' — refused, not bypassed.
+      return { nodeIds: [str(input.from), str(input.to)] };
+    case 'edge.remove': {
+      const id = str(input.id) || str(input.edge_id);
+      const edge = canvasState.getEdges().find((entry) => entry.id === id);
+      return edge ? { nodeIds: [edge.from, edge.to] } : {}; // missing edge: the op 404s on its own
+    }
+    case 'group.create':
+      return { nodeIds: stringList(input.childIds ?? input.children) };
+    case 'group.add':
+    case 'group.remove':
+      return { nodeIds: [str(input.groupId), ...stringList(input.childIds)] };
+    case 'annotation.add': {
+      const points = Array.isArray(input.points) ? input.points : [];
+      return {
+        points: points.map((point) => {
+          const p = asRecord(point);
+          return { x: Number(p.x), y: Number(p.y) };
+        }),
+      };
+    }
+    case 'annotation.remove': {
+      const annotation = canvasState.getAnnotations().find((entry) => entry.id === str(input.id));
+      if (!annotation) return {};
+      const { bounds } = annotation;
+      return {
+        points: [
+          { x: bounds.x, y: bounds.y },
+          { x: bounds.x + bounds.width, y: bounds.y + bounds.height },
+        ],
+      };
+    }
+    case 'node.focus':
+      return {}; // navigation, not a write
+    default:
+      return { unknown: op.name };
+  }
+}
+
+/** Registry entry point: refusal text or null. Only call for mutating, agent-originated ops. */
+export function checkScopeFence(op: Operation, rawInput: unknown, writerKey?: string): string | null {
+  return checkFenceTarget(describeOpTarget(op, rawInput), op.name, writerKey);
+}
+
+/**
+ * The GLOBAL fence belongs to the human: an agent must not clear, widen, or
+ * replace it through `ax.policy.set`. Per-agent territories (`agentScopes`)
+ * are the orchestration surface — an agent MAY set territories for OTHER
+ * writers (fencing its workers), but never its own: granting yourself a wider
+ * territory (or deleting it) is escalation.
+ */
+export function checkScopeOwnership(rawInput: unknown, writerKey?: string): string | null {
+  const input = asRecord(rawInput);
+  if ('scope' in input)
+    return 'the scope fence is set and cleared by the human in the session panel, not by the agent.';
+  const agentScopes = input.agentScopes;
+  if (writerKey && agentScopes && typeof agentScopes === 'object' && !Array.isArray(agentScopes)) {
+    if (Object.prototype.hasOwnProperty.call(agentScopes, writerKey)) {
+      return `an agent cannot set or clear its OWN territory ("${writerKey}") — only the human or a different writer (the orchestrator) may.`;
+    }
+  }
+  return null;
+}

package/src/server/server.ts

@@ -74,9 +74,15 @@ import {
 } from './canvas-operations.js';
 import { dispatchOperationRoute, setOperationEventEmitter } from './operations/index.js';
 import { intentRegistry } from './intent-registry.js';
+import { agentPresence } from './agent-presence.js';
+import { HUMAN_STARTED_SESSION_LABEL } from '../shared/agent-presence.js';
+import { diffLayouts } from './mutation-history.js';
+import { humanPresence } from './human-presence.js';
+import { startGateTtlSweeper, stopGateTtlSweeper } from './ax-gate-ttl.js';
 import { setWebviewRunner } from './operations/webview-runner.js';
 import { closeNodeAppSession, nodeAppSessionId } from './operations/ops/nodes.js';
 import { traceManager } from './trace-manager.js';
+import { IFRAME_PROBE_MESSAGE_SOURCE } from '../shared/iframe-probe.js';
 import { buildJsonRenderViewerHtml } from '../json-render/server.js';
 import type { JsonRenderSpec } from '../json-render/server.js';
 
@@ -112,6 +118,80 @@ intentRegistry.setEmitter((event, payload) => {
   emitPrimaryWorkbenchEvent(event, payload);
 });
 
+// Agent presence (rail-chrome-v2 phase 2) emits its `agent-presence` snapshot
+// frames the same way — including TTL-expiry sweeps, so clients never run
+// their own expiry ticker.
+agentPresence.setEmitter((event, payload) => {
+  emitPrimaryWorkbenchEvent(event, payload);
+});
+humanPresence.setEmitter((event, payload) => {
+  emitPrimaryWorkbenchEvent(event, payload);
+});
+
+// Session receipt (rail-chrome-v2 phase 5, design item 2). The snapshot is
+// taken when a session ATTACHES — the board before the agent touched it — so
+// the receipt's View diff shows exactly what the session did and a restore
+// undoes it. (A detach-time snapshot would equal the current board.)
+agentPresence.setSessionStartListener((presence) => {
+  if (canvasState.getLayout().nodes.length === 0) return null;
+  const startedAt = new Date().toISOString();
+  return canvasState.saveSnapshot(`Before session · ${presence.label} · ${startedAt.slice(11, 16)}`)?.id ?? null;
+});
+agentPresence.setSessionEndListener((presence, startSnapshotId, endedBy) => {
+  const ax = canvasState.getAxState();
+  const endedAt = new Date().toISOString();
+  let snapshot = startSnapshotId
+    ? (canvasState.listSnapshots({ all: true }).find((entry) => entry.id === startSnapshotId) ?? null)
+    : null;
+  let unchanged = false;
+  // A session that changed NOTHING on the board leaves no snapshot behind —
+  // session churn (idle timeouts, receipt tests, attach/detach cycles) was
+  // flooding the History drawer with identical boards.
+  if (snapshot) {
+    const snapData = canvasState.getSnapshotData(snapshot.id);
+    if (snapData) {
+      const diff = diffLayouts(snapData.name, snapData, canvasState.getLayout());
+      if (
+        diff.addedNodes.length === 0 &&
+        diff.removedNodes.length === 0 &&
+        diff.modifiedNodes.length === 0 &&
+        diff.addedEdges.length === 0 &&
+        diff.removedEdges.length === 0
+      ) {
+        canvasState.deleteSnapshot(snapshot.id);
+        snapshot = null;
+        unchanged = true;
+      }
+    }
+  }
+  // A human-started session was named after the agent that filled it; the
+  // snapshot taken at attach still carries the placeholder — settle it now.
+  if (snapshot?.name.includes(HUMAN_STARTED_SESSION_LABEL) && presence.label !== HUMAN_STARTED_SESSION_LABEL) {
+    const name = snapshot.name.replace(HUMAN_STARTED_SESSION_LABEL, presence.label);
+    if (canvasState.renameSnapshot(snapshot.id, name)) snapshot.name = name;
+  }
+  // Three DIFFERENT outcomes, never one "vetoed" pile: a cancelled item was
+  // withdrawn (duplicate, scratch), a rejected gate is a human's explicit no,
+  // and a held gate is a TTL expiry nobody answered. The receipt tells them apart.
+  const counts = {
+    items: ax.workItems.length,
+    done: ax.workItems.filter((item) => item.status === 'done').length,
+    cancelled: ax.workItems.filter((item) => item.status === 'cancelled').length,
+    rejected: ax.approvalGates.filter((gate) => gate.status === 'rejected').length,
+    held: ax.approvalGates.filter((gate) => gate.status === 'held').length,
+  };
+  // No agent `sessionId` here: the SSE envelope reserves that key for the
+  // workbench session and would overwrite it. The label is what the receipt shows.
+  emitPrimaryWorkbenchEvent('agent-session-ended', {
+    label: presence.label,
+    endedAt,
+    endedBy,
+    counts,
+    unchanged,
+    snapshot: snapshot ? { id: snapshot.id, name: snapshot.name } : null,
+  });
+});
+
 // Webview-runner wiring (plan-008 Wave 3): the webview ops never import this
 // module — the Bun.WebView automation runner is injected here, mirroring the
 // setOperationEventEmitter pattern. The closures call the real automation
@@ -236,7 +316,9 @@ interface BunWithOptionalWebView {
   WebView?: CanvasWebViewConstructor;
 }
 
-const DEFAULT_CANVAS_AUTOMATION_WEBVIEW_TIMEOUT_MS = 5000;
+// A COLD WebView launch on macOS regularly needs >5s (0.5.0 readiness: the
+// default-backend start timed out, the immediate retry succeeded warm).
+const DEFAULT_CANVAS_AUTOMATION_WEBVIEW_TIMEOUT_MS = 15_000;
 
 export interface CanvasAutomationWebViewOptions {
   backend?: 'webkit' | 'chrome';
@@ -1028,11 +1110,28 @@ function canvasSpaHtml(): string {
     process.env.AMP_ORB ? '<script>window.__PMX_AMP_ORB = true;</script>' : ''
   }
   <script>window.__PMX_BOOT_SERVER_VERSION = ${JSON.stringify(serverPackageVersion())};</script>
+  <script>window.__PMX_BOOT_BUNDLE_STAMP = ${JSON.stringify(canvasBundleStamp())};</script>
   <script type="module" src="/canvas/index.js?v=${CANVAS_ASSET_VERSION}"></script>
 </body>
 </html>`;
 }
 
+/**
+ * Identity of the SERVED client bundle, read once per process: a tab whose
+ * boot stamp differs from the live server's reloads itself on (re)connect.
+ */
+let _bundleStamp: string | null = null;
+function canvasBundleStamp(): string {
+  if (_bundleStamp !== null) return _bundleStamp;
+  try {
+    const stat = statSync(join(resolveCanvasBundleDir(), 'index.js'));
+    _bundleStamp = `${Math.round(stat.mtimeMs)}-${stat.size}`;
+  } catch {
+    _bundleStamp = 'unknown';
+  }
+  return _bundleStamp;
+}
+
 const CANVAS_STATIC_MIME: Record<string, string> = {
   '.js': 'application/javascript',
   '.css': 'text/css',
@@ -1090,6 +1189,17 @@ function resolveCanvasBundleDir(): string {
 // the same bundle root that serves /canvas/surface-theme.css; null keeps the
 // <link> fallback when the asset is missing (e.g. an unbuilt dev tree).
 let _surfaceThemeCss: string | null | undefined;
+let _mermaidEntryJs: string | null | undefined;
+function mermaidEntryJsInline(): string | null {
+  if (_mermaidEntryJs !== undefined) return _mermaidEntryJs;
+  try {
+    _mermaidEntryJs = readFileSync(resolve(resolveCanvasBundleDir(), 'mermaid-entry.js'), 'utf-8');
+  } catch {
+    _mermaidEntryJs = null;
+  }
+  return _mermaidEntryJs;
+}
+
 function surfaceThemeCssInline(): string | null {
   if (_surfaceThemeCss !== undefined) return _surfaceThemeCss;
   try {
@@ -1204,13 +1314,22 @@ function handleFrameDocument(pathname: string): Response {
 // iframe hosts like the Amp orb portal block them, and the client then falls
 // back to fetch() + srcdoc surfaces (see src/client/state/iframe-mode.ts).
 function handleIframeProbe(): Response {
-  return new Response('<!doctype html><title>pmx-canvas iframe probe</title>', {
-    headers: {
-      'Content-Type': 'text/html; charset=utf-8',
-      'Cache-Control': 'no-store',
-      'Content-Security-Policy': 'sandbox allow-scripts',
+  // The postMessage handshake IS the probe signal: hosts that block sub-frame
+  // requests (the Claude Code desktop browser) still fire `load` on the error
+  // page they commit, so only this document actually executing proves that
+  // src-URL iframes work (see src/client/state/iframe-mode.ts).
+  return new Response(
+    `<!doctype html><title>pmx-canvas iframe probe</title><script>parent.postMessage({ source: ${JSON.stringify(
+      IFRAME_PROBE_MESSAGE_SOURCE,
+    )} }, "*")</script>`,
+    {
+      headers: {
+        'Content-Type': 'text/html; charset=utf-8',
+        'Cache-Control': 'no-store',
+        'Content-Security-Policy': 'sandbox allow-scripts',
+      },
     },
-  });
+  );
 }
 
 // ── Ext-app recovery diagnostics (0.3.2 report Finding N) ──────
@@ -1310,18 +1429,22 @@ function handleNodeSurface(pathname: string, url: URL): Response {
     // Display-only surface: same theme/height plumbing as html nodes, but no AX
     // bridge and no presentation mode — the document is our own wrapper around
     // escaped diagram source, rendered by /canvas/mermaid-entry.js.
-    const doc = buildHtmlSurfaceDocument(buildMermaidSurfaceHtml(source), {
-      theme,
-      title: surfaceTitle,
-      themeToken: url.searchParams.get('themeToken') ?? undefined,
-      // Content-height reporter nonce (lets the node grow to fit the diagram).
-      ...(url.searchParams.get('frameToken')
-        ? { contentHeightToken: url.searchParams.get('frameToken') as string }
-        : {}),
-      // Inline the theme tokens so srcdoc-rendered surfaces (Amp orb portals)
-      // are styled without depending on the <link> subresource.
-      ...(surfaceThemeCssInline() ? { inlineThemeCss: surfaceThemeCssInline() as string } : {}),
-    });
+    const inlineAssets = url.searchParams.get('inline-assets') === '1';
+    const doc = buildHtmlSurfaceDocument(
+      buildMermaidSurfaceHtml(source, inlineAssets ? mermaidEntryJsInline() : null),
+      {
+        theme,
+        title: surfaceTitle,
+        themeToken: url.searchParams.get('themeToken') ?? undefined,
+        // Content-height reporter nonce (lets the node grow to fit the diagram).
+        ...(url.searchParams.get('frameToken')
+          ? { contentHeightToken: url.searchParams.get('frameToken') as string }
+          : {}),
+        // Inline the theme tokens so srcdoc-rendered surfaces (Amp orb portals)
+        // are styled without depending on the <link> subresource.
+        ...(surfaceThemeCssInline() ? { inlineThemeCss: surfaceThemeCssInline() as string } : {}),
+      },
+    );
     return surfaceHtmlResponse(doc, HTML_SURFACE_SANDBOX);
   }
 
@@ -1931,8 +2054,11 @@ function buildWorkbenchConnectSnapshot(
       path: primaryWorkbenchPath,
       theme: canvasState.theme,
       // Lets a long-lived client detect that the server was upgraded under it
-      // (stale in-memory SPA — 0.4.5 report Finding W) and reload once.
+      // (stale in-memory SPA — 0.4.5 report Finding W) and reload once. The
+      // bundle stamp catches DEV rolls too: a rebuild+restart never bumps the
+      // package version, so tabs silently kept month-old JS (rule 3's trap).
       version: serverPackageVersion(),
+      bundleStamp: canvasBundleStamp(),
       timestamp: new Date().toISOString(),
     },
   });
@@ -1994,6 +2120,25 @@ function buildWorkbenchConnectSnapshot(
       },
     });
   }
+  // A fresh tab must not start blind to who is on the board: both presence
+  // registries broadcast only on CHANGE, so without these frames a reload
+  // shows no agent cursors/chips and no human cursors until the next move.
+  events.push({
+    event: 'agent-presence',
+    payload: {
+      ...(agentPresence.snapshot() as unknown as Record<string, unknown>),
+      reason: 'connect-snapshot',
+      timestamp: new Date().toISOString(),
+    },
+  });
+  events.push({
+    event: 'human-presence',
+    payload: {
+      ...(humanPresence.snapshot() as unknown as Record<string, unknown>),
+      reason: 'connect-snapshot',
+      timestamp: new Date().toISOString(),
+    },
+  });
   return events;
 }
 
@@ -2157,7 +2302,6 @@ async function handleCanvasPrompt(req: Request): Promise<Response> {
         zIndex: 1,
         collapsed: false,
         pinned: false,
-        dockPosition: null,
         data: {
           text,
           turns: [],
@@ -2287,7 +2431,6 @@ async function handleCanvasPrompt(req: Request): Promise<Response> {
     zIndex: 1,
     collapsed: false,
     pinned: false,
-    dockPosition: null,
     data: {
       text,
       turns: [{ role: 'user', text, status: 'pending' }],
@@ -2601,9 +2744,8 @@ function syncContextNodeToCanvasState(
       position: { x: 1130, y: 80 },
       size: { width: 320, height: 400 },
       zIndex: 1,
-      collapsed: true,
+      collapsed: false,
       pinned: false,
-      dockPosition: 'right',
       data: mergedData,
     });
     return;
@@ -2612,57 +2754,6 @@ function syncContextNodeToCanvasState(
   canvasState.updateNode(id, { data: mergedData });
 }
 
-/**
- * Seed the docked status (left) + context (right) widgets so a freshly opened
- * canvas shows them by default — the same nodes the agent-event path creates on
- * demand (`status-main`, `context-main`), just present from the start.
- *
- * First-run only: we bail if the workspace canvas already has persisted state,
- * so we never add them to a board with content, and — because first-run state is
- * persisted on save — deleting or undocking them later is respected (they are
- * not re-seeded). Create-if-missing keeps it idempotent if the agent path
- * already made one. Returns true if anything was seeded.
- */
-export function ensureDefaultDockedNodes(): boolean {
-  if (canvasState.hasPersistedState()) return false;
-  let seeded = false;
-  // NOTE: these node specs mirror the agent-event create paths below
-  // (`canvas-status` for status-main, `syncContextNodeToCanvasState` for
-  // context-main) — keep geometry/dock defaults in sync if you change them.
-  if (!canvasState.getNode('status-main')) {
-    canvasState.addNode({
-      id: 'status-main',
-      type: 'status',
-      position: { x: 40, y: 80 },
-      size: { width: 300, height: 120 },
-      zIndex: 0,
-      collapsed: true,
-      pinned: false,
-      dockPosition: 'left',
-      data: { phase: 'idle', message: '', elapsed: 0 },
-    });
-    seeded = true;
-  }
-  if (!canvasState.getNode('context-main')) {
-    canvasState.addNode({
-      id: 'context-main',
-      type: 'context',
-      position: { x: 1130, y: 80 },
-      size: { width: 320, height: 400 },
-      zIndex: 1,
-      collapsed: true,
-      pinned: false,
-      dockPosition: 'right',
-      data: { cards: [], auxTabs: [] },
-    });
-    seeded = true;
-  }
-  if (seeded) {
-    emitPrimaryWorkbenchEvent('canvas-layout-update', { layout: canvasState.getLayout() });
-  }
-  return seeded;
-}
-
 // Maps responseNodeId -> thread prompt node ID for O(1) routing of response events
 const serverResponseToThreadMap = new Map<string, string>();
 
@@ -2683,7 +2774,6 @@ function syncEventToCanvasState(event: string, payload: PrimaryWorkbenchEventPay
         zIndex: 1,
         collapsed: false,
         pinned: false,
-        dockPosition: null,
         data: { path, title, content: '', rendered: '' },
       });
     } else {
@@ -2772,7 +2862,6 @@ function syncEventToCanvasState(event: string, payload: PrimaryWorkbenchEventPay
         zIndex: 1,
         collapsed: false,
         pinned: false,
-        dockPosition: null,
         data: dataPatch,
       });
     }
@@ -2836,6 +2925,12 @@ function syncEventToCanvasState(event: string, payload: PrimaryWorkbenchEventPay
       utilization: payload.utilization,
       nearLimit: payload.nearLimit,
     });
+    // The same numbers feed the top-bar context meter of the attached session.
+    const used = Number(payload.currentTokens);
+    const total = Number(payload.tokenLimit);
+    if (Number.isFinite(used) && Number.isFinite(total) && total > 0) {
+      agentPresence.reportContextUsage({ used: Math.max(0, used), total });
+    }
   } else if (event === 'aux-open') {
     const existing = canvasState.getNode('context-main');
     const auxTabs = Array.isArray(existing?.data.auxTabs)
@@ -2864,7 +2959,6 @@ function syncEventToCanvasState(event: string, payload: PrimaryWorkbenchEventPay
         zIndex: 0,
         collapsed: false,
         pinned: false,
-        dockPosition: 'left',
         data: { phase: 'idle', message: '', elapsed: 0 },
       });
     }
@@ -2901,7 +2995,6 @@ function syncEventToCanvasState(event: string, payload: PrimaryWorkbenchEventPay
       zIndex: 1,
       collapsed: false,
       pinned: false,
-      dockPosition: null,
       data: { content: '', status: 'streaming', promptNodeId },
     });
 
@@ -3122,6 +3215,8 @@ export function startCanvasServer(options: CanvasServerOptions = {}): string | n
   canvasState.setWorkspaceRoot(activeWorkspaceRoot);
   canvasState.setTheme(initialCanvasThemeSetting as CanvasTheme);
   const loaded = canvasState.loadFromDisk({ clearExisting: true });
+  // Unattended-approval policy: hold pending gates whose TTL elapsed.
+  startGateTtlSweeper((event, payload) => emitPrimaryWorkbenchEvent(event, payload));
   setCanvasLayoutUpdateEmitter(() => {
     emitPrimaryWorkbenchEvent('canvas-layout-update', { layout: canvasState.getLayout() });
   });
@@ -3333,6 +3428,9 @@ export function startCanvasServer(options: CanvasServerOptions = {}): string | n
 }
 
 export function stopCanvasServer(): void {
+  stopGateTtlSweeper();
+  agentPresence.reset();
+  humanPresence.reset();
   intentRegistry.reset();
   canvasState.close();
   closeAllMcpAppSessions();

package/src/server/trace-manager.ts

@@ -101,7 +101,6 @@ class TraceManager {
       zIndex: 0,
       collapsed: false,
       pinned: true,
-      dockPosition: null,
       data: {
         toolName: payload.name,
         category,
@@ -199,7 +198,6 @@ class TraceManager {
       zIndex: 0,
       collapsed: false,
       pinned: true,
-      dockPosition: null,
       data: {
         toolName: payload.agentDisplayName ?? payload.agentName,
         category: 'subagent' as TraceCategory,

package/src/server/web-artifacts.ts

@@ -716,7 +716,6 @@ export function openWebArtifactInCanvas(input: {
     zIndex: 1,
     collapsed: false,
     pinned: false,
-    dockPosition: null,
     data: {
       title: input.title,
       ...(typeof input.content === 'string' ? { content: input.content } : {}),