pmx-canvas 0.1.36 → 0.2.1

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

@@ -1,167 +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 IngestActivityInput = Parameters<PmxCanvas['ingestActivity']>[0];
 type IngestActivityResult = ReturnType<PmxCanvas['ingestActivity']>;
-type AwaitApprovalResult = Awaited<ReturnType<PmxCanvas['awaitApproval']>>;
-type AwaitElicitationResult = Awaited<ReturnType<PmxCanvas['awaitElicitation']>>;
-type AwaitModeResult = Awaited<ReturnType<PmxCanvas['awaitMode']>>;
-type GetCommandRegistryResult = ReturnType<PmxCanvas['getCommandRegistry']>;
-type InvokeCommandResult = ReturnType<PmxCanvas['invokeCommand']>;
 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(options?: {
         consumer?: string;
     }): 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>;
     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>;
@@ -169,65 +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;
-        source?: PmxAxSource;
-    }): Promise<ResolveModeRequestResult>;
     ingestActivity(input: IngestActivityInput, options?: {
         source?: PmxAxSource;
     }): Promise<IngestActivityResult>;
-    awaitApproval(id: string, options?: {
-        timeoutMs?: number;
-    }): Promise<AwaitApprovalResult>;
-    awaitElicitation(id: string, options?: {
-        timeoutMs?: number;
-    }): Promise<AwaitElicitationResult>;
-    awaitMode(id: string, options?: {
-        timeoutMs?: number;
-    }): Promise<AwaitModeResult>;
-    getCommandRegistry(): Promise<GetCommandRegistryResult>;
-    invokeCommand(name: string, args?: Record<string, unknown> | null, options?: {
-        source?: PmxAxSource;
-    }): Promise<InvokeCommandResult>;
     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-state-manager.d.ts

@@ -0,0 +1,267 @@
+/**
+ * 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[];
+    /**
+     * NEWEST undelivered steering first, for the compact AX context lead block (report
+     * #57) — so a fresh steer is visible even behind a long backlog. Loop-safe like
+     * getPendingSteering, but ordered DESC instead of the FIFO ASC delivery queue.
+     */
+    getPendingSteeringForContext(options?: {
+        consumer?: string;
+        limit?: number;
+    }): PmxAxSteeringMessage[];
+    /** Total undelivered steering for a consumer (loop-safe), for the context backlog counts. */
+    getPendingSteeringCount(consumer?: string): number;
+    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';
@@ -145,6 +145,8 @@ export interface PendingAxActivityItem {
 }
 export interface PmxAxDeliveryContext {
     pendingSteering: PmxAxSteeringMessage[];
+    totalPending: number;
+    omittedPending: number;
     pendingActivity: PendingAxActivityItem[];
 }
 export interface PmxAxContext {

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

@@ -53,6 +53,19 @@ export declare function loadPendingAxSteeringFromDB(db: Database, options?: {
     consumer?: string;
     limit?: number;
 }): PmxAxSteeringMessage[];
+/**
+ * NEWEST undelivered steering first (report #57) for the compact AX context lead
+ * block — so a fresh steer is visible even behind a long backlog. Loop-safe: excludes
+ * the consumer's own steering in SQL so the LIMIT applies after loop-prevention.
+ * Distinct from loadPendingAxSteeringFromDB (FIFO oldest-first) which the claim/ack
+ * delivery queue uses for ordered processing.
+ */
+export declare function loadNewestPendingAxSteeringFromDB(db: Database, options?: {
+    consumer?: string;
+    limit?: number;
+}): PmxAxSteeringMessage[];
+/** Total undelivered steering for a consumer (loop-safe — excludes the consumer's own). */
+export declare function countPendingAxSteeringFromDB(db: Database, consumer?: string): number;
 export declare function loadAxTimelineSummaryFromDB(db: Database): PmxAxTimelineSummary;
 export declare function upsertAxHostCapabilityToDB(db: Database, cap: PmxAxHostCapability): void;
 export declare function loadAxHostCapabilityFromDB(db: Database): PmxAxHostCapability | null;

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 {};

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

@@ -142,9 +142,8 @@ declare class CanvasStateManager {
     private _viewport;
     private _theme;
     private _contextPinnedNodeIds;
-    private _axState;
-    private _axHostCapability;
     private _workspaceRoot;
+    private readonly ax;
     private _changeListeners;
     /**
      * Register a listener for state changes. Used by MCP server to emit resource
@@ -164,8 +163,6 @@ declare class CanvasStateManager {
     private suppressed;
     private recordMutation;
     private currentNodeIdSet;
-    private normalizeAxForCurrentNodes;
-    private applyAxState;
     private applyResolvedGroupBounds;
     private getGroupSnapshot;
     private normalizeNode;
@@ -364,10 +361,10 @@ declare class CanvasStateManager {
     setPolicy(patch: {
         tools?: Partial<PmxAxPolicy['tools']>;
         prompt?: Partial<PmxAxPolicy['prompt']>;
-    }, _options?: {
+    }, options?: {
         source?: PmxAxSource;
     }): PmxAxPolicy;
-    setHostCapability(input: unknown, _options?: {
+    setHostCapability(input: unknown, options?: {
         source?: PmxAxSource;
     }): PmxAxHostCapability;
     recordAxEvent(input: {
@@ -393,18 +390,6 @@ declare class CanvasStateManager {
         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;
@@ -442,15 +427,15 @@ declare class CanvasStateManager {
     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[];
+    getPendingSteeringForContext(options?: {
+        consumer?: string;
+        limit?: number;
+    }): PmxAxSteeringMessage[];
+    getPendingSteeringCount(consumer?: string): number;
     getAxTimelineSummary(): PmxAxTimelineSummary;
     getAxTimeline(q?: AxTimelineQuery): {
         events: PmxAxEvent[];