pmx-canvas 0.1.35 → 0.2.0

package/src/mcp/canvas-access.ts

@@ -6,95 +6,48 @@ import {
   type CanvasEdge,
   type CanvasLayout,
   type CanvasNodeState,
-  type CanvasSnapshot,
   type PmxCanvas,
 } from '../server/index.js';
 import type { PmxAxSource } from '../server/ax-state.js';
+import {
+  HttpOperationInvoker,
+  LocalOperationInvoker,
+  type OperationInvoker,
+} from '../server/operations/index.js';
 
-type AddNodeInput = Parameters<PmxCanvas['addNode']>[0];
-type AddWebpageNodeInput = Parameters<PmxCanvas['addWebpageNode']>[0];
 type RefreshWebpageNodeResult = Awaited<ReturnType<PmxCanvas['refreshWebpageNode']>>;
-type OpenMcpAppInput = Parameters<PmxCanvas['openMcpApp']>[0];
-type OpenMcpAppResult = Awaited<ReturnType<PmxCanvas['openMcpApp']>>;
-type AddDiagramInput = Parameters<PmxCanvas['addDiagram']>[0];
-type AddJsonRenderNodeInput = Parameters<PmxCanvas['addJsonRenderNode']>[0];
-type AddJsonRenderNodeResult = ReturnType<PmxCanvas['addJsonRenderNode']>;
-type StreamJsonRenderNodeInput = Parameters<PmxCanvas['streamJsonRenderNode']>[0];
-type StreamJsonRenderNodeResult = ReturnType<PmxCanvas['streamJsonRenderNode']>;
+// openMcpApp / addDiagram / buildWebArtifact CanvasAccess methods + their type
+// aliases removed with the standalone MCP tools (plan-008 Wave 4): those tools
+// migrated to the operation registry (mcpapp.open / diagram.open /
+// webartifact.build) and the composite/registry tools dispatch via the invoker,
+// not CanvasAccess. The public SDK PmxCanvas methods are unchanged.
 type AddHtmlNodeInput = Parameters<PmxCanvas['addHtmlNode']>[0];
 type AddHtmlPrimitiveInput = Parameters<PmxCanvas['addHtmlPrimitive']>[0];
 type AddHtmlPrimitiveResult = ReturnType<PmxCanvas['addHtmlPrimitive']>;
-type AddGraphNodeInput = Parameters<PmxCanvas['addGraphNode']>[0];
-type AddGraphNodeResult = ReturnType<PmxCanvas['addGraphNode']>;
-type UpdateNodePatch = Parameters<PmxCanvas['updateNode']>[1];
-type AddEdgeInput = Parameters<PmxCanvas['addEdge']>[0];
-type CreateGroupInput = Parameters<PmxCanvas['createGroup']>[0];
-type GroupNodesOptions = Parameters<PmxCanvas['groupNodes']>[2];
-type ArrangeLayout = Parameters<PmxCanvas['arrange']>[0];
-type FocusNodeResult = ReturnType<PmxCanvas['focusNode']>;
-type FitViewOptions = Parameters<PmxCanvas['fitView']>[0];
-type FitViewResult = ReturnType<PmxCanvas['fitView']>;
 type AxStateResult = ReturnType<PmxCanvas['getAxState']>;
 type AxContextResult = ReturnType<PmxCanvas['getAxContext']>;
-type SetAxFocusResult = ReturnType<PmxCanvas['setAxFocus']>;
-type RecordAxEventInput = Parameters<PmxCanvas['recordAxEvent']>[0];
-type RecordAxEventResult = ReturnType<PmxCanvas['recordAxEvent']>;
-type SendSteeringResult = ReturnType<PmxCanvas['sendSteering']>;
 type SubmitAxInteractionInput = Parameters<PmxCanvas['submitAxInteraction']>[0];
 type SubmitAxInteractionResult = ReturnType<PmxCanvas['submitAxInteraction']>;
 type GetPendingSteeringResult = ReturnType<PmxCanvas['getPendingSteering']>;
 type ListElicitationsResult = ReturnType<PmxCanvas['listElicitations']>;
-type RequestElicitationInput = Parameters<PmxCanvas['requestElicitation']>[0];
-type RequestElicitationResult = ReturnType<PmxCanvas['requestElicitation']>;
-type RespondElicitationResult = ReturnType<PmxCanvas['respondElicitation']>;
 type ListModeRequestsResult = ReturnType<PmxCanvas['listModeRequests']>;
-type RequestModeInput = Parameters<PmxCanvas['requestMode']>[0];
-type RequestModeResult = ReturnType<PmxCanvas['requestMode']>;
-type ResolveModeRequestResult = ReturnType<PmxCanvas['resolveModeRequest']>;
-type GetCommandRegistryResult = ReturnType<PmxCanvas['getCommandRegistry']>;
-type InvokeCommandResult = ReturnType<PmxCanvas['invokeCommand']>;
+type IngestActivityInput = Parameters<PmxCanvas['ingestActivity']>[0];
+type IngestActivityResult = ReturnType<PmxCanvas['ingestActivity']>;
 type GetPolicyResult = ReturnType<PmxCanvas['getPolicy']>;
-type SetPolicyInput = Parameters<PmxCanvas['setPolicy']>[0];
-type SetPolicyResult = ReturnType<PmxCanvas['setPolicy']>;
 type GetAxTimelineQuery = Parameters<PmxCanvas['getAxTimeline']>[0];
 type GetAxTimelineResult = ReturnType<PmxCanvas['getAxTimeline']>;
-type AddWorkItemInput = Parameters<PmxCanvas['addWorkItem']>[0];
-type AddWorkItemResult = ReturnType<PmxCanvas['addWorkItem']>;
-type UpdateWorkItemPatch = Parameters<PmxCanvas['updateWorkItem']>[1];
-type UpdateWorkItemResult = ReturnType<PmxCanvas['updateWorkItem']>;
 type ListWorkItemsResult = ReturnType<PmxCanvas['listWorkItems']>;
-type RequestApprovalInput = Parameters<PmxCanvas['requestApproval']>[0];
-type RequestApprovalResult = ReturnType<PmxCanvas['requestApproval']>;
-type ResolveApprovalResult = ReturnType<PmxCanvas['resolveApproval']>;
 type ListApprovalGatesResult = ReturnType<PmxCanvas['listApprovalGates']>;
-type AddEvidenceInput = Parameters<PmxCanvas['addEvidence']>[0];
-type AddEvidenceResult = ReturnType<PmxCanvas['addEvidence']>;
-type AddReviewAnnotationInput = Parameters<PmxCanvas['addReviewAnnotation']>[0];
-type AddReviewAnnotationResult = ReturnType<PmxCanvas['addReviewAnnotation']>;
-type UpdateReviewAnnotationPatch = Parameters<PmxCanvas['updateReviewAnnotation']>[1];
-type UpdateReviewAnnotationResult = ReturnType<PmxCanvas['updateReviewAnnotation']>;
 type ListReviewAnnotationsResult = ReturnType<PmxCanvas['listReviewAnnotations']>;
