pmx-canvas 0.1.35 → 0.2.0

package/src/mcp/server.ts

@@ -22,15 +22,15 @@
 
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { isAbsolute, relative, resolve } from 'node:path';
 import { z } from 'zod';
-import { canvasState, describeCanvasSchema, validateStructuredCanvasPayload } from '../server/index.js';
+import { canvasState, describeCanvasSchema } from '../server/index.js';
 import { AX_INTERACTION_TYPES } from '../server/ax-interaction.js';
+import { buildPendingAxActivity } from '../server/ax-state.js';
 import { isHtmlPrimitiveKind } from '../server/html-primitives.js';
 import type { HtmlPrimitiveKind } from '../server/html-primitives.js';
+import { registerOperationTools, registerCompositeTools } from '../server/operations/index.js';
 import { createCanvasAccess, refreshCanvasAccess, type CanvasAccess } from './canvas-access.js';
 import { serializeNodeForAgentContext } from '../server/agent-context.js';
-import { wrapCanvasAutomationScript } from '../server/server.js';
 import { buildSpatialContext, findNeighborhoods } from '../server/spatial-analysis.js';
 import {
   getCanvasNodeTitle,
@@ -46,19 +46,6 @@ let resourceNotificationServer: McpServer | null = null;
 let localResourceNotificationsStarted = false;
 let remoteResourceNotificationsBaseUrl: string | null = null;
 
-const jsonRenderSpecSchema = z.union([
-  z.object({
-    root: z.string(),
-    elements: z.record(z.string(), z.unknown()),
-    state: z.record(z.string(), z.unknown()).optional(),
-  }).passthrough(),
-  z.object({
-    type: z.string(),
-    props: z.record(z.string(), z.unknown()).optional(),
-    children: z.array(z.string()).optional(),
-  }).passthrough(),
-]);
-
 const htmlPrimitiveKindSchema = z.string().refine(isHtmlPrimitiveKind, 'Unknown HTML primitive kind');
 
 function structuredSchemaDescription(): string {
@@ -68,24 +55,9 @@ function structuredSchemaDescription(): string {
     .join(', ');
 }
 
-function workspaceRoot(): string {
-  return resolve(process.cwd());
-}
-
-function isPathInside(base: string, candidate: string): boolean {
-  const rel = relative(base, candidate);
-  if (rel === '') return true;
-  return !rel.startsWith('..') && rel !== '..' && !isAbsolute(rel);
-}
-
-function safeWorkspacePath(pathLike: string): string {
-  const workspace = workspaceRoot();
-  const resolved = resolve(workspace, pathLike);
-  if (!isPathInside(workspace, resolved)) {
-    throw new Error(`Path "${pathLike}" resolves outside workspace.`);
-  }
-  return resolved;
-}
+// workspaceRoot / isPathInside / safeWorkspacePath removed with the
+// canvas_build_web_artifact MCP tool (plan-008 Wave 4). The webartifact.build op
+// sandboxes projectPath/outputPath via web-artifacts.ts resolveWorkspacePath.
 
 async function ensureCanvas(): Promise<CanvasAccess> {
   if (!canvas) {
@@ -200,56 +172,6 @@ function wantsFullPayload(input: { full?: boolean; verbose?: boolean; includeDat
   return input.full === true || input.verbose === true || input.includeData === true;
 }
 
-interface PendingAxActivityItem {
-  kind: 'work-item' | 'approval-gate' | 'elicitation' | 'mode-request';
-  id: string;
-  title: string;
-  status: string;
-  nodeIds: string[];
-  source: string | null;
-}
-
-const OPEN_AX_WORK_STATUSES = new Set(['todo', 'in-progress', 'blocked']);
-
-/**
- * Open, agent-actionable canvas-bound AX items (open work items + pending approval
- * gates / elicitations / mode requests). Unlike steering (a directive routed through
- * the claim/ack delivery queue), these are STATE the human curates in the browser —
- * they fire `ax-state-changed` (so resource-subscribers are pushed canvas://ax-work),
- * but an adapterless client that only POLLS the delivery surface never saw them.
- * Surfacing this digest there closes report #43 without conflating state with steering.
- * Optionally excludes items the consumer itself originated (loop prevention), mirroring
- * getPendingSteering.
- */
-function buildPendingAxActivity(
-  state: Awaited<ReturnType<CanvasAccess['getAxState']>>,
-  consumer?: string,
-): PendingAxActivityItem[] {
-  const notMine = (source: string | null) => !consumer || source !== consumer;
-  const out: PendingAxActivityItem[] = [];
-  for (const w of state.workItems ?? []) {
-    if (OPEN_AX_WORK_STATUSES.has(w.status) && notMine(w.source)) {
-      out.push({ kind: 'work-item', id: w.id, title: w.title, status: w.status, nodeIds: w.nodeIds ?? [], source: w.source });
-    }
-  }
-  for (const g of state.approvalGates ?? []) {
-    if (g.status === 'pending' && notMine(g.source)) {
-      out.push({ kind: 'approval-gate', id: g.id, title: g.title, status: g.status, nodeIds: g.nodeIds ?? [], source: g.source });
-    }
-  }
-  for (const e of state.elicitations ?? []) {
-    if (e.status === 'pending' && notMine(e.source)) {
-      out.push({ kind: 'elicitation', id: e.id, title: e.prompt, status: e.status, nodeIds: e.nodeIds ?? [], source: e.source });
-    }
-  }
-  for (const m of state.modeRequests ?? []) {
-    if (m.status === 'pending' && notMine(m.source)) {
-      out.push({ kind: 'mode-request', id: m.id, title: m.reason ? `${m.mode}: ${m.reason}` : `mode: ${m.mode}`, status: m.status, nodeIds: m.nodeIds ?? [], source: m.source });
-    }
-  }
-  return out;
-}
-
 function compactNodePayload(node: Awaited<ReturnType<CanvasAccess['getNode']>>): Record<string, unknown> | null {
   if (!node) return null;
   const serialized = serializeCanvasNode(node);
@@ -293,28 +215,6 @@ function agentSafeFullLayoutPayload(layout: Awaited<ReturnType<CanvasAccess['get
   };
 }
 
-function compactBatchValue(value: unknown): unknown {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return value;
-  const record = value as Record<string, unknown>;
-  const nodeLike = typeof record.id === 'string' && typeof record.type === 'string';
-  const compact: Record<string, unknown> = {};
-  for (const key of ['ok', 'id', 'type', 'kind', 'title', 'content', 'position', 'size', 'fetch', 'error', 'from', 'to', 'groupId', 'nodeIds', 'snapshot', 'arranged', 'layout']) {
-    if (record[key] !== undefined) compact[key] = record[key];
-  }
-  if (nodeLike) return compact;
-  return record;
-}
-
-function compactBatchResult(result: { ok: boolean; results: Array<Record<string, unknown>>; refs: Record<string, unknown>; failedIndex?: number; error?: string }): Record<string, unknown> {
-  return {
-    ok: result.ok,
-    ...(result.failedIndex !== undefined ? { failedIndex: result.failedIndex } : {}),
-    ...(result.error ? { error: result.error } : {}),
-    results: result.results.map((entry) => compactBatchValue(entry)),
-    refs: Object.fromEntries(Object.entries(result.refs).map(([key, value]) => [key, compactBatchValue(value)])),
-  };
-}
-
 async function createdNodePayload(c: CanvasAccess, id: string, options: { full?: boolean; verbose?: boolean; includeData?: boolean } = {}): Promise<Record<string, unknown>> {
   // Expose both `id` and a `nodeId` alias on every node-create response so
   // agents using either key (or a cached schema) work — matching the
@@ -349,20 +249,6 @@ function buildSummaryFromLayout(layout: Awaited<ReturnType<CanvasAccess['getLayo
   };
 }
 
-function buildSnapshotRestoreSummary(layout: Awaited<ReturnType<CanvasAccess['getLayout']>>): Record<string, unknown> {
-  const nodesByType: Record<string, number> = {};
-  for (const node of layout.nodes) {
-    nodesByType[node.type] = (nodesByType[node.type] ?? 0) + 1;
-  }
-  return {
-    nodeCount: layout.nodes.length,
-    edgeCount: layout.edges.length,
-    annotationCount: (layout.annotations ?? []).length,
-    nodesByType,
-    viewport: layout.viewport,
-  };
-}
-
 export async function startMcpServer(): Promise<void> {
   const server = new McpServer({
     name: 'pmx-canvas',
@@ -370,118 +256,27 @@ export async function startMcpServer(): Promise<void> {
   });
   resourceNotificationServer = server;
 
-  // ── canvas_get_layout ──────────────────────────────────────────
-  server.tool(
-    'canvas_get_layout',
-    'Get the canvas layout. Defaults to a compact agent-safe projection; pass full:true for full node data.',
-    {
-      full: z.boolean().optional().describe('Return the full layout including node data. Default false keeps responses compact.'),
-      verbose: z.boolean().optional().describe('Alias for full:true.'),
-    },
-    async (input) => {
-      const c = await ensureCanvas();
-      const layout = await c.getLayout();
-      const payload = wantsFullPayload(input)
-        ? agentSafeFullLayoutPayload(layout)
-        : compactLayoutPayload(layout, await c.getPinnedNodeIds());
-      return {
-        content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
-      };
-    },
-  );
-
-  // ── canvas_get_node ────────────────────────────────────────────
-  server.tool(
-    'canvas_get_node',
-    'Get a single node by ID. Defaults to compact metadata; pass full:true to include full data/tool results.',
-    {
-      id: z.string().describe('The node ID to retrieve'),
-      full: z.boolean().optional().describe('Include full node data, including mcp-app tool results. Default false.'),
-      verbose: z.boolean().optional().describe('Alias for full:true.'),
-    },
-    async (input) => {
-      const c = await ensureCanvas();
-      const node = await c.getNode(input.id);
-      if (!node) {
-        return {
-          content: [{ type: 'text', text: `Node "${input.id}" not found.` }],
-          isError: true,
-        };
-      }
-      const payload = wantsFullPayload(input) ? serializeCanvasNodeForAgent(node) : compactNodePayload(node);
-      return {
-        content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
-      };
-    },
-  );
-
-  // ── canvas_add_node ────────────────────────────────────────────
-  server.tool(
-    'canvas_add_node',
-    'Add a basic node to the canvas. Returns the created node with normalized title/content and rendered geometry. Supported here: markdown, status, context, ledger, trace, file, image, webpage, mcp-app, html, group. Dedicated node tools: json-render -> canvas_add_json_render_node, graph -> canvas_add_graph_node, web-artifact -> canvas_build_web_artifact, external apps -> canvas_open_mcp_app, html (preferred) -> canvas_add_html_node, groups -> canvas_create_group. Call canvas_describe_schema for the full nodeTypeRouting table.',
-    {
-      type: z.enum(['markdown', 'status', 'context', 'ledger', 'trace', 'file', 'image', 'webpage', 'mcp-app', 'html', 'group'])
-        .describe('Node type (prefer canvas_create_group for groups)'),
-      title: z.string().optional().describe('Node title'),
-      content: z.string().optional().describe('Node content (markdown for markdown nodes, file path for file nodes, image path/URL/data-URI for image nodes, URL for webpage nodes)'),
-      path: z.string().optional().describe('Compatibility alias for image node content. Prefer content for image paths.'),
-      url: z.string().optional().describe('Canonical webpage URL field for webpage nodes. Overrides content when both are provided.'),
-      x: z.number().optional().describe('X position (auto-placed if omitted)'),
-      y: z.number().optional().describe('Y position (auto-placed if omitted)'),
-      width: z.number().optional().describe('Width in pixels (default: 720)'),
-      height: z.number().optional().describe('Height in pixels (default: 600)'),
-      strictSize: z.boolean().optional().describe('Keep explicit width/height fixed and scroll overflowing content instead of browser auto-fitting'),
-      children: z.array(z.string()).optional().describe('Group-only alias for childIds. Node IDs to include in a generic group node.'),
-      childIds: z.array(z.string()).optional().describe('Group-only field. Node IDs to include in a generic group node. Prefer canvas_create_group for groups.'),
-      childLayout: z.enum(['grid', 'column', 'flow']).optional().describe('Group-only optional layout for grouped children.'),
-      color: z.string().optional().describe('Group-only frame accent color.'),
-      toolName: z.string().optional().describe('Trace node tool or operation label'),
-      category: z.string().optional().describe('Trace node category: mcp, file, subagent, or other'),
-      status: z.string().optional().describe('Trace node status: running, success, or failed'),
-      duration: z.string().optional().describe('Trace node duration badge text'),
-      resultSummary: z.string().optional().describe('Trace node result summary'),
-      error: z.string().optional().describe('Trace node error message'),
-      full: z.boolean().optional().describe('Return the full created node payload. Default false returns compact metadata.'),
-      verbose: z.boolean().optional().describe('Alias for full:true.'),
-    },
-    async (input) => {
-      const c = await ensureCanvas();
-      if (input.type === 'webpage') {
-        const url = input.url ?? input.content;
-        if (!url) {
-          return {
-            content: [{ type: 'text', text: 'Webpage nodes require a page URL via "url" (preferred) or "content".' }],
-            isError: true,
-          };
-        }
-        const result = await c.addWebpageNode({
-          ...(typeof input.title === 'string' ? { title: input.title } : {}),
-          url,
-          ...(typeof input.x === 'number' ? { x: input.x } : {}),
-          ...(typeof input.y === 'number' ? { y: input.y } : {}),
-          ...(typeof input.width === 'number' ? { width: input.width } : {}),
-          ...(typeof input.height === 'number' ? { height: input.height } : {}),
-          ...(input.strictSize === true ? { strictSize: true } : {}),
-        });
-        return {
-          content: [{ type: 'text', text: JSON.stringify(result) }],
-          ...(result.ok ? {} : { isError: true }),
-        };
-      }
-      const nodeInput = input.type === 'image' && input.path && !input.content
-        ? { ...input, content: input.path }
-        : input;
-      const id = await c.addNode(nodeInput);
-      return {
-        content: [{ type: 'text', text: JSON.stringify(await createdNodePayload(c, id, input), null, 2) }],
-      };
-    },
-  );
+  // ── Operation-registry tools (plan-005) ────────────────────────
+  // canvas_get_layout / canvas_get_node / canvas_add_node /
+  // canvas_update_node / canvas_remove_node are registered from the shared
+  // operation registry. Tool names and compact/full payload behavior are
+  // frozen (tests/unit/mcp-tool-freeze.test.ts, operation-parity.test.ts).
+  registerOperationTools(server, ensureCanvas);
+
+  // ── Composite (action-discriminated) tools (plan-006) ───────────
+  // Consolidate single-purpose tools into action-routed composites
+  // (canvas_node, canvas_render, canvas_edge, canvas_group, canvas_history,
+  // canvas_view, canvas_query, plus the AX composites). Each action dispatches
+  // to the same registered operation as its standalone tool, so behavior is
+  // identical. Additive in v0.2 (legacy tools still registered below); legacy
+  // removed in v0.3 per docs/api-stability.md. (canvas_snapshot composite is
+  // deferred to v0.3 — its name is still held by the legacy save-snapshot tool.)
+  registerCompositeTools(server, ensureCanvas);
 
   // ── canvas_add_html_node ────────────────────────────────────────
   server.tool(
     'canvas_add_html_node',
-    'Add a normal html node: a self-contained HTML document (with optional inline <script> and CDN <script src="...">) rendered inside a sandboxed iframe (sandbox="allow-scripts"). This is the default HTML surface for reports, widgets, and bespoke visualizations. Presentation mode is opt-in: only pass presentation:true when the user explicitly asks for a deck/fullscreen presentation, or use canvas_add_html_primitive with kind="presentation". The iframe inherits live canvas theme tokens via injected CSS custom properties (both --c-* and common --color-* aliases) so authored HTML using var(--color-text-secondary), var(--color-bg), etc. renders cohesively. No same-origin access; no top-navigation; no forms. For declarative-only views with zero JS, prefer canvas_add_json_render_node. For React + shadcn + routing or multi-component apps, use canvas_build_web_artifact.',
+    'Deprecated: use canvas_node with action "add" and type:"html". Add a normal html node: a self-contained HTML document (with optional inline <script> and CDN <script src="...">) rendered inside a sandboxed iframe (sandbox="allow-scripts"). This is the default HTML surface for reports, widgets, and bespoke visualizations. Presentation mode is opt-in: only pass presentation:true when the user explicitly asks for a deck/fullscreen presentation, or use canvas_add_html_primitive with kind="presentation". The iframe inherits live canvas theme tokens via injected CSS custom properties (both --c-* and common --color-* aliases) so authored HTML using var(--color-text-secondary), var(--color-bg), etc. renders cohesively. No same-origin access; no top-navigation; no forms. For declarative-only views with zero JS, prefer canvas_add_json_render_node. For React + shadcn + routing or multi-component apps, use canvas_build_web_artifact.',
     {
       html: z.string().describe('HTML document or fragment. Full <html>...</html> documents are passed through with theme styles injected into <head>; bare fragments are wrapped in a minimal document. Inline <script> and remote CDN <script src="..."> are allowed. If this is a bare path to an existing local .html/.htm file, the file contents are read and used as the HTML.'),
       title: z.string().optional().describe('Node title shown in the canvas titlebar.'),
@@ -520,1602 +315,204 @@ export async function startMcpServer(): Promise<void> {
         ...(typeof input.x === 'number' ? { x: input.x } : {}),
         ...(typeof input.y === 'number' ? { y: input.y } : {}),
         ...(typeof input.width === 'number' ? { width: input.width } : {}),
-        ...(typeof input.height === 'number' ? { height: input.height } : {}),
-        ...(input.strictSize === true ? { strictSize: true } : {}),
-      });
-      return {
-        content: [{ type: 'text', text: JSON.stringify(await createdNodePayload(c, id, input), null, 2) }],
-      };
-    },
-  );
-
-  server.tool(
-    'canvas_add_html_primitive',
-    'Create a reusable HTML communication primitive as a normal sandboxed html node. Use this instead of long markdown for side-by-side choices, implementation plans, PR review sheets, module maps, design sheets, component galleries, flowcharts, explainers, status reports, and throwaway editors with export/copy paths. Use kind="presentation" only when the user explicitly asks for a PowerPoint-like deck, pitch, briefing, workshop walkthrough, or fullscreen story.',
-    {
-      kind: htmlPrimitiveKindSchema.describe('Primitive kind. Call canvas_describe_schema and read htmlPrimitives for data shapes and examples.'),
-      title: z.string().optional().describe('Node title shown in the canvas titlebar.'),
-      data: z.record(z.string(), z.unknown()).optional().describe('Primitive-specific data payload. For kind="presentation", data may include theme:"canvas"|"midnight"|"paper"|"aurora" or a custom color object. See canvas_describe_schema.htmlPrimitives for each shape.'),
-      x: z.number().optional().describe('X position (auto-placed if omitted).'),
-      y: z.number().optional().describe('Y position (auto-placed if omitted).'),
-      width: z.number().optional().describe('Width in pixels (defaults per primitive).'),
-      height: z.number().optional().describe('Height in pixels (defaults per primitive).'),
-      strictSize: z.boolean().optional().describe('Keep explicit width/height fixed; iframe scrolls overflow internally.'),
-      full: z.boolean().optional().describe('Return the full created node payload. Default false returns compact metadata.'),
-      verbose: z.boolean().optional().describe('Alias for full:true.'),
-    },
-    async (input) => {
-      const c = await ensureCanvas();
-      const kind = input.kind as HtmlPrimitiveKind;
-      const result = await c.addHtmlPrimitive({
-        kind,
-        ...(typeof input.title === 'string' ? { title: input.title } : {}),
-        ...(input.data ? { data: input.data } : {}),
-        ...(typeof input.x === 'number' ? { x: input.x } : {}),
-        ...(typeof input.y === 'number' ? { y: input.y } : {}),
-        ...(typeof input.width === 'number' ? { width: input.width } : {}),
-        ...(typeof input.height === 'number' ? { height: input.height } : {}),
-        ...(input.strictSize === true ? { strictSize: true } : {}),
-      });
-      return {
-        content: [{
-          type: 'text',
-          text: JSON.stringify({
-            ...(await createdNodePayload(c, result.id, input)),
-            primitive: { kind: result.kind, title: result.title, htmlBytes: result.htmlBytes },
-          }, null, 2),
-        }],
-      };
-    },
-  );
-
-  server.tool(
-    'canvas_open_mcp_app',
-    'Connect to an external MCP server that declares a ui:// app resource, call the specified tool, and open the resulting MCP App inside a canvas mcp-app node. This is a full external-MCP transport call, not the CLI kind shortcut; use canvas_add_diagram for the built-in Excalidraw preset.',
-    {
-      toolName: z.string().describe('Tool name on the external MCP server'),
-      serverName: z.string().optional().describe('Optional display name for the external MCP server'),
-      toolArguments: z.record(z.string(), z.unknown()).optional().describe('Arguments passed to the external tool call'),
-      nodeId: z.string().optional().describe('Existing mcp-app node ID to update in place instead of creating a new node.'),
-      title: z.string().optional().describe('Optional canvas node title override'),
-      x: z.number().optional().describe('X position (auto-placed if omitted)'),
-      y: z.number().optional().describe('Y position (auto-placed if omitted)'),
-      width: z.number().optional().describe('Width in pixels (default: 720)'),
-      height: z.number().optional().describe('Height in pixels (default: 500)'),
-      timeoutMs: z.number().optional().describe('Optional MCP request timeout in milliseconds for cold external app servers'),
-      transport: z.union([
-        z.object({
-          type: z.literal('stdio'),
-          command: z.string().describe('Executable used to start the external MCP server'),
-          args: z.array(z.string()).optional().describe('Arguments for the executable'),
-          cwd: z.string().optional().describe('Optional working directory'),
-          env: z.record(z.string(), z.string()).optional().describe('Optional environment overrides'),
-        }),
-        z.object({
-          type: z.literal('http'),
-          url: z.string().describe('Streamable HTTP MCP endpoint URL'),
-          headers: z.record(z.string(), z.string()).optional().describe('Optional HTTP headers'),
-        }),
-      ]).describe('How PMX Canvas should connect to the external MCP server'),
-    },
-    async (input) => {
-      const c = await ensureCanvas();
-      try {
-        const result = await c.openMcpApp({
-          transport: input.transport,
-          toolName: input.toolName,
-          ...(typeof input.serverName === 'string' ? { serverName: input.serverName } : {}),
-          ...(input.toolArguments ? { toolArguments: input.toolArguments } : {}),
-          ...(typeof input.nodeId === 'string' ? { nodeId: input.nodeId } : {}),
-          ...(typeof input.title === 'string' ? { title: input.title } : {}),
-          ...(typeof input.x === 'number' ? { x: input.x } : {}),
-          ...(typeof input.y === 'number' ? { y: input.y } : {}),
-          ...(typeof input.width === 'number' ? { width: input.width } : {}),
-          ...(typeof input.height === 'number' ? { height: input.height } : {}),
-          ...(typeof input.timeoutMs === 'number' ? { timeoutMs: input.timeoutMs } : {}),
-        });
-        return {
-          content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-        };
-      } catch (error) {
-        return {
-          content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
-          isError: true,
-        };
-      }
-    },
-  );
-
-  server.tool(
-    'canvas_add_diagram',
-    'Draw a hand-drawn diagram on the canvas via the hosted Excalidraw MCP app. Pass an array of Excalidraw elements (rectangles, ellipses, diamonds, arrows, text). The diagram opens inside an mcp-app node that supports fullscreen editing. For other MCP apps, use canvas_open_mcp_app.',
-    {
-      elements: z.union([
-        z.string().describe('JSON array string of Excalidraw elements'),
-        z.array(z.record(z.string(), z.unknown())).describe('Array of Excalidraw elements'),
-      ]).describe('Excalidraw elements to render. See https://github.com/excalidraw/excalidraw-mcp for the element format.'),
-      nodeId: z.string().optional().describe('Existing Excalidraw mcp-app node ID to update in place instead of creating a new node.'),
-      title: z.string().optional().describe('Optional canvas node title override'),
-      x: z.number().optional().describe('X position (auto-placed if omitted)'),
-      y: z.number().optional().describe('Y position (auto-placed if omitted)'),
-      width: z.number().optional().describe('Width in pixels (default: 720)'),
-      height: z.number().optional().describe('Height in pixels (default: 500)'),
-      timeoutMs: z.number().optional().describe('Optional MCP request timeout in milliseconds for Excalidraw cold starts. Client-side MCP hosts may still enforce their own total request timeout.'),
-    },
-    async (input, extra) => {
-      const c = await ensureCanvas();
-      try {
-        const result = await c.addDiagram({
-          elements: input.elements,
-          ...(typeof input.nodeId === 'string' ? { nodeId: input.nodeId } : {}),
-          ...(typeof input.title === 'string' ? { title: input.title } : {}),
-          ...(typeof input.x === 'number' ? { x: input.x } : {}),
-          ...(typeof input.y === 'number' ? { y: input.y } : {}),
-          ...(typeof input.width === 'number' ? { width: input.width } : {}),
-          ...(typeof input.height === 'number' ? { height: input.height } : {}),
-          ...(typeof input.timeoutMs === 'number' ? { timeoutMs: input.timeoutMs } : {}),
-        });
-        return {
-          content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-        };
-      } catch (error) {
-        if (extra.signal.aborted) {
-          return {
-            content: [{ type: 'text', text: 'canvas_add_diagram was cancelled by the MCP client before Excalidraw finished. Retry with a higher client request timeout and pass timeoutMs to PMX Canvas for the downstream Excalidraw call.' }],
-            isError: true,
-          };
-        }
-        return {
-          content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
-          isError: true,
-        };
-      }
-    },
-  );
-
-  server.tool(
-    'canvas_describe_schema',
-    'Describe the current server-supported canvas create schemas, json-render component catalog, canonical examples, and related MCP entry points. Includes mcp.nodeTypeRouting, the authoritative map from node type to MCP creation tool.',
-    {},
-    async () => ({
-      content: [{ type: 'text', text: JSON.stringify(describeCanvasSchema(), null, 2) }],
-    }),
-  );
-
-  server.tool(
-    'canvas_validate_spec',
-    'Validate a json-render spec, graph payload, or HTML primitive payload without creating a node. Returns normalized metadata the server would accept.',
-    {
-      type: z.enum(['json-render', 'graph', 'html-primitive']).describe('Structured payload type to validate'),
-      spec: jsonRenderSpecSchema.optional().describe('json-render spec to validate when type="json-render"'),
-      kind: htmlPrimitiveKindSchema.optional().describe('HTML primitive kind when type="html-primitive"'),
-      primitive: htmlPrimitiveKindSchema.optional().describe('Alias for kind when type="html-primitive"'),
-      primitiveData: z.record(z.string(), z.unknown()).optional().describe('HTML primitive data payload when type="html-primitive"'),
-      title: z.string().optional().describe('Optional graph title'),
-      graphType: z.string().optional().describe('Graph type when type="graph"'),
-      data: z.array(z.record(z.string(), z.unknown())).optional().describe('Graph dataset when type="graph"'),
-      xKey: z.string().optional().describe('X-axis key for line/bar graphs'),
-      yKey: z.string().optional().describe('Y-axis key for line/bar graphs'),
-      zKey: z.string().optional().describe('Optional bubble-size key for scatter charts'),
-      nameKey: z.string().optional().describe('Slice name key for pie graphs'),
-      valueKey: z.string().optional().describe('Value key for pie slices, sparkline, dot-plot, and the bullet measure'),
-      axisKey: z.string().optional().describe('Category key for radar charts'),
-      metrics: z.array(z.string()).optional().describe('Series keys to plot as radar polygons'),
-      series: z.array(z.string()).optional().describe('Series keys for stacked-bar segments'),
-      barKey: z.string().optional().describe('Bar series key for composed charts'),
-      lineKey: z.string().optional().describe('Line series key for composed charts'),
-      aggregate: z.enum(['sum', 'count', 'avg']).optional().describe('Optional aggregation for repeated keys'),
-      color: z.string().optional().describe('Optional graph color'),
-      colorBy: z.enum(['series', 'category', 'value', 'none']).optional().describe("Bar charts only: how bars are colored (default 'series')"),
-      highlight: z.union([z.number(), z.enum(['max', 'min'])]).nullable().optional().describe("Bar charts only, colorBy='series': which bar gets the accent"),
-      barColor: z.string().optional().describe('Optional bar color for composed charts'),
-      lineColor: z.string().optional().describe('Optional line color for composed charts'),
-      labelKey: z.string().optional().describe('Category label key for dot-plot / bullet / slopegraph rows'),
-      targetKey: z.string().optional().describe('Per-row target value key for bullet charts'),
-      rangesKey: z.string().optional().describe('Per-row qualitative band thresholds key (number[]) for bullet charts'),
-      beforeKey: z.string().optional().describe('Left-column value key for slopegraph'),
-      afterKey: z.string().optional().describe('Right-column value key for slopegraph'),
-      beforeLabel: z.string().optional().describe('Header label for the slopegraph left column'),
-      afterLabel: z.string().optional().describe('Header label for the slopegraph right column'),
-      sort: z.enum(['asc', 'desc', 'none']).optional().describe('Row sort order for dot-plot (defaults to desc)'),
-      fill: z.boolean().optional().describe('Sparkline: draw a light area fill under the line'),
-      showEndDot: z.boolean().optional().describe('Sparkline: draw a dot at the last point (default true)'),
-      showMinMax: z.boolean().optional().describe('Sparkline: mark the min and max points'),
-      showValue: z.boolean().optional().describe('Sparkline: print the last value inline'),
-      colorByDirection: z.boolean().optional().describe('Slopegraph: accent rising lines and mute falling ones (default off)'),
-      height: z.number().optional().describe('Optional graph content height'),
-    },
-    async (input) => {
-      try {
-        const result = input.type === 'json-render'
-          ? validateStructuredCanvasPayload({
-              type: 'json-render',
-              spec: input.spec,
-            })
-          : input.type === 'html-primitive'
-            ? validateStructuredCanvasPayload({
-                type: 'html-primitive',
-                primitive: {
-                  kind: (input.kind ?? input.primitive ?? '') as HtmlPrimitiveKind | '',
-                  ...(typeof input.title === 'string' ? { title: input.title } : {}),
-                  ...(input.primitiveData ? { data: input.primitiveData } : {}),
-                },
-              })
-            : validateStructuredCanvasPayload({
-                type: 'graph',
-                graph: {
-                  title: input.title,
-                  graphType: input.graphType ?? 'line',
-                  data: input.data ?? [],
-                  ...(typeof input.xKey === 'string' ? { xKey: input.xKey } : {}),
-                  ...(typeof input.yKey === 'string' ? { yKey: input.yKey } : {}),
-                  ...(typeof input.zKey === 'string' ? { zKey: input.zKey } : {}),
-                  ...(typeof input.nameKey === 'string' ? { nameKey: input.nameKey } : {}),
-                  ...(typeof input.valueKey === 'string' ? { valueKey: input.valueKey } : {}),
-                  ...(typeof input.axisKey === 'string' ? { axisKey: input.axisKey } : {}),
-                  ...(Array.isArray(input.metrics) ? { metrics: input.metrics } : {}),
-                  ...(Array.isArray(input.series) ? { series: input.series } : {}),
-                  ...(typeof input.barKey === 'string' ? { barKey: input.barKey } : {}),
-                  ...(typeof input.lineKey === 'string' ? { lineKey: input.lineKey } : {}),
-                  ...(typeof input.aggregate === 'string' ? { aggregate: input.aggregate } : {}),
-                  ...(typeof input.color === 'string' ? { color: input.color } : {}),
-                  ...(typeof input.colorBy === 'string' ? { colorBy: input.colorBy } : {}),
-                  ...(input.highlight !== undefined ? { highlight: input.highlight } : {}),
-                  ...(typeof input.barColor === 'string' ? { barColor: input.barColor } : {}),
-                  ...(typeof input.lineColor === 'string' ? { lineColor: input.lineColor } : {}),
-                  ...(typeof input.labelKey === 'string' ? { labelKey: input.labelKey } : {}),
-                  ...(typeof input.targetKey === 'string' ? { targetKey: input.targetKey } : {}),
-                  ...(typeof input.rangesKey === 'string' ? { rangesKey: input.rangesKey } : {}),
-                  ...(typeof input.beforeKey === 'string' ? { beforeKey: input.beforeKey } : {}),
-                  ...(typeof input.afterKey === 'string' ? { afterKey: input.afterKey } : {}),
-                  ...(typeof input.beforeLabel === 'string' ? { beforeLabel: input.beforeLabel } : {}),
-                  ...(typeof input.afterLabel === 'string' ? { afterLabel: input.afterLabel } : {}),
-                  ...(typeof input.sort === 'string' ? { sort: input.sort } : {}),
-                  ...(typeof input.fill === 'boolean' ? { fill: input.fill } : {}),
-                  ...(typeof input.showEndDot === 'boolean' ? { showEndDot: input.showEndDot } : {}),
-                  ...(typeof input.showMinMax === 'boolean' ? { showMinMax: input.showMinMax } : {}),
-                  ...(typeof input.showValue === 'boolean' ? { showValue: input.showValue } : {}),
-                  ...(typeof input.colorByDirection === 'boolean' ? { colorByDirection: input.colorByDirection } : {}),
-                  ...(typeof input.height === 'number' ? { height: input.height } : {}),
-                },
-              });
-
-        return {
-          content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-        };
-      } catch (error) {
-        return {
-          content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
-          isError: true,
-        };
-      }
-    },
-  );
-
-  server.tool(
-    'canvas_refresh_webpage_node',
-    'Refresh a webpage node from its persisted URL so the server re-fetches and caches the latest page text and metadata.',
-    {
-      id: z.string().describe('Webpage node ID to refresh'),
-      url: z.string().optional().describe('Optional replacement URL before refresh'),
-    },
-    async ({ id, url }) => {
-      const c = await ensureCanvas();
-      const result = await c.refreshWebpageNode(id, url);
-      return {
-        content: [{ type: 'text', text: JSON.stringify(result) }],
-        ...(result.ok ? {} : { isError: true }),
-      };
-    },
-  );
-
-  // ── canvas_build_web_artifact ───────────────────────────────
-  server.tool(
-    'canvas_build_web_artifact',
-    'Build a bundled single-file HTML web artifact from React/Tailwind source files using the bundled web-artifacts-builder skill scripts. MCP callers pass source content in appTsx (the CLI app-file flag reads a file before calling this path). Builds can exceed default 60s MCP client timeouts on cold workspaces; set a long client timeout or retry with the same projectPath/outputPath if the client times out. Optionally opens the generated artifact as an embedded node on the canvas. Read canvas://skills/web-artifacts-builder for the full workflow, stack, and anti-slop design guidelines before calling.',
-    {
-      title: z.string().describe('Artifact title used for default project and output paths'),
-      appTsx: z.string().describe('Contents for src/App.tsx'),
-      indexCss: z.string().optional().describe('Optional contents for src/index.css'),
-      mainTsx: z.string().optional().describe('Optional contents for src/main.tsx'),
-      indexHtml: z.string().optional().describe('Optional contents for index.html'),
-      files: z.record(z.string(), z.string()).optional().describe('Optional map of additional project-relative file paths to file contents'),
-      deps: z.array(z.string()).optional().describe('Optional npm dependencies to install before bundling (e.g. ["recharts", "framer-motion@^11"]). Validated against npm-name format; flags and shell metacharacters are rejected.'),
-      projectPath: z.string().optional().describe('Optional workspace-relative reusable project path. Defaults to .pmx-canvas/artifacts/.web-artifacts/<slug>'),
-      outputPath: z.string().optional().describe('Optional workspace-relative HTML output path. Defaults to .pmx-canvas/artifacts/<slug>.html'),
-      openInCanvas: z.boolean().optional().describe('Open the generated artifact in canvas after build (default true)'),
-      includeLogs: z.boolean().optional().describe('Include raw build stdout/stderr in the response (default false)'),
-      initScriptPath: z.string().optional().describe('Optional script path override for tests/debugging. Must resolve inside the workspace.'),
-      bundleScriptPath: z.string().optional().describe('Optional script path override for tests/debugging. Must resolve inside the workspace.'),
-      timeoutMs: z.number().optional().describe('Optional timeout in milliseconds for init and bundle commands'),
-    },
-    async (input) => {
-      const c = await ensureCanvas();
-      try {
-        const result = await c.buildWebArtifact({
-          title: input.title,
-          appTsx: input.appTsx,
-          ...(typeof input.indexCss === 'string' ? { indexCss: input.indexCss } : {}),
-          ...(typeof input.mainTsx === 'string' ? { mainTsx: input.mainTsx } : {}),
-          ...(typeof input.indexHtml === 'string' ? { indexHtml: input.indexHtml } : {}),
-          ...(input.files ? { files: input.files } : {}),
-          ...(Array.isArray(input.deps) ? { deps: input.deps } : {}),
-          ...(typeof input.projectPath === 'string'
-            ? { projectPath: safeWorkspacePath(input.projectPath) }
-            : {}),
-          ...(typeof input.outputPath === 'string'
-            ? { outputPath: safeWorkspacePath(input.outputPath) }
-            : {}),
-          ...(typeof input.initScriptPath === 'string'
-            ? { initScriptPath: input.initScriptPath }
-            : {}),
-          ...(typeof input.bundleScriptPath === 'string'
-            ? { bundleScriptPath: input.bundleScriptPath }
-            : {}),
-          ...(typeof input.timeoutMs === 'number' ? { timeoutMs: input.timeoutMs } : {}),
-          ...(typeof input.openInCanvas === 'boolean' ? { openInCanvas: input.openInCanvas } : {}),
-        });
-        return {
-          content: [{
-            type: 'text',
-            text: JSON.stringify({
-              path: result.filePath,
-              bytes: result.fileSize,
-              projectPath: result.projectPath,
-              openedInCanvas: result.openedInCanvas,
-              startedAt: result.startedAt,
-              completedAt: result.completedAt,
-              durationMs: result.durationMs,
-              timeoutMs: result.timeoutMs,
-              // `id` only present when a canvas node was actually created.
-              // See the matching block in src/server/server.ts handleCanvasBuildWebArtifact.
-              ...(typeof result.nodeId === 'string' ? { id: result.nodeId } : {}),
-              nodeId: result.nodeId,
-              url: result.url,
-              metadata: result.metadata,
-              logs: result.logs,
-              ...(input.includeLogs === true ? {
-                stdout: result.stdout,
-                stderr: result.stderr,
-              } : {}),
-            }, null, 2),
-          }],
-        };
-      } catch (error) {
-        return {
-          content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
-          isError: true,
-        };
-      }
-    },
-  );
-
-  // ── canvas_add_json_render_node ───────────────────────────
-  server.tool(
-    'canvas_add_json_render_node',
-    'Create a native json-render canvas node from a complete spec. Use this for structured dashboards, forms, tables, and other interactive UI panels that should render directly inside PMX Canvas.',
-    {
-      title: z.string().optional().describe('Optional node title. If omitted, PMX Canvas infers one from the root element.'),
-      spec: z.unknown().describe('json-render spec. Prefer a complete {root, elements, state?} document; a single bare component object is accepted for legacy callers.'),
-      x: z.number().optional().describe('Optional X position'),
-      y: z.number().optional().describe('Optional Y position'),
-      width: z.number().optional().describe('Optional node width'),
-      height: z.number().optional().describe('Optional node height'),
-      strictSize: z.boolean().optional().describe('Keep explicit width/height fixed and scroll overflowing content instead of browser auto-fitting'),
-    },
-    async (input) => {
-      const c = await ensureCanvas();
-      try {
-        const result = await c.addJsonRenderNode({
-          ...(typeof input.title === 'string' ? { title: input.title } : {}),
-          spec: input.spec,
-          ...(typeof input.x === 'number' ? { x: input.x } : {}),
-          ...(typeof input.y === 'number' ? { y: input.y } : {}),
-          ...(typeof input.width === 'number' ? { width: input.width } : {}),
-          ...(typeof input.height === 'number' ? { height: input.height } : {}),
-          ...(input.strictSize === true ? { strictSize: true } : {}),
-        });
-        return {
-          content: [{
-            type: 'text',
-            text: JSON.stringify({
-              ...(await createdNodePayload(c, result.id)),
-              url: result.url,
-              spec: result.spec,
-            }, null, 2),
-          }],
-        };
-      } catch (error) {
-        return {
-          content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
-          isError: true,
-        };
-      }
-    },
-  );
-
-  // ── canvas_stream_json_render_node ────────────────────────
-  server.tool(
-    'canvas_stream_json_render_node',
-    'Progressively build a json-render node by streaming SpecStream patches, so a panel fills in live as you generate it. Omit nodeId on the first call to create a new streaming node (returns its id); pass that same nodeId on later calls to append more patches; set done=true on the final call. Each call updates the live node. Patches are JSON-Patch operations, e.g. {"op":"add","path":"/elements/card","value":{"type":"Card","props":{"title":"Live"},"children":[]}}, {"op":"replace","path":"/root","value":"card"}, {"op":"add","path":"/elements/card/children/-","value":"row1"}. Build the spec incrementally: set /root, add container elements, then append children. The server accumulates the spec (it is the source of truth); partial specs render what they can.',
-    {
-      nodeId: z.string().optional().describe('Existing streaming node id to append to; omit to create a new streaming node'),
-      title: z.string().optional().describe('Title when creating a new streaming node'),
-      patches: z
-        .array(z.union([z.string(), z.record(z.string(), z.unknown())]))
-        .optional()
-        .describe('SpecStream patches to apply this call: JSON-Patch objects ({op,path,value}) or raw JSONL patch lines'),
-      done: z.boolean().optional().describe('Set true on the final call to mark the stream complete'),
-      x: z.number().optional().describe('Optional X position (new node)'),
-      y: z.number().optional().describe('Optional Y position (new node)'),
-      width: z.number().optional().describe('Optional node width (new node)'),
-      nodeHeight: z.number().optional().describe('Optional node height (new node)'),
-      strictSize: z.boolean().optional().describe('Keep explicit node size fixed and scroll overflowing content (new node)'),
-    },
-    async (input) => {
-      const c = await ensureCanvas();
-      try {
-        const result = await c.streamJsonRenderNode({
-          ...(typeof input.nodeId === 'string' ? { nodeId: input.nodeId } : {}),
-          ...(typeof input.title === 'string' ? { title: input.title } : {}),
-          ...(Array.isArray(input.patches) ? { patches: input.patches } : {}),
-          ...(input.done === true ? { done: true } : {}),
-          ...(typeof input.x === 'number' ? { x: input.x } : {}),
-          ...(typeof input.y === 'number' ? { y: input.y } : {}),
-          ...(typeof input.width === 'number' ? { width: input.width } : {}),
-          ...(typeof input.nodeHeight === 'number' ? { height: input.nodeHeight } : {}),
-          ...(input.strictSize === true ? { strictSize: true } : {}),
-        });
-        return {
-          content: [{
-            type: 'text',
-            text: JSON.stringify({
-              ...(await createdNodePayload(c, result.id)),
-              url: result.url,
-              applied: result.applied,
-              skipped: result.skipped,
-              specVersion: result.specVersion,
-              elementCount: result.elementCount,
-              streamStatus: result.streamStatus,
-            }, null, 2),
-          }],
-        };
-      } catch (error) {
-        return {
-          content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
-          isError: true,
-        };
-      }
-    },
-  );
-
-  // ── canvas_add_graph_node ─────────────────────────────────
-  server.tool(
-    'canvas_add_graph_node',
-    'Create a native graph node backed by the json-render chart catalog. Supports line, bar, pie, area, scatter, radar, stacked-bar, composed (bar+line), sparkline, dot-plot (Cleveland), bullet (Few KPI vs target), and slopegraph (paired before/after) graphs rendered directly inside PMX Canvas.',
-    {
-      title: z.string().optional().describe('Optional node title'),
-      graphType: z.string().describe('Graph type: line, bar, pie, area, scatter, radar, stacked-bar (or "stack"), composed (or "combo"), sparkline, dot-plot (or "dot"), bullet, slopegraph (or "slope")'),
-      data: z.array(z.record(z.string(), z.unknown())).describe('Array of chart data objects'),
-      xKey: z.string().optional().describe('X-axis key (line/bar/area/scatter/stacked/composed)'),
-      yKey: z.string().optional().describe('Y-axis key (line/bar/area/scatter); falls back to barKey for composed'),
-      zKey: z.string().optional().describe('Optional bubble-size key for scatter charts'),
-      nameKey: z.string().optional().describe('Name key for pie graphs'),
-      valueKey: z.string().optional().describe('Value key for pie slices, sparkline, dot-plot, and the bullet measure'),
-      axisKey: z.string().optional().describe('Category key for radar charts'),
-      metrics: z.array(z.string()).optional().describe('Series keys to plot as radar polygons (defaults to non-axis numeric columns)'),
-      series: z.array(z.string()).optional().describe('Series keys for stacked-bar segments (defaults to non-x numeric columns)'),
-      barKey: z.string().optional().describe('Bar series key for composed charts'),
-      lineKey: z.string().optional().describe('Line series key for composed charts'),
-      aggregate: z.enum(['sum', 'count', 'avg']).optional().describe('Optional aggregation for repeated x-axis values (line/bar/area/stacked)'),
-      color: z.string().optional().describe('Optional series color (line/bar/area/scatter)'),
-      colorBy: z
-        .enum(['series', 'category', 'value', 'none'])
-        .optional()
-        .describe("Bar charts only: how bars are colored. 'series' (default) = single accent with one highlighted bar; 'category' = rotate palette per bar; 'value' = shade by magnitude; 'none' = flat. Prefer 'series' — color should encode data, not decorate."),
-      highlight: z
-        .union([z.number(), z.enum(['max', 'min'])])
-        .nullable()
-        .optional()
-        .describe("Bar charts only, for colorBy='series': which bar gets the accent — 'max' (default), 'min', a 0-based index, or null for no emphasis."),
-      barColor: z.string().optional().describe('Optional bar color for composed charts'),
-      lineColor: z.string().optional().describe('Optional line color for composed charts'),
-      labelKey: z.string().optional().describe('Category label key for dot-plot / bullet / slopegraph rows'),
-      targetKey: z.string().optional().describe('Per-row target value key for bullet charts'),
-      rangesKey: z.string().optional().describe('Per-row qualitative band thresholds key (number[]) for bullet charts'),
-      beforeKey: z.string().optional().describe('Left-column value key for slopegraph'),
-      afterKey: z.string().optional().describe('Right-column value key for slopegraph'),
-      beforeLabel: z.string().optional().describe('Header label for the slopegraph left column'),
-      afterLabel: z.string().optional().describe('Header label for the slopegraph right column'),
-      sort: z.enum(['asc', 'desc', 'none']).optional().describe('Row sort order for dot-plot (defaults to desc)'),
-      fill: z.boolean().optional().describe('Sparkline: draw a light area fill under the line'),
-      showEndDot: z.boolean().optional().describe('Sparkline: draw a dot at the last point (default true)'),
-      showMinMax: z.boolean().optional().describe('Sparkline: mark the min and max points'),
-      showValue: z.boolean().optional().describe('Sparkline: print the last value inline'),
-      colorByDirection: z.boolean().optional().describe('Slopegraph: accent rising lines and mute falling ones (default off — lines use one neutral ink)'),
-      height: z.number().optional().describe('Optional chart content height'),
-      showLegend: z.boolean().optional().describe('Show chart legend when supported; pass false for compact node layouts'),
-      showLabels: z.boolean().optional().describe('Show direct labels when supported, such as pie slice labels (defaults to true)'),
-      x: z.number().optional().describe('Optional X position'),
-      y: z.number().optional().describe('Optional Y position'),
-      width: z.number().optional().describe('Optional node width'),
-      nodeHeight: z.number().optional().describe('Optional node height'),
-      strictSize: z.boolean().optional().describe('Keep explicit node size fixed and scroll overflowing content instead of browser auto-fitting'),
-    },
-    async (input) => {
-      const c = await ensureCanvas();
-      try {
-        const result = await c.addGraphNode({
-          graphType: input.graphType,
-          data: input.data,
-          ...(typeof input.title === 'string' ? { title: input.title } : {}),
-          ...(typeof input.xKey === 'string' ? { xKey: input.xKey } : {}),
-          ...(typeof input.yKey === 'string' ? { yKey: input.yKey } : {}),
-          ...(typeof input.zKey === 'string' ? { zKey: input.zKey } : {}),
-          ...(typeof input.nameKey === 'string' ? { nameKey: input.nameKey } : {}),
-          ...(typeof input.valueKey === 'string' ? { valueKey: input.valueKey } : {}),
-          ...(typeof input.axisKey === 'string' ? { axisKey: input.axisKey } : {}),
-          ...(Array.isArray(input.metrics) ? { metrics: input.metrics } : {}),
-          ...(Array.isArray(input.series) ? { series: input.series } : {}),
-          ...(typeof input.barKey === 'string' ? { barKey: input.barKey } : {}),
-          ...(typeof input.lineKey === 'string' ? { lineKey: input.lineKey } : {}),
-          ...(typeof input.aggregate === 'string' ? { aggregate: input.aggregate } : {}),
-          ...(typeof input.color === 'string' ? { color: input.color } : {}),
-          ...(typeof input.colorBy === 'string' ? { colorBy: input.colorBy } : {}),
-          ...(input.highlight !== undefined ? { highlight: input.highlight } : {}),
-          ...(typeof input.barColor === 'string' ? { barColor: input.barColor } : {}),
-          ...(typeof input.lineColor === 'string' ? { lineColor: input.lineColor } : {}),
-          ...(typeof input.labelKey === 'string' ? { labelKey: input.labelKey } : {}),
-          ...(typeof input.targetKey === 'string' ? { targetKey: input.targetKey } : {}),
-          ...(typeof input.rangesKey === 'string' ? { rangesKey: input.rangesKey } : {}),
-          ...(typeof input.beforeKey === 'string' ? { beforeKey: input.beforeKey } : {}),
-          ...(typeof input.afterKey === 'string' ? { afterKey: input.afterKey } : {}),
-          ...(typeof input.beforeLabel === 'string' ? { beforeLabel: input.beforeLabel } : {}),
-          ...(typeof input.afterLabel === 'string' ? { afterLabel: input.afterLabel } : {}),
-          ...(typeof input.sort === 'string' ? { sort: input.sort } : {}),
-          ...(typeof input.fill === 'boolean' ? { fill: input.fill } : {}),
-          ...(typeof input.showEndDot === 'boolean' ? { showEndDot: input.showEndDot } : {}),
-          ...(typeof input.showMinMax === 'boolean' ? { showMinMax: input.showMinMax } : {}),
-          ...(typeof input.showValue === 'boolean' ? { showValue: input.showValue } : {}),
-          ...(typeof input.colorByDirection === 'boolean' ? { colorByDirection: input.colorByDirection } : {}),
-          ...(typeof input.height === 'number' ? { height: input.height } : {}),
-          ...(typeof input.showLegend === 'boolean' ? { showLegend: input.showLegend } : {}),
-          ...(typeof input.showLabels === 'boolean' ? { showLabels: input.showLabels } : {}),
-          ...(typeof input.x === 'number' ? { x: input.x } : {}),
-          ...(typeof input.y === 'number' ? { y: input.y } : {}),
-          ...(typeof input.width === 'number' ? { width: input.width } : {}),
-          ...(typeof input.nodeHeight === 'number' ? { heightPx: input.nodeHeight } : {}),
-          ...(input.strictSize === true ? { strictSize: true } : {}),
-        });
-        return {
-          content: [{
-            type: 'text',
-            text: JSON.stringify({
-              ...(await createdNodePayload(c, result.id)),
-              url: result.url,
-              spec: result.spec,
-            }, null, 2),
-          }],
-        };
-      } catch (error) {
-        return {
-          content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
-          isError: true,
-        };
-      }
-    },
-  );
-
-  // ── canvas_update_node ─────────────────────────────────────────
-  server.tool(
-    'canvas_update_node',
-    'Update an existing node. You can change its content, title, position, size, dock placement, or data.',
-    {
-      id: z.string().describe('Node ID to update'),
-      title: z.string().optional().describe('New title'),
-      content: z.string().optional().describe('New content'),
-      x: z.number().optional().describe('New X position'),
-      y: z.number().optional().describe('New Y position'),
-      width: z.number().optional().describe('New width'),
-      height: z.number().optional().describe('New height'),
-      spec: z.record(z.string(), z.unknown()).optional().describe('New json-render spec, or a graph payload with graphType/data for graph nodes'),
-      graphType: z.string().optional().describe('Graph type when updating a graph node'),
-      data: z.array(z.record(z.string(), z.unknown())).optional().describe('Graph dataset when updating a graph node'),
-      xKey: z.string().optional().describe('Graph x/category key'),
-      yKey: z.string().optional().describe('Graph y/value key'),
-      chartHeight: z.number().optional().describe('Graph chart content height, distinct from node height'),
-      toolName: z.string().optional().describe('Trace node tool or operation label'),
-      category: z.string().optional().describe('Trace node category: mcp, file, subagent, or other'),
-      status: z.string().optional().describe('Trace node status: running, success, or failed'),
-      duration: z.string().optional().describe('Trace node duration badge text'),
-      resultSummary: z.string().optional().describe('Trace node result summary'),
-      error: z.string().optional().describe('Trace node error message'),
-      collapsed: z.boolean().optional().describe('Collapse or expand the node'),
-      dockPosition: z.enum(['left', 'right']).nullable().optional().describe('Dock the node to the left/right HUD column, or pass null to return it to the canvas'),
-      pinned: z.boolean().optional().describe('Pin or unpin the node to exclude it from auto-arrange'),
-      arrangeLocked: z.boolean().optional().describe('Prevent auto-arrange from moving this node. Pinned nodes are also skipped.'),
-      axCapabilities: z.object({
-        enabled: z.boolean().optional(),
-        allowed: z.array(z.string()).optional(),
-      }).optional().describe('Enable/disable AX interactions on an existing node (e.g. flip an html node on with { enabled: true, allowed: ["ax.work.create"] }). Merged into the node data; clamped to the node-type ceiling server-side.'),
-      full: z.boolean().optional().describe('Return the full updated node payload. Default false returns compact metadata.'),
-      verbose: z.boolean().optional().describe('Alias for full:true.'),
-    },
-    async (input) => {
-      const { id, title, content, x, y, width, height, spec, graphType, data, xKey, yKey, chartHeight, collapsed, dockPosition, pinned, arrangeLocked, axCapabilities, toolName, category, status, duration, resultSummary, error } = input;
-      const c = await ensureCanvas();
-      const node = await c.getNode(id);
-      if (!node) {
-        return {
-          content: [{ type: 'text', text: `Node "${id}" not found.` }],
-          isError: true,
-        };
-      }
-      const patch: Record<string, unknown> = {};
-      if (x !== undefined || y !== undefined) {
-        patch.position = { x: x ?? node.position.x, y: y ?? node.position.y };
-      }
-      if (width !== undefined || height !== undefined) {
-        patch.size = { width: width ?? node.size.width, height: height ?? node.size.height };
-      }
-      if (collapsed !== undefined) {
-        patch.collapsed = collapsed;
-      }
-      if (dockPosition !== undefined) {
-        patch.dockPosition = dockPosition;
-      }
-      if (pinned !== undefined) {
-        patch.pinned = pinned;
-      }
-      if (title !== undefined) patch.title = title;
-      if (content !== undefined) patch.content = content;
-      if (spec !== undefined) patch.spec = spec;
-      if (graphType !== undefined) patch.graphType = graphType;
-      if (data !== undefined) patch.data = data;
-      if (xKey !== undefined) patch.xKey = xKey;
-      if (yKey !== undefined) patch.yKey = yKey;
-      if (chartHeight !== undefined) patch.chartHeight = chartHeight;
-      if (toolName !== undefined) patch.toolName = toolName;
-      if (category !== undefined) patch.category = category;
-      if (status !== undefined) patch.status = status;
-      if (duration !== undefined) patch.duration = duration;
-      if (resultSummary !== undefined) patch.resultSummary = resultSummary;
-      if (error !== undefined) patch.error = error;
-      if (arrangeLocked !== undefined) {
-        patch.arrangeLocked = arrangeLocked;
-      }
-      if (axCapabilities !== undefined) {
-        // A graph dataset update (`data` array) and an axCapabilities toggle collide
-        // on patch.data (array vs object) — reject rather than silently dropping the
-        // dataset. Otherwise merge into existing node data so enabling AX doesn't
-        // clobber html/spec/etc. The server re-clamps axCapabilities to the ceiling.
-        if (Array.isArray(patch.data)) {
-          return {
-            content: [{ type: 'text', text: 'Update the graph dataset and axCapabilities in separate canvas_update_node calls.' }],
-            isError: true,
-          };
-        }
-        patch.data = { ...(node.data as Record<string, unknown>), axCapabilities };
-      }
-      await c.updateNode(id, patch);
-      const updated = await c.getNode(id);
-      return {
-        content: [{ type: 'text', text: JSON.stringify(updated ? await createdNodePayload(c, id, input) : { ok: true, id }, null, 2) }],
-      };
-    },
-  );
-
-  // ── canvas_remove_node ─────────────────────────────────────────
-  server.tool(
-    'canvas_remove_node',
-    'Remove a node from the canvas. Also removes all edges connected to it.',
-    { id: z.string().describe('Node ID to remove') },
-    async ({ id }) => {
-      const c = await ensureCanvas();
-      await c.removeNode(id);
-      return {
-        content: [{ type: 'text', text: JSON.stringify({ ok: true, removed: id }) }],
-      };
-    },
-  );
-
-  // ── canvas_remove_annotation ─────────────────────────────────────
-  server.tool(
-    'canvas_remove_annotation',
-    'Remove a human-drawn canvas annotation by ID.',
-    { id: z.string().describe('Annotation ID to remove') },
-    async ({ id }) => {
-      const c = await ensureCanvas();
-      const removed = await c.removeAnnotation(id);
-      if (!removed) {
-        return {
-          content: [{ type: 'text', text: `Annotation "${id}" not found.` }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: JSON.stringify({ ok: true, removed: id }) }],
-      };
-    },
-  );
-
-  // ── canvas_add_edge ────────────────────────────────────────────
-  server.tool(
-    'canvas_add_edge',
-    'Add an edge (connection) between two nodes. Edge types: flow (sequential), depends-on (dependency), relation (general), references (cross-reference).',
-    {
-      from: z.string().optional().describe('Source node ID'),
-      to: z.string().optional().describe('Target node ID'),
-      fromSearch: z.string().optional().describe('Resolve the source node by exact or fuzzy title/content search'),
-      toSearch: z.string().optional().describe('Resolve the target node by exact or fuzzy title/content search'),
-      type: z.enum(['flow', 'depends-on', 'relation', 'references']).describe('Edge type'),
-      label: z.string().optional().describe('Edge label text'),
-      style: z.enum(['solid', 'dashed', 'dotted']).optional().describe('Optional edge stroke style'),
-      animated: z.boolean().optional().describe('Animate the edge stroke'),
-    },
-    async (input) => {
-      const c = await ensureCanvas();
-      if (!input.from && !input.fromSearch) {
-        return {
-          content: [{ type: 'text', text: 'Provide either "from" or "fromSearch".' }],
-          isError: true,
-        };
-      }
-      if (!input.to && !input.toSearch) {
-        return {
-          content: [{ type: 'text', text: 'Provide either "to" or "toSearch".' }],
-          isError: true,
-        };
-      }
-      try {
-        const id = await c.addEdge(input);
-        const edge = (await c.getLayout()).edges.find((entry) => entry.id === id);
-        return {
-          content: [{
-            type: 'text',
-            text: JSON.stringify(edge ? { id, from: edge.from, to: edge.to, type: edge.type, label: edge.label, style: edge.style, animated: edge.animated } : { id }, null, 2),
-          }],
-        };
-      } catch (error) {
-        return {
-          content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
-          isError: true,
-        };
-      }
-    },
-  );
-
-  // ── canvas_remove_edge ─────────────────────────────────────────
-  server.tool(
-    'canvas_remove_edge',
-    'Remove an edge from the canvas.',
-    { id: z.string().describe('Edge ID to remove') },
-    async ({ id }) => {
-      const c = await ensureCanvas();
-      await c.removeEdge(id);
-      return {
-        content: [{ type: 'text', text: JSON.stringify({ ok: true, removed: id }) }],
-      };
-    },
-  );
-
-  // ── canvas_arrange ─────────────────────────────────────────────
-  server.tool(
-    'canvas_arrange',
-    'Auto-arrange all nodes on the canvas. Layouts: grid (default), column (vertical stack), flow (horizontal row).',
-    {
-      layout: z.enum(['grid', 'column', 'flow']).optional().describe('Arrangement layout (default: grid)'),
-    },
-    async ({ layout }) => {
-      const c = await ensureCanvas();
-      await c.arrange(layout ?? 'grid');
-      return {
-        content: [{ type: 'text', text: JSON.stringify({ ok: true, layout: layout ?? 'grid' }) }],
-      };
-    },
-  );
-
-  // ── canvas_focus_node ──────────────────────────────────────────
-  server.tool(
-    'canvas_focus_node',
-    'Bring a node into focus. By default the viewport pans so the node is centered. Pass noPan=true to raise/select the node without moving the human\'s camera (useful when reacting to background events without disrupting the human\'s current view).',
-    {
-      id: z.string().describe('Node ID to focus on'),
-      noPan: z
-        .boolean()
-        .optional()
-        .describe('If true, raise/select the node without panning the viewport. Default false.'),
-    },
-    async ({ id, noPan }) => {
-      const c = await ensureCanvas();
-      const result = await c.focusNode(id, { ...(noPan === true ? { noPan: true } : {}) });
-      if (!result) {
-        return {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify({ ok: false, error: `Node "${id}" not found.` }),
-            },
-          ],
-        };
-      }
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify({ ok: true, focused: result.focused, panned: result.panned }),
-          },
-        ],
-      };
-    },
-  );
-
-  // ── AX context and focus ───────────────────────────────────────
-  server.tool(
-    'canvas_get_ax',
-    'Read the host-agnostic PMX AX state and agent-ready AX context. Use this when you need pinned context plus the current focus field.',
-    {
-      includeContext: z.boolean().optional().describe('Include serialized agent-ready AX context. Default true.'),
-    },
-    async ({ includeContext }) => {
-      const c = await ensureCanvas();
-      const state = await c.getAxState();
-      const host = await c.getHostCapability();
-      const context = includeContext === false ? undefined : await c.getAxContext();
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify({
-              ok: true,
-              state,
-              host,
-              ...(context ? { context } : {}),
-            }),
-          },
-        ],
-      };
-    },
-  );
-
-  server.tool(
-    'canvas_set_ax_focus',
-    'Set the PMX AX focus field without requiring viewport movement. Focus is persisted and available through canvas://ax-context.',
-    {
-      nodeIds: z.array(z.string()).describe('Node IDs to place in the AX focus field. Missing nodes are ignored.'),
-      source: z.enum(['agent', 'api', 'browser', 'cli', 'codex', 'copilot', 'mcp', 'sdk', 'system'])
-        .optional()
-        .describe('Optional host/source label for adapter-originated focus. Defaults to mcp. Use codex from the Codex app adapter.'),
-    },
-    async ({ nodeIds, source }) => {
-      const c = await ensureCanvas();
-      const focus = await c.setAxFocus(nodeIds, { source: source ?? 'mcp' });
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify({ ok: true, focus }),
-          },
-        ],
-      };
-    },
-  );
-
-  server.tool(
-    'canvas_record_ax_event',
-    'Record a normalized AX timeline event (prompt/assistant-message/tool-start/tool-result/failure/approval/steering). Timeline events persist for diagnostics and continuity but are not restored by snapshots.',
-    {
-      kind: z.enum(['prompt', 'assistant-message', 'tool-start', 'tool-result', 'failure', 'approval', 'steering'])
-        .describe('Normalized event kind.'),
-      summary: z.string().describe('Short human-readable summary of the event.'),
-      detail: z.string().optional().describe('Optional longer detail or payload text.'),
-      nodeIds: z.array(z.string()).optional().describe('Optional node IDs this event relates to.'),
-      data: z.record(z.string(), z.unknown()).optional().describe('Optional structured data payload.'),
-      source: z.enum(['agent', 'api', 'browser', 'cli', 'codex', 'copilot', 'mcp', 'sdk', 'system'])
-        .optional()
-        .describe('Optional host/source label. Defaults to mcp.'),
-    },
-    async ({ kind, summary, detail, nodeIds, data, source }) => {
-      const c = await ensureCanvas();
-      const event = await c.recordAxEvent(
-        {
-          kind,
-          summary,
-          ...(typeof detail === 'string' ? { detail } : {}),
-          ...(Array.isArray(nodeIds) ? { nodeIds } : {}),
-          ...(data ? { data } : {}),
-        },
-        { source: source ?? 'mcp' },
-      );
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify({ ok: true, event }),
-          },
-        ],
-      };
-    },
-  );
-
-  server.tool(
-    'canvas_send_steering',
-    'Record a steering message: a user instruction from the surface to the active agent session. Persisted on the AX timeline and exposed via canvas://ax-timeline.',
-    {
-      message: z.string().describe('The steering instruction to deliver to the active agent session.'),
-      source: z.enum(['agent', 'api', 'browser', 'cli', 'codex', 'copilot', 'mcp', 'sdk', 'system'])
-        .optional()
-        .describe('Optional host/source label. Defaults to mcp.'),
-    },
-    async ({ message, source }) => {
-      const c = await ensureCanvas();
-      const steering = await c.sendSteering(message, { source: source ?? 'mcp' });
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify({ ok: true, steering }),
-          },
-        ],
-      };
-    },
-  );
-
-  server.tool(
-    'canvas_get_ax_timeline',
-    'Read the bounded AX timeline: recent agent-events, evidence, and steering messages plus counts. Use this for diagnostics and session continuity.',
-    {
-      limit: z.number().optional().describe('Max rows per timeline table (default 50, max 200).'),
-    },
-    async ({ limit }) => {
-      const c = await ensureCanvas();
-      const timeline = await c.getAxTimeline(
-        typeof limit === 'number' && limit > 0 ? { limit } : undefined,
-      );
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify({ ok: true, ...timeline }),
-          },
-        ],
-      };
-    },
-  );
-
-  server.tool(
-    'canvas_add_work_item',
-    'Add a canvas-bound AX work item: a visible task/plan/status tied to nodes and agent work. Work items participate in snapshots and are exposed via canvas://ax-work.',
-    {
-      title: z.string().describe('Short title of the work item.'),
-      status: z.enum(['todo', 'in-progress', 'blocked', 'done', 'cancelled'])
-        .optional()
-        .describe('Work item status. Defaults to todo.'),
-      detail: z.string().optional().describe('Optional longer description.'),
-      nodeIds: z.array(z.string()).optional().describe('Optional node IDs this work item is tied to.'),
-      source: z.enum(['agent', 'api', 'browser', 'cli', 'codex', 'copilot', 'mcp', 'sdk', 'system'])
-        .optional()
-        .describe('Optional host/source label. Defaults to mcp.'),
-    },
-    async ({ title, status, detail, nodeIds, source }) => {
-      const c = await ensureCanvas();
-      const workItem = await c.addWorkItem(
-        {
-          title,
-          ...(status ? { status } : {}),
-          ...(typeof detail === 'string' ? { detail } : {}),
-          ...(Array.isArray(nodeIds) ? { nodeIds } : {}),
-        },
-        { source: source ?? 'mcp' },
-      );
-      return {
-        content: [{ type: 'text', text: JSON.stringify({ ok: true, workItem }) }],
-      };
-    },
-  );
-
-  server.tool(
-    'canvas_update_work_item',
-    'Update a canvas-bound AX work item by ID (title/status/detail/nodeIds). Returns null if the work item does not exist.',
-    {
-      id: z.string().describe('Work item ID to update.'),
-      title: z.string().optional().describe('New title.'),
-      status: z.enum(['todo', 'in-progress', 'blocked', 'done', 'cancelled'])
-        .optional()
-        .describe('New status.'),
-      detail: z.string().optional().describe('New detail text.'),
-      nodeIds: z.array(z.string()).optional().describe('Replacement node IDs.'),
-      source: z.enum(['agent', 'api', 'browser', 'cli', 'codex', 'copilot', 'mcp', 'sdk', 'system'])
-        .optional()
-        .describe('Optional host/source label. Defaults to mcp.'),
-    },
-    async ({ id, title, status, detail, nodeIds, source }) => {
-      const c = await ensureCanvas();
-      const workItem = await c.updateWorkItem(
-        id,
-        {
-          ...(typeof title === 'string' ? { title } : {}),
-          ...(status ? { status } : {}),
-          ...(typeof detail === 'string' ? { detail } : {}),
-          ...(Array.isArray(nodeIds) ? { nodeIds } : {}),
-        },
-        { source: source ?? 'mcp' },
-      );
-      return {
-        content: [{ type: 'text', text: JSON.stringify({ ok: workItem !== null, workItem }) }],
-      };
-    },
-  );
-
-  server.tool(
-    'canvas_request_approval',
-    'Request human approval before a high-impact AX action: creates a pending approval gate tied to nodes. Canvas-bound and snapshotted; exposed via canvas://ax-work.',
-    {
-      title: z.string().describe('Short title of what needs approval.'),
-      detail: z.string().optional().describe('Optional explanation of the action and its impact.'),
-      action: z.string().optional().describe('Optional machine-readable action identifier the approval gates.'),
-      nodeIds: z.array(z.string()).optional().describe('Optional node IDs this approval relates to.'),
-      source: z.enum(['agent', 'api', 'browser', 'cli', 'codex', 'copilot', 'mcp', 'sdk', 'system'])
-        .optional()
-        .describe('Optional host/source label. Defaults to mcp.'),
-    },
-    async ({ title, detail, action, nodeIds, source }) => {
-      const c = await ensureCanvas();
-      const approvalGate = await c.requestApproval(
-        {
-          title,
-          ...(typeof detail === 'string' ? { detail } : {}),
-          ...(typeof action === 'string' ? { action } : {}),
-          ...(Array.isArray(nodeIds) ? { nodeIds } : {}),
-        },
-        { source: source ?? 'mcp' },
-      );
-      return {
-        content: [{ type: 'text', text: JSON.stringify({ ok: true, approvalGate }) }],
-      };
-    },
-  );
-
-  server.tool(
-    'canvas_resolve_approval',
-    'Resolve a pending approval gate by ID with approved or rejected. Returns null if the gate does not exist or is already resolved.',
-    {
-      id: z.string().describe('Approval gate ID to resolve.'),
-      decision: z.enum(['approved', 'rejected']).describe('Approval decision.'),
-      resolution: z.string().optional().describe('Optional human-readable resolution note.'),
-      source: z.enum(['agent', 'api', 'browser', 'cli', 'codex', 'copilot', 'mcp', 'sdk', 'system'])
-        .optional()
-        .describe('Optional host/source label. Defaults to mcp.'),
-    },
-    async ({ id, decision, resolution, source }) => {
-      const c = await ensureCanvas();
-      const approvalGate = await c.resolveApproval(id, decision, {
-        ...(typeof resolution === 'string' ? { resolution } : {}),
-        source: source ?? 'mcp',
-      });
-      return {
-        content: [{ type: 'text', text: JSON.stringify({ ok: approvalGate !== null, approvalGate }) }],
-      };
-    },
-  );
-
-  server.tool(
-    'canvas_add_evidence',
-    'Record an AX evidence item (logs/tool-result/screenshot/file/diff/test-output) on the timeline. Evidence persists for diagnostics and continuity but is not restored by snapshots; exposed via canvas://ax-timeline.',
-    {
-      kind: z.enum(['logs', 'tool-result', 'screenshot', 'file', 'diff', 'test-output'])
-        .describe('Evidence kind.'),
-      title: z.string().describe('Short human-readable title for the evidence.'),
-      body: z.string().optional().describe('Optional inline body/content.'),
-      ref: z.string().optional().describe('Optional reference (path, URL, or external locator).'),
-      nodeIds: z.array(z.string()).optional().describe('Optional node IDs this evidence relates to.'),
-      data: z.record(z.string(), z.unknown()).optional().describe('Optional structured data payload.'),
-      source: z.enum(['agent', 'api', 'browser', 'cli', 'codex', 'copilot', 'mcp', 'sdk', 'system'])
-        .optional()
-        .describe('Optional host/source label. Defaults to mcp.'),
-    },
-    async ({ kind, title, body, ref, nodeIds, data, source }) => {
-      const c = await ensureCanvas();
-      const evidence = await c.addEvidence(
-        {
-          kind,
-          title,
-          ...(typeof body === 'string' ? { body } : {}),
-          ...(typeof ref === 'string' ? { ref } : {}),
-          ...(Array.isArray(nodeIds) ? { nodeIds } : {}),
-          ...(data ? { data } : {}),
-        },
-        { source: source ?? 'mcp' },
-      );
-      return {
-        content: [{ type: 'text', text: JSON.stringify({ ok: true, evidence }) }],
-      };
-    },
-  );
-
-  server.tool(
-    'canvas_add_review_annotation',
-    'Add a canvas-bound review annotation: a comment or finding anchored to a node, file, or region. Review annotations participate in snapshots and are exposed via canvas://ax-work.',
-    {
-      body: z.string().describe('Annotation body text.'),
-      kind: z.enum(['comment', 'finding']).optional().describe('Annotation kind. Default comment.'),
-      severity: z.enum(['info', 'warning', 'error']).optional().describe('Severity. Default info.'),
-      anchorType: z.enum(['node', 'file', 'region']).optional().describe('Anchor type. Default node.'),
-      nodeId: z.string().optional().describe('Node ID when anchorType is node.'),
-      file: z.string().optional().describe('File path when anchorType is file.'),
-      region: z.object({
-        line: z.number().optional(),
-        endLine: z.number().optional(),
-        label: z.string().optional(),
-      }).optional().describe('Region descriptor when anchorType is region.'),
-      author: z.string().optional().describe('Optional author label.'),
-      source: z.enum(['agent', 'api', 'browser', 'cli', 'codex', 'copilot', 'mcp', 'sdk', 'system'])
-        .optional()
-        .describe('Optional host/source label. Defaults to mcp.'),
-    },
-    async ({ body, kind, severity, anchorType, nodeId, file, region, author, source }) => {
-      const c = await ensureCanvas();
-      const reviewAnnotation = await c.addReviewAnnotation(
-        {
-          body,
-          ...(kind ? { kind } : {}),
-          ...(severity ? { severity } : {}),
-          ...(anchorType ? { anchorType } : {}),
-          ...(typeof nodeId === 'string' ? { nodeId } : {}),
-          ...(typeof file === 'string' ? { file } : {}),
-          ...(region ? { region } : {}),
-          ...(typeof author === 'string' ? { author } : {}),
-        },
-        { source: source ?? 'mcp' },
-      );
-      if (!reviewAnnotation) {
-        return {
-          content: [{ type: 'text', text: JSON.stringify({ ok: false, error: 'node-anchored review annotation requires a nodeId that exists on the canvas.' }) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: JSON.stringify({ ok: true, reviewAnnotation }) }],
-      };
-    },
-  );
-
-  server.tool(
-    'canvas_report_host_capability',
-    'Report host/session capability from an adapter: what the host can do (canvas/hooks/tools/sessionMessaging/permissions/files/uiPrompts). Stored for diagnostics; core does not depend on a host.',
-    {
-      host: z.string().optional().describe('Host identifier (e.g. copilot, codex).'),
-      canvas: z.boolean().optional(),
-      hooks: z.boolean().optional(),
-      tools: z.boolean().optional(),
-      sessionMessaging: z.boolean().optional(),
-      permissions: z.boolean().optional(),
-      files: z.boolean().optional(),
-      uiPrompts: z.boolean().optional(),
-      raw: z.record(z.string(), z.unknown()).optional().describe('Optional raw capability payload for diagnostics.'),
-      source: z.enum(['agent', 'api', 'browser', 'cli', 'codex', 'copilot', 'mcp', 'sdk', 'system'])
-        .optional()
-        .describe('Optional host/source label. Defaults to mcp.'),
-    },
-    async (input) => {
-      const c = await ensureCanvas();
-      const { source, ...capability } = input;
-      const host = await c.reportHostCapability(capability, { source: source ?? 'mcp' });
-      return {
-        content: [{ type: 'text', text: JSON.stringify({ ok: true, host }) }],
-      };
-    },
-  );
-
-  server.tool(
-    'canvas_ax_interaction',
-    'Submit a node-originated AX interaction: a capability-gated, validated event from an eligible node that maps onto an AX operation (work item, evidence, approval, review, focus, steering, event). Returns { ok: false, code } if the node type/metadata does not allow the interaction type or the payload is invalid.',
-    {
-      type: z.enum(AX_INTERACTION_TYPES).describe('Interaction type, e.g. ax.work.create, ax.evidence.add, ax.focus.set.'),
-      sourceNodeId: z.string().describe('The node emitting the interaction.'),
-      payload: z.record(z.string(), z.unknown()).optional().describe('Type-specific payload, e.g. {"title":"..."} for ax.work.create.'),
-      sourceSurface: z.enum(['native-node', 'json-render', 'html-node', 'mcp-app', 'adapter']).optional(),
-      correlationId: z.string().optional(),
-      source: z.enum(['agent', 'api', 'browser', 'cli', 'codex', 'copilot', 'mcp', 'sdk', 'system'])
-        .optional()
-        .describe('Optional host/source label. Defaults to mcp.'),
-    },
-    async ({ type, sourceNodeId, payload, sourceSurface, correlationId, source }) => {
-      const c = await ensureCanvas();
-      const result = await c.submitAxInteraction(
-        {
-          type,
-          sourceNodeId,
-          ...(payload ? { payload } : {}),
-          ...(sourceSurface ? { sourceSurface } : {}),
-          ...(correlationId ? { correlationId } : {}),
-        },
-        { source: source ?? 'mcp' },
-      );
-      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-    },
-  );
-
-  server.tool(
-    'canvas_claim_ax_delivery',
-    'Claim pending PMX AX deliveries for a consumer (adapterless delivery). Returns `pending` undelivered steering (mark each with canvas_mark_ax_delivery after acting) AND `pendingActivity`: open canvas-bound AX items awaiting the agent (open work items, pending approval gates / elicitations / mode requests) — typically created by the human in the browser. Both exclude items the consumer itself originated (loop prevention). pendingActivity is read-only here: resolve each via its own tool (canvas_resolve_approval / canvas_respond_elicitation / canvas_resolve_mode / canvas_update_work_item), not canvas_mark_ax_delivery.',
-    {
-      consumer: z.string().optional().describe('Consumer/source label to exclude from results (e.g. copilot, mcp).'),
-      limit: z.number().optional().describe('Max steering messages to return.'),
-    },
-    async ({ consumer, limit }) => {
-      const c = await ensureCanvas();
-      const pending = await c.getPendingSteering({
-        ...(consumer ? { consumer } : {}),
-        ...(typeof limit === 'number' ? { limit } : {}),
-      });
-      const pendingActivity = buildPendingAxActivity(await c.getAxState(), consumer);
-      return { content: [{ type: 'text', text: JSON.stringify({ ok: true, pending, pendingActivity }) }] };
-    },
-  );
-
-  server.tool(
-    'canvas_mark_ax_delivery',
-    'Mark a PMX AX steering message as delivered so it is not handed out again.',
-    {
-      id: z.string().describe('The steering message id to mark delivered.'),
-    },
-    async ({ id }) => {
-      const c = await ensureCanvas();
-      const delivered = await c.markSteeringDelivered(id);
-      return { content: [{ type: 'text', text: JSON.stringify({ ok: true, delivered }) }] };
-    },
-  );
-
-  server.tool(
-    'canvas_request_elicitation',
-    'Request structured human input (an elicitation): a pending question/form tied to nodes. Canvas-bound and snapshotted; exposed via canvas://ax-work. Answer it with canvas_respond_elicitation.',
-    {
-      prompt: z.string().describe('The question or instruction for the human.'),
-      fields: z.array(z.string()).optional().describe('Optional field names to request (a simple structured form).'),
-      nodeIds: z.array(z.string()).optional(),
-      source: z.enum(['agent', 'api', 'browser', 'cli', 'codex', 'copilot', 'mcp', 'sdk', 'system']).optional(),
-    },
-    async ({ prompt, fields, nodeIds, source }) => {
-      const c = await ensureCanvas();
-      const elicitation = await c.requestElicitation(
-        { prompt, ...(fields ? { fields } : {}), ...(Array.isArray(nodeIds) ? { nodeIds } : {}) },
-        { source: source ?? 'mcp' },
-      );
-      return { content: [{ type: 'text', text: JSON.stringify({ ok: true, elicitation }) }] };
-    },
-  );
-
-  server.tool(
-    'canvas_respond_elicitation',
-    'Answer a pending elicitation with a structured response.',
-    {
-      id: z.string().describe('The elicitation id.'),
-      response: z.record(z.string(), z.unknown()).describe('The structured answer.'),
-      source: z.enum(['agent', 'api', 'browser', 'cli', 'codex', 'copilot', 'mcp', 'sdk', 'system']).optional(),
-    },
-    async ({ id, response, source }) => {
-      const c = await ensureCanvas();
-      const elicitation = await c.respondElicitation(id, response, { source: source ?? 'mcp' });
-      return { content: [{ type: 'text', text: JSON.stringify({ ok: Boolean(elicitation), elicitation }) }] };
-    },
-  );
-
-  server.tool(
-    'canvas_request_mode',
-    'Request a workflow mode transition (plan/execute/autonomous): a pending mode request tied to nodes. Canvas-bound and snapshotted; exposed via canvas://ax-work. Resolve with canvas_resolve_mode.',
-    {
-      mode: z.enum(['plan', 'execute', 'autonomous']).describe('Requested target mode.'),
-      reason: z.string().optional(),
-      nodeIds: z.array(z.string()).optional(),
-      source: z.enum(['agent', 'api', 'browser', 'cli', 'codex', 'copilot', 'mcp', 'sdk', 'system']).optional(),
-    },
-    async ({ mode, reason, nodeIds, source }) => {
-      const c = await ensureCanvas();
-      const modeRequest = await c.requestMode(
-        { mode, ...(typeof reason === 'string' ? { reason } : {}), ...(Array.isArray(nodeIds) ? { nodeIds } : {}) },
-        { source: source ?? 'mcp' },
-      );
-      return { content: [{ type: 'text', text: JSON.stringify({ ok: true, modeRequest }) }] };
-    },
-  );
-
-  server.tool(
-    'canvas_resolve_mode',
-    'Resolve a pending mode request (approved or rejected).',
-    {
-      id: z.string(),
-      decision: z.enum(['approved', 'rejected']),
-      resolution: z.string().optional(),
-      source: z.enum(['agent', 'api', 'browser', 'cli', 'codex', 'copilot', 'mcp', 'sdk', 'system']).optional(),
-    },
-    async ({ id, decision, resolution, source }) => {
-      const c = await ensureCanvas();
-      const modeRequest = await c.resolveModeRequest(id, decision, {
-        ...(typeof resolution === 'string' ? { resolution } : {}),
-        source: source ?? 'mcp',
-      });
-      return { content: [{ type: 'text', text: JSON.stringify({ ok: Boolean(modeRequest), modeRequest }) }] };
-    },
-  );
-
-  server.tool(
-    'canvas_invoke_command',
-    'Invoke a registry-gated PMX command intent (pmx.plan | pmx.execute | pmx.promote-context | pmx.summarize | pmx.review). Records a timeline event a host/agent can observe — NOT arbitrary execution; unknown names are rejected.',
-    {
-      name: z.string().describe('A command name from the PMX command registry.'),
-      args: z.record(z.string(), z.unknown()).optional(),
-      source: z.enum(['agent', 'api', 'browser', 'cli', 'codex', 'copilot', 'mcp', 'sdk', 'system']).optional(),
-    },
-    async ({ name, args, source }) => {
-      const c = await ensureCanvas();
-      const event = await c.invokeCommand(name, args ?? null, { source: source ?? 'mcp' });
-      return { content: [{ type: 'text', text: JSON.stringify({ ok: Boolean(event), event }) }] };
-    },
-  );
-
-  server.tool(
-    'canvas_set_ax_policy',
-    'Set the declarative AX policy (allowed/excluded/approval-required tools; prompt mode/append). PMX stores it and exposes it via canvas://ax-context; host adapters READ and enforce it. Merges with the existing policy.',
-    {
-      tools: z.object({
-        allowed: z.array(z.string()).optional(),
-        excluded: z.array(z.string()).optional(),
-        approvalRequired: z.array(z.string()).optional(),
-      }).optional(),
-      prompt: z.object({ systemAppend: z.string().optional(), mode: z.string().optional() }).optional(),
-      source: z.enum(['agent', 'api', 'browser', 'cli', 'codex', 'copilot', 'mcp', 'sdk', 'system']).optional(),
-    },
-    async ({ tools, prompt, source }) => {
-      const c = await ensureCanvas();
-      const policy = await c.setPolicy({ ...(tools ? { tools } : {}), ...(prompt ? { prompt } : {}) }, { source: source ?? 'mcp' });
-      return { content: [{ type: 'text', text: JSON.stringify({ ok: true, policy }) }] };
-    },
-  );
-
-  server.tool(
-    'canvas_fit_view',
-    'Fit the canvas viewport to all nodes or a selected subset. Useful before screenshots and whole-board review.',
-    {
-      width: z.number().optional().describe('Viewport width used for fit math (default 1440)'),
-      height: z.number().optional().describe('Viewport height used for fit math (default 900)'),
-      padding: z.number().optional().describe('World-space padding around fitted nodes (default 60)'),
-      maxScale: z.number().optional().describe('Maximum zoom scale (default 1)'),
-      nodeIds: z.array(z.string()).optional().describe('Optional node IDs to fit instead of the whole canvas'),
-    },
-    async (input) => {
-      const c = await ensureCanvas();
-      const result = await c.fitView({
-        ...(typeof input.width === 'number' ? { width: input.width } : {}),
-        ...(typeof input.height === 'number' ? { height: input.height } : {}),
-        ...(typeof input.padding === 'number' ? { padding: input.padding } : {}),
-        ...(typeof input.maxScale === 'number' ? { maxScale: input.maxScale } : {}),
-        ...(Array.isArray(input.nodeIds) ? { nodeIds: input.nodeIds } : {}),
-      });
-      return {
-        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-      };
-    },
-  );
-
-  // ── canvas_clear ───────────────────────────────────────────────
-  server.tool(
-    'canvas_clear',
-    'Remove all nodes and edges from the canvas. Use with caution.',
-    {},
-    async () => {
-      const c = await ensureCanvas();
-      await c.clear();
-      return {
-        content: [{ type: 'text', text: JSON.stringify({ ok: true, cleared: true }) }],
-      };
-    },
-  );
-
-  // ── canvas_search ───────────────────────────────────────────
-  server.tool(
-    'canvas_search',
-    'Search for nodes by title or content keywords. Returns matching nodes ranked by relevance with snippets. Much faster than reading the full layout when you need to find specific nodes.',
-    {
-      query: z.string().describe('Search query — matches against node titles, content, and file paths'),
-      limit: z.number().optional().describe('Max results to return (default: 10)'),
-    },
-    async ({ query, limit }) => {
-      const c = await ensureCanvas();
-      const results = await c.search(query);
-      const capped = results.slice(0, limit ?? 10);
-      return {
-        content: [{
-          type: 'text',
-          text: JSON.stringify({ query, resultCount: results.length, results: capped }, null, 2),
-        }],
-      };
-    },
-  );
-
-  // ── canvas_undo ────────────────────────────────────────────────
-  server.tool(
-    'canvas_undo',
-    'Undo the last canvas mutation. Returns a description of what was undone. Use this to backtrack when an approach is wrong — explore without fear.',
-    {},
-    async () => {
-      const c = await ensureCanvas();
-      const result = await c.undo();
-      const history = await c.getHistory();
-      return {
-        content: [{ type: 'text', text: JSON.stringify({ ...result, canUndo: history.canUndo, canRedo: history.canRedo }) }],
-      };
-    },
-  );
-
-  // ── canvas_redo ────────────────────────────────────────────────
-  server.tool(
-    'canvas_redo',
-    'Redo the last undone canvas mutation. Use after undo to re-apply a change.',
-    {},
-    async () => {
-      const c = await ensureCanvas();
-      const result = await c.redo();
-      const history = await c.getHistory();
+        ...(typeof input.height === 'number' ? { height: input.height } : {}),
+        ...(input.strictSize === true ? { strictSize: true } : {}),
+      });
       return {
-        content: [{ type: 'text', text: JSON.stringify({ ...result, canUndo: history.canUndo, canRedo: history.canRedo }) }],
+        content: [{ type: 'text', text: JSON.stringify(await createdNodePayload(c, id, input), null, 2) }],
       };
     },
   );
 
