pmx-canvas 0.5.1 → 0.6.2

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;
@@ -1313,7 +1377,7 @@ body,
   animation: session-panel-in 180ms ease;
 }
 .session-panel.is-collapsed {
-  width: 28px;
+  width: 40px;
   align-items: center;
   padding-top: 10px;
   gap: 10px;
@@ -1326,6 +1390,17 @@ body,
   text-transform: uppercase;
   color: var(--c-dim);
 }
+.session-collapsed-live {
+  display: inline-flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 4px;
+  font: 9px var(--mono);
+  color: var(--c-dim);
+}
+.session-collapsed-live .session-live-dot {
+  background: var(--c-ok);
+}
 
 .session-panel-header {
   height: var(--hud-bar-height);
@@ -1653,7 +1728,7 @@ body,
 }
 .session-timeline-filters .activity-filter {
   flex-shrink: 0;
-  padding: 2px 4px;
+  padding: 2px 3px;
 }
 
 .session-timeline-row {
@@ -2830,9 +2905,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;
@@ -3670,6 +3756,12 @@ body,
 }
 
 /* Node resize handle */
+.canvas-node:has(.node-resize-handle) {
+  /* Keep the four-pixel corner grab inside the shell's inner clip, not on
+     its rounded border. The other corners retain the standard card radius. */
+  border-bottom-right-radius: 8px;
+}
+
 .canvas-node .node-resize-handle {
   position: absolute;
   bottom: 0;
@@ -3714,7 +3806,9 @@ html.is-node-dragging .attention-field-layer {
 }
 
 html.is-node-dragging,
-html.is-node-dragging * {
+html.is-node-dragging *,
+html.is-canvas-panning,
+html.is-canvas-panning * {
   cursor: grabbing !important;
   user-select: none !important;
   -webkit-user-select: none !important;

package/src/server/canvas-operations.ts

@@ -726,7 +726,7 @@ function shouldTreatFileContentAsPath(input: CanvasAddNodeInput): boolean {
   const content = input.content?.trim() ?? '';
   if (!content || content.includes('\n') || content.includes('\r')) return false;
   if (typeof input.data?.path === 'string' && input.data.path.length > 0) return true;
-  if (existsSync(resolve(content))) return true;
+  if (existsSync(resolve(canvasState.getWorkspaceRoot(), content))) return true;
   if (!input.title) return true;
   return content.startsWith('/') || content.startsWith('./') || content.startsWith('../') || content.includes('/');
 }
@@ -748,7 +748,7 @@ function buildFileNodeData(input: CanvasAddNodeInput): Record<string, unknown> {
 
   const rawPath =
     typeof input.data?.path === 'string' && input.data.path.length > 0 ? input.data.path : (input.content ?? '');
-  const resolved = resolve(rawPath);
+  const resolved = resolve(canvasState.getWorkspaceRoot(), rawPath);
   const fileName = basename(resolved) || rawPath;
   const data: Record<string, unknown> = {
     ...(input.data ?? {}),

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/viewport.ts

@@ -135,8 +135,10 @@ const focusOperation = defineOperation<z.infer<typeof focusSchema>, Record<strin
     }
     const focus = canvasState.setAxFocus([nodeId], { source: 'api', recordHistory: false });
     ctx.emit('ax-state-changed', { focus });
-    ctx.emit('canvas-focus-node', { nodeId, noPan });
+    // Apply the server fallback first; the browser then refines it using its
+    // actual canvas region and floating chrome instead of cancelling that fit.
     if (!noPan) ctx.emit('canvas-viewport-update', { viewport: canvasState.viewport });
+    ctx.emit('canvas-focus-node', { nodeId, noPan });
     return { ok: true, focused: nodeId, panned: !noPan, axFocus: focus };
   },
 });
@@ -250,6 +252,9 @@ const viewportSetOperation = defineOperation<z.infer<typeof viewportSetSchema>,
     // sizes to the human's actual window instead of a hardcoded 1440x900
     // (0.4.6 orb feedback #2).
     setClientViewportSize(body.clientWidth, body.clientHeight);
+    // A size-only report is not a camera command. Echoing the stored camera
+    // here would cancel an in-flight browser focus with its stale fallback.
+    if (![body.x, body.y, body.scale].some((value) => typeof value === 'number')) return { ok: true };
     const next = {
       x: typeof body.x === 'number' ? body.x : canvasState.viewport.x,
       y: typeof body.y === 'number' ? body.y : canvasState.viewport.y,

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

package/src/server/server.ts

@@ -556,22 +556,22 @@ export async function startCanvasAutomationWebView(
       await closeCanvasAutomationWebViewInternal();
     }
 
-    const view = new WebView({
-      width: normalized.width,
-      height: normalized.height,
-      headless: true,
-      backend,
-      dataStore: normalized.dataStoreDir ? { directory: normalized.dataStoreDir } : 'ephemeral',
-    });
-
+    let view: CanvasWebViewLike | null = null;
     try {
+      view = new WebView({
+        width: normalized.width,
+        height: normalized.height,
+        headless: true,
+        backend,
+        dataStore: normalized.dataStoreDir ? { directory: normalized.dataStoreDir } : 'ephemeral',
+      });
       await withCanvasAutomationWebViewTimeout(view.navigate(url), 'starting the workbench automation WebView');
     } catch (error) {
       canvasAutomationWebViewStatus = {
         ...canvasAutomationWebViewStatus,
         lastError: error instanceof Error ? error.message : String(error),
       };
-      await Promise.resolve(view.close()).catch(() => undefined);
+      if (view) await Promise.resolve(view.close()).catch(() => undefined);
       throw error;
     }
 

package/src/server/web-artifacts/scripts/bundle-artifact.sh

@@ -56,14 +56,12 @@ function replay_filtered_stderr() {
 
 function run_with_filtered_stderr() {
   local stderr_file
+  local status
   stderr_file="$(mktemp)"
-  if "$@" 2>"$stderr_file"; then
-    replay_filtered_stderr "$stderr_file"
-    rm -f "$stderr_file"
-    return 0
-  fi
-
-  local status=$?
+  set +e
+  "$@" 2>"$stderr_file"
+  status=$?
+  set -e
   replay_filtered_stderr "$stderr_file"
   rm -f "$stderr_file"
   return "$status"
@@ -109,6 +107,17 @@ function ensure_bundle_dependencies() {
     fi
   done
 
+  # package.json lists the deps, but node_modules may not be in sync (e.g. fresh
+  # CI checkout where node_modules is gitignored). Run a regular install so the
+  # local binaries actually exist before we hand off to Parcel. The build
+  # allowlist is already persisted in package.json's pnpm.onlyBuiltDependencies
+  # by the original `pnpm add` step, so plain `install` is enough here.
+  if [ ! -x "./node_modules/.bin/parcel" ]; then
+    echo "📦 Syncing bundling dependencies into node_modules..."
+    run_pnpm_quiet install
+    return 0
+  fi
+
   echo "✅ Reusing existing bundling dependencies"
 }
 
@@ -150,7 +159,19 @@ rm -rf dist bundle.html
 
 # Build with Parcel
 echo "🔨 Building with Parcel..."
-run_with_filtered_stderr run_local_binary parcel build index.html --dist-dir dist --no-source-maps --log-level error
+parcel_status=0
+run_with_filtered_stderr run_local_binary parcel build index.html --dist-dir dist --no-source-maps --log-level error || parcel_status=$?
+
+# Self-heal a wedged cache: these build projects are REUSED across artifact
+# builds, and a parcel killed mid-write (e.g. the canvas server torn down
+# during a build) leaves a corrupted .parcel-cache that makes every later
+# build die before emitting anything — permanently, until the cache goes.
+# Retry exactly once from a cold cache, then preserve a genuine build failure.
+if [ "$parcel_status" -ne 0 ] || [ ! -s "dist/index.html" ]; then
+  echo "🧹 Parcel build failed or produced no output — clearing .parcel-cache and retrying cold..."
+  rm -rf .parcel-cache dist
+  run_with_filtered_stderr run_local_binary parcel build index.html --dist-dir dist --no-source-maps --log-level error
+fi
 
 if [ ! -s "dist/index.html" ]; then
   echo "❌ Error: Parcel did not produce dist/index.html" >&2