pmx-canvas 0.5.1 → 0.6.1

package/src/client/canvas/TopBar.tsx

@@ -31,59 +31,99 @@ import { formatCountdown, gateRemainingMs } from '../../shared/approval-gates.js
  * session is attached — the quiet board shows nothing here until phase 5
  * lands the "Start agent session" affordance.
  */
+const AGENT_CHIP_LIMIT = 3;
+const AGENT_PHASE_RANK: Record<string, number> = { 'waiting-approval': 0, thinking: 1, tooling: 2, idle: 3 };
+
 function AgentChip() {
   // Every attached session gets its chip — with several agents on the board,
-  // showing only the first hid the rest from the top bar entirely.
+  // showing only the first hid the rest from the top bar entirely. But one
+  // chip PER agent floods the bar on a many-agent board (user feedback,
+  // 0.5.1 cycle: 16 unshrinkable chips shoved the zoom cluster out of the
+  // bar and over the session panel, and the total was invisible): the most
+  // active few wear their own chips and the rest fold into a census chip
+  // that always names the total.
   const sessions = attachedSessions.value;
   if (sessions.length === 0) return null;
+  const ranked = [...sessions].sort((a, b) => (AGENT_PHASE_RANK[a.phase] ?? 4) - (AGENT_PHASE_RANK[b.phase] ?? 4));
+  const visible = ranked.slice(0, AGENT_CHIP_LIMIT);
+  const overflow = ranked.slice(AGENT_CHIP_LIMIT);
+  const phaseCounts = sessions.reduce<Record<string, number>>((acc, s) => {
+    acc[s.phase] = (acc[s.phase] ?? 0) + 1;
+    return acc;
+  }, {});
+  const breakdown = [
+    phaseCounts['waiting-approval'] && `${phaseCounts['waiting-approval']} waiting on approval`,
+    phaseCounts.thinking && `${phaseCounts.thinking} thinking`,
+    phaseCounts.tooling && `${phaseCounts.tooling} running tools`,
+    phaseCounts.idle && `${phaseCounts.idle} idle`,
+  ]
+    .filter(Boolean)
+    .join(', ');
   return (
     <>
-      {sessions.map((session) => {
-        // Fleet roll-up: workers declaring this session as their parent count
-        // into its chip instead of growing the bar one chip per worker.
-        const workers = agentPresences.value.filter(
-          (presence) =>
-            presence.parentAgentId != null &&
-            (presence.parentAgentId === session.sessionId || presence.parentAgentId === session.source),
-        ).length;
-        return (
-          <BarHint
-            key={session.sessionId}
-            label={`Agent session — ${session.label}`}
-            tapToOpen
-            body="What this attached agent is doing right now: idle, thinking, running a tool, or waiting on your approval. Steer it from the composer below."
-          >
-            <span
-              class={`agent-chip phase-${session.phase}`}
-              data-phase={session.phase}
-              style={{ '--identity-color': `hsl(${agentIdentityHue(session.sessionId)} 65% 62%)` }}
+      {/* The chips live in their own clipping flex wrapper: each chip keeps
+          its natural readable width and the WRAPPER absorbs the squeeze,
+          clipping at its edge — no per-child shrink cascade, and chip
+          content can never paint over the census, meter, or zoom cluster. */}
+      <span class="agent-chips">
+        {visible.map((session) => {
+          // Fleet roll-up: workers declaring this session as their parent count
+          // into its chip instead of growing the bar one chip per worker.
+          const workers = agentPresences.value.filter(
+            (presence) =>
+              presence.parentAgentId != null &&
+              (presence.parentAgentId === session.sessionId || presence.parentAgentId === session.source),
+          ).length;
+          return (
+            <BarHint
+              key={session.sessionId}
+              label={`Agent session — ${session.label}`}
+              tapToOpen
+              body="What this attached agent is doing right now: idle, thinking, running a tool, or waiting on your approval. Steer it from the composer below."
             >
-              <span class="agent-chip-dot" aria-hidden="true" />
-              <span class="agent-chip-label">{agentPhaseLabel(session)}</span>
-              <span class="agent-chip-who hud-collapsible-text">{session.label}</span>
-              {workers > 0 && (
-                <span class="agent-chip-workers">
-                  +{workers} worker{workers === 1 ? '' : 's'}
-                </span>
-              )}
-              <button
-                type="button"
-                class="agent-chip-end"
-                aria-label={`End ${session.label} session`}
-                title={`End ${session.label}'s session`}
-                onClick={(e) => {
-                  // The chip sits inside a tap-to-open hint — ending a session
-                  // must not also open it.
-                  e.stopPropagation();
-                  void endSession({ source: session.source, agentId: session.agentId });
-                }}
+              <span
+                class={`agent-chip phase-${session.phase}`}
+                data-phase={session.phase}
+                style={{ '--identity-color': `hsl(${agentIdentityHue(session.sessionId)} 65% 62%)` }}
               >
-                ×
-              </button>
-            </span>
-          </BarHint>
-        );
-      })}
+                <span class="agent-chip-dot" aria-hidden="true" />
+                <span class="agent-chip-label">{agentPhaseLabel(session)}</span>
+                <span class="agent-chip-who hud-collapsible-text">{session.label}</span>
+                {workers > 0 && (
+                  <span class="agent-chip-workers">
+                    +{workers} worker{workers === 1 ? '' : 's'}
+                  </span>
+                )}
+                <button
+                  type="button"
+                  class="agent-chip-end"
+                  aria-label={`End ${session.label} session`}
+                  title={`End ${session.label}'s session`}
+                  onClick={(e) => {
+                    // The chip sits inside a tap-to-open hint — ending a session
+                    // must not also open it.
+                    e.stopPropagation();
+                    void endSession({ source: session.source, agentId: session.agentId });
+                  }}
+                >
+                  ×
+                </button>
+              </span>
+            </BarHint>
+          );
+        })}
+      </span>
+      {overflow.length > 0 && (
+        <BarHint
+          label={`${sessions.length} agent sessions attached`}
+          tapToOpen
+          body={`${sessions.length} agents on this board — ${breakdown}. The most active wear their own chips; the rest are here, and idle agents' cursors leave the board until they work again.`}
+        >
+          <span class="agent-chip agent-chip-more" data-testid="agent-chip-more">
+            +{overflow.length} · {sessions.length} agents
+          </span>
+        </BarHint>
+      )}
     </>
   );
 }