-  // ── canvas_diff ────────────────────────────────────────────────
   server.tool(
-    'canvas_diff',
-    'Compare the current canvas state against a saved snapshot. Shows added/removed/modified nodes and edges. Pass either a snapshot name or ID.',
+    'canvas_add_html_primitive',
+    'Deprecated: use canvas_node with action "add", type:"html", primitive:"<kind>" (and data). Create a reusable HTML communication primitive as a normal sandboxed html node. Use this instead of long markdown for side-by-side choices, implementation plans, PR review sheets, module maps, design sheets, component galleries, flowcharts, explainers, status reports, and throwaway editors with export/copy paths. Use kind="presentation" only when the user explicitly asks for a PowerPoint-like deck, pitch, briefing, workshop walkthrough, or fullscreen story.',
     {
-      snapshot: z.string().describe('Snapshot name or ID to compare against'),
+      kind: htmlPrimitiveKindSchema.describe('Primitive kind. Call canvas_describe_schema and read htmlPrimitives for data shapes and examples.'),
+      title: z.string().optional().describe('Node title shown in the canvas titlebar.'),
+      data: z.record(z.string(), z.unknown()).optional().describe('Primitive-specific data payload. For kind="presentation", data may include theme:"canvas"|"midnight"|"paper"|"aurora" or a custom color object. See canvas_describe_schema.htmlPrimitives for each shape.'),
+      x: z.number().optional().describe('X position (auto-placed if omitted).'),
+      y: z.number().optional().describe('Y position (auto-placed if omitted).'),
+      width: z.number().optional().describe('Width in pixels (defaults per primitive).'),
+      height: z.number().optional().describe('Height in pixels (defaults per primitive).'),
+      strictSize: z.boolean().optional().describe('Keep explicit width/height fixed; iframe scrolls overflow internally.'),
+      full: z.boolean().optional().describe('Return the full created node payload. Default false returns compact metadata.'),
+      verbose: z.boolean().optional().describe('Alias for full:true.'),
     },
-    async ({ snapshot }) => {
+    async (input) => {
       const c = await ensureCanvas();
-      const result = await c.diffSnapshot(snapshot);
-      if (!result.ok) {
-        return { content: [{ type: 'text', text: `Snapshot "${snapshot}" not found. Use canvas_snapshot to save one first.` }], isError: true };
-      }
+      const kind = input.kind as HtmlPrimitiveKind;
+      const result = await c.addHtmlPrimitive({
+        kind,
+        ...(typeof input.title === 'string' ? { title: input.title } : {}),
+        ...(input.data ? { data: input.data } : {}),
+        ...(typeof input.x === 'number' ? { x: input.x } : {}),
+        ...(typeof input.y === 'number' ? { y: input.y } : {}),
+        ...(typeof input.width === 'number' ? { width: input.width } : {}),
+        ...(typeof input.height === 'number' ? { height: input.height } : {}),
+        ...(input.strictSize === true ? { strictSize: true } : {}),
+      });
       return {
-        content: [{ type: 'text', text: result.text ?? '' }],
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            ...(await createdNodePayload(c, result.id, input)),
+            primitive: { kind: result.kind, title: result.title, htmlBytes: result.htmlBytes },
+          }, null, 2),
+        }],
       };
     },
   );
 