-type GetHostCapabilityResult = ReturnType<PmxCanvas['getHostCapability']>;
-type ReportHostCapabilityResult = ReturnType<PmxCanvas['reportHostCapability']>;
-type SearchResult = ReturnType<PmxCanvas['search']>;
-type UndoRedoResult = Awaited<ReturnType<PmxCanvas['undo']>>;
 type HistoryResult = ReturnType<PmxCanvas['getHistory']>;
-type SetContextPinsResult = ReturnType<PmxCanvas['setContextPins']>;
 type RunBatchInput = Parameters<PmxCanvas['runBatch']>[0];
 type RunBatchResult = Awaited<ReturnType<PmxCanvas['runBatch']>>;
-type SnapshotListOptions = Parameters<PmxCanvas['listSnapshots']>[0];
-type SnapshotList = ReturnType<PmxCanvas['listSnapshots']>;
-type DeleteSnapshotResult = ReturnType<PmxCanvas['deleteSnapshot']>;
-type GcSnapshotsOptions = Parameters<PmxCanvas['gcSnapshots']>[0];
-type GcSnapshotsResult = ReturnType<PmxCanvas['gcSnapshots']>;
-type DiffSnapshotResult = ReturnType<PmxCanvas['diffSnapshot']>;
 type CodeGraphResult = ReturnType<PmxCanvas['getCodeGraph']>;
