pmx-canvas 0.1.35 → 0.2.0

package/dist/types/client/nodes/ExtAppFrame.d.ts

@@ -16,6 +16,8 @@ export declare function resolveExtAppDisplayModeRequest(requestedMode: DisplayMo
 };
 export declare function sendExtAppBootstrapState(bridge: ExtAppBridgeNotifications, toolInput: Record<string, unknown>, toolResult: CallToolResult | undefined): Promise<void>;
 export declare function resolveExtAppSandbox(value: unknown): string;
+export declare function buildExtAppAxBridgeScript(axToken: string, nodeId: string): string;
+export declare function injectExtAppAxBridgeScript(html: string, axBridgeScript: string): string;
 export declare function resolveExtAppContainerDimensions(target: ExtAppHostDimensionsTarget | null | undefined, fallback: {
     width: number;
     height: number;

package/dist/types/mcp/canvas-access.d.ts

@@ -1,160 +1,49 @@
-import { type CanvasLayout, type CanvasNodeState, type CanvasSnapshot, type PmxCanvas } from '../server/index.js';
+import { type CanvasLayout, type CanvasNodeState, type PmxCanvas } from '../server/index.js';
 import type { PmxAxSource } from '../server/ax-state.js';
-type AddNodeInput = Parameters<PmxCanvas['addNode']>[0];
-type AddWebpageNodeInput = Parameters<PmxCanvas['addWebpageNode']>[0];
+import { type OperationInvoker } from '../server/operations/index.js';
 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']>;
 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']>>;
+type AutomationWebViewStatus = Awaited<ReturnType<PmxCanvas['getAutomationWebViewStatus']>>;
 type AutomationScreenshotOptions = Parameters<PmxCanvas['screenshotAutomationWebView']>[0];
 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>;
@@ -162,53 +51,17 @@ export interface CanvasAccess {
         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;
+    ingestActivity(input: IngestActivityInput, options?: {
         source?: PmxAxSource;
-    }): Promise<ResolveModeRequestResult>;
-    getCommandRegistry(): Promise<GetCommandRegistryResult>;
-    invokeCommand(name: string, args?: Record<string, unknown> | null, options?: {
-        source?: PmxAxSource;
-    }): Promise<InvokeCommandResult>;
+    }): 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>;
     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>;
 }
 export declare function refreshCanvasAccess(access: CanvasAccess): Promise<CanvasAccess>;

package/dist/types/server/ax-context.d.ts