-  // ── canvas_webview_status ─────────────────────────────────────
-  server.tool(
-    'canvas_webview_status',
-    'Get the current Bun.WebView automation status for the PMX Canvas workbench. Returns whether Bun.WebView is supported, whether an automation session is active, backend, viewport size, and the current workbench URL if active.',
-    {},
-    async () => {
-      const c = await ensureCanvas();
-      return {
-        content: [{ type: 'text', text: JSON.stringify(await c.getAutomationWebViewStatus(), null, 2) }],
-      };
-    },
-  );
+  // canvas_open_mcp_app + canvas_add_diagram migrated to the operation registry
+  // (plan-008 Wave 4): src/server/operations/ops/app.ts (mcpapp.open /
+  // diagram.open). Folded into the canvas_app composite.
 
-  // ── canvas_webview_start ──────────────────────────────────────
   server.tool(
-    'canvas_webview_start',
-    'Start or replace the headless Bun.WebView automation session for the current PMX Canvas workbench. Use this before screenshot, evaluate, or resize when no automation session is active.',
+    'canvas_refresh_webpage_node',
+    'Deprecated: use canvas_node with action "update" and refresh:true. Refresh a webpage node from its persisted URL so the server re-fetches and caches the latest page text and metadata.',
     {
-      backend: z.enum(['chrome', 'webkit']).optional()
-        .describe('Automation backend. Default: webkit on macOS, chrome elsewhere.'),
-      width: z.number().optional().describe('Viewport width in pixels (default: 1280)'),
-      height: z.number().optional().describe('Viewport height in pixels (default: 800)'),
-      chromePath: z.string().optional().describe('Optional Chrome/Chromium executable path'),
-      chromeArgv: z.array(z.string()).optional().describe('Optional extra Chrome launch args'),
-      dataStoreDir: z.string().optional().describe('Optional persistent data store directory'),
+      id: z.string().describe('Webpage node ID to refresh'),
+      url: z.string().optional().describe('Optional replacement URL before refresh'),
     },
-    async ({ backend, width, height, chromePath, chromeArgv, dataStoreDir }) => {
+    async ({ id, url }) => {
       const c = await ensureCanvas();
-      try {
-        const status = await c.startAutomationWebView({
-          ...(backend ? { backend } : {}),
-          ...(typeof width === 'number' ? { width } : {}),
-          ...(typeof height === 'number' ? { height } : {}),
-          ...(typeof chromePath === 'string' ? { chromePath } : {}),
-          ...(Array.isArray(chromeArgv) ? { chromeArgv } : {}),
-          ...(typeof dataStoreDir === 'string' ? { dataStoreDir: safeWorkspacePath(dataStoreDir) } : {}),
-        });
-        return {
-          content: [{ type: 'text', text: JSON.stringify(status, null, 2) }],
-        };
-      } catch (error) {
-        return {
-          content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
-          isError: true,
-        };
-      }
+      const result = await c.refreshWebpageNode(id, url);
+      return {
+        content: [{ type: 'text', text: JSON.stringify(result) }],
+        ...(result.ok ? {} : { isError: true }),
+      };
     },
   );
 
-  // ── canvas_webview_stop ───────────────────────────────────────
-  server.tool(
-    'canvas_webview_stop',
-    'Stop the current Bun.WebView automation session if one is active.',
-    {},
-    async () => {
-      const c = await ensureCanvas();
-      try {
-        const stopped = await c.stopAutomationWebView();
-        const webview = await c.getAutomationWebViewStatus();
-        return {
-          content: [{
-            type: 'text',
-            text: JSON.stringify({
-              ok: true,
-              stopped,
-              webview,
-            }, null, 2),
-          }],
-        };
-      } catch (error) {
-        return {
-          content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
-          isError: true,
-        };
-      }
-    },
-  );
+  // canvas_build_web_artifact migrated to the operation registry (plan-008
+  // Wave 4): src/server/operations/ops/app.ts (webartifact.build). Folded into
+  // the canvas_app composite.
+
+  // canvas_remove_annotation migrated to the operation registry (plan-008
+  // Wave 1): src/server/operations/ops/annotation.ts.
+
+  // ── AX context and focus ───────────────────────────────────────
+  // canvas_get_ax + canvas_set_ax_focus migrated to the operation registry
+  // (plan-007 Slice B.1): src/server/operations/ops/ax-state.ts.
+
+  // canvas_record_ax_event / canvas_send_steering / canvas_get_ax_timeline
+  // migrated to the operation registry (plan-007 Slice B wave 3):
+  // src/server/operations/ops/ax-timeline.ts.
+
+  // canvas_add_work_item / canvas_update_work_item / canvas_request_approval /
+  // canvas_resolve_approval migrated to the operation registry (plan-007 Slice B
+  // wave 2): src/server/operations/ops/ax-work.ts.
+
+  // canvas_add_evidence migrated to the operation registry (plan-007 Slice B
+  // wave 3): src/server/operations/ops/ax-timeline.ts.
+
+  // canvas_add_review_annotation migrated to the operation registry (plan-007
+  // Slice B wave 2): src/server/operations/ops/ax-work.ts.
+
+  // canvas_report_host_capability migrated to the operation registry
+  // (plan-007 Slice B.1): src/server/operations/ops/ax-state.ts.
 
-  // ── canvas_evaluate ───────────────────────────────────────────
   server.tool(
-    'canvas_evaluate',
-    'Evaluate JavaScript in the active Bun.WebView automation session for the workbench page. Use this to inspect rendered browser state. Requires an active automation session started via canvas_webview_start.',
+    'canvas_ax_interaction',
+    'Submit a node-originated AX interaction: a capability-gated, validated event from an eligible node that maps onto an AX operation (work item, evidence, approval, review, focus, steering, event). Returns { ok: false, code } if the node type/metadata does not allow the interaction type or the payload is invalid.',
     {
-      expression: z.string().optional().describe('JavaScript expression to evaluate in the page context'),
-      script: z.string().optional().describe('Multi-statement JavaScript body. The MCP server wraps it in an async IIFE and evaluates the resolved return value.'),
+      type: z.enum(AX_INTERACTION_TYPES).describe('Interaction type, e.g. ax.work.create, ax.evidence.add, ax.focus.set.'),
+      sourceNodeId: z.string().describe('The node emitting the interaction.'),
+      payload: z.record(z.string(), z.unknown()).optional().describe('Type-specific payload, e.g. {"title":"..."} for ax.work.create.'),
+      sourceSurface: z.enum(['native-node', 'json-render', 'html-node', 'mcp-app', 'adapter']).optional(),
+      correlationId: z.string().optional(),
+      source: z.enum(['agent', 'api', 'browser', 'cli', 'codex', 'copilot', 'mcp', 'sdk', 'system'])
+        .optional()
+        .describe('Optional host/source label. Defaults to mcp.'),
     },
-    async ({ expression, script }) => {
+    async ({ type, sourceNodeId, payload, sourceSurface, correlationId, source }) => {
       const c = await ensureCanvas();
-      if ((expression ? 1 : 0) + (script ? 1 : 0) !== 1) {
-        return {
-          content: [{ type: 'text', text: 'Pass exactly one of "expression" or "script".' }],
-          isError: true,
-        };
-      }
-
-      const source = script ? wrapCanvasAutomationScript(script) : expression!;
-      try {
-        const value = await c.evaluateAutomationWebView(source);
-        return {
-          content: [{ type: 'text', text: JSON.stringify({ value }, null, 2) }],
-        };
-      } catch (error) {
-        return {
-          content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
-          isError: true,
-        };
-      }
+      const result = await c.submitAxInteraction(
+        {
+          type,
+          sourceNodeId,
+          ...(payload ? { payload } : {}),
+          ...(sourceSurface ? { sourceSurface } : {}),
+          ...(correlationId ? { correlationId } : {}),
+        },
+        { source: source ?? 'mcp' },
+      );
+      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
     },
   );
 
-  // ── canvas_resize ─────────────────────────────────────────────
+  // canvas_claim_ax_delivery / canvas_mark_ax_delivery migrated to the operation
+  // registry (plan-007 Slice B wave 3): src/server/operations/ops/ax-timeline.ts.
+
+  // canvas_request_elicitation / canvas_respond_elicitation / canvas_request_mode /
+  // canvas_resolve_mode migrated to the operation registry (plan-007 Slice B
+  // wave 2): src/server/operations/ops/ax-work.ts.
+
   server.tool(
-    'canvas_resize',
-    'Resize the active Bun.WebView automation viewport. Requires an active automation session started via canvas_webview_start.',
+    'canvas_ingest_activity',
+    'Ingest a normalized agent activity (a tool/session event your harness forwards) so the board reacts automatically — primitive A, makes AX bidirectional. Always records a timeline event; kind-driven default reactions (overridable per call via `reactions`): failure/error → work item (blocked) + review finding + evidence (logs); tool-result + outcome:"success" → evidence (tool-result); everything else (tool-start, session-*, command, note) → event only. Set any reaction to false to suppress it, or to an object to override its fields. Returns { event, workItem, evidence, review }.',
     {
-      width: z.number().describe('Viewport width in pixels'),
-      height: z.number().describe('Viewport height in pixels'),
+      kind: z.enum(['tool-start', 'tool-result', 'failure', 'error', 'session-start', 'session-end', 'command', 'note']),
+      title: z.string(),
+      summary: z.string().optional(),
+      outcome: z.enum(['success', 'failure']).optional(),
+      ref: z.string().optional().describe('A file path, URL, or commit the activity refers to (used as the review file anchor for failures).'),
+      nodeIds: z.array(z.string()).optional(),
+      data: z.record(z.string(), z.unknown()).optional(),
+      reactions: z.object({
+        workItem: z.union([z.literal(false), z.object({
+          status: z.enum(['todo', 'in-progress', 'blocked', 'done', 'cancelled']).optional(),
+          detail: z.string().nullable().optional(),
+        })]).optional(),
+        evidence: z.union([z.literal(false), z.object({
+          kind: z.enum(['logs', 'tool-result', 'screenshot', 'file', 'diff', 'test-output']).optional(),
+          body: z.string().nullable().optional(),
+        })]).optional(),
+        review: z.union([z.literal(false), z.object({
+          severity: z.enum(['info', 'warning', 'error']).optional(),
+          kind: z.enum(['comment', 'finding']).optional(),
+          anchorType: z.enum(['node', 'file', 'region']).optional(),
+          nodeId: z.string().nullable().optional(),
+        })]).optional(),
+      }).optional().describe('Override or suppress the kind-driven default reactions.'),
+      source: z.enum(['agent', 'api', 'browser', 'cli', 'codex', 'copilot', 'mcp', 'sdk', 'system']).optional(),
     },
-    async ({ width, height }) => {
+    async ({ kind, title, summary, outcome, ref, nodeIds, data, reactions, source }) => {
       const c = await ensureCanvas();
-      try {
-        const status = await c.resizeAutomationWebView(width, height);
-        return {
-          content: [{ type: 'text', text: JSON.stringify(status, null, 2) }],
-        };
-      } catch (error) {
-        return {
-          content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
-          isError: true,
-        };
-      }
+      const result = await c.ingestActivity(
+        {
+          kind,
+          title,
+          ...(summary !== undefined ? { summary } : {}),
+          ...(outcome !== undefined ? { outcome } : {}),
+          ...(ref !== undefined ? { ref } : {}),
+          ...(nodeIds !== undefined ? { nodeIds } : {}),
+          ...(data !== undefined ? { data } : {}),
+          ...(reactions !== undefined ? { reactions } : {}),
+        },
+        { source: source ?? 'mcp' },
+      );
+      return { content: [{ type: 'text', text: JSON.stringify({ ok: true, ...result }) }] };
     },
   );
 
+  // canvas_await_approval / canvas_await_elicitation / canvas_await_mode migrated
+  // to the operation registry (plan-007 Slice B wave 4):
+  // src/server/operations/ops/ax-await.ts.
+
+  // canvas_invoke_command migrated to the operation registry (plan-007 Slice B
+  // wave 3): src/server/operations/ops/ax-timeline.ts.
+
+  // canvas_set_ax_policy migrated to the operation registry
+  // (plan-007 Slice B.1): src/server/operations/ops/ax-state.ts.
+
+  // canvas_webview_status / canvas_webview_start / canvas_webview_stop /
+  // canvas_evaluate / canvas_resize migrated to the operation registry
+  // (plan-008 Wave 3): src/server/operations/ops/webview.ts (via the injected
+  // webview runner). canvas_screenshot stays hand-written below — it returns a
+  // binary image payload, which the registry's JSON wire shape does not model.
+
   // ── canvas_screenshot ─────────────────────────────────────────
   server.tool(
     'canvas_screenshot',
@@ -2283,7 +680,7 @@ export async function startMcpServer(): Promise<void> {
     },
     async () => {
       const c = await ensureCanvas();
-      const context = await c.getAxContext();
+      const context = await c.getAxContext({ consumer: 'mcp' });
       return {
         contents: [
           {
@@ -2394,7 +791,7 @@ export async function startMcpServer(): Promise<void> {
     'Inject the current PMX Canvas AX context (pins, focus, work items, approvals, review, timeline) so an MCP-aware client can ground its next action without a host-native adapter.',
     async () => {
       const c = await ensureCanvas();
-      const context = await c.getAxContext();
+      const context = await c.getAxContext({ consumer: 'mcp' });
       return {
         messages: [
           {
@@ -2593,218 +990,10 @@ export async function startMcpServer(): Promise<void> {
     );
   }
 
-  // ── canvas_create_group ──────────────────────────────────────
-  server.tool(
-    'canvas_create_group',
-    'Create a group (frame) on the canvas that visually contains other nodes. Groups are spatial containers — they communicate "these nodes belong together." If childIds are provided, grouping preserves child positions by default; pass childLayout to auto-pack them. You can also provide an explicit frame (x/y/width/height) and auto-arrange children inside it.',
-    {
-      title: z.string().optional().describe('Group title (default: "Group")'),
-      childIds: z.array(z.string()).optional().describe('Node IDs to include in the group. Group auto-sizes to fit them.'),
-      color: z.string().optional().describe('Group accent color (CSS color string, e.g. "#4a9eff")'),
-      x: z.number().optional().describe('X position (auto-computed from children if omitted)'),
-      y: z.number().optional().describe('Y position (auto-computed from children if omitted)'),
-      width: z.number().optional().describe('Width (auto-computed from children if omitted)'),
-      height: z.number().optional().describe('Height (auto-computed from children if omitted)'),
-      childLayout: z.enum(['grid', 'column', 'flow']).optional().describe('Optional child auto-layout. Omit to preserve current child positions.'),
-      full: z.boolean().optional().describe('Return the full created group payload. Default false returns compact metadata.'),
-      verbose: z.boolean().optional().describe('Alias for full:true.'),
-    },
-    async (input) => {
-      const c = await ensureCanvas();
-      const id = await c.createGroup(input);
-      return {
-        content: [{ type: 'text', text: JSON.stringify(await createdNodePayload(c, id, input), null, 2) }],
-      };
-    },
-  );
-
-  // ── canvas_group_nodes ──────────────────────────────────────
-  server.tool(
-    'canvas_group_nodes',
-    'Add nodes to an existing group. The nodes will be visually contained within the group frame.',
-    {
-      groupId: z.string().describe('The group node ID'),
-      childIds: z.array(z.string()).describe('Node IDs to add to the group'),
-      childLayout: z.enum(['grid', 'column', 'flow']).optional().describe('Optional child layout to apply while grouping'),
-    },
-    async ({ groupId, childIds, childLayout }) => {
-      const c = await ensureCanvas();
-      const ok = await c.groupNodes(groupId, childIds, childLayout ? { childLayout } : undefined);
-      if (!ok) {
-        return { content: [{ type: 'text', text: 'Group not found or no valid children.' }], isError: true };
-      }
-      return { content: [{ type: 'text', text: JSON.stringify({ ok: true, groupId }) }] };
-    },
-  );
-
-  server.tool(
-    'canvas_batch',
-    'Run a non-atomic batch of canvas operations with optional assigned references. Use assign to name a result, then reference it later as "$name" for the created node id or "$name.id" for a specific result field. On failure, earlier successful operations remain applied and the response includes ok:false, failedIndex, error, results, and refs. Supports node.add, node.update, node.remove, graph.add, edge.add, group.create, group.add, group.remove, pin.set/add/remove, snapshot.save, and arrange.',
-    {
-      operations: z.array(z.object({
-        op: z.string().describe('Operation name, e.g. "node.add" or "edge.add"'),
-        assign: z.string().optional().describe('Optional reference name for later operations'),
-        args: z.record(z.string(), z.unknown()).optional().describe('Operation arguments'),
-      })).describe('Ordered array of batch operations'),
-      full: z.boolean().optional().describe('Return full batch operation results. Default false compacts node-like payloads.'),
-      verbose: z.boolean().optional().describe('Alias for full:true.'),
-    },
-    async (input) => {
-      const c = await ensureCanvas();
-      const result = await c.runBatch(input.operations);
-      const payload = wantsFullPayload(input) ? result : compactBatchResult(result);
-      return {
-        content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
-        ...(result.ok ? {} : { isError: true }),
-      };
-    },
-  );
-
-  server.tool(
-    'canvas_validate',
-    'Validate the current canvas layout. Distinguishes true node collisions from expected group-child containment and reports missing edge endpoints.',
-    {},
-    async () => {
-      const c = await ensureCanvas();
-      return {
-        content: [{ type: 'text', text: JSON.stringify(await c.validate(), null, 2) }],
-      };
-    },
-  );
-
-  // ── canvas_ungroup ──────────────────────────────────────────
-  server.tool(
-    'canvas_ungroup',
-    'Remove all children from a group, releasing them as independent nodes. The group node itself remains (delete it separately with canvas_remove_node if desired).',
-    {
-      groupId: z.string().describe('The group node ID to ungroup'),
-    },
-    async ({ groupId }) => {
-      const c = await ensureCanvas();
-      const ok = await c.ungroupNodes(groupId);
-      if (!ok) {
-        return { content: [{ type: 'text', text: 'Group not found or already empty.' }], isError: true };
-      }
-      return { content: [{ type: 'text', text: JSON.stringify({ ok: true, groupId }) }] };
-    },
-  );
-
-  // ── canvas_pin_nodes ─────────────────────────────────────────
-  server.tool(
-    'canvas_pin_nodes',
-    'Pin nodes to include them in the agent context. Pinned nodes appear in the canvas://pinned-context resource. The human can also pin nodes by clicking in the browser.',
-    {
-      nodeIds: z.array(z.string()).describe('Array of node IDs to pin'),
-      mode: z.enum(['set', 'add', 'remove']).optional()
-        .describe('set: replace all pins, add: add to existing pins, remove: unpin these nodes (default: set)'),
-    },
-    async ({ nodeIds, mode }) => {
-      const c = await ensureCanvas();
-      const result = await c.setContextPins(nodeIds, mode ?? 'set');
-
-      return {
-        content: [{
-          type: 'text',
-          text: JSON.stringify({
-            ok: true,
-            pinnedNodeIds: result.nodeIds,
-          }),
-        }],
-      };
-    },
-  );
-
-  // ── canvas_snapshot ──────────────────────────────────────────
-  server.tool(
-    'canvas_snapshot',
-    'Save the current canvas state as a named snapshot. Snapshots persist to disk and can be restored later.',
-    {
-      name: z.string().describe('Name for this snapshot (e.g., "before refactor", "investigation v2")'),
-    },
-    async (input) => {
-      const c = await ensureCanvas();
-      const snapshot = await c.saveSnapshot(input.name);
-      if (!snapshot) {
-        return { content: [{ type: 'text', text: JSON.stringify({ ok: false, error: 'Failed to save snapshot' }) }] };
-      }
-      return { content: [{ type: 'text', text: JSON.stringify({ ok: true, id: snapshot.id, snapshot }) }] };
-    },
-  );
-
-  // ── canvas_list_snapshots ───────────────────────────────────
-  server.tool(
-    'canvas_list_snapshots',
-    'List saved canvas snapshots with IDs, names, timestamps, and node/edge counts. Defaults to the 20 newest snapshots; pass all=true to return every snapshot.',
-    {
-      limit: z.number().optional().describe('Maximum snapshots to return (default: 20)'),
-      query: z.string().optional().describe('Optional case-insensitive ID/name filter'),
-      before: z.string().optional().describe('Only return snapshots created at or before this ISO timestamp'),
-      after: z.string().optional().describe('Only return snapshots created at or after this ISO timestamp'),
-      all: z.boolean().optional().describe('Return all snapshots instead of the default limit'),
-    },
-    async (input) => {
-      const c = await ensureCanvas();
-      return {
-        content: [{ type: 'text', text: JSON.stringify({ snapshots: await c.listSnapshots(input) }, null, 2) }],
-      };
-    },
-  );
-
-  // ── canvas_gc_snapshots ─────────────────────────────────────
-  server.tool(
-    'canvas_gc_snapshots',
-    'Delete old saved canvas snapshots, keeping the newest N snapshots. Use dryRun=true to preview deletions.',
-    {
-      keep: z.number().optional().describe('Number of newest snapshots to keep (default: 20)'),
-      dryRun: z.boolean().optional().describe('Preview deletions without removing snapshot files'),
-    },
-    async (input) => {
-      const c = await ensureCanvas();
-      const result = await c.gcSnapshots(input);
-      return {
-        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-      };
-    },
-  );
-
-  // ── canvas_restore ──────────────────────────────────────────
-  server.tool(
-    'canvas_restore',
-    'Restore the canvas to a previously saved snapshot. Use canvas_snapshot to save first. Pass either the snapshot ID or name to restore.',
-    {
-      id: z.string().describe('Snapshot ID or name to restore (from canvas_snapshot or snapshot list)'),
-    },
-    async (input) => {
-      const c = await ensureCanvas();
-      const result = await c.restoreSnapshot(input.id);
-      if (!result.ok) {
-        return { content: [{ type: 'text', text: JSON.stringify({ ok: false, error: 'Snapshot not found' }) }] };
-      }
-      const layout = await c.getLayout();
-      return {
-        content: [{ type: 'text', text: JSON.stringify({ ok: true, restored: input.id, summary: buildSnapshotRestoreSummary(layout) }, null, 2) }],
-      };
-    },
-  );
-
-  // ── canvas_delete_snapshot ──────────────────────────────────
-  server.tool(
-    'canvas_delete_snapshot',
-    'Delete a saved snapshot by ID.',
-    {
-      id: z.string().describe('Snapshot ID to delete'),
-    },
-    async ({ id }) => {
-      const c = await ensureCanvas();
-      const result = await c.deleteSnapshot(id);
-      if (!result.ok) {
-        return { content: [{ type: 'text', text: JSON.stringify({ ok: false, error: 'Snapshot not found' }) }], isError: true };
-      }
-      return {
-        content: [{ type: 'text', text: JSON.stringify({ ok: true, deleted: id }) }],
-      };
-    },
-  );
+  // canvas_batch migrated to the operation registry (plan-008 Wave 2):
+  // src/server/operations/ops/batch.ts.
+  // canvas_validate migrated to the operation registry (plan-008 Wave 1):
+  // src/server/operations/ops/validate.ts.
 
   // Connect via stdio
   const transport = new StdioServerTransport();