pmx-canvas 0.5.0 → 0.6.1

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;
@@ -1632,7 +1696,9 @@ body,
   flex-wrap: nowrap;
   gap: 1px;
   margin: 2px -12px 8px;
-  padding: 0 10px;
+  /* Compact panels (Amp portal, 0.5.0 report B): six chips overflowed the
+     row by 11px — tighter inset + chip padding buys ~16px back. */
+  padding: 0 8px;
   overflow-x: auto;
   scrollbar-width: none;
 }
@@ -1651,7 +1717,7 @@ body,
 }
 .session-timeline-filters .activity-filter {
   flex-shrink: 0;
-  padding: 2px 5px;
+  padding: 2px 4px;
 }
 
 .session-timeline-row {
@@ -2828,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/canvas-operations.ts

@@ -1,6 +1,8 @@
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { basename, resolve } from 'node:path';
+import { agentPresence } from './agent-presence.js';
 import { recomputeCodeGraph } from './code-graph.js';
+import { diffLayouts } from './mutation-history.js';
 import {
   canvasState,
   type CanvasEdge,
@@ -1396,6 +1398,30 @@ export function listCanvasSnapshots(options?: Parameters<typeof canvasState.list
   return canvasState.listSnapshots(options);
 }
 
+/**
+ * Snapshot save with unchanged-board reuse — the ONE path every surface must
+ * take (op registry, SDK). The SDK once called saveCanvasSnapshot directly and
+ * stacked identical snapshots the HTTP/MCP path deduplicated (0.5.0 Codex
+ * finding V).
+ */
+export function saveCanvasSnapshotWithReuse(name: string): { snapshot: CanvasSnapshot | null; reused: boolean } {
+  const newest = canvasState.listSnapshots({ limit: 1 })[0];
+  if (newest) {
+    const newestData = canvasState.getSnapshotData(newest.id);
+    if (newestData) {
+      const diff = diffLayouts(newestData.name, newestData, canvasState.getLayout());
+      const identical =
+        diff.addedNodes.length === 0 &&
+        diff.removedNodes.length === 0 &&
+        diff.modifiedNodes.length === 0 &&
+        diff.addedEdges.length === 0 &&
+        diff.removedEdges.length === 0;
+      if (identical) return { snapshot: newest, reused: true };
+    }
+  }
+  return { snapshot: saveCanvasSnapshot(name), reused: false };
+}
+
 export function saveCanvasSnapshot(name: string): CanvasSnapshot | null {
   return canvasState.saveSnapshot(name);
 }
@@ -1748,7 +1774,7 @@ export function getClientViewportSize(): { width: number; height: number } | nul
 export function fitCanvasView(options: CanvasFitViewOptions = {}): CanvasFitViewResult {
   const width = positiveNumber(options.width, lastClientViewportSize?.width ?? 1440);
   const height = positiveNumber(options.height, lastClientViewportSize?.height ?? 900);
-  const padding = positiveNumber(options.padding, 60);
+  const padding = positiveNumber(options.padding, 24); // screen px now, not world units
   const maxScale = positiveNumber(options.maxScale, 1);
   const nodeIdFilter = options.nodeIds && options.nodeIds.length > 0 ? new Set(options.nodeIds) : null;
   const targetNodes = canvasState.getLayout().nodes.filter((node) => !nodeIdFilter || nodeIdFilter.has(node.id));
@@ -1770,14 +1796,23 @@ export function fitCanvasView(options: CanvasFitViewOptions = {}): CanvasFitView
   }
 
   const bounds = { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
-  const worldWidth = Math.max(1, bounds.width + padding * 2);
-  const worldHeight = Math.max(1, bounds.height + padding * 2);
-  const scale = Math.min(maxScale, width / worldWidth, height / worldHeight);
+  // Screen-space fit (architecture rule 9): `padding` and the chrome reserve
+  // are SCREEN pixels — world-space padding shrank with the fit zoom and
+  // parked nodes under the command bar and minimap (0.5.0 Amp report,
+  // finding A). The server cannot measure the client's chrome, so it reserves
+  // nominal bottom space: the minimap is always there; the command bar only
+  // while a session is attached.
+  const bottomReserve = agentPresence.snapshot().sessionActive ? 128 : 96;
+  const usableWidth = Math.max(80, width - padding * 2);
+  const usableHeight = Math.max(80, height - padding - bottomReserve);
+  const worldWidth = Math.max(1, bounds.width);
+  const worldHeight = Math.max(1, bounds.height);
+  const scale = Math.min(maxScale, usableWidth / worldWidth, usableHeight / worldHeight);
   const centerX = minX + bounds.width / 2;
   const centerY = minY + bounds.height / 2;
   const viewport = {
-    x: width / 2 - centerX * scale,
-    y: height / 2 - centerY * scale,
+    x: padding + usableWidth / 2 - centerX * scale,
+    y: padding + usableHeight / 2 - centerY * scale,
     scale,
   };
 

package/src/server/index.ts

@@ -59,7 +59,7 @@ import {
   removeCanvasEdge,
   resolveHtmlContent,
   restoreCanvasSnapshot,
-  saveCanvasSnapshot,
+  saveCanvasSnapshotWithReuse,
   scheduleCodeGraphRecompute,
   syncCanvasRuntimeBackends,
   setCanvasContextPins,
@@ -1072,7 +1072,9 @@ export class PmxCanvas extends EventEmitter {
   }
 
   saveSnapshot(name: string) {
-    return saveCanvasSnapshot(name);
+    // Same reuse path as HTTP/MCP: an unchanged board returns the existing
+    // newest snapshot instead of stacking an identical copy (Codex finding V).
+    return saveCanvasSnapshotWithReuse(name).snapshot;
   }
 
   async restoreSnapshot(id: string): Promise<{ ok: boolean }> {

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/operations/ops/nodes.ts

@@ -422,6 +422,13 @@ export function createBasicCanvasNode(
         : '"path" is only an image-node compatibility alias — use `content`.',
     );
   }
+  // Docking was removed in 0.5.0 — a create that still sends it silently
+  // succeeded and read as "docking works" (0.5.0 Copilot report, PASS-ish).
+  if (body.dockPosition !== undefined) {
+    throw new OperationError(
+      'Unknown field "dockPosition" — docking was removed in 0.5.0; use `position` and `pinned`.',
+    );
+  }
   const content =
     type === 'image' && typeof body.path === 'string' && typeof body.content !== 'string' ? body.path : body.content;
   // For html nodes, accept top-level `html` AND `axCapabilities` and merge into data
@@ -496,6 +503,11 @@ export function buildNodePatch(
   if (body.src !== undefined) {
     throw new OperationError('Unknown field "src" — update the image source via `content`.');
   }
+  if (body.dockPosition !== undefined) {
+    throw new OperationError(
+      'Unknown field "dockPosition" — docking was removed in 0.5.0; use `position` and `pinned`.',
+    );
+  }
   if (body.path !== undefined && existing.type !== 'image') {
     if (existing.type === 'file') {
       // Repoint: `path` on a file-node patch moves the node to another file

package/src/server/operations/ops/snapshots.ts

@@ -29,9 +29,9 @@ import {
   gcCanvasSnapshots,
   listCanvasSnapshots,
   restoreCanvasSnapshot,
-  saveCanvasSnapshot,
+  saveCanvasSnapshotWithReuse,
 } from '../../canvas-operations.js';
-import { diffLayouts, formatDiff } from '../../mutation-history.js';
+import { formatDiff, diffLayouts } from '../../mutation-history.js';
 import { defineOperation, OperationError, type Operation } from '../types.js';
 import { isRecord } from './nodes.js';
 
@@ -129,24 +129,11 @@ const snapshotSaveOperation = defineOperation<z.infer<typeof snapshotSaveSchema>
     const name = typeof input.name === 'string' ? input.name.trim() : '';
     if (!name) throw new OperationError('Missing snapshot name');
     // A save of an unchanged board reuses the newest snapshot instead of
-    // stacking an identical copy in the History drawer.
-    const newest = canvasState.listSnapshots({ limit: 1 })[0];
-    if (newest) {
-      const newestData = canvasState.getSnapshotData(newest.id);
-      if (newestData) {
-        const diff = diffLayouts(newestData.name, newestData, canvasState.getLayout());
-        const identical =
-          diff.addedNodes.length === 0 &&
-          diff.removedNodes.length === 0 &&
-          diff.modifiedNodes.length === 0 &&
-          diff.addedEdges.length === 0 &&
-          diff.removedEdges.length === 0;
-        if (identical) return { ok: true, id: newest.id, snapshot: newest, reused: true };
-      }
-    }
-    const snapshot = saveCanvasSnapshot(name);
+    // stacking an identical copy — via the ONE shared path the SDK uses too
+    // (0.5.0 Codex finding V).
+    const { snapshot, reused } = saveCanvasSnapshotWithReuse(name);
     if (!snapshot) throw new OperationError('Failed to save snapshot');
-    return { ok: true, id: snapshot.id, snapshot };
+    return { ok: true, id: snapshot.id, snapshot, ...(reused ? { reused: true } : {}) };
   },
 });
 

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.`;
     }
   }