@@ -23,4 +23,4 @@ export interface PmxAxSurfaceSnapshot {
  */
 export declare function buildCanvasAxSurfaceSnapshot(): PmxAxSurfaceSnapshot;
 export declare function buildCanvasAxPinnedContext(): PmxAxPinnedContext;
-export declare function buildCanvasAxContext(): PmxAxContext;
+export declare function buildCanvasAxContext(consumer?: string): PmxAxContext;

package/dist/types/server/ax-state-manager.d.ts

@@ -0,0 +1,256 @@
+/**
+ * AX state manager.
+ *
+ * Owns the agent-experience (AX) state that previously lived inline in
+ * `CanvasStateManager`. Splits cleanly into the three documented partitions
+ * (see `docs/ax-state-contract.md`):
+ *
+ *   • Canvas-bound (`_axState`): focus, work items, approval gates, review
+ *     annotations, elicitations, mode requests, policy. Snapshotted, cleared by
+ *     `canvas_clear`, replaced by `restore`. Mutators record undo/redo history
+ *     (via the injected `recordMutation` / `suppressed` callbacks).
+ *   • Timeline (audit-only): agent events, evidence, steering. DB-direct, NOT in
+ *     `_axState`, NOT history-recorded, NOT snapshotted, retention-bounded.
+ *   • Host/session: a single host-capability row in its own table.
+ *
+ * `CanvasStateManager` holds one of these and DELEGATES its public AX methods to
+ * it, so the SDK/HTTP/MCP surface is byte-stable. The manager takes injected
+ * callbacks for everything it does not own: a node-id-validity provider (used by
+ * normalization on write), the live DB handle, `scheduleSave`, `notifyChange`,
+ * `recordMutation`, and a `suppressed` wrapper for history closures.
+ */
+import { type AxTimelineQuery } from './canvas-db.js';
+import { type PmxAxActivityKind, type PmxAxElicitation, type PmxAxModeRequest, type PmxAxMode, type PmxAxCommandDescriptor, type PmxAxPolicy, type PmxAxFocusState, type PmxAxSource, type PmxAxState, type PmxAxWorkItem, type PmxAxWorkItemStatus, type PmxAxApprovalGate, type PmxAxReviewAnnotation, type PmxAxReviewKind, type PmxAxReviewSeverity, type PmxAxReviewStatus, type PmxAxReviewAnchorType, type PmxAxReviewRegion, type PmxAxEvent, type PmxAxEventKind, type PmxAxEvidence, type PmxAxEvidenceKind, type PmxAxSteeringMessage, type PmxAxHostCapability, type PmxAxTimelineSummary } from './ax-state.js';
+import type { CanvasChangeType, MutationRecordInfo } from './canvas-state.js';
+type Database = import('bun:sqlite').Database;
+/** Host-environment hooks the AX manager needs from its owner (CanvasStateManager). */
+export interface AxStateManagerDeps {
+    /** Current valid node-id set — used by normalization on write to prune dangling refs. */
+    getNodeIds(): Set<string>;
+    /** Live DB handle for the timeline tables / host-capability table (null when no workspace). */
+    getDb(): Database | null;
+    /** Debounced save of the canvas-bound blob (timeline ops do NOT trigger this — they are DB-direct). */
+    scheduleSave(): void;
+    /** Emit a change notification (drives MCP resource notifications + blocking-wait endpoints). */
+    notifyChange(type: CanvasChangeType): void;
+    /** Record an undo/redo history entry. */
+    recordMutation(info: MutationRecordInfo): void;
+    /** Wrap a closure so it runs with mutation recording suppressed (for undo/redo replay). */
+    suppressed(fn: () => void): () => void;
+}
+export declare class AxStateManager {
+    private readonly deps;
+    private _axState;
+    private _axHostCapability;
+    constructor(deps: AxStateManagerDeps);
+    private normalizeForCurrentNodes;
+    private applyAxState;
+    /** Reset the canvas-bound partition to empty (used by clear() and applyPersistedState()). */
+    resetCanvasBound(): void;
+    /** Replace the canvas-bound partition from a persisted/restored blob, normalized against current nodes. */
+    applyPersistedAx(ax: unknown): void;
+    /** Load the host-capability row from its own table (own partition; not snapshotted). */
+    loadHostCapabilityFromDb(): void;
+    /**
+     * Re-normalize the canvas-bound partition against the current node set after a
+     * node was removed, and report what the removal orphaned. Work items / approval
+     * gates / elicitations / mode requests keep the item but strip the dangling node
+     * id ("re-anchored"); node-anchored review annotations are dropped ("removed").
+     * Returns the affected ids so the owner can record one audit timeline event.
+     */
+    revalidateAfterNodeRemoval(removedNodeId: string): {
+        reanchoredIds: string[];
+        removedReviewIds: string[];
+        reanchoredFocus: boolean;
+    };
+    getAxState(): PmxAxState;
+    getAxFocus(): PmxAxFocusState;
+    setAxFocus(nodeIds: string[], options?: {
+        source?: PmxAxSource;
+        recordHistory?: boolean;
+    }): PmxAxFocusState;
+    clearAxFocus(): PmxAxFocusState;
+    getWorkItems(): PmxAxWorkItem[];
+    addWorkItem(input: {
+        title: string;
+        status?: PmxAxWorkItemStatus;
+        detail?: string | null;
+        nodeIds?: string[];
+    }, options?: {
+        source?: PmxAxSource;
+    }): PmxAxWorkItem;
+    updateWorkItem(id: string, patch: {
+        title?: string;
+        status?: PmxAxWorkItemStatus;
+        detail?: string | null;
+        nodeIds?: string[];
+    }, options?: {
+        source?: PmxAxSource;
+    }): PmxAxWorkItem | null;
+    getApprovalGates(): PmxAxApprovalGate[];
+    requestApproval(input: {
+        title: string;
+        detail?: string | null;
+        action?: string | null;
+        nodeIds?: string[];
+    }, options?: {
+        source?: PmxAxSource;
+    }): PmxAxApprovalGate;
+    resolveApproval(id: string, decision: 'approved' | 'rejected', options?: {
+        resolution?: string;
+        source?: PmxAxSource;
+    }): PmxAxApprovalGate | null;
+    getReviewAnnotations(): PmxAxReviewAnnotation[];
+    addReviewAnnotation(input: {
+        body: string;
+        kind?: PmxAxReviewKind;
+        severity?: PmxAxReviewSeverity;
+        anchorType?: PmxAxReviewAnchorType;
+        nodeId?: string | null;
+        file?: string | null;
+        region?: PmxAxReviewRegion | null;
+        author?: string | null;
+    }, options?: {
+        source?: PmxAxSource;
+    }): PmxAxReviewAnnotation | null;
+    updateReviewAnnotation(id: string, patch: {
+        body?: string;
+        status?: PmxAxReviewStatus;
+        severity?: PmxAxReviewSeverity;
+        kind?: PmxAxReviewKind;
+    }, options?: {
+        source?: PmxAxSource;
+    }): PmxAxReviewAnnotation | null;
+    getHostCapability(): PmxAxHostCapability | null;
+    getElicitations(): PmxAxElicitation[];
+    requestElicitation(input: {
+        prompt: string;
+        fields?: string[];
+        nodeIds?: string[];
+    }, options?: {
+        source?: PmxAxSource;
+    }): PmxAxElicitation;
+    respondElicitation(id: string, response: Record<string, unknown>, options?: {
+        source?: PmxAxSource;
+    }): PmxAxElicitation | null;
+    getModeRequests(): PmxAxModeRequest[];
+    requestMode(input: {
+        mode: PmxAxMode;
+        reason?: string | null;
+        nodeIds?: string[];
+    }, options?: {
+        source?: PmxAxSource;
+    }): PmxAxModeRequest;
+    resolveModeRequest(id: string, decision: 'approved' | 'rejected', options?: {
+        resolution?: string;
+        source?: PmxAxSource;
+    }): PmxAxModeRequest | null;
+    getApproval(id: string): PmxAxApprovalGate | null;
+    getElicitation(id: string): PmxAxElicitation | null;
+    getModeRequest(id: string): PmxAxModeRequest | null;
+    getCommandRegistry(): PmxAxCommandDescriptor[];
+    /** Invoke a registry-gated PMX command intent — records a timeline event (no execution). */
+    invokeCommand(name: string, args?: Record<string, unknown> | null, options?: {
+        source?: PmxAxSource;
+    }): PmxAxEvent | null;
+    getPolicy(): PmxAxPolicy;
+    /** Merge a declarative tool/prompt policy patch (canvas-bound, snapshotted). */
+    setPolicy(patch: {
+        tools?: Partial<PmxAxPolicy['tools']>;
+        prompt?: Partial<PmxAxPolicy['prompt']>;
+    }, _options?: {
+        source?: PmxAxSource;
+    }): PmxAxPolicy;
+    setHostCapability(input: unknown, _options?: {
+        source?: PmxAxSource;
+    }): PmxAxHostCapability;
+    recordAxEvent(input: {
+        kind: PmxAxEventKind;
+        summary: string;
+        detail?: string | null;
+        nodeIds?: string[];
+        data?: Record<string, unknown> | null;
+    }, options?: {
+        source?: PmxAxSource;
+    }): PmxAxEvent;
+    addEvidence(input: {
+        kind: PmxAxEvidenceKind;
+        title: string;
+        body?: string | null;
+        ref?: string | null;
+        nodeIds?: string[];
+        data?: Record<string, unknown> | null;
+    }, options?: {
+        source?: PmxAxSource;
+    }): PmxAxEvidence;
+    recordSteeringMessage(message: string, options?: {
+        source?: PmxAxSource;
+    }): PmxAxSteeringMessage;
+    markSteeringDelivered(id: string): boolean;
+    /**
+     * Ingest a normalized agent activity (a tool/session event a harness forwards)
+     * and apply kind-driven board reactions, so the agent's real work flows back into
+     * the board without it remembering to push each item (report primitive A — makes
+     * AX bidirectional). Always records a timeline event; then, unless the caller
+     * overrides/suppresses via `reactions`, applies defaults by kind/outcome:
+     *   • failure | error | outcome==='failure' → work item (blocked) + review
+     *     (finding/error, anchored to a valid nodeId else the `ref` file) + evidence (logs)
+     *   • tool-result + outcome==='success'      → evidence (tool-result)
+     *   • everything else (tool-start, session-*, command, note) → event only
+     * A reaction value of `false` suppresses it; an object overrides its fields/forces it on.
+     */
+    ingestActivity(input: {
+        kind: PmxAxActivityKind;
+        title: string;
+        summary?: string | null;
+        outcome?: 'success' | 'failure';
+        ref?: string | null;
+        nodeIds?: string[];
+        data?: Record<string, unknown> | null;
+        reactions?: {
+            workItem?: false | {
+                status?: PmxAxWorkItemStatus;
+                detail?: string | null;
+            };
+            evidence?: false | {
+                kind?: PmxAxEvidenceKind;
+                body?: string | null;
+            };
+            review?: false | {
+                severity?: PmxAxReviewSeverity;
+                kind?: PmxAxReviewKind;
+                anchorType?: PmxAxReviewAnchorType;
+                nodeId?: string | null;
+            };
+        };
+    }, options?: {
+        source?: PmxAxSource;
+    }): {
+        event: PmxAxEvent;
+        workItem: PmxAxWorkItem | null;
+        evidence: PmxAxEvidence | null;
+        review: PmxAxReviewAnnotation | null;
+    };
+    getAxEvents(q?: AxTimelineQuery): PmxAxEvent[];
+    getAxEvidence(q?: AxTimelineQuery): PmxAxEvidence[];
+    getAxSteering(q?: AxTimelineQuery & {
+        onlyPending?: boolean;
+    }): PmxAxSteeringMessage[];
+    /**
+     * Undelivered steering for a consumer (Phase 4 delivery). Excludes messages
+     * whose source equals the consumer to prevent delivery loops (e.g. Copilot
+     * should not be handed back steering it originated).
+     */
+    getPendingSteering(options?: {
+        consumer?: string;
+        limit?: number;
+    }): PmxAxSteeringMessage[];
+    getAxTimelineSummary(): PmxAxTimelineSummary;
+    getAxTimeline(q?: AxTimelineQuery): {
+        events: PmxAxEvent[];
+        evidence: PmxAxEvidence[];
+        steering: PmxAxSteeringMessage[];
+        summary: PmxAxTimelineSummary;
+    };
+}
+export {};

package/dist/types/server/ax-state.d.ts

@@ -7,7 +7,7 @@ export interface PmxAxFocusState {
     updatedAt: string | null;
     source: PmxAxSource | null;
 }
-export type PmxAxEventKind = 'prompt' | 'assistant-message' | 'tool-start' | 'tool-result' | 'failure' | 'approval' | 'steering' | 'command';
+export type PmxAxEventKind = 'prompt' | 'assistant-message' | 'tool-start' | 'tool-result' | 'failure' | 'approval' | 'steering' | 'command' | 'note';
 export type PmxAxEvidenceKind = 'logs' | 'tool-result' | 'screenshot' | 'file' | 'diff' | 'test-output';
 export type PmxAxWorkItemStatus = 'todo' | 'in-progress' | 'blocked' | 'done' | 'cancelled';
 export type PmxAxApprovalStatus = 'pending' | 'approved' | 'rejected';
@@ -135,6 +135,18 @@ export interface PmxAxPinnedContext {
 export interface PmxAxFocusContext extends PmxAxFocusState {
     nodes: AgentContextNode[];
 }
+export interface PendingAxActivityItem {
+    kind: 'work-item' | 'approval-gate' | 'elicitation' | 'mode-request';
+    id: string;
+    title: string;
+    status: string;
+    nodeIds: string[];
+    source: PmxAxSource | null;
+}
+export interface PmxAxDeliveryContext {
+    pendingSteering: PmxAxSteeringMessage[];
+    pendingActivity: PendingAxActivityItem[];
+}
 export interface PmxAxContext {
     version: 1;
     generatedAt: string;
@@ -142,6 +154,7 @@ export interface PmxAxContext {
         nodeCount: number;
         edgeCount: number;
     };
+    delivery: PmxAxDeliveryContext;
     pinned: PmxAxPinnedContext;
     focus: PmxAxFocusContext;
     workItems: PmxAxWorkItem[];
@@ -153,6 +166,20 @@ export interface PmxAxContext {
     timeline: PmxAxTimelineSummary;
     host: PmxAxHostCapability | null;
 }
+/**
+ * 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.
+ * Optionally excludes items the consumer itself originated (loop prevention),
+ * mirroring getPendingSteering. Shared by the MCP delivery surface and the HTTP
+ * context lead block so the digest never drifts between the two.
+ */
+export declare function buildPendingAxActivity(state: PmxAxState, consumer?: string): PendingAxActivityItem[];
+export type PmxAxActivityKind = 'tool-start' | 'tool-result' | 'failure' | 'error' | 'session-start' | 'session-end' | 'command' | 'note';
+export declare function isAxActivityKind(value: unknown): value is PmxAxActivityKind;
+export declare function mapAxActivityKindToEventKind(kind: PmxAxActivityKind): PmxAxEventKind;
 export interface PmxAxCommandDescriptor {
     name: string;
     description: string;
@@ -264,6 +291,7 @@ export declare function createAxSteeringMessage(message: string, source: PmxAxSo
 export declare function normalizeAxState(input: unknown, validNodeIds?: Set<string>): PmxAxState;
 export declare function buildAxContext(input: {
     layout: CanvasLayout;
+    delivery: PmxAxDeliveryContext;
     pinned: PmxAxPinnedContext;
     focus: PmxAxFocusState;
     focusNodes: AgentContextNode[];

package/dist/types/server/ax-wait.d.ts

@@ -0,0 +1,23 @@
+/** Hard ceiling on a single blocking wait, regardless of the requested timeout. */
+export declare const AX_WAIT_MAX_MS = 120000;
+export interface AxWaitResult<T> {
+    /** Latest value, or null if the item does not exist / vanished mid-wait. */
+    value: T | null;
+    /** True only when the item still exists and is still pending after the wait. */
+    pending: boolean;
+}
+/**
+ * Block until a canvas-bound AX item resolves (its status leaves `pending`), the
+ * timeout elapses, or the request aborts — the server side of report primitive D
+ * ("gates that actually gate"). Resolves immediately when the item is already
+ * resolved, missing, or `timeoutMs <= 0` (a plain single read). Subscribes to the
+ * `ax` change channel and always disposes the listener + timer.
+ */
+export declare function waitForAxResolution<T extends {
+    status: string;
+}>(opts: {
+    read: () => T | null;
+    isResolved: (value: T) => boolean;
+    timeoutMs: number;
+    signal?: AbortSignal;
+}): Promise<AxWaitResult<T>>;

package/dist/types/server/canvas-operations.d.ts

@@ -3,6 +3,7 @@ import { type GraphNodeInput, type JsonRenderNodeInput, type JsonRenderSpec } fr
 export type CanvasArrangeMode = 'grid' | 'column' | 'flow';
 export type CanvasPinMode = 'set' | 'add' | 'remove';
 export declare function setCanvasLayoutUpdateEmitter(emitter: (() => void) | null): void;
+export declare function emitCanvasLayoutUpdate(): void;
 export interface CanvasFitViewOptions {
     width?: number;
     height?: number;
@@ -82,11 +83,6 @@ interface CanvasCreateGroupInput {
     color?: string;
     childLayout?: CanvasArrangeMode;
 }
-export interface CanvasBatchOperation {
-    op: string;
-    assign?: string;
-    args?: Record<string, unknown>;
-}
 interface CanvasNodeLookupInput {
     id?: string;
     search?: string;
@@ -262,11 +258,4 @@ export declare function createCanvasGraphNode(input: GraphNodeInput): {
     node: CanvasNodeState;
 };
 export declare function fitCanvasView(options?: CanvasFitViewOptions): CanvasFitViewResult;
-export declare function executeCanvasBatch(operations: CanvasBatchOperation[]): Promise<{
-    ok: boolean;
-    results: Array<Record<string, unknown>>;
-    refs: Record<string, unknown>;
-    failedIndex?: number;
-    error?: string;
-}>;
 export {};