pmx-canvas 0.1.26 → 0.1.28

package/dist/types/json-render/server.d.ts

@@ -28,8 +28,23 @@ export interface GraphNodeInput {
     lineKey?: string;
     aggregate?: 'sum' | 'count' | 'avg';
     color?: string;
+    colorBy?: 'series' | 'category' | 'value' | 'none';
+    highlight?: number | 'max' | 'min' | null;
     barColor?: string;
     lineColor?: string;
+    labelKey?: string;
+    beforeKey?: string;
+    afterKey?: string;
+    beforeLabel?: string;
+    afterLabel?: string;
+    targetKey?: string;
+    rangesKey?: string;
+    sort?: 'asc' | 'desc' | 'none';
+    fill?: boolean;
+    showEndDot?: boolean;
+    showMinMax?: boolean;
+    showValue?: boolean;
+    colorByDirection?: boolean;
     height?: number;
     showLegend?: boolean;
     showLabels?: boolean;
@@ -47,16 +62,32 @@ export declare const GRAPH_NODE_SIZE: {
     width: number;
     height: number;
 };
-export type GraphChartType = 'LineChart' | 'BarChart' | 'PieChart' | 'AreaChart' | 'ScatterChart' | 'RadarChart' | 'StackedBarChart' | 'ComposedChart';
+export type GraphChartType = 'LineChart' | 'BarChart' | 'PieChart' | 'AreaChart' | 'ScatterChart' | 'RadarChart' | 'StackedBarChart' | 'ComposedChart' | 'Sparkline' | 'DotPlot' | 'BulletChart' | 'Slopegraph';
 export declare function inferJsonRenderNodeTitle(spec: JsonRenderSpec, fallback?: string): string;
 export declare function normalizeAndValidateJsonRenderSpec(spec: unknown): JsonRenderSpec;
 export declare function normalizeGraphType(value: string): GraphChartType;
 export declare function buildGraphSpec(input: GraphNodeInput): JsonRenderSpec;
 export declare function buildGraphConfig(input: GraphNodeInput): Record<string, unknown>;
+/** The minimal spec a streaming json-render node starts from before any patches. */
+export declare function emptyStreamingSpec(): JsonRenderSpec;
+/**
+ * Apply a batch of SpecStream patches to the current spec, accumulating the
+ * result. The canvas is the source of truth — patches are applied server-side
+ * and the browser only renders the current accumulated spec, so there is no
+ * client-side reconciliation. Tolerant by design: malformed or inapplicable
+ * patches are skipped and counted, never thrown, so a partial stream keeps
+ * building toward the final spec.
+ */
+export declare function applyJsonRenderStreamPatches(currentSpec: JsonRenderSpec, items: unknown[]): {
+    spec: JsonRenderSpec;
+    applied: number;
+    skipped: number;
+};
 export declare function createJsonRenderNodeData(nodeId: string, title: string, spec: JsonRenderSpec, extra?: Record<string, unknown>): Record<string, unknown>;
 export declare function buildJsonRenderViewerHtml(options: {
     title: string;
     spec: JsonRenderSpec;
     theme?: 'dark' | 'light' | 'high-contrast';
     display?: 'expanded';
+    devtools?: boolean;
 }): Promise<string>;

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

@@ -8,6 +8,8 @@ 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']>;
@@ -24,6 +26,29 @@ 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 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']>;
@@ -55,6 +80,7 @@ export interface CanvasAccess {
     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>;
@@ -77,6 +103,42 @@ export interface CanvasAccess {
     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>;
     clear(): Promise<void>;
     search(query: string): Promise<SearchResult>;
     undo(): Promise<UndoRedoResult>;

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

@@ -7,9 +7,121 @@ export interface PmxAxFocusState {
     updatedAt: string | null;
     source: PmxAxSource | null;
 }
+export type PmxAxEventKind = 'prompt' | 'assistant-message' | 'tool-start' | 'tool-result' | 'failure' | 'approval' | 'steering';
+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';
+export type PmxAxReviewKind = 'comment' | 'finding';
+export type PmxAxReviewSeverity = 'info' | 'warning' | 'error';
+export type PmxAxReviewStatus = 'open' | 'resolved' | 'dismissed';
+export type PmxAxReviewAnchorType = 'node' | 'file' | 'region';
+export interface PmxAxWorkItem {
+    id: string;
+    title: string;
+    status: PmxAxWorkItemStatus;
+    detail: string | null;
+    nodeIds: string[];
+    createdAt: string;
+    updatedAt: string;
+    source: PmxAxSource | null;
+}
+export interface PmxAxApprovalGate {
+    id: string;
+    title: string;
+    detail: string | null;
+    action: string | null;
+    status: PmxAxApprovalStatus;
+    nodeIds: string[];
+    createdAt: string;
+    resolvedAt: string | null;
+    resolution: string | null;
+    source: PmxAxSource | null;
+}
+export interface PmxAxReviewRegion {
+    line?: number;
+    endLine?: number;
+    label?: string;
+}
+export interface PmxAxReviewAnnotation {
+    id: string;
+    kind: PmxAxReviewKind;
+    body: string;
+    severity: PmxAxReviewSeverity;
+    status: PmxAxReviewStatus;
+    anchorType: PmxAxReviewAnchorType;
+    nodeId: string | null;
+    file: string | null;
+    region: PmxAxReviewRegion | null;
+    author: string | null;
+    createdAt: string;
+    updatedAt: string;
+    source: PmxAxSource | null;
+}
+export interface PmxAxEvent {
+    id: string;
+    seq: number;
+    kind: PmxAxEventKind;
+    summary: string;
+    detail: string | null;
+    nodeIds: string[];
+    data: Record<string, unknown> | null;
+    createdAt: string;
+    source: PmxAxSource | null;
+}
+export interface PmxAxEvidence {
+    id: string;
+    seq: number;
+    kind: PmxAxEvidenceKind;
+    title: string;
+    body: string | null;
+    ref: string | null;
+    nodeIds: string[];
+    data: Record<string, unknown> | null;
+    createdAt: string;
+    source: PmxAxSource | null;
+}
+export interface PmxAxSteeringMessage {
+    id: string;
+    seq: number;
+    message: string;
+    delivered: boolean;
+    createdAt: string;
+    source: PmxAxSource | null;
+}
+export interface PmxAxHostCapability {
+    host: string | null;
+    canvas: boolean;
+    hooks: boolean;
+    tools: boolean;
+    sessionMessaging: boolean;
+    permissions: boolean;
+    files: boolean;
+    uiPrompts: boolean;
+    reportedAt: string | null;
+    raw: Record<string, unknown> | null;
+}
+export interface PmxAxTimelineSummary {
+    recentEvents: PmxAxEvent[];
+    recentEvidence: PmxAxEvidence[];
+    pendingSteering: PmxAxSteeringMessage[];
+    counts: {
+        events: number;
+        evidence: number;
+        steering: number;
+    };
+}
+export declare const AX_TIMELINE_RETENTION = 500;
+export declare const AX_TIMELINE_DEFAULT_LIMIT = 50;
+export declare const AX_TIMELINE_MAX_LIMIT = 200;
+export declare const AX_CONTEXT_EVENT_LIMIT = 20;
+export declare const AX_CONTEXT_EVIDENCE_LIMIT = 10;
+export declare const AX_CONTEXT_STEERING_LIMIT = 10;
 export interface PmxAxState {
     version: 1;
     focus: PmxAxFocusState;
+    workItems: PmxAxWorkItem[];
+    approvalGates: PmxAxApprovalGate[];
+    reviewAnnotations: PmxAxReviewAnnotation[];
 }
 export interface PmxAxPinnedContext {
     preamble: string;
@@ -29,15 +141,73 @@ export interface PmxAxContext {
     };
     pinned: PmxAxPinnedContext;
     focus: PmxAxFocusContext;
+    workItems: PmxAxWorkItem[];
+    approvalGates: PmxAxApprovalGate[];
+    reviewAnnotations: PmxAxReviewAnnotation[];
+    timeline: PmxAxTimelineSummary;
+    host: PmxAxHostCapability | null;
 }
+export declare function isAxEventKind(value: unknown): value is PmxAxEventKind;
+export declare function isAxEvidenceKind(value: unknown): value is PmxAxEvidenceKind;
 export declare function createEmptyAxFocusState(): PmxAxFocusState;
 export declare function createEmptyAxState(): PmxAxState;
+export declare function createEmptyAxHostCapability(): PmxAxHostCapability;
 export declare function normalizeAxFocusState(input: unknown, validNodeIds?: Set<string>): PmxAxFocusState;
+export declare function normalizeAxWorkItem(input: unknown, validNodeIds?: Set<string>): PmxAxWorkItem | null;
+export declare function normalizeAxApprovalGate(input: unknown, validNodeIds?: Set<string>): PmxAxApprovalGate | null;
+export declare function normalizeAxReviewAnnotation(input: unknown, validNodeIds?: Set<string>): PmxAxReviewAnnotation | null;
+export declare function normalizeAxHostCapability(input: unknown): PmxAxHostCapability | null;
+export declare function normalizeAxEvent(input: unknown): PmxAxEvent | null;
+export declare function normalizeAxEvidence(input: unknown): PmxAxEvidence | null;
+export declare function normalizeAxSteeringMessage(input: unknown): PmxAxSteeringMessage | null;
+export declare function createAxWorkItem(input: {
+    title: string;
+    status?: PmxAxWorkItemStatus;
+    detail?: string | null;
+    nodeIds?: string[];
+}, source: PmxAxSource | null, validNodeIds?: Set<string>): PmxAxWorkItem;
+export declare function createAxApprovalGate(input: {
+    title: string;
+    detail?: string | null;
+    action?: string | null;
+    nodeIds?: string[];
+}, source: PmxAxSource | null, validNodeIds?: Set<string>): PmxAxApprovalGate;
+export declare function createAxReviewAnnotation(input: {
+    body: string;
+    kind?: PmxAxReviewKind;
+    severity?: PmxAxReviewSeverity;
+    anchorType?: PmxAxReviewAnchorType;
+    nodeId?: string | null;
+    file?: string | null;
+    region?: PmxAxReviewRegion | null;
+    author?: string | null;
+}, source: PmxAxSource | null): PmxAxReviewAnnotation;
+export declare function createAxEvent(input: {
+    kind: PmxAxEventKind;
+    summary: string;
+    detail?: string | null;
+    nodeIds?: string[];
+    data?: Record<string, unknown> | null;
+}, source: PmxAxSource | null): Omit<PmxAxEvent, 'seq'>;
+export declare function createAxEvidence(input: {
+    kind: PmxAxEvidenceKind;
+    title: string;
+    body?: string | null;
+    ref?: string | null;
+    nodeIds?: string[];
+    data?: Record<string, unknown> | null;
+}, source: PmxAxSource | null): Omit<PmxAxEvidence, 'seq'>;
+export declare function createAxSteeringMessage(message: string, source: PmxAxSource | null): Omit<PmxAxSteeringMessage, 'seq'>;
 export declare function normalizeAxState(input: unknown, validNodeIds?: Set<string>): PmxAxState;
 export declare function buildAxContext(input: {
     layout: CanvasLayout;
     pinned: PmxAxPinnedContext;
     focus: PmxAxFocusState;
     focusNodes: AgentContextNode[];
+    workItems: PmxAxWorkItem[];
+    approvalGates: PmxAxApprovalGate[];
+    reviewAnnotations: PmxAxReviewAnnotation[];
+    timeline: PmxAxTimelineSummary;
+    host: PmxAxHostCapability | null;
 }): PmxAxContext;
 export declare function nodeSetFromLayout(nodes: CanvasNodeState[]): Set<string>;

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

@@ -6,7 +6,7 @@
  */
 import { Database } from 'bun:sqlite';
 import type { CanvasAnnotation, CanvasEdge, CanvasNodeState, CanvasSnapshot, CanvasSnapshotListOptions, ViewportState } from './canvas-state.js';
-import { type PmxAxState } from './ax-state.js';
+import { type PmxAxState, type PmxAxEvent, type PmxAxEvidence, type PmxAxSteeringMessage, type PmxAxHostCapability, type PmxAxTimelineSummary } from './ax-state.js';
 export type CanvasTheme = 'dark' | 'light' | 'high-contrast';
 export declare function normalizeCanvasTheme(value: unknown, fallback?: CanvasTheme): CanvasTheme;
 export interface PersistedCanvasState {
@@ -36,3 +36,19 @@ export declare function deleteSnapshotFromDB(db: Database, id: string): boolean;
 export declare function writeBlobToDB(db: Database, sha256: string, jsonValue: string): number;
 export declare function readBlobFromDB(db: Database, sha256: string): string | null;
 export declare function hasBlobInDB(db: Database, sha256: string): boolean;
+export interface AxTimelineQuery {
+    limit?: number;
+    sessionId?: string;
+}
+export declare function appendAxEventToDB(db: Database, ev: Omit<PmxAxEvent, 'seq'>): PmxAxEvent;
+export declare function appendAxEvidenceToDB(db: Database, ev: Omit<PmxAxEvidence, 'seq'>): PmxAxEvidence;
+export declare function appendAxSteeringToDB(db: Database, s: Omit<PmxAxSteeringMessage, 'seq'>): PmxAxSteeringMessage;
+export declare function markAxSteeringDeliveredInDB(db: Database, id: string): boolean;
+export declare function loadAxEventsFromDB(db: Database, q?: AxTimelineQuery): PmxAxEvent[];
+export declare function loadAxEvidenceFromDB(db: Database, q?: AxTimelineQuery): PmxAxEvidence[];
+export declare function loadAxSteeringFromDB(db: Database, q?: AxTimelineQuery & {
+    onlyPending?: boolean;
+}): PmxAxSteeringMessage[];
+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

@@ -64,6 +64,14 @@ export declare const MCP_APP_NODE_DEFAULT_SIZE: {
     width: number;
     height: number;
 };
+export declare const IMAGE_NODE_DEFAULT_SIZE: {
+    width: number;
+    height: number;
+};
+export declare const LEDGER_NODE_DEFAULT_SIZE: {
+    width: number;
+    height: number;
+};
 interface CanvasCreateGroupInput {
     title?: string;
     childIds?: string[];
@@ -124,6 +132,18 @@ export declare function validateCanvasNodePatch(patch: {
 export declare function mergeTraceNodeDataFields(base: Record<string, unknown>, input: Record<string, unknown>): Record<string, unknown>;
 export declare function hasTraceNodeDataFields(input: Record<string, unknown>): boolean;
 export declare function scheduleCodeGraphRecompute(onComplete?: () => void): void;
+/**
+ * Resolve an html-node `html` field that may be a path to a local .html/.htm file.
+ *
+ * If the string looks like a bare filesystem path to an existing HTML file
+ * (no markup, no newlines, short, ends in .html/.htm, exists on disk), read the
+ * file and return its contents. Otherwise return the string unchanged as raw HTML.
+ * On read failure, fall back to the raw string and warn — never throw.
+ *
+ * This is a local dev tool, so reading a user-pointed-at local file is acceptable;
+ * the markup/newline guards prevent misclassifying genuine HTML as a path.
+ */
+export declare function resolveHtmlContent(html: string): string;
 export declare function addCanvasNode(input: CanvasAddNodeInput): {
     id: string;
     node: CanvasNodeState;
@@ -206,6 +226,39 @@ export declare function createCanvasJsonRenderNode(input: JsonRenderNodeInput):
     spec: JsonRenderSpec;
     node: CanvasNodeState;
 };
+/**
+ * Create an empty streaming json-render node. Unlike createCanvasJsonRenderNode
+ * this does NOT validate a complete spec — the node starts blank and is filled
+ * in by appendCanvasJsonRenderStream as SpecStream patches arrive.
+ */
+export declare function createCanvasStreamingJsonRenderNode(input: {
+    title?: string;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    strictSize?: boolean;
+}): {
+    id: string;
+    url: string;
+    spec: JsonRenderSpec;
+    node: CanvasNodeState;
+};
+/**
+ * Apply a batch of SpecStream patches to an existing json-render node, bumping
+ * its specVersion so the browser reloads the viewer with the accumulated spec.
+ */
+export declare function appendCanvasJsonRenderStream(nodeId: string, patches: unknown[], done: boolean): {
+    ok: true;
+    applied: number;
+    skipped: number;
+    specVersion: number;
+    elementCount: number;
+    streamStatus: 'open' | 'closed';
+} | {
+    ok: false;
+    error: string;
+};
 export declare function createCanvasGraphNode(input: GraphNodeInput): {
     id: string;
     url: string;

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

@@ -33,7 +33,7 @@ export interface StructuredValidationResult {
     };
     summary: Record<string, unknown>;
 }
-declare const CANONICAL_GRAPH_TYPES: readonly ["line", "bar", "pie", "area", "scatter", "radar", "stacked-bar", "composed"];
+declare const CANONICAL_GRAPH_TYPES: readonly ["line", "bar", "pie", "area", "scatter", "radar", "stacked-bar", "composed", "sparkline", "dot-plot", "bullet", "slopegraph"];
 type CanvasGraphType = typeof CANONICAL_GRAPH_TYPES[number];
 export declare function describeCanvasSchema(): {
     ok: true;
@@ -43,6 +43,10 @@ export declare function describeCanvasSchema(): {
     jsonRender: {
         rootShape: Record<string, string>;
         components: JsonRenderComponentDescriptor[];
+        directives: Array<{
+            name: string;
+            usage: string;
+        }>;
     };
     graph: {
         graphTypes: CanvasGraphType[];

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

@@ -9,8 +9,8 @@
  * in the workspace root on every mutation (debounced). Auto-loads on `loadFromDisk()`.
  * Legacy `.pmx-canvas/state.json` is auto-migrated on first boot.
  */
-import { type PersistedCanvasState, type CanvasTheme } from './canvas-db.js';
-import { type PmxAxFocusState, type PmxAxSource, type PmxAxState } from './ax-state.js';
+import { type PersistedCanvasState, type CanvasTheme, type AxTimelineQuery } from './canvas-db.js';
+import { 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';
 export declare const PMX_CANVAS_DIR = ".pmx-canvas";
 export interface PersistedBlobRef {
     __pmxCanvasBlob: 'v1';
@@ -120,9 +120,9 @@ export interface CanvasNodeUpdate {
     collapsed?: boolean;
     dockPosition?: 'left' | 'right' | null;
 }
-export type CanvasChangeType = 'pins' | 'nodes' | 'ax';
+export type CanvasChangeType = 'pins' | 'nodes' | 'ax' | 'ax-timeline';
 export interface MutationRecordInfo {
-    operationType: 'addNode' | 'updateNode' | 'removeNode' | 'addEdge' | 'removeEdge' | 'addAnnotation' | 'removeAnnotation' | 'clear' | 'restoreSnapshot' | 'setPins' | 'setAxFocus' | 'arrange' | 'batch' | 'groupNodes' | 'ungroupNodes' | 'viewport';
+    operationType: 'addNode' | 'updateNode' | 'removeNode' | 'addEdge' | 'removeEdge' | 'addAnnotation' | 'removeAnnotation' | 'clear' | 'restoreSnapshot' | 'setPins' | 'setAxFocus' | 'addWorkItem' | 'updateWorkItem' | 'requestApproval' | 'resolveApproval' | 'addReviewAnnotation' | 'updateReviewAnnotation' | 'arrange' | 'batch' | 'groupNodes' | 'ungroupNodes' | 'viewport';
     description: string;
     forward: () => void;
     inverse: () => void;
@@ -143,6 +143,7 @@ declare class CanvasStateManager {
     private _theme;
     private _contextPinnedNodeIds;
     private _axState;
+    private _axHostCapability;
     private _workspaceRoot;
     private _changeListeners;
     /** Register a listener for state changes. Used by MCP server to emit resource notifications. */
@@ -263,6 +264,96 @@ declare class CanvasStateManager {
         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;
+    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;
+    getAxEvents(q?: AxTimelineQuery): PmxAxEvent[];
+    getAxEvidence(q?: AxTimelineQuery): PmxAxEvidence[];
+    getAxSteering(q?: AxTimelineQuery & {
+        onlyPending?: boolean;
+    }): PmxAxSteeringMessage[];
+    getAxTimelineSummary(): PmxAxTimelineSummary;
+    getAxTimeline(q?: AxTimelineQuery): {
+        events: PmxAxEvent[];
+        evidence: PmxAxEvidence[];
+        steering: PmxAxSteeringMessage[];
+        summary: PmxAxTimelineSummary;
+    };
     setContextPins(nodeIds: string[]): void;
     clearContextPins(): void;
     /** Move child nodes into a group. Sets data.parentGroup on children and data.children on the group. */