-type ValidationResult = ReturnType<PmxCanvas['validate']>;
-type WebArtifactInput = Parameters<PmxCanvas['buildWebArtifact']>[0];
-type WebArtifactResult = Awaited<ReturnType<PmxCanvas['buildWebArtifact']>>;
-type AutomationWebViewOptions = Parameters<PmxCanvas['startAutomationWebView']>[0];
-type AutomationWebViewStatus = Awaited<ReturnType<PmxCanvas['startAutomationWebView']>>;
-type AutomationEvaluateResult = Awaited<ReturnType<PmxCanvas['evaluateAutomationWebView']>>;
+// canvas_screenshot (the only webview tool still hand-written) needs the status
+// + screenshot accessors; the other four webview methods (start/stop/evaluate/
+// resize) migrated to the operation registry (plan-008 Wave 3) and were removed
+// from CanvasAccess.
+type AutomationWebViewStatus = Awaited<ReturnType<PmxCanvas['getAutomationWebViewStatus']>>;
 type AutomationScreenshotOptions = Parameters<PmxCanvas['screenshotAutomationWebView']>[0];
 
 interface HealthResponse {
@@ -107,120 +60,41 @@ interface NodeResponse {
   node?: { id?: string };
 }
 
-interface JsonRenderNodeResponse extends NodeResponse {
-  url: string;
-  spec: AddJsonRenderNodeResult['spec'];
-}
-
-interface GraphNodeResponse extends NodeResponse {
-  url: string;
-  spec: AddGraphNodeResult['spec'];
-}
-
-interface SearchResponse {
-  results?: SearchResult;
-}
-
-interface SnapshotSaveResponse {
-  snapshot?: CanvasSnapshot;
-}
-
-interface WebViewEnvelope {
-  webview?: AutomationWebViewStatus;
-}
-
-interface WebViewStopEnvelope extends WebViewEnvelope {
-  stopped?: boolean;
-}
-
-interface WebViewEvaluateEnvelope {
-  value?: AutomationEvaluateResult;
-}
-
 export interface CanvasAccess {
   readonly port: number;
   readonly remoteBaseUrl: string | null;
+  /** Operation-registry invoker (plan-005): local in-process or HTTP, matching the access mode. */
+  invoker(): OperationInvoker;
   getLayout(): Promise<CanvasLayout>;
   getNode(id: string): Promise<CanvasNodeState | undefined>;
-  addNode(input: AddNodeInput): Promise<string>;
-  addWebpageNode(input: AddWebpageNodeInput): Promise<Awaited<ReturnType<PmxCanvas['addWebpageNode']>>>;
   refreshWebpageNode(id: string, url?: string): Promise<RefreshWebpageNodeResult>;
-  openMcpApp(input: OpenMcpAppInput): Promise<OpenMcpAppResult>;
-  addDiagram(input: AddDiagramInput): Promise<OpenMcpAppResult>;
-  addJsonRenderNode(input: AddJsonRenderNodeInput): Promise<AddJsonRenderNodeResult>;
-  streamJsonRenderNode(input: StreamJsonRenderNodeInput): Promise<StreamJsonRenderNodeResult>;
   addHtmlNode(input: AddHtmlNodeInput): Promise<string>;
   addHtmlPrimitive(input: AddHtmlPrimitiveInput): Promise<AddHtmlPrimitiveResult>;
-  addGraphNode(input: AddGraphNodeInput): Promise<AddGraphNodeResult>;
-  buildWebArtifact(input: WebArtifactInput): Promise<WebArtifactResult>;
-  updateNode(id: string, patch: UpdateNodePatch): Promise<void>;
-  removeNode(id: string): Promise<void>;
-  removeAnnotation(id: string): Promise<boolean>;
-  addEdge(input: AddEdgeInput): Promise<string>;
-  removeEdge(id: string): Promise<void>;
-  createGroup(input: CreateGroupInput): Promise<string>;
-  groupNodes(groupId: string, childIds: string[], options?: GroupNodesOptions): Promise<boolean>;
-  ungroupNodes(groupId: string): Promise<boolean>;
-  arrange(layout?: ArrangeLayout): Promise<void>;
-  focusNode(id: string, options?: { noPan?: boolean }): Promise<FocusNodeResult>;
-  fitView(options?: FitViewOptions): Promise<FitViewResult>;
   getAxState(): Promise<AxStateResult>;
-  getAxContext(): Promise<AxContextResult>;
-  setAxFocus(nodeIds: string[], options?: { source?: PmxAxSource }): Promise<SetAxFocusResult>;
-  recordAxEvent(input: RecordAxEventInput, options?: { source?: PmxAxSource }): Promise<RecordAxEventResult>;
-  sendSteering(message: string, options?: { source?: PmxAxSource }): Promise<SendSteeringResult>;
+  getAxContext(options?: { consumer?: string }): Promise<AxContextResult>;
   getAxTimeline(query?: GetAxTimelineQuery): Promise<GetAxTimelineResult>;
-  addWorkItem(input: AddWorkItemInput, options?: { source?: PmxAxSource }): Promise<AddWorkItemResult>;
-  updateWorkItem(id: string, patch: UpdateWorkItemPatch, options?: { source?: PmxAxSource }): Promise<UpdateWorkItemResult>;
   listWorkItems(): Promise<ListWorkItemsResult>;
-  requestApproval(input: RequestApprovalInput, options?: { source?: PmxAxSource }): Promise<RequestApprovalResult>;
-  resolveApproval(id: string, decision: 'approved' | 'rejected', options?: { resolution?: string; source?: PmxAxSource }): Promise<ResolveApprovalResult>;
   listApprovalGates(): Promise<ListApprovalGatesResult>;
-  addEvidence(input: AddEvidenceInput, options?: { source?: PmxAxSource }): Promise<AddEvidenceResult>;
-  addReviewAnnotation(input: AddReviewAnnotationInput, options?: { source?: PmxAxSource }): Promise<AddReviewAnnotationResult>;
-  updateReviewAnnotation(id: string, patch: UpdateReviewAnnotationPatch, options?: { source?: PmxAxSource }): Promise<UpdateReviewAnnotationResult>;
   listReviewAnnotations(): Promise<ListReviewAnnotationsResult>;
-  getHostCapability(): Promise<GetHostCapabilityResult>;
-  reportHostCapability(input: unknown, options?: { source?: PmxAxSource }): Promise<ReportHostCapabilityResult>;
   submitAxInteraction(input: SubmitAxInteractionInput, options?: { source?: PmxAxSource }): Promise<SubmitAxInteractionResult>;
   getPendingSteering(options?: { consumer?: string; limit?: number }): Promise<GetPendingSteeringResult>;
-  markSteeringDelivered(id: string): Promise<boolean>;
   listElicitations(): Promise<ListElicitationsResult>;
-  requestElicitation(input: RequestElicitationInput, options?: { source?: PmxAxSource }): Promise<RequestElicitationResult>;
-  respondElicitation(id: string, response: Record<string, unknown>, options?: { source?: PmxAxSource }): Promise<RespondElicitationResult>;
   listModeRequests(): Promise<ListModeRequestsResult>;
-  requestMode(input: RequestModeInput, options?: { source?: PmxAxSource }): Promise<RequestModeResult>;
-  resolveModeRequest(id: string, decision: 'approved' | 'rejected', options?: { resolution?: string; source?: PmxAxSource }): Promise<ResolveModeRequestResult>;
-  getCommandRegistry(): Promise<GetCommandRegistryResult>;
-  invokeCommand(name: string, args?: Record<string, unknown> | null, options?: { source?: PmxAxSource }): Promise<InvokeCommandResult>;
+  ingestActivity(input: IngestActivityInput, options?: { source?: PmxAxSource }): Promise<IngestActivityResult>;
   getPolicy(): Promise<GetPolicyResult>;
-  setPolicy(patch: SetPolicyInput, options?: { source?: PmxAxSource }): Promise<SetPolicyResult>;
-  clear(): Promise<void>;
-  search(query: string): Promise<SearchResult>;
-  undo(): Promise<UndoRedoResult>;
-  redo(): Promise<UndoRedoResult>;
   getHistory(): Promise<HistoryResult>;
-  setContextPins(nodeIds: string[], mode?: 'set' | 'add' | 'remove'): Promise<SetContextPinsResult>;
   getPinnedNodeIds(): Promise<string[]>;
   runBatch(operations: RunBatchInput): Promise<RunBatchResult>;
-  listSnapshots(options?: SnapshotListOptions): Promise<SnapshotList>;
-  saveSnapshot(name: string): Promise<CanvasSnapshot | null>;
-  restoreSnapshot(id: string): Promise<{ ok: boolean }>;
-  deleteSnapshot(id: string): Promise<DeleteSnapshotResult>;
-  gcSnapshots(options?: GcSnapshotsOptions): Promise<GcSnapshotsResult>;
-  diffSnapshot(idOrName: string): Promise<DiffSnapshotResult>;
   getCodeGraph(): Promise<CodeGraphResult>;
-  validate(): Promise<ValidationResult>;
+  // canvas_screenshot (still hand-written — binary payload) is the only webview
+  // tool left on CanvasAccess; it needs the status + screenshot accessors.
   getAutomationWebViewStatus(): Promise<AutomationWebViewStatus>;
-  startAutomationWebView(options?: AutomationWebViewOptions): Promise<AutomationWebViewStatus>;
-  stopAutomationWebView(): Promise<boolean>;
-  evaluateAutomationWebView(expression: string): Promise<AutomationEvaluateResult>;
-  resizeAutomationWebView(width: number, height: number): Promise<AutomationWebViewStatus>;
   screenshotAutomationWebView(options?: AutomationScreenshotOptions): Promise<Uint8Array>;
 }
 
 class LocalCanvasAccess implements CanvasAccess {
   readonly remoteBaseUrl = null;
+  private readonly operationInvoker = new LocalOperationInvoker();
 
   constructor(
     private readonly canvas: PmxCanvas,
@@ -232,6 +106,10 @@ class LocalCanvasAccess implements CanvasAccess {
     return this.canvas.port;
   }
 
+  invoker(): OperationInvoker {
+    return this.operationInvoker;
+  }
+
   async getLayout(): Promise<CanvasLayout> {
     return this.canvas.getLayout();
   }
@@ -240,36 +118,10 @@ class LocalCanvasAccess implements CanvasAccess {
     return this.canvas.getNode(id);
   }
 
-  async addNode(input: AddNodeInput): Promise<string> {
-    // PmxCanvas.addNode returns the created node; the CanvasAccess contract
-    // (shared with the remote proxy + MCP) stays id-only.
-    return this.canvas.addNode(input).id;
-  }
-
-  async addWebpageNode(input: AddWebpageNodeInput): Promise<Awaited<ReturnType<PmxCanvas['addWebpageNode']>>> {
-    return await this.canvas.addWebpageNode(input);
-  }
-
   async refreshWebpageNode(id: string, url?: string): Promise<RefreshWebpageNodeResult> {
     return await this.canvas.refreshWebpageNode(id, url);
   }
 
-  async openMcpApp(input: OpenMcpAppInput): Promise<OpenMcpAppResult> {
-    return await this.canvas.openMcpApp(input);
-  }
-
-  async addDiagram(input: AddDiagramInput): Promise<OpenMcpAppResult> {
-    return await this.canvas.addDiagram(input);
-  }
-
-  async addJsonRenderNode(input: AddJsonRenderNodeInput): Promise<AddJsonRenderNodeResult> {
-    return this.canvas.addJsonRenderNode(input);
-  }
-
-  async streamJsonRenderNode(input: StreamJsonRenderNodeInput): Promise<StreamJsonRenderNodeResult> {
-    return this.canvas.streamJsonRenderNode(input);
-  }
-
   async addHtmlNode(input: AddHtmlNodeInput): Promise<string> {
     // PmxCanvas.addHtmlNode returns the created node; the CanvasAccess contract
     // is a bare id string, so extract it (mirrors addNode above).
@@ -280,86 +132,18 @@ class LocalCanvasAccess implements CanvasAccess {
     return this.canvas.addHtmlPrimitive(input);
   }
 
-  async addGraphNode(input: AddGraphNodeInput): Promise<AddGraphNodeResult> {
-    return this.canvas.addGraphNode(input);
-  }
-
-  async buildWebArtifact(input: WebArtifactInput): Promise<WebArtifactResult> {
-    return await this.canvas.buildWebArtifact(input);
-  }
-
-  async updateNode(id: string, patch: UpdateNodePatch): Promise<void> {
-    this.canvas.updateNode(id, patch);
-  }
-
-  async removeNode(id: string): Promise<void> {
-    this.canvas.removeNode(id);
-  }
-
-  async removeAnnotation(id: string): Promise<boolean> {
-    return this.canvas.removeAnnotation(id);
-  }
-
-  async addEdge(input: AddEdgeInput): Promise<string> {
-    return this.canvas.addEdge(input);
-  }
-
-  async removeEdge(id: string): Promise<void> {
-    this.canvas.removeEdge(id);
-  }
-
-  async createGroup(input: CreateGroupInput): Promise<string> {
-    return this.canvas.createGroup(input);
-  }
-
-  async groupNodes(groupId: string, childIds: string[], options?: GroupNodesOptions): Promise<boolean> {
-    return this.canvas.groupNodes(groupId, childIds, options);
-  }
-
-  async ungroupNodes(groupId: string): Promise<boolean> {
-    return this.canvas.ungroupNodes(groupId);
-  }
-
-  async arrange(layout?: ArrangeLayout): Promise<void> {
-    this.canvas.arrange(layout);
-  }
-
-  async focusNode(id: string, options?: { noPan?: boolean }): Promise<FocusNodeResult> {
-    return this.canvas.focusNode(id, options);
-  }
-
-  async fitView(options?: FitViewOptions): Promise<FitViewResult> {
-    return this.canvas.fitView(options);
-  }
-
   async getAxState(): Promise<AxStateResult> {
     return this.canvas.getAxState();
   }
 
-  async getAxContext(): Promise<AxContextResult> {
-    return this.canvas.getAxContext();
-  }
-
-  async setAxFocus(nodeIds: string[], options?: { source?: PmxAxSource }): Promise<SetAxFocusResult> {
-    return this.canvas.setAxFocus(nodeIds, { source: options?.source ?? 'mcp' });
-  }
-
-  async recordAxEvent(input: RecordAxEventInput, options?: { source?: PmxAxSource }): Promise<RecordAxEventResult> {
-    return this.canvas.recordAxEvent(input, { source: options?.source ?? 'mcp' });
-  }
-
-  async sendSteering(message: string, options?: { source?: PmxAxSource }): Promise<SendSteeringResult> {
-    return this.canvas.sendSteering(message, { source: options?.source ?? 'mcp' });
+  async getAxContext(options?: { consumer?: string }): Promise<AxContextResult> {
+    return this.canvas.getAxContext(options);
   }
 
   async getAxTimeline(query?: GetAxTimelineQuery): Promise<GetAxTimelineResult> {
     return this.canvas.getAxTimeline(query);
   }
 
-  async addWorkItem(input: AddWorkItemInput, options?: { source?: PmxAxSource }): Promise<AddWorkItemResult> {
-    return this.canvas.addWorkItem(input, { source: options?.source ?? 'mcp' });
-  }
-
   async submitAxInteraction(input: SubmitAxInteractionInput, options?: { source?: PmxAxSource }): Promise<SubmitAxInteractionResult> {
     return this.canvas.submitAxInteraction(input, { source: options?.source ?? 'mcp' });
   }
@@ -368,121 +152,38 @@ class LocalCanvasAccess implements CanvasAccess {
     return this.canvas.getPendingSteering(options);
   }
 
-  async markSteeringDelivered(id: string): Promise<boolean> {
-    return this.canvas.markSteeringDelivered(id);
-  }
-
   async listElicitations(): Promise<ListElicitationsResult> {
     return this.canvas.listElicitations();
   }
 
-  async requestElicitation(input: RequestElicitationInput, options?: { source?: PmxAxSource }): Promise<RequestElicitationResult> {
-    return this.canvas.requestElicitation(input, { source: options?.source ?? 'mcp' });
-  }
-
-  async respondElicitation(id: string, response: Record<string, unknown>, options?: { source?: PmxAxSource }): Promise<RespondElicitationResult> {
-    return this.canvas.respondElicitation(id, response, { source: options?.source ?? 'mcp' });
-  }
-
   async listModeRequests(): Promise<ListModeRequestsResult> {
     return this.canvas.listModeRequests();
   }
 
-  async requestMode(input: RequestModeInput, options?: { source?: PmxAxSource }): Promise<RequestModeResult> {
-    return this.canvas.requestMode(input, { source: options?.source ?? 'mcp' });
-  }
-
-  async resolveModeRequest(id: string, decision: 'approved' | 'rejected', options?: { resolution?: string; source?: PmxAxSource }): Promise<ResolveModeRequestResult> {
-    return this.canvas.resolveModeRequest(id, decision, { ...(options ?? {}), source: options?.source ?? 'mcp' });
-  }
-
-  async getCommandRegistry(): Promise<GetCommandRegistryResult> {
-    return this.canvas.getCommandRegistry();
-  }
-
-  async invokeCommand(name: string, args?: Record<string, unknown> | null, options?: { source?: PmxAxSource }): Promise<InvokeCommandResult> {
-    return this.canvas.invokeCommand(name, args ?? null, { source: options?.source ?? 'mcp' });
+  async ingestActivity(input: IngestActivityInput, options?: { source?: PmxAxSource }): Promise<IngestActivityResult> {
+    return this.canvas.ingestActivity(input, { source: options?.source ?? 'mcp' });
   }
 
   async getPolicy(): Promise<GetPolicyResult> {
     return this.canvas.getPolicy();
   }
 
-  async setPolicy(patch: SetPolicyInput, options?: { source?: PmxAxSource }): Promise<SetPolicyResult> {
-    return this.canvas.setPolicy(patch, { source: options?.source ?? 'mcp' });
-  }
-
-  async updateWorkItem(id: string, patch: UpdateWorkItemPatch, options?: { source?: PmxAxSource }): Promise<UpdateWorkItemResult> {
-    return this.canvas.updateWorkItem(id, patch, { source: options?.source ?? 'mcp' });
-  }
-
   async listWorkItems(): Promise<ListWorkItemsResult> {
     return this.canvas.listWorkItems();
   }
 
-  async requestApproval(input: RequestApprovalInput, options?: { source?: PmxAxSource }): Promise<RequestApprovalResult> {
-    return this.canvas.requestApproval(input, { source: options?.source ?? 'mcp' });
-  }
-
-  async resolveApproval(id: string, decision: 'approved' | 'rejected', options?: { resolution?: string; source?: PmxAxSource }): Promise<ResolveApprovalResult> {
-    return this.canvas.resolveApproval(id, decision, {
-      ...(options?.resolution !== undefined ? { resolution: options.resolution } : {}),
-      source: options?.source ?? 'mcp',
-    });
-  }
-
   async listApprovalGates(): Promise<ListApprovalGatesResult> {
     return this.canvas.listApprovalGates();
   }
 
-  async addEvidence(input: AddEvidenceInput, options?: { source?: PmxAxSource }): Promise<AddEvidenceResult> {
-    return this.canvas.addEvidence(input, { source: options?.source ?? 'mcp' });
-  }
-
-  async addReviewAnnotation(input: AddReviewAnnotationInput, options?: { source?: PmxAxSource }): Promise<AddReviewAnnotationResult> {
-    return this.canvas.addReviewAnnotation(input, { source: options?.source ?? 'mcp' });
-  }
-
-  async updateReviewAnnotation(id: string, patch: UpdateReviewAnnotationPatch, options?: { source?: PmxAxSource }): Promise<UpdateReviewAnnotationResult> {
-    return this.canvas.updateReviewAnnotation(id, patch, { source: options?.source ?? 'mcp' });
-  }
-
   async listReviewAnnotations(): Promise<ListReviewAnnotationsResult> {
     return this.canvas.listReviewAnnotations();
   }
 
-  async getHostCapability(): Promise<GetHostCapabilityResult> {
-    return this.canvas.getHostCapability();
-  }
-
-  async reportHostCapability(input: unknown, options?: { source?: PmxAxSource }): Promise<ReportHostCapabilityResult> {
-    return this.canvas.reportHostCapability(input, { source: options?.source ?? 'mcp' });
-  }
-
-  async clear(): Promise<void> {
-    this.canvas.clear();
-  }
-
-  async search(query: string): Promise<SearchResult> {
-    return this.canvas.search(query);
-  }
-
-  async undo(): Promise<UndoRedoResult> {
-    return await this.canvas.undo();
-  }
-
-  async redo(): Promise<UndoRedoResult> {
-    return await this.canvas.redo();
-  }
-
   async getHistory(): Promise<HistoryResult> {
     return this.canvas.getHistory();
   }
 
-  async setContextPins(nodeIds: string[], mode: 'set' | 'add' | 'remove' = 'set'): Promise<SetContextPinsResult> {
-    return this.canvas.setContextPins(nodeIds, mode);
-  }
-
   async getPinnedNodeIds(): Promise<string[]> {
     return Array.from(canvasState.contextPinnedNodeIds);
   }
@@ -491,58 +192,14 @@ class LocalCanvasAccess implements CanvasAccess {
     return await this.canvas.runBatch(operations);
   }
 
-  async listSnapshots(options?: SnapshotListOptions): Promise<SnapshotList> {
-    return this.canvas.listSnapshots(options);
-  }
-
-  async saveSnapshot(name: string): Promise<CanvasSnapshot | null> {
-    return this.canvas.saveSnapshot(name);
-  }
-
-  async restoreSnapshot(id: string): Promise<{ ok: boolean }> {
-    return await this.canvas.restoreSnapshot(id);
-  }
-
-  async deleteSnapshot(id: string): Promise<DeleteSnapshotResult> {
-    return this.canvas.deleteSnapshot(id);
-  }
-
-  async gcSnapshots(options?: GcSnapshotsOptions): Promise<GcSnapshotsResult> {
-    return this.canvas.gcSnapshots(options);
-  }
-
-  async diffSnapshot(idOrName: string): Promise<DiffSnapshotResult> {
-    return this.canvas.diffSnapshot(idOrName);
-  }
-
   async getCodeGraph(): Promise<CodeGraphResult> {
     return this.canvas.getCodeGraph();
   }
 
-  async validate(): Promise<ValidationResult> {
-    return this.canvas.validate();
-  }
-
   async getAutomationWebViewStatus(): Promise<AutomationWebViewStatus> {
     return this.canvas.getAutomationWebViewStatus();
   }
 
-  async startAutomationWebView(options: AutomationWebViewOptions = {}): Promise<AutomationWebViewStatus> {
-    return await this.canvas.startAutomationWebView(options);
-  }
-
-  async stopAutomationWebView(): Promise<boolean> {
-    return await this.canvas.stopAutomationWebView();
-  }
-
-  async evaluateAutomationWebView(expression: string): Promise<AutomationEvaluateResult> {
-    return await this.canvas.evaluateAutomationWebView(expression);
-  }
-
-  async resizeAutomationWebView(width: number, height: number): Promise<AutomationWebViewStatus> {
-    return await this.canvas.resizeAutomationWebView(width, height);
-  }
-
   async screenshotAutomationWebView(options: AutomationScreenshotOptions = {}): Promise<Uint8Array> {
     return await this.canvas.screenshotAutomationWebView(options);
   }
@@ -551,11 +208,17 @@ class LocalCanvasAccess implements CanvasAccess {
 class RemoteCanvasAccess implements CanvasAccess {
   readonly remoteBaseUrl: string;
   readonly port: number;
+  private readonly operationInvoker: HttpOperationInvoker;
 
   constructor(baseUrl: string) {
     this.remoteBaseUrl = baseUrl.replace(/\/$/, '');
     const parsed = new URL(this.remoteBaseUrl);
     this.port = Number(parsed.port || '80');
+    this.operationInvoker = new HttpOperationInvoker(this.remoteBaseUrl);
+  }
+
+  invoker(): OperationInvoker {
+    return this.operationInvoker;
   }
 
   private async requestJson<T>(method: string, path: string, body?: unknown): Promise<T> {
@@ -621,61 +284,12 @@ class RemoteCanvasAccess implements CanvasAccess {
     return parsed as CanvasNodeState;
   }
 
-  async addNode(input: AddNodeInput): Promise<string> {
-    return await this.requestNodeId('POST', '/api/canvas/node', input);
-  }
-
-  async addWebpageNode(input: AddWebpageNodeInput): Promise<Awaited<ReturnType<PmxCanvas['addWebpageNode']>>> {
-    return await this.requestJson<Awaited<ReturnType<PmxCanvas['addWebpageNode']>>>('POST', '/api/canvas/node', {
-      type: 'webpage',
-      ...input,
-    });
-  }
-
   async refreshWebpageNode(id: string, url?: string): Promise<RefreshWebpageNodeResult> {
     return await this.requestJson<RefreshWebpageNodeResult>('POST', `/api/canvas/node/${encodeURIComponent(id)}/refresh`, {
       ...(url ? { url } : {}),
     });
   }
 
-  async openMcpApp(input: OpenMcpAppInput): Promise<OpenMcpAppResult> {
-    return await this.requestJson<OpenMcpAppResult>('POST', '/api/canvas/mcp-app/open', input);
-  }
-
-  async addDiagram(input: AddDiagramInput): Promise<OpenMcpAppResult> {
-    return await this.requestJson<OpenMcpAppResult>('POST', '/api/canvas/diagram', input);
-  }
-
-  async addJsonRenderNode(input: AddJsonRenderNodeInput): Promise<AddJsonRenderNodeResult> {
-    const response = await this.requestJson<JsonRenderNodeResponse>('POST', '/api/canvas/json-render', input);
-    const id = typeof response.id === 'string' ? response.id : response.node?.id;
-    if (!id) throw new Error('json-render response did not include a node id.');
-    return { id, url: response.url, spec: response.spec };
-  }
-
-  async streamJsonRenderNode(input: StreamJsonRenderNodeInput): Promise<StreamJsonRenderNodeResult> {
-    const response = await this.requestJson<{
-      id?: string;
-      url?: string;
-      applied?: number;
-      skipped?: number;
-      specVersion?: number;
-      elementCount?: number;
-      streamStatus?: 'open' | 'closed';
-    }>('POST', '/api/canvas/json-render/stream', input);
-    const id = typeof response.id === 'string' ? response.id : undefined;
-    if (!id) throw new Error('json-render stream response did not include a node id.');
-    return {
-      id,
-      url: response.url ?? '',
-      applied: response.applied ?? 0,
-      skipped: response.skipped ?? 0,
-      specVersion: response.specVersion ?? 0,
-      elementCount: response.elementCount ?? 0,
-      streamStatus: response.streamStatus ?? 'open',
-    };
-  }
-
   async addHtmlNode(input: AddHtmlNodeInput): Promise<string> {
     const {
       summary,
@@ -729,98 +343,6 @@ class RemoteCanvasAccess implements CanvasAccess {
     };
   }
 
-  async addGraphNode(input: AddGraphNodeInput): Promise<AddGraphNodeResult> {
-    const response = await this.requestJson<GraphNodeResponse>('POST', '/api/canvas/graph', {
-      ...input,
-      ...(typeof input.heightPx === 'number' ? { nodeHeight: input.heightPx } : {}),
-    });
-    const id = typeof response.id === 'string' ? response.id : response.node?.id;
-    if (!id) throw new Error('graph response did not include a node id.');
-    return { id, url: response.url, spec: response.spec };
-  }
-
-  async buildWebArtifact(input: WebArtifactInput): Promise<WebArtifactResult> {
-    return await this.requestJson<WebArtifactResult>('POST', '/api/canvas/web-artifact', input);
-  }
-
-  async updateNode(id: string, patch: UpdateNodePatch): Promise<void> {
-    await this.requestJson<unknown>('PATCH', `/api/canvas/node/${encodeURIComponent(id)}`, patch);
-  }
-
-  async removeNode(id: string): Promise<void> {
-    await this.requestJson<unknown>('DELETE', `/api/canvas/node/${encodeURIComponent(id)}`);
-  }
-
-  async removeAnnotation(id: string): Promise<boolean> {
-    const response = await this.requestJson<{ ok?: boolean }>('DELETE', `/api/canvas/annotation/${encodeURIComponent(id)}`);
-    return response.ok === true;
-  }
-
-  async addEdge(input: AddEdgeInput): Promise<string> {
-    const response = await this.requestJson<{ id?: string }>('POST', '/api/canvas/edge', input);
-    if (!response.id) throw new Error('Canvas edge response did not include an edge id.');
-    return response.id;
-  }
-
-  async removeEdge(id: string): Promise<void> {
-    await this.requestJson<unknown>('DELETE', '/api/canvas/edge', { edge_id: id });
-  }
-
-  async createGroup(input: CreateGroupInput): Promise<string> {
-    return await this.requestNodeId('POST', '/api/canvas/group', input);
-  }
-
-  async groupNodes(groupId: string, childIds: string[], options?: GroupNodesOptions): Promise<boolean> {
-    const response = await this.requestJson<{ ok?: boolean }>('POST', '/api/canvas/group/add', {
-      groupId,
-      childIds,
-      ...(options?.childLayout ? { childLayout: options.childLayout } : {}),
-    });
-    return response.ok === true;
-  }
-
-  async ungroupNodes(groupId: string): Promise<boolean> {
-    const response = await this.requestJson<{ ok?: boolean }>('POST', '/api/canvas/group/ungroup', { groupId });
-    return response.ok === true;
-  }
-
-  async arrange(layout?: ArrangeLayout): Promise<void> {
-    await this.requestJson<unknown>('POST', '/api/canvas/arrange', { ...(layout ? { layout } : {}) });
-  }
-
-  async focusNode(id: string, options?: { noPan?: boolean }): Promise<FocusNodeResult> {
-    const response = await fetch(`${this.remoteBaseUrl}/api/canvas/focus`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ id, ...(options?.noPan === true ? { noPan: true } : {}) }),
-    });
-    if (response.status === 404) return null;
-    const parsed = await response.json() as { focused?: string; panned?: boolean };
-    if (!response.ok || typeof parsed.focused !== 'string' || typeof parsed.panned !== 'boolean') return null;
-    return { focused: parsed.focused, panned: parsed.panned };
-  }
-
-  async fitView(options?: FitViewOptions): Promise<FitViewResult> {
-    return await this.requestJson<FitViewResult>('POST', '/api/canvas/fit', options ?? {});
-  }
-
-  async clear(): Promise<void> {
-    await this.requestJson<unknown>('POST', '/api/canvas/clear', {});
-  }
-
-  async search(query: string): Promise<SearchResult> {
-    const response = await this.requestJson<SearchResponse>('GET', `/api/canvas/search?q=${encodeURIComponent(query)}`);
-    return response.results ?? [];
-  }
-
-  async undo(): Promise<UndoRedoResult> {
-    return await this.requestJson<UndoRedoResult>('POST', '/api/canvas/undo', {});
-  }
-
-  async redo(): Promise<UndoRedoResult> {
-    return await this.requestJson<UndoRedoResult>('POST', '/api/canvas/redo', {});
-  }
-
   async getHistory(): Promise<HistoryResult> {
     return await this.requestJson<HistoryResult>('GET', '/api/canvas/history');
   }
@@ -831,35 +353,9 @@ class RemoteCanvasAccess implements CanvasAccess {
     return response.state;
   }
 
-  async getAxContext(): Promise<AxContextResult> {
-    return await this.requestJson<AxContextResult>('GET', '/api/canvas/ax/context');
-  }
-
-  async setAxFocus(nodeIds: string[], options?: { source?: PmxAxSource }): Promise<SetAxFocusResult> {
-    const response = await this.requestJson<{ focus?: SetAxFocusResult }>('POST', '/api/canvas/ax/focus', {
-      nodeIds,
-      source: options?.source ?? 'mcp',
-    });
-    if (!response.focus) throw new Error('Remote canvas did not return AX focus.');
-    return response.focus;
-  }
-
-  async recordAxEvent(input: RecordAxEventInput, options?: { source?: PmxAxSource }): Promise<RecordAxEventResult> {
-    const response = await this.requestJson<{ event?: RecordAxEventResult }>('POST', '/api/canvas/ax/event', {
-      ...input,
-      source: options?.source ?? 'mcp',
-    });
-    if (!response.event) throw new Error('Remote canvas did not return an AX event.');
-    return response.event;
-  }
-
-  async sendSteering(message: string, options?: { source?: PmxAxSource }): Promise<SendSteeringResult> {
-    const response = await this.requestJson<{ steering?: SendSteeringResult }>('POST', '/api/canvas/ax/steer', {
-      message,
-      source: options?.source ?? 'mcp',
-    });
-    if (!response.steering) throw new Error('Remote canvas did not return a steering message.');
-    return response.steering;
+  async getAxContext(options?: { consumer?: string }): Promise<AxContextResult> {
+    const qs = options?.consumer ? `?consumer=${encodeURIComponent(options.consumer)}` : '';
+    return await this.requestJson<AxContextResult>('GET', `/api/canvas/ax/context${qs}`);
   }
 
   async getAxTimeline(query?: GetAxTimelineQuery): Promise<GetAxTimelineResult> {
@@ -867,15 +363,6 @@ class RemoteCanvasAccess implements CanvasAccess {
     return await this.requestJson<GetAxTimelineResult>('GET', `/api/canvas/ax/timeline${qs}`);
   }
 
-  async addWorkItem(input: AddWorkItemInput, options?: { source?: PmxAxSource }): Promise<AddWorkItemResult> {
-    const response = await this.requestJson<{ workItem?: AddWorkItemResult }>('POST', '/api/canvas/ax/work', {
-      ...input,
-      source: options?.source ?? 'mcp',
-    });
-    if (!response.workItem) throw new Error('Remote canvas did not return a work item.');
-    return response.workItem;
-  }
-
   async submitAxInteraction(input: SubmitAxInteractionInput, options?: { source?: PmxAxSource }): Promise<SubmitAxInteractionResult> {
     // The interaction endpoint returns its structured outcome (ok/code/error) in
     // the body for both accepted and rejected interactions, so read the body
@@ -902,77 +389,21 @@ class RemoteCanvasAccess implements CanvasAccess {
     return response.pending ?? [];
   }
 
-  async markSteeringDelivered(id: string): Promise<boolean> {
-    const response = await this.requestJson<{ delivered?: boolean }>(
-      'POST',
-      `/api/canvas/ax/delivery/${encodeURIComponent(id)}/mark`,
-      {},
-    );
-    return response.delivered ?? false;
-  }
-
   async listElicitations(): Promise<ListElicitationsResult> {
     const r = await this.requestJson<{ elicitations?: ListElicitationsResult }>('GET', '/api/canvas/ax/elicitation');
     return r.elicitations ?? [];
   }
 
-  async requestElicitation(input: RequestElicitationInput, options?: { source?: PmxAxSource }): Promise<RequestElicitationResult> {
-    const r = await this.requestJson<{ elicitation?: RequestElicitationResult }>('POST', '/api/canvas/ax/elicitation', {
-      ...input,
-      source: options?.source ?? 'mcp',
-    });
-    if (!r.elicitation) throw new Error('Remote canvas did not return an elicitation.');
-    return r.elicitation;
-  }
-
-  async respondElicitation(id: string, response: Record<string, unknown>, options?: { source?: PmxAxSource }): Promise<RespondElicitationResult> {
-    const res = await fetch(`${this.remoteBaseUrl}/api/canvas/ax/elicitation/${encodeURIComponent(id)}/respond`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ response, source: options?.source ?? 'mcp' }),
-    });
-    if (res.status === 404) return null;
-    if (!res.ok) throw new Error(`HTTP ${res.status}`);
-    return (await res.json() as { elicitation?: RespondElicitationResult }).elicitation ?? null;
-  }
-
   async listModeRequests(): Promise<ListModeRequestsResult> {
     const r = await this.requestJson<{ modeRequests?: ListModeRequestsResult }>('GET', '/api/canvas/ax/mode');
     return r.modeRequests ?? [];
   }
 
-  async requestMode(input: RequestModeInput, options?: { source?: PmxAxSource }): Promise<RequestModeResult> {
-    const r = await this.requestJson<{ modeRequest?: RequestModeResult }>('POST', '/api/canvas/ax/mode', {
+  async ingestActivity(input: IngestActivityInput, options?: { source?: PmxAxSource }): Promise<IngestActivityResult> {
+    return await this.requestJson<IngestActivityResult>('POST', '/api/canvas/ax/activity', {
       ...input,
       source: options?.source ?? 'mcp',
     });
-    if (!r.modeRequest) throw new Error('Remote canvas did not return a mode request.');
-    return r.modeRequest;
-  }
-
-  async resolveModeRequest(id: string, decision: 'approved' | 'rejected', options?: { resolution?: string; source?: PmxAxSource }): Promise<ResolveModeRequestResult> {
-    const res = await fetch(`${this.remoteBaseUrl}/api/canvas/ax/mode/${encodeURIComponent(id)}/resolve`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ decision, ...(options?.resolution ? { resolution: options.resolution } : {}), source: options?.source ?? 'mcp' }),
-    });
-    if (res.status === 404) return null;
-    if (!res.ok) throw new Error(`HTTP ${res.status}`);
-    return (await res.json() as { modeRequest?: ResolveModeRequestResult }).modeRequest ?? null;
-  }
-
-  async getCommandRegistry(): Promise<GetCommandRegistryResult> {
-    const r = await this.requestJson<{ commands?: GetCommandRegistryResult }>('GET', '/api/canvas/ax/command');
-    return r.commands ?? [];
-  }
-
-  async invokeCommand(name: string, args?: Record<string, unknown> | null, options?: { source?: PmxAxSource }): Promise<InvokeCommandResult> {
-    const r = await this.requestJson<{ event?: InvokeCommandResult }>('POST', '/api/canvas/ax/command', {
-      name,
-      ...(args ? { args } : {}),
-      source: options?.source ?? 'mcp',
-    });
-    return r.event ?? null;
   }
 
   async getPolicy(): Promise<GetPolicyResult> {
@@ -981,125 +412,21 @@ class RemoteCanvasAccess implements CanvasAccess {
     return r.policy;
   }
 
-  async setPolicy(patch: SetPolicyInput, options?: { source?: PmxAxSource }): Promise<SetPolicyResult> {
-    const r = await this.requestJson<{ policy?: SetPolicyResult }>('POST', '/api/canvas/ax/policy', {
-      ...patch,
-      source: options?.source ?? 'mcp',
-    });
-    if (!r.policy) throw new Error('Remote canvas did not return a policy.');
-    return r.policy;
-  }
-
-  async updateWorkItem(id: string, patch: UpdateWorkItemPatch, options?: { source?: PmxAxSource }): Promise<UpdateWorkItemResult> {
-    const response = await fetch(`${this.remoteBaseUrl}/api/canvas/ax/work/${encodeURIComponent(id)}`, {
-      method: 'PATCH',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ ...patch, source: options?.source ?? 'mcp' }),
-    });
-    if (response.status === 404) return null;
-    if (!response.ok) throw new Error(`HTTP ${response.status}`);
-    return (await response.json() as { workItem?: AddWorkItemResult }).workItem ?? null;
-  }
-
   async listWorkItems(): Promise<ListWorkItemsResult> {
     const response = await this.requestJson<{ workItems?: ListWorkItemsResult }>('GET', '/api/canvas/ax/work');
     return response.workItems ?? [];
   }
 
-  async requestApproval(input: RequestApprovalInput, options?: { source?: PmxAxSource }): Promise<RequestApprovalResult> {
-    const response = await this.requestJson<{ approvalGate?: RequestApprovalResult }>('POST', '/api/canvas/ax/approval', {
-      ...input,
-      source: options?.source ?? 'mcp',
-    });
-    if (!response.approvalGate) throw new Error('Remote canvas did not return an approval gate.');
-    return response.approvalGate;
-  }
-
-  async resolveApproval(id: string, decision: 'approved' | 'rejected', options?: { resolution?: string; source?: PmxAxSource }): Promise<ResolveApprovalResult> {
-    const response = await fetch(`${this.remoteBaseUrl}/api/canvas/ax/approval/${encodeURIComponent(id)}/resolve`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        decision,
-        ...(options?.resolution !== undefined ? { resolution: options.resolution } : {}),
-        source: options?.source ?? 'mcp',
-      }),
-    });
-    if (response.status === 404) return null;
-    if (!response.ok) throw new Error(`HTTP ${response.status}`);
-    return (await response.json() as { approvalGate?: RequestApprovalResult }).approvalGate ?? null;
-  }
-
   async listApprovalGates(): Promise<ListApprovalGatesResult> {
     const response = await this.requestJson<{ approvalGates?: ListApprovalGatesResult }>('GET', '/api/canvas/ax/approval');
     return response.approvalGates ?? [];
   }
 
-  async addEvidence(input: AddEvidenceInput, options?: { source?: PmxAxSource }): Promise<AddEvidenceResult> {
-    const response = await this.requestJson<{ evidence?: AddEvidenceResult }>('POST', '/api/canvas/ax/evidence', {
-      ...input,
-      source: options?.source ?? 'mcp',
-    });
-    if (!response.evidence) throw new Error('Remote canvas did not return an evidence item.');
-    return response.evidence;
-  }
-
-  async addReviewAnnotation(input: AddReviewAnnotationInput, options?: { source?: PmxAxSource }): Promise<AddReviewAnnotationResult> {
-    const response = await fetch(`${this.remoteBaseUrl}/api/canvas/ax/review`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ ...input, source: options?.source ?? 'mcp' }),
-    });
-    // 400 = validation rejection (e.g. node-anchored review with an unknown
-    // nodeId); mirror the local path and return null rather than throwing.
-    if (response.status === 400) return null;
-    if (!response.ok) throw new Error(`HTTP ${response.status}`);
-    return (await response.json() as { reviewAnnotation?: AddReviewAnnotationResult }).reviewAnnotation ?? null;
-  }
-
-  async updateReviewAnnotation(id: string, patch: UpdateReviewAnnotationPatch, options?: { source?: PmxAxSource }): Promise<UpdateReviewAnnotationResult> {
-    const response = await fetch(`${this.remoteBaseUrl}/api/canvas/ax/review/${encodeURIComponent(id)}`, {
-      method: 'PATCH',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ ...patch, source: options?.source ?? 'mcp' }),
-    });
-    if (response.status === 404) return null;
-    if (!response.ok) throw new Error(`HTTP ${response.status}`);
-    return (await response.json() as { reviewAnnotation?: AddReviewAnnotationResult }).reviewAnnotation ?? null;
-  }
-
   async listReviewAnnotations(): Promise<ListReviewAnnotationsResult> {
     const response = await this.requestJson<{ reviewAnnotations?: ListReviewAnnotationsResult }>('GET', '/api/canvas/ax/review');
     return response.reviewAnnotations ?? [];
   }
 