package/src/client/canvas/use-pan-zoom.ts

@@ -110,6 +110,13 @@ export function usePanZoom({ viewport, onViewportChange, onViewportCommit, disab
         // Pan tool / held Space: the world layer is pointer-inert (CSS), so
         // the event target is the container even over nodes.
         if (e.target !== container) return;
+        // A pan gesture must not double as the browser's drag-select: without
+        // preventDefault the sweep still extends a text selection through the
+        // pointer-inert world, and a later pointerdown inside that selection
+        // starts a native text drag the canvas mis-reads as a URL drop —
+        // panning from a node minted webpage nodes from card text (0.5.1 Amp
+        // finding D).
+        e.preventDefault();
       } else {
         // Select tool: background drag belongs to the lasso (CanvasViewport).
         return;

package/src/client/nodes/ExtAppFrame.tsx

@@ -137,7 +137,7 @@ export function extAppRecoveryLog(nodeId: string, event: string): void {
 // panel without devtools access — the Copilot WKWebView, exactly where the
 // black tiles happen — still yields an actionable trace: agents read it back
 // via GET /api/canvas/debug/ext-app-recovery (0.3.2 report Finding N).
-let extAppReportQueue: Array<{ t: number; nodeId: string; event: string; visibility?: string }> = [];
+const extAppReportQueue: Array<{ t: number; nodeId: string; event: string; visibility?: string }> = [];
 let extAppReportTimer: ReturnType<typeof setTimeout> | null = null;
 function queueExtAppRecoveryReport(entry: { t: number; nodeId: string; event: string }): void {
   extAppReportQueue.push({
@@ -287,28 +287,72 @@ export function buildExtAppBootBeaconScript(frameToken: string, nodeId: string):
   // rendering pipeline is actually running — a frame whose layer WebKit never
   // composites stays silent, and that silence drives the parent's recovery
   // ladder. One unsolicited tick at boot, then on-demand answers to probes.
-  // Content oracle (Finding N, 0.5.0 reopen): a double rAF fires even while
-  // WKWebKit composites nothing — the tick alone was a false green. The tick
-  // now carries a verdict: does this document actually CONTAIN rendered
-  // content (a laid-out canvas/svg, or real text)? The parent only accepts
-  // paint-ok when it does.
-  function contentReady() {
+  // Content oracle v2 (Finding N, 0.5.1 reopen): a LAID-OUT canvas passed the
+  // 0.5.1 oracle even when nothing was ever drawn into it — Excalidraw mounts
+  // its canvas element the moment React renders, so blank cream tiles read
+  // paint-ok (content-verified), the ladder concluded success, and Retry
+  // never engaged (Copilot 0.5.1 report: A/C/E cream with a green trail).
+  // The oracle now samples the canvas's PIXELS: a readable main drawing
+  // surface with uniform pixels is not content, whatever shell chrome or
+  // boilerplate text the document laid out around it.
+  function canvasInk(el) {
     try {
-      var els = document.querySelectorAll('canvas, svg');
-      for (var i = 0; i < els.length; i++) {
-        var r = els[i].getBoundingClientRect();
-        if (r.width > 8 && r.height > 8) return true;
+      if (!el.width || !el.height) return 'blank';
+      var sw = Math.min(96, el.width);
+      var sh = Math.min(64, el.height);
+      var probe = document.createElement('canvas');
+      probe.width = sw;
+      probe.height = sh;
+      var ctx = probe.getContext('2d', { willReadFrequently: true });
+      if (!ctx) return 'unknown';
+      ctx.drawImage(el, 0, 0, sw, sh);
+      var d = ctx.getImageData(0, 0, sw, sh).data;
+      var r = d[0], g = d[1], b = d[2], a = d[3];
+      for (var i = 4; i < d.length; i += 4) {
+        if (Math.abs(d[i] - r) > 3 || Math.abs(d[i + 1] - g) > 3 || Math.abs(d[i + 2] - b) > 3 || Math.abs(d[i + 3] - a) > 3) return 'ink';
+      }
+      return 'blank';
+    } catch (e) {
+      return 'unknown'; // tainted or WebGL-unreadable: pixels cannot be judged
+    }
+  }
+  function contentVerdict() {
+    try {
+      var canvases = document.querySelectorAll('canvas');
+      var blankMain = false;
+      var unreadable = false;
+      for (var i = 0; i < canvases.length; i++) {
+        var r = canvases[i].getBoundingClientRect();
+        if (r.width <= 8 || r.height <= 8) continue;
+        var ink = canvasInk(canvases[i]);
+        if (ink === 'ink') return { content: true, detail: 'ink' };
+        if (ink === 'unknown') unreadable = true;
+        else if (r.width >= 160 && r.height >= 120) blankMain = true;
+      }
+      // A readable, never-painted main surface vetoes everything below:
+      // toolbar icons and shell text around a blank drawing surface is
+      // exactly the false green the human reports as an empty cream tile.
+      if (blankMain) return { content: false, detail: 'blank-canvas' };
+      if (unreadable) return { content: true, detail: 'canvas-unreadable' };
+      var svgs = document.querySelectorAll('svg');
+      for (var j = 0; j < svgs.length; j++) {
+        var sr = svgs[j].getBoundingClientRect();
+        if (sr.width > 8 && sr.height > 8 && svgs[j].querySelector('path, rect, circle, ellipse, line, polyline, polygon, text, image, use')) {
+          return { content: true, detail: 'svg' };
+        }
       }
       var body = document.body;
-      return !!(body && body.innerText && body.innerText.trim().length > 0);
+      if (body && body.innerText && body.innerText.trim().length > 0) return { content: true, detail: 'text' };
+      return { content: false, detail: 'empty' };
     } catch (e) {
-      return false;
+      return { content: false, detail: 'probe-error' };
     }
   }
   function sendPaintTick() {
     requestAnimationFrame(function () {
       requestAnimationFrame(function () {
-        window.parent.postMessage({ source: '${EXT_APP_BOOT_BEACON_SOURCE}', token: TOKEN, nodeId: NODE_ID, kind: 'paint-tick', content: contentReady() }, '*');
+        var v = contentVerdict();
+        window.parent.postMessage({ source: '${EXT_APP_BOOT_BEACON_SOURCE}', token: TOKEN, nodeId: NODE_ID, kind: 'paint-tick', content: v.content, detail: v.detail }, '*');
       });
     });
   }
@@ -388,8 +432,11 @@ export function ExtAppFrame({ node, expanded = false }: { node: CanvasNodeState;
   const themeUnsubRef = useRef<(() => void) | null>(null);
   const webkitRemountAttemptsRef = useRef(0);
   // Paint oracle (Finding N): resolvers waiting for the frame's next paint-tick,
-  // each handed the tick's content verdict.
-  const paintTickWaitersRef = useRef<Array<(content: boolean) => void>>([]);
+  // each handed the tick's content verdict + the oracle's reason for it.
+  const paintTickWaitersRef = useRef<Array<(tick: { content: boolean; detail: string }) => void>>([]);
+  // Last tick's oracle detail (ink / blank-canvas / svg / text / …) for the
+  // recovery trail — the label is the diagnostic the field reports read.
+  const lastPaintDetailRef = useRef<string>('');
   // Genuine boot signal: set ONLY when the app completes the ui/initialize
   // handshake (bridge.oninitialized) — NOT by the 1200ms bootstrap fallback,
   // which flips status via notifications that resolve even into a dead iframe.
@@ -471,8 +518,12 @@ export function ExtAppFrame({ node, expanded = false }: { node: CanvasNodeState;
         return;
       appScriptsRanRef.current = true;
       if (data.kind === 'paint-tick') {
-        const content = (data as { content?: unknown }).content === true;
-        for (const waiter of paintTickWaitersRef.current.splice(0)) waiter(content);
+        const tickData = data as { content?: unknown; detail?: unknown };
+        const tick = {
+          content: tickData.content === true,
+          detail: typeof tickData.detail === 'string' ? tickData.detail : '',
+        };
+        for (const waiter of paintTickWaitersRef.current.splice(0)) waiter(tick);
       }
     }
     window.addEventListener('message', onBootBeacon);
@@ -590,13 +641,14 @@ export function ExtAppFrame({ node, expanded = false }: { node: CanvasNodeState;
         settled = true;
         resolve('timeout');
       }, PAINT_TICK_TIMEOUT_MS);
-      paintTickWaitersRef.current.push((content) => {
+      paintTickWaitersRef.current.push((tick) => {
         if (settled) return;
         settled = true;
         window.clearTimeout(timer);
+        lastPaintDetailRef.current = tick.detail;
         // A tick without content is NOT paint-ok: the rAF pipeline runs while
         // the document is empty cream / never composited (Finding N reopen).
-        resolve(content ? 'content-verified' : 'tick-no-content');
+        resolve(tick.content ? 'content-verified' : 'tick-no-content');
       });
       contentWindow.postMessage({ source: EXT_APP_PAINT_PROBE_SOURCE, token: axToken }, '*');
     });
@@ -672,10 +724,14 @@ export function ExtAppFrame({ node, expanded = false }: { node: CanvasNodeState;
   // A paint-ok collected while the document claims hidden proves only that the
   // app's rAF pipeline is alive — NOT that anything composited (Finding N,
   // 0.4.7). Say so in the trail instead of recording an unqualified success.
-  const paintOkLabel = (suffix = ''): string =>
-    typeof document !== 'undefined' && document.visibilityState === 'hidden'
-      ? `paint-ok (content-verified)${suffix} (host hidden)`
-      : `paint-ok (content-verified)${suffix}`;
+  // The [detail] bracket names WHAT the oracle verified (ink / svg / text) so
+  // field reports can distinguish pixel-verified greens from weaker ones.
+  const paintOkLabel = (suffix = ''): string => {
+    const detail = lastPaintDetailRef.current ? ` [${lastPaintDetailRef.current}]` : '';
+    return typeof document !== 'undefined' && document.visibilityState === 'hidden'
+      ? `paint-ok (content-verified)${detail}${suffix} (host hidden)`
+      : `paint-ok (content-verified)${detail}${suffix}`;
+  };
 
   const runPaintLadder = async (): Promise<void> => {
     // Runs for the EXPANDED instance too (Finding N reopen: expanded C was a
@@ -692,7 +748,9 @@ export function ExtAppFrame({ node, expanded = false }: { node: CanvasNodeState;
     }
     extAppRecoveryLog(
       nodeId,
-      verdict === 'tick-no-content' ? 'paint-fail (tick without content)' : 'paint-fail (no tick)',
+      verdict === 'tick-no-content'
+        ? `paint-fail (tick without content: ${lastPaintDetailRef.current || 'unknown'})`
+        : 'paint-fail (no tick)',
     );
     await runSoftExpandCycle();
     verdict = await probePaint();
@@ -777,7 +835,7 @@ export function ExtAppFrame({ node, expanded = false }: { node: CanvasNodeState;
     () => () => {
       unmountedRef.current = true;
       for (const waiter of bootWaitersRef.current.splice(0)) waiter();
-      for (const waiter of paintTickWaitersRef.current.splice(0)) waiter(false);
+      for (const waiter of paintTickWaitersRef.current.splice(0)) waiter({ content: false, detail: 'unmounted' });
     },
     [],
   );
@@ -1096,7 +1154,12 @@ export function ExtAppFrame({ node, expanded = false }: { node: CanvasNodeState;
             };
             if (typeof navigator !== 'undefined' && isWebKitOnlyHost(navigator.userAgent)) {
               void awaitContentVerified(4_000).then((verified) => {
-                extAppRecoveryLog(nodeId, verified ? 'settled (content-verified)' : 'settled (content-timeout)');
+                extAppRecoveryLog(
+                  nodeId,
+                  verified
+                    ? 'settled (content-verified)'
+                    : `settled (content-timeout${lastPaintDetailRef.current ? `: ${lastPaintDetailRef.current}` : ''})`,
+                );
                 releaseQueue();
               });
             } else {

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

@@ -9,7 +9,7 @@ import {
   type ViewportState,
 } from '../types';
 import { computeAutoArrange } from '../../shared/auto-arrange';
-import { canvasAreaCenter, canvasFitInsets } from '../canvas/canvas-area';
+import { canvasArea, canvasAreaCenter, canvasFitInsets } from '../canvas/canvas-area';
 import { pushCanvasUpdate, requestBestEffort, requestOk, updateViewportFromClient } from './intent-bridge';
 
 function logCanvasStoreError(action: string, error: unknown): void {
@@ -833,14 +833,26 @@ export function focusNode(id: string, options: { recordHistory?: boolean } = {})
   const node = nodes.value.get(id);
   if (!node) return;
   const v = viewport.value;
+  // Same screen-space frame as fitAll: viewport x/y are CONTAINER-relative
+  // (screen = world*scale + viewport inside the canvas region), so the centre
+  // is built from the region's dimensions + chrome insets — the old
+  // window-coordinate canvasAreaCenter() over-shifted focus by the region
+  // origin, and centring without insets parked tall nodes (the 960×600
+  // mcp-app open) under the command bar (0.5.1 Amp finding C).
+  const area = canvasArea();
+  const insets = canvasFitInsets();
+  const usableW = Math.max(80, area.width - insets.left - insets.right);
+  const usableH = Math.max(80, area.height - insets.top - insets.bottom);
+  // Shrink (never grow) so the whole node — resize corner included — fits the
+  // usable rect clear of the floating chrome.
+  const scale = Math.min(v.scale, usableW / node.size.width, usableH / node.size.height);
   const cx = node.position.x + node.size.width / 2;
   const cy = node.position.y + node.size.height / 2;
-  const centre = canvasAreaCenter();
   animateViewport(
     {
-      x: centre.x - cx * v.scale,
-      y: centre.y - cy * v.scale,
-      scale: v.scale,
+      x: insets.left + usableW / 2 - cx * scale,
+      y: insets.top + usableH / 2 - cy * scale,
+      scale,
     },
     300,
     options,

package/src/client/theme/global.css

@@ -986,10 +986,21 @@ body,
   /* NOT overflow:hidden — the BarHint tooltips hang below the bar and were
      clipped invisible for everyone (the e2e asserted opacity, which cannot
      see ancestor clipping). Children ellipsize themselves; the narrow-screen
-     collapse is media-query display, not clipping. */
+     collapse is media-query display, not clipping. overflow-x: clip is the
+     one safe axis (visible/clip is the valid mixed pair): tooltips still
+     hang below, but bar content can never paint over the session panel
+     again (0.5.1 user feedback — the agent-chip flood pushed the zoom
+     cluster out of the bar). */
+  overflow-x: clip;
   min-width: 0;
   z-index: 9998;
 }
+/* CHIP BarHint anchors must pass shrink through to their chip (flex min-auto
+   sizing) or an unshrinkable anchor re-creates the overflow. Chip anchors
+   ONLY — a blanket min-width: 0 crushed the zoom buttons to slivers. */
+.top-bar .toolbar-tooltip-anchor:has(.agent-chip) {
+  min-width: 0;
+}
 
 .top-bar-title {
   font-size: 13px;
@@ -1104,14 +1115,46 @@ body,
   font-size: 11px;
   font-weight: 600;
   white-space: nowrap;
+  /* Rigid: the chip never shrinks and never lies about its min size (a
+     min-width: 0 here let BarHint anchors collapse under their chips, and
+     neighboring chips painted over each other). The .agent-chips wrapper is
+     the ONE squeeze point — it clips whole trailing chips at its edge. */
   flex-shrink: 0;
-  min-width: 0;
   max-width: 280px;
 }
+/* Many-agent bar (0.5.1 user feedback): the visible chips sit in ONE
+   clipping flex wrapper. Chips keep their natural readable width; when the
+   bar is overconstrained the WRAPPER shrinks and clips at its edge, so chip
+   content can never shove or paint over the census chip, the context meter,
+   or the zoom cluster (16 unshrinkable chips used to push the zoom controls
+   out of the bar and over the session panel). */
+.agent-chips {
+  display: inline-flex;
+  align-items: center;
+  gap: 12px;
+  min-width: 0;
+  overflow: hidden;
+}
+/* Rigid anchors: nested-flex min-content lets a BarHint anchor collapse
+   under its chip (ellipsizing spans zero the chip's min-content), and the
+   chip then paints into the next anchor. Only the wrapper above may give. */
+.agent-chips .toolbar-tooltip-anchor {
+  flex-shrink: 0;
+}
 .agent-chip.phase-idle {
   background: none;
   border-color: var(--c-line);
 }
+/* The census chip is the "how many" answer — it never compresses away. Its
+   BarHint anchor must hold width too: a shrinking anchor around an
+   unshrinkable chip lets the chip paint over the next bar item. */
+.agent-chip-more {
+  flex-shrink: 0;
+}
+.top-bar .toolbar-tooltip-anchor:has(.agent-chip-more) {
+  flex-shrink: 0;
+  min-width: max-content;
+}
 .agent-chip-dot {
   width: 7px;
   height: 7px;
@@ -1134,6 +1177,11 @@ body,
   font-weight: 400;
   color: var(--c-muted);
   white-space: nowrap;
+  /* Leaf-level truncation: a compressed chip must ellipsize the agent name,
+     never paint it past the pill (0.5.1 user feedback, many-agent bar). */
+  overflow: hidden;
+  text-overflow: ellipsis;
+  min-width: 0;
 }
 
 /* On-canvas cursor + phase chip (world layer; counter-scaled inner) */
@@ -1146,7 +1194,9 @@ body,
   top: 0;
   z-index: 9000;
   pointer-events: none;
-  transition: transform 220ms cubic-bezier(0.22, 1, 0.36, 1);
+  transition:
+    transform 220ms cubic-bezier(0.22, 1, 0.36, 1),
+    opacity 320ms ease;
   color: var(--presence-color);
 }
 .agent-cursor.is-worker {
@@ -1160,6 +1210,20 @@ body,
   font-size: 9px;
   padding: 1px 6px;
 }
+/* Idle cursors leave the board (user feedback, 0.5.1 cycle): with many agents
+   attached, a wall of parked "Idle" pills covers real node content. The
+   element stays MOUNTED — counts, twin-merge, and cursor-follow logic are
+   untouched, and visibility (not display) keeps its layout box so position
+   polls still resolve — but it paints nothing; any non-idle phase fades it
+   back in. Placed after .is-worker so opacity: 0 wins that collision. */
+.agent-cursor.phase-idle {
+  opacity: 0;
+  visibility: hidden;
+  transition:
+    transform 220ms cubic-bezier(0.22, 1, 0.36, 1),
+    opacity 320ms ease,
+    visibility 0s linear 320ms;
+}
 .agent-chip-workers {
   margin-left: 4px;
   padding: 0 5px;
@@ -2830,9 +2894,20 @@ body,
 }
 
 /* Pan tool / held Space: the world layer goes pointer-inert so drags land on
-   the viewport container itself and pan — nodes cannot swallow the drag. */
+   the viewport container itself and pan — nodes cannot swallow the drag.
+   user-select too: text selection sweeps straight through pointer-inert
+   content, and a selection made mid-pan later becomes a native text drag the
+   drop handler mints webpage nodes from (0.5.1 Amp finding D). */
 .canvas-viewport.pan-mode .canvas-world {
   pointer-events: none;
+  -webkit-user-select: none;
+  user-select: none;
+}
+/* The resize handle and connect ports carry their own pointer-events: auto,
+   which punches through the inert world — a pan started on them never pans. */
+.canvas-viewport.pan-mode .node-resize-handle,
+.canvas-viewport.pan-mode .node-port {
+  pointer-events: none;
 }
 .canvas-viewport.pan-mode:active {
   cursor: grabbing;

package/src/server/operations/mcp.ts

@@ -27,10 +27,18 @@ export function registerOperationTools(server: McpServer, getHost: () => Promise
     if (foldedOpNames.has(op.name)) continue;
     const tool = op.mcp;
     if (!tool) continue;
-    server.tool(
+    server.registerTool(
       tool.toolName,
-      tool.description,
-      { ...op.inputShape, ...(tool.extraShape ?? {}) },
+      {
+        description: tool.description,
+        // A LOOSE object, not a raw shape: the SDK wraps raw shapes in a
+        // stripping z.object, which silently dropped unknown args before the
+        // op layer could reject them — a removed field (dockPosition) looked
+        // successful over MCP while the same HTTP call 400'd (0.5.1 Amp
+        // finding A). Loose parsing forwards unknown keys to the op layer,
+        // the single authority on dead-field rejection, HTTP and MCP alike.
+        inputSchema: z.looseObject({ ...op.inputShape, ...(tool.extraShape ?? {}) }),
+      },
       async (input: Record<string, unknown>) => {
         try {
           const host = await getHost();
@@ -231,34 +239,40 @@ export function registerCompositeTools(
     for (const [publicKey, opField] of Object.entries(def.fieldRemap ?? {})) {
       publicFieldName.set(opField, publicKey);
     }
-    server.tool(def.toolName, def.description, buildCompositeShape(def), async (input: Record<string, unknown>) => {
-      try {
-        const host = await getHost();
-        const opName = resolveCompositeOp(def, input);
-        const op = getOperation(opName);
-        // Strip the composite discriminators (action + any extra, e.g. `kind`)
-        // and undo any field remap; the rest is the op's raw MCP args — the same
-        // value the standalone tool would receive.
-        const rest = stripCompositeDiscriminators(def, input);
-        const missing = requiredMcpFields(op).filter((field) => !requiredFieldSatisfied(opName, field, rest));
-        if (missing.length > 0) {
-          const named = missing.map((field) => `"${publicFieldName.get(field) ?? field}"`).join(', ');
-          throw new OperationError(
-            `${def.toolName} action "${String(input.action)}" requires ${named}. Unknown parameters are ignored — check the argument names.`,
-          );
-        }
-        const opInput = op.mcp?.buildInput ? op.mcp.buildInput(rest) : rest;
-        const result = await host.invoker().invoke(opName, opInput);
-        if (op.mcp?.formatResult) {
-          return await op.mcp.formatResult(result, rest, host);
+    // Loose for the same reason as registerOperationTools above: unknown args
+    // must reach the op layer's dead-field rejection instead of being stripped.
+    server.registerTool(
+      def.toolName,
+      { description: def.description, inputSchema: z.looseObject(buildCompositeShape(def)) },
+      async (input: Record<string, unknown>) => {
+        try {
+          const host = await getHost();
+          const opName = resolveCompositeOp(def, input);
+          const op = getOperation(opName);
+          // Strip the composite discriminators (action + any extra, e.g. `kind`)
+          // and undo any field remap; the rest is the op's raw MCP args — the same
+          // value the standalone tool would receive.
+          const rest = stripCompositeDiscriminators(def, input);
+          const missing = requiredMcpFields(op).filter((field) => !requiredFieldSatisfied(opName, field, rest));
+          if (missing.length > 0) {
+            const named = missing.map((field) => `"${publicFieldName.get(field) ?? field}"`).join(', ');
+            throw new OperationError(
+              `${def.toolName} action "${String(input.action)}" requires ${named}. Unknown parameters are ignored — check the argument names.`,
+            );
+          }
+          const opInput = op.mcp?.buildInput ? op.mcp.buildInput(rest) : rest;
+          const result = await host.invoker().invoke(opName, opInput);
+          if (op.mcp?.formatResult) {
+            return await op.mcp.formatResult(result, rest, host);
+          }
+          return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+        } catch (error) {
+          return {
+            content: [{ type: 'text' as const, text: error instanceof Error ? error.message : String(error) }],
+            isError: true,
+          };
         }
-        return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
-      } catch (error) {
-        return {
-          content: [{ type: 'text' as const, text: error instanceof Error ? error.message : String(error) }],
-          isError: true,
-        };
-      }
-    });
+      },
+    );
   }
 }

package/src/server/operations/ops/ax-presence.ts

@@ -34,6 +34,9 @@ const presenceSetShape = {
   focusNodeId: PRESENCE_SET_SHAPE.focusNodeId.describe('Node the agent is working on'),
   cursor: PRESENCE_SET_SHAPE.cursor.describe('Agent cursor in world coordinates'),
   attached: PRESENCE_SET_SHAPE.attached.describe('true attaches a session (Focus Session chrome); false detaches it'),
+  contextUsage: PRESENCE_SET_SHAPE.contextUsage.describe(
+    "The agent's real token window as {used,total} — shown on the board's context meter instead of the pinned-context estimate (null clears it)",
+  ),
 };
 const presenceSetSchema = z.looseObject(presenceSetShape);
 

package/src/server/scope-fence.ts

@@ -199,7 +199,7 @@ export function checkScopeOwnership(rawInput: unknown, writerKey?: string): stri
     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)) {
+    if (Object.hasOwn(agentScopes, writerKey)) {
       return `an agent cannot set or clear its OWN territory ("${writerKey}") — only the human or a different writer (the orchestrator) may.`;
     }
   }