-  async getHostCapability(): Promise<GetHostCapabilityResult> {
-    const response = await this.requestJson<{ host?: GetHostCapabilityResult }>('GET', '/api/canvas/ax/host-capability');
-    return response.host ?? null;
-  }
-
-  async reportHostCapability(input: unknown, options?: { source?: PmxAxSource }): Promise<ReportHostCapabilityResult> {
-    const body = input !== null && typeof input === 'object' && !Array.isArray(input) ? { ...input } : {};
-    const response = await this.requestJson<{ host?: ReportHostCapabilityResult }>('PUT', '/api/canvas/ax/host-capability', {
-      ...body,
-      source: options?.source ?? 'mcp',
-    });
-    if (!response.host) throw new Error('Remote canvas did not return host capability.');
-    return response.host;
-  }
-
-  async setContextPins(nodeIds: string[], mode: 'set' | 'add' | 'remove' = 'set'): Promise<SetContextPinsResult> {
-    const existing = mode === 'set' ? [] : await this.getPinnedNodeIds();
-    const requested = new Set(nodeIds);
-    const next = mode === 'set'
-      ? nodeIds
-      : mode === 'add'
-        ? [...new Set([...existing, ...nodeIds])]
-        : existing.filter((id) => !requested.has(id));
-    const response = await this.requestJson<{ count?: number }>('POST', '/api/canvas/context-pins', { nodeIds: next });
-    return { count: response.count ?? next.length, nodeIds: next };
-  }
-
   async getPinnedNodeIds(): Promise<string[]> {
     const response = await this.requestJson<{ nodeIds?: string[] }>('GET', '/api/canvas/pinned-context');
     return Array.isArray(response.nodeIds) ? response.nodeIds : [];
@@ -1109,73 +436,15 @@ class RemoteCanvasAccess implements CanvasAccess {
     return await this.requestJson<RunBatchResult>('POST', '/api/canvas/batch', { operations });
   }
 
-  async listSnapshots(options?: SnapshotListOptions): Promise<SnapshotList> {
-    const params = new URLSearchParams();
-    if (typeof options?.limit === 'number') params.set('limit', String(options.limit));
-    if (options?.query) params.set('q', options.query);
-    if (options?.before) params.set('before', options.before);
-    if (options?.after) params.set('after', options.after);
-    if (options?.all) params.set('all', 'true');
-    const query = params.size > 0 ? `?${params.toString()}` : '';
-    return await this.requestJson<SnapshotList>('GET', `/api/canvas/snapshots${query}`);
-  }
-
-  async saveSnapshot(name: string): Promise<CanvasSnapshot | null> {
-    const response = await this.requestJson<SnapshotSaveResponse>('POST', '/api/canvas/snapshots', { name });
-    return response.snapshot ?? null;
-  }
-
-  async restoreSnapshot(id: string): Promise<{ ok: boolean }> {
-    return await this.requestJson<{ ok: boolean }>('POST', `/api/canvas/snapshots/${encodeURIComponent(id)}`, {});
-  }
-
-  async deleteSnapshot(id: string): Promise<DeleteSnapshotResult> {
-    return await this.requestJson<DeleteSnapshotResult>('DELETE', `/api/canvas/snapshots/${encodeURIComponent(id)}`);
-  }
-
-  async gcSnapshots(options?: GcSnapshotsOptions): Promise<GcSnapshotsResult> {
-    return await this.requestJson<GcSnapshotsResult>('POST', '/api/canvas/snapshots/gc', options ?? {});
-  }
-
-  async diffSnapshot(idOrName: string): Promise<DiffSnapshotResult> {
-    return await this.requestJson<DiffSnapshotResult>('GET', `/api/canvas/snapshots/${encodeURIComponent(idOrName)}/diff`);
-  }
-
   async getCodeGraph(): Promise<CodeGraphResult> {
     const summary = await this.requestJson<CodeGraphResult['summary']>('GET', '/api/canvas/code-graph');
     return { text: JSON.stringify(summary, null, 2), summary };
   }
 
-  async validate(): Promise<ValidationResult> {
-    return await this.requestJson<ValidationResult>('GET', '/api/canvas/validate');
-  }
-
   async getAutomationWebViewStatus(): Promise<AutomationWebViewStatus> {
     return await this.requestJson<AutomationWebViewStatus>('GET', '/api/workbench/webview');
   }
 
-  async startAutomationWebView(options: AutomationWebViewOptions = {}): Promise<AutomationWebViewStatus> {
-    const response = await this.requestJson<WebViewEnvelope>('POST', '/api/workbench/webview/start', options);
-    if (!response.webview) throw new Error('WebView start response did not include status.');
-    return response.webview;
-  }
-
-  async stopAutomationWebView(): Promise<boolean> {
-    const response = await this.requestJson<WebViewStopEnvelope>('DELETE', '/api/workbench/webview');
-    return response.stopped === true;
-  }
-
-  async evaluateAutomationWebView(expression: string): Promise<AutomationEvaluateResult> {
-    const response = await this.requestJson<WebViewEvaluateEnvelope>('POST', '/api/workbench/webview/evaluate', { expression });
-    return response.value as AutomationEvaluateResult;
-  }
-
-  async resizeAutomationWebView(width: number, height: number): Promise<AutomationWebViewStatus> {
-    const response = await this.requestJson<WebViewEnvelope>('POST', '/api/workbench/webview/resize', { width, height });
-    if (!response.webview) throw new Error('WebView resize response did not include status.');
-    return response.webview;
-  }
-
   async screenshotAutomationWebView(options: AutomationScreenshotOptions = {}): Promise<Uint8Array> {
     const response = await fetch(`${this.remoteBaseUrl}/api/workbench/webview/screenshot`, {
       method: 'POST',