pmx-canvas 0.9.2 → 0.10.0

package/dist/types/client/canvas/submit-without-navigation.d.ts

@@ -0,0 +1,3 @@
+import type { JSX } from 'preact';
+/** A scripts-only host blocks native submission before onSubmit can run. */
+export declare function submitWithoutNavigation(event: JSX.TargetedMouseEvent<HTMLFormElement>): void;

package/dist/types/client/state/intent-bridge.d.ts

@@ -1,4 +1,3 @@
-import type { AgentPresenceSnapshot } from '../../shared/agent-presence.js';
 import type { CanvasNodeState } from '../types';
 /**
  * Per-tab identity: an AGENT driving the workbench UI from its own pane opens
@@ -156,8 +155,6 @@ export interface AxInteractionResponse {
 }
 /** Fetch the compact AX state snapshot pushed into AX-enabled surfaces. */
 export declare function fetchAxSurfaceState(): Promise<unknown>;
-/** Connect-time agent-presence read; live updates arrive as `agent-presence` SSE frames. */
-export declare function fetchAgentPresence(): Promise<Partial<AgentPresenceSnapshot> | null>;
 /** Ask the server to open a node's surface in the system browser. */
 export declare function openNodeInSystemBrowserRequest(nodeId: string, url?: string): Promise<{
     ok: boolean;

package/dist/types/client/state/presence-store.d.ts

@@ -1,9 +1,9 @@
 import type { PmxAxIntent } from '../../shared/ax-intent.js';
 import { type AgentActivityEntry, type AgentPresence, type AgentPresenceSnapshot } from '../../shared/agent-presence.js';
 /**
- * Agent presence (rail-chrome-v2 phase 2). Fed by the server's `agent-presence`
- * SSE snapshot (every change, including TTL expiry) and the connect-time read,
- * so this store never runs its own expiry ticker.
+ * Agent presence (rail-chrome-v2 phase 2). Fed by the server's ordered
+ * `agent-presence` frames: a connect snapshot and every change, including TTL
+ * expiry, over SSE or polling. This store never runs its own expiry ticker.
  *
  * `sessionActive` is the ONE selector every agent surface reads — the session
  * panel, command bar, presence layer, and top-bar chip all mount on it.

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

@@ -75,7 +75,7 @@ export type AnnotationTool = 'pen' | 'eraser' | 'text' | null;
 export type ConnectionStatus = 'connecting' | 'connected' | 'disconnected';
 export declare const TYPE_LABELS: Record<CanvasNodeState['type'], string>;
 /** Node types that support the full-viewport expand/focus overlay. */
-export declare const EXPANDABLE_TYPES: Set<"image" | "board" | "file" | "markdown" | "mcp-app" | "webpage" | "json-render" | "graph" | "prompt" | "response" | "status" | "context" | "ledger" | "trace" | "diff" | "mermaid" | "html" | "group">;
+export declare const EXPANDABLE_TYPES: Set<"board" | "image" | "file" | "markdown" | "mcp-app" | "webpage" | "json-render" | "graph" | "prompt" | "response" | "status" | "context" | "ledger" | "trace" | "diff" | "mermaid" | "html" | "group">;
 export declare const EXCALIDRAW_SERVER_NAME = "Excalidraw";
 export declare const EXCALIDRAW_CREATE_VIEW_TOOL = "create_view";
 export declare function isExcalidrawNode(node: CanvasNodeState): boolean;

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

@@ -1,16 +1,11 @@
 import { type CanvasLayout, type CanvasNodeState, type PmxCanvas } from '../server/index.js';
-import type { PmxAxSource } from '../server/ax-state.js';
 import type { ContextReadInput } from '../server/context-reads.js';
 import { type OperationInvoker } from '../server/operations/index.js';
 type AxStateResult = ReturnType<PmxCanvas['getAxState']>;
 type AxContextResult = ReturnType<PmxCanvas['getAxContext']>;
-type SubmitAxInteractionInput = Parameters<PmxCanvas['submitAxInteraction']>[0];
-type SubmitAxInteractionResult = ReturnType<PmxCanvas['submitAxInteraction']>;
 type GetPendingSteeringResult = ReturnType<PmxCanvas['getPendingSteering']>;
 type ListElicitationsResult = ReturnType<PmxCanvas['listElicitations']>;
 type ListModeRequestsResult = ReturnType<PmxCanvas['listModeRequests']>;
-type IngestActivityInput = Parameters<PmxCanvas['ingestActivity']>[0];
-type IngestActivityResult = ReturnType<PmxCanvas['ingestActivity']>;
 type GetPolicyResult = ReturnType<PmxCanvas['getPolicy']>;
 type GetAxTimelineQuery = Parameters<PmxCanvas['getAxTimeline']>[0];
 type GetAxTimelineResult = ReturnType<PmxCanvas['getAxTimeline']>;
@@ -38,18 +33,12 @@ export interface CanvasAccess {
     listWorkItems(): Promise<ListWorkItemsResult>;
     listApprovalGates(): Promise<ListApprovalGatesResult>;
     listReviewAnnotations(): Promise<ListReviewAnnotationsResult>;
-    submitAxInteraction(input: SubmitAxInteractionInput, options?: {
-        source?: PmxAxSource;
-    }): Promise<SubmitAxInteractionResult>;
     getPendingSteering(options?: {
         consumer?: string;
         limit?: number;
     }): Promise<GetPendingSteeringResult>;
     listElicitations(): Promise<ListElicitationsResult>;
     listModeRequests(): Promise<ListModeRequestsResult>;
-    ingestActivity(input: IngestActivityInput, options?: {
-        source?: PmxAxSource;
-    }): Promise<IngestActivityResult>;
     getPolicy(): Promise<GetPolicyResult>;
     getHistory(): Promise<HistoryResult>;
     getPinnedNodeIds(board?: string): Promise<string[]>;
@@ -62,7 +51,7 @@ export interface CanvasAccess {
     runBatch(operations: RunBatchInput): Promise<RunBatchResult>;
     getCodeGraph(): Promise<CodeGraphResult>;
     getAutomationWebViewStatus(): Promise<AutomationWebViewStatus>;
-    screenshotAutomationWebView(options?: AutomationScreenshotOptions): Promise<Uint8Array>;
+    screenshotAutomationWebView(options?: AutomationScreenshotOptions, signal?: AbortSignal): Promise<Uint8Array>;
 }
 export declare function refreshCanvasAccess(access: CanvasAccess): Promise<CanvasAccess>;
 /**

package/dist/types/mcp/resource-subscriptions.d.ts

@@ -0,0 +1,7 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CanvasAccess } from './canvas-access.js';
+/** One subscription set and event source per MCP connection. Notifications are not reads. */
+export declare function registerResourceSubscriptions(server: McpServer, getCanvas: () => Promise<CanvasAccess>): {
+    attach: (canvas: CanvasAccess) => void;
+    dispose: () => void;
+};

package/dist/types/mcp/server.d.ts

@@ -19,4 +19,6 @@
  * }
  * ```
  */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createMcpServer(): McpServer;
 export declare function startMcpServer(): Promise<void>;

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

@@ -33,4 +33,5 @@ export declare function waitForAxCondition(opts: {
     ready: () => boolean;
     timeoutMs: number;
     channel?: string;
+    signal?: AbortSignal;
 }): Promise<void>;

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

@@ -168,6 +168,7 @@ export declare function resolveCanvasNode(nodeRef: CanvasNodeLookupInput): {
 };
 export declare function refreshCanvasWebpageNode(id: string, options?: {
     url?: string;
+    signal?: AbortSignal;
 }): Promise<{
     ok: boolean;
     id: string;

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

@@ -432,6 +432,8 @@ declare class CanvasStateManager {
     updateNode(id: string, patch: Partial<CanvasNodeState>, savedWikiLinks?: WikiLink[] | null): void;
     removeNode(id: string): void;
     getNode(id: string): CanvasNodeState | undefined;
+    /** Camera targets need geometry, not hydrated documents, frames or image blobs. */
+    nodeGeometry(): Array<Pick<CanvasNodeState, 'id' | 'type' | 'position' | 'size'>>;
     /** Who made and last edited each card, and its content revision — no content, no copies. */
     nodeStamps(): Array<Pick<CanvasNodeState, 'id' | 'createdBy' | 'lastEditedBy' | 'contentRevision'>>;
     getNodeForPersistence(id: string): CanvasNodeState | undefined;

package/dist/types/server/index.d.ts

@@ -1,8 +1,8 @@
 import { EventEmitter } from 'node:events';
-import { type Camera, type Tour, type TourStop } from '../shared/tour.js';
-import { type TourStep, type TourStepResult } from './tour-control.js';
+import type { Camera, Tour, TourStop } from '../shared/tour.js';
+import { type TourState, type TourStep, type TourStepResult } from './tour-control.js';
 export type { Tour, TourStop } from '../shared/tour.js';
-export type { TourStep, TourStepResult } from './tour-control.js';
+export type { TourState, TourStep, TourStepResult } from './tour-control.js';
 import type { AgentPhase, AgentPresence, AgentPresenceSnapshot } from '../shared/agent-presence.js';
 import { canvasState } from './canvas-state.js';
 import type { CanvasAnnotation, CanvasNodeState, CanvasEdge, CanvasLayout } from './canvas-state.js';
@@ -22,7 +22,7 @@ import type { HtmlPrimitiveKind } from './html-primitives.js';
 import { type WebArtifactBuildInput, type WebArtifactCanvasBuildResult } from './web-artifacts.js';
 import { type ExternalMcpTransportConfig } from './mcp-app-runtime.js';
 import type { DiagramPresetOpenInput } from './diagram-presets.js';
-import { type GraphNodeInput, type JsonRenderNodeInput, type JsonRenderSpec } from '../json-render/server.js';
+import type { GraphNodeInput, JsonRenderNodeInput, JsonRenderSpec } from '../json-render/server.js';
 import type { CanvasAutomationWebViewOptions, CanvasAutomationWebViewStatus } from './server.js';
 /**
  * Node object returned by the SDK's create/get methods. It is the fully
@@ -163,7 +163,7 @@ export declare class PmxCanvas extends EventEmitter {
     ungroupNodes(groupId: string, options?: {
         intentId?: string;
     }): boolean;
-    getTour(): Tour;
+    getTour(): TourState;
     setTour(tour: Tour | null): void;
     /** Present a tour stop (index, `next` or `previous`) in the workbench. Not recorded in undo history. */
     goToTourStop(step: TourStep, options?: {

package/dist/types/server/knowledge-lifecycle.d.ts

@@ -1,5 +1,6 @@
 import type { Database } from 'bun:sqlite';
 import { z } from 'zod';
+import { type MemoryTarget } from '../shared/memory-graph.js';
 import { type ActorAttribution } from './attribution.js';
 import type { LifecycleQualification } from '../shared/lifecycle-status.js';
 import type { CanvasNodeState } from './canvas-state.js';
@@ -182,7 +183,7 @@ export declare class KnowledgeLifecycle {
             cadenceDays?: number | undefined;
         } | null;
         lifecycleSourceFolder: string | null;
-        lifecycleSource: "unknown" | "card" | "folder";
+        lifecycleSource: "card" | "unknown" | "folder";
     };
     resolveCard(folderPath: string | null, node: Pick<CanvasNodeState, 'type' | 'data'>, catalog?: {
         categories: KnowledgeCategory[];
@@ -208,8 +209,16 @@ export declare class KnowledgeLifecycle {
             cadenceDays?: number | undefined;
         } | null;
         lifecycleSourceFolder: string | null;
-        lifecycleSource: "unknown" | "card" | "folder";
+        lifecycleSource: "card" | "unknown" | "folder";
     };
+    private indexedDb;
+    /** Stored owners of semantic sources; the caller overlays the active board's unsaved edges. */
+    incomingSourceBoards(target: MemoryTarget, activeBoardId: string | null): string[];
+    /** One indexed latest validation and retirement per card, never its full audit history. */
+    reviewSummaries(targets: MemoryTarget[]): Map<string, {
+        lastValidation: ReviewRecord | null;
+        retired: boolean;
+    }>;
     reviews(boardId: string, nodeId: string): {
         records: ReviewRecord[];
         retired: boolean;

package/dist/types/server/lifecycle-status.d.ts

@@ -3,8 +3,10 @@ import type { LifecycleQualification } from '../shared/lifecycle-status.js';
 import type { ReviewCardSummary } from './knowledge-lifecycle.js';
 /** A read-only qualification, shared by briefs, search, Home and card review. No clock is renewed. */
 export declare function lifecycleQualifications(now?: number, atUse?: MemoryTarget[]): Record<string, LifecycleQualification>;
+/** A card being inspected is in use, including its transitive sources and portal contents. */
+export declare function lifecycleQualification(target: MemoryTarget, now?: number): LifecycleQualification | undefined;
 /** Compact queue metadata and qualifications come from the same authoritative read. */
-export declare function lifecycleSnapshot(now?: number, atUse?: MemoryTarget[]): {
+export declare function lifecycleSnapshot(now?: number, atUse?: MemoryTarget[], only?: MemoryTarget): {
     cards: Record<string, LifecycleQualification>;
     reviewCards: ReviewCardSummary[];
 };

package/dist/types/server/operations/http.d.ts

@@ -1,3 +1,13 @@
+import { type OperationProgress } from './types.js';
+/** Opt-in NDJSON; the terminal frame retains the ordinary HTTP status/body. */
+export type OperationStreamFrame = {
+    type: 'progress';
+    progress: OperationProgress;
+} | {
+    type: 'result';
+    status: number;
+    body: unknown;
+};
 export declare function matchOperationPath(template: string, pathname: string): Record<string, string> | null;
 /**
  * Shared body reader: preserves the parsed JSON value as-is (object, array,

package/dist/types/server/operations/index.d.ts

@@ -3,6 +3,6 @@ export { dispatchOperationRoute } from './http.js';
 export { runCanvasBatchOperation, type BatchEnvelope } from './ops/batch.js';
 export type { OpenMcpAppCoreResult } from './ops/app.js';
 export { LocalOperationInvoker, HttpOperationInvoker, type OperationInvoker } from './invoker.js';
-export { registerOperationTools, registerCompositeTools, type OperationToolHost } from './mcp.js';
+export { registerOperationTools, registerCompositeTools, registerOperationHelpTool, type OperationToolHost, } from './mcp.js';
 export { compositeToolDefinitions, type CompositeToolDefinition } from './composites.js';
-export { OperationError, defineOperation, type Operation, type OperationContext, type OperationDefinition, type OperationErrorStatus, } from './types.js';
+export { OperationError, defineOperation, type Operation, type OperationContext, type OperationDefinition, type OperationExecutionOptions, type OperationErrorStatus, type OperationProgress, } from './types.js';

package/dist/types/server/operations/invoker.d.ts

@@ -1,5 +1,6 @@
+import { type OperationExecutionOptions } from './types.js';
 export interface OperationInvoker {
-    invoke(name: string, input: Record<string, unknown>): Promise<unknown>;
+    invoke(name: string, input: Record<string, unknown>, options?: OperationExecutionOptions): Promise<unknown>;
 }
 /**
  * The agent-presence label for a transport: `PMX_CANVAS_AGENT_SOURCE` lets a
@@ -14,7 +15,7 @@ export declare class LocalOperationInvoker implements OperationInvoker {
     private readonly proxiedRead;
     /** `source` labels this caller's agent presence ('mcp', 'sdk', …). */
     constructor(source?: string, allowExternalMcp?: boolean);
-    invoke(name: string, input: Record<string, unknown>): Promise<unknown>;
+    invoke(name: string, input: Record<string, unknown>, options?: OperationExecutionOptions): Promise<unknown>;
 }
 /** Builds the HTTP request from the op's route template (`:id` from input, GET flags to query). */
 export declare class HttpOperationInvoker implements OperationInvoker {
@@ -24,5 +25,5 @@ export declare class HttpOperationInvoker implements OperationInvoker {
     private readonly proxiedRead;
     /** `source` labels this caller's agent presence on the server ('cli', 'mcp', …). */
     constructor(baseUrl: string, source?: string, allowExternalMcp?: boolean);
-    invoke(name: string, rawInput: Record<string, unknown>): Promise<unknown>;
+    invoke(name: string, rawInput: Record<string, unknown>, options?: OperationExecutionOptions): Promise<unknown>;
 }

package/dist/types/server/operations/mcp-contracts.d.ts

@@ -0,0 +1,20 @@
+/**
+ * MCP's output is the FORMATTER projection, never the larger HTTP payload.
+ * `result` wraps prose/arrays without pretending they are JSON objects. Each
+ * operation validates its stable fields; loose payloads preserve full:true and
+ * extensible node/app data. No schema advertises an unconstrained root record.
+ */
+import { z } from 'zod';
+import type { CallToolResult, ToolAnnotations } from '@modelcontextprotocol/sdk/types.js';
+export declare function operationOutputSchema(operations: string[]): z.ZodObject<{
+    result: z.ZodUnion<readonly [...z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>[], z.ZodObject<{
+        operation: z.ZodNull;
+        outcome: z.ZodLiteral<"error">;
+        data: z.ZodObject<{
+            message: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>]>;
+}, z.core.$strict>;
+export declare function structuredOperationResult(operation: string, formatted: CallToolResult): CallToolResult;
+export declare function operationToolError(error: unknown): CallToolResult;
+export declare function operationToolAnnotations(toolName: string): ToolAnnotations;

package/dist/types/server/operations/mcp.d.ts

@@ -12,6 +12,8 @@ export interface OperationToolHost extends OperationMcpToolHost {
     recordContextRead(read: ContextReadInput): Promise<void>;
 }
 export declare function registerOperationTools(server: McpServer, getHost: () => Promise<OperationToolHost>): void;
+/** Registry metadata only: never boots a canvas or records a content read. */
+export declare function registerOperationHelpTool(server: McpServer): void;
 /**
  * Register composite (action-discriminated) MCP tools (plan-006). Each action
  * dispatches to a registered operation, reusing that op's `mcp.buildInput` and

package/dist/types/server/operations/ops/batch.d.ts

@@ -5,6 +5,7 @@ export interface BatchEnvelope {
     refs: Record<string, unknown>;
     failedIndex?: number;
     error?: string;
+    cancelled?: boolean;
 }
 export declare const batchOperations: Operation[];
 /**

package/dist/types/server/operations/registry.d.ts

@@ -1,4 +1,4 @@
-import { type Operation } from './types.js';
+import { type Operation, type OperationExecutionOptions } from './types.js';
 export declare function registerOperation(op: Operation): void;
 export declare function getOperation(name: string): Operation;
 export declare function listOperations(): Operation[];
@@ -12,7 +12,7 @@ export declare function getOperationEventEmitter(): OperationEventEmitter | null
 export declare function isEmitSuppressed(): boolean;
 /** Suppress this call chain's per-entry frames; the batch emits its final frame afterward. */
 export declare function runWithSuppressedEmits<T>(fn: () => Promise<T>): Promise<T>;
-export interface ExecuteOperationMeta {
+export interface ExecuteOperationMeta extends OperationExecutionOptions {
     /**
      * Skip the synthesized auto-ghost: set by the workbench's own HTTP calls
      * (a human dragging a node is not agent activity) and by canvas.batch for

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

@@ -20,7 +20,17 @@ export declare class OperationError extends Error {
     readonly details?: Record<string, unknown>;
     constructor(message: string, status?: OperationErrorStatus, details?: Record<string, unknown>);
 }
-export interface OperationContext {
+export interface OperationProgress {
+    progress: number;
+    total?: number;
+    message?: string;
+}
+/** Cooperative cancellation: completed writes are never rolled back. */
+export interface OperationExecutionOptions {
+    signal?: AbortSignal;
+    onProgress?: (progress: OperationProgress) => void | Promise<void>;
+}
+export interface OperationContext extends OperationExecutionOptions {
     /** Emit a workbench SSE event (e.g. extra `canvas-layout-update` frames, focus, viewport). */
     emit(event: string, payload?: Record<string, unknown>): void;
 }
@@ -53,7 +63,7 @@ export interface OperationMcpToolHost {
      * restore summary).
      */
     invoker(): {
-        invoke(name: string, input: Record<string, unknown>): Promise<unknown>;
+        invoke(name: string, input: Record<string, unknown>, options?: OperationExecutionOptions): Promise<unknown>;
     };
 }
 export interface OperationMcpTool {

package/dist/types/server/server.d.ts

@@ -80,6 +80,8 @@ export interface PrimaryWorkbenchCanvasPromptRequest {
     contextNodeIds: string[];
 }
 type PrimaryWorkbenchCanvasPromptHandler = (request: PrimaryWorkbenchCanvasPromptRequest) => Promise<void>;
+/** In-process invalidation observers share the same events as daemon SSE clients. */
+export declare function onWorkbenchEvent(listener: (event: string) => void): () => void;
 export declare function setPrimaryWorkbenchAutoOpenEnabled(enabled: boolean): void;
 export declare function isPrimaryWorkbenchAutoOpenEnabled(): boolean;
 export declare function hasWorkbenchSubscribers(): boolean;

package/dist/types/server/tour-control.d.ts

@@ -15,9 +15,12 @@ export interface TourStepResult {
     total: number;
     stop: TourStop;
 }
-export declare function currentTour(): Tour;
-/** The stop the tour is on for the active board, or null when not touring. */
-export declare function tourPosition(tour?: Tour): number | null;
+export interface TourState {
+    tour: Tour;
+    derived: boolean;
+    position: number | null;
+}
+export declare function currentTour(): TourState;
 /** Move the shared cursor. `next`/`previous` clamp at the ends; an explicit index must exist. */
 export declare function goToTourStop(step: TourStep): TourStepResult;
 export declare function exitTour(): void;

package/dist/types/server/webpage-node.d.ts

@@ -37,6 +37,7 @@ export declare function checkWebpageHop(originScope: AddressScope, hopScope: Add
 export declare function fetchWebpageSnapshot(inputUrl: string, options?: {
     resolveHost?: ResolveHost;
     timeoutMs?: number;
+    signal?: AbortSignal;
 }): Promise<WebpageSnapshot>;
 export declare function getWebpageFetchErrorDetails(error: unknown): {
     message: string;

package/docs/api-reference.md

@@ -6,7 +6,7 @@
 
 ## MCP Server
 
-24 tools: 18 action-discriminated composites (`canvas_import`, `canvas_board`, `canvas_node`, `canvas_render`, `canvas_edge`, `canvas_group`, `canvas_history`, `canvas_view`, `canvas_query`, `canvas_webview`, `canvas_app`, `canvas_snapshot`, `canvas_ax_state`, `canvas_ax_work`, `canvas_ax_gate`, `canvas_ax_timeline`, `canvas_ax_delivery`, `canvas_intent`) plus 6 standalone tools (`canvas_batch`, `canvas_pin_nodes`, `canvas_invoke_command`, `canvas_ax_interaction`, `canvas_ingest_activity`, `canvas_screenshot`). `canvas_import` is the agent half of the human-consented attachment workflow: agents list/read requested imports, submit reviewable Markdown, or report unavailable; they cannot request, cancel, or commit. The 57 legacy single-purpose tools the composites replaced were removed in v0.3.0; v0.4.0 shipped the `canvas_snapshot` composite and removed the 6 deprecated snapshot standalones. Prefer composites for new MCP calls; see `docs/mcp.md` for the authoritative tool list and the legacy-to-composite migration reference.
+25 tools: 18 action-discriminated composites (`canvas_import`, `canvas_board`, `canvas_node`, `canvas_render`, `canvas_edge`, `canvas_group`, `canvas_history`, `canvas_view`, `canvas_query`, `canvas_webview`, `canvas_app`, `canvas_snapshot`, `canvas_ax_state`, `canvas_ax_work`, `canvas_ax_gate`, `canvas_ax_timeline`, `canvas_ax_delivery`, `canvas_intent`) plus 7 standalone tools (`canvas_help`, `canvas_batch`, `canvas_pin_nodes`, `canvas_invoke_command`, `canvas_ax_interaction`, `canvas_ingest_activity`, `canvas_screenshot`). `canvas_help { op }` returns one MCP registry operation's public arguments and guidance without accessing the canvas; omit `op` to list names. `canvas_import` is the agent half of the human-consented attachment workflow: agents list/read requested imports, submit reviewable Markdown, or report unavailable; they cannot request, cancel, or commit. The 57 legacy single-purpose tools the composites replaced were removed in v0.3.0; v0.4.0 shipped the `canvas_snapshot` composite and removed the 6 deprecated snapshot standalones. Prefer composites for new MCP calls; see `docs/mcp.md` for the authoritative tool list and the legacy-to-composite migration reference.
 
 ### Agent-assisted document imports
 
@@ -18,7 +18,7 @@ The `diagram` action of `canvas_app` is a thin preset in `src/server/diagram-pre
 
 15 static canvas resources: `canvas://boards`, `canvas://pinned-context`, `canvas://schema`, `canvas://layout`, `canvas://summary`, `canvas://spatial-context`, `canvas://history`, `canvas://code-graph`, `canvas://ax`, `canvas://ax-context`, `canvas://ax-timeline`, `canvas://ax-work`, `canvas://ax-pending-steering`, `canvas://ax-delivery`, `canvas://skills`; two canvas resource templates: `canvas://context{?budget,consumer,since}` and `canvas://graph{?focus,depth}`. Bundled skills additionally register per-skill `canvas://skills/<name>` resources and the `skill://{name}/{+path}` file template.
 
-Resource change notifications: the MCP server emits `notifications/resources/updated` when canvas state changes. Pin changes notify `canvas://pinned-context`; all mutations notify `canvas://layout`, `canvas://summary`, `canvas://spatial-context`, `canvas://history`, `canvas://code-graph`, and `canvas://graph`. This enables real-time human→agent collaboration — humans pin nodes in the browser, agents are notified immediately.
+Resource change notifications: subscribe to each live URI to receive `notifications/resources/updated` when canvas state or knowledge policies change. Notifications invalidate cached data without reading it. Subscriptions belong to the connection; subscribe again after reconnecting. See [Resource subscriptions](mcp.md#resource-subscriptions-010).
 
 ### AX Primitives (host-agnostic)
 

package/docs/cli.md

@@ -99,7 +99,8 @@ offset mid-move without changing endpoints. Tours allow at most 1000 stops.
 Tours persist with the board and snapshots, participate in undo, and clear with
 the board. A file containing `null` resets the tour: when none is saved, groups
 are sorted by y, then x, then ID. A saved empty `stops` array deliberately has no
-stops. SDK: `canvas.setTour(tourOrNull)` / `canvas.getTour()`.
+stops. SDK: `canvas.setTour(tourOrNull)` / `canvas.getTour()`, which returns
+`{ tour, derived, position }` as of 0.10; read stops from `.tour.stops`.
 
 ### Driving a tour (agents)
 
@@ -593,6 +594,14 @@ pmx-canvas copilot install-extension --dry-run   # Preview target, writes nothin
 pmx-canvas copilot install-extension --yes        # Install/overwrite into .github/extensions/pmx-canvas/
 ```
 
+After updating the adapter, start a new Copilot project session to load it.
+Panel instructions, `send_instruction` and canvas steering request the SDK's
+`immediate` mode: during an active turn, Copilot receives them before its next
+model call, without aborting an executing tool. If the turn has already ended,
+the SDK queues the instruction instead. A successful send means the host accepted
+the instruction, not that the model has consumed it. Failed sends are not marked
+delivered; the delivery pump retries them.
+
 ## Skill sync
 
 Refresh the pmx-canvas skill copies **already installed** in this workspace.

package/docs/design/Chrome.dc.html

@@ -125,6 +125,7 @@ body{margin:0}
 <div style="height: 350px; display: flex; flex-direction: column; border: 1px solid #1b2c44; border-radius: 14px; overflow: hidden; background: #0f1d31">
 <div style="flex-shrink: 0; height: 46px; display: flex; align-items: center; gap: 10px; padding: 0 16px; border-bottom: 1px solid #1b2c44; font-size: 13px; font-weight: 600">Research index <span style="margin-left: auto; font-size: 12px; font-weight: 400">Relations</span><span style="margin-left: 12px">×</span></div>
 <div style="flex: 1; min-height: 0; overflow: auto; padding: 16px; font-size: 13px; color: #b9c6d6">Read and edit the source here. Actual edits finish saving before a reference opens; a refused save keeps this reader and its draft.</div>
+<button style="flex-shrink: 0; align-self: flex-end; margin: 16px; padding: 8px 18px; border: 1px solid #1b2c44; border-radius: 6px; font: 600 13px 'IBM Plex Sans', sans-serif; background: #13243b; color: #8ea3bd">&lt;/&gt; Source</button>
 <div role="region" aria-label="Cross-board references" tabindex="0" style="flex-shrink: 0; max-height: min(40%, 132px); overflow: auto; overscroll-behavior: contain">
 <div style="padding: 6px 12px; border-top: 1px solid #1b2c44; font-size: 12px; color: #b9c6d6">↗ references: Research / Interview notes</div>
 <div style="padding: 6px 12px; border-top: 1px solid #1b2c44; font-size: 12px; color: #b9c6d6">↗ references: Research / Findings</div>

package/docs/design.md

@@ -504,7 +504,9 @@ retain their hit targets. Grab areas yield to every card, including neighboring
 but outrank connection labels and lines. Group interiors still select and open their menus,
 below child ports and labels; the frames and labels keep their existing visual stacking.
 Expanded flow documents put Source in a separate row above the reader, clear of the
-bottom dock's action hints; ordinary documents keep their bottom-right Source button.
+bottom dock's action hints. Ordinary documents keep Source at the bottom right in a
+reserved row below the scroll viewport, so it cannot cover text at narrow widths
+or intermediate scroll positions (0.9.2 review follow-up, 2026-10-24).
 Hovering a flow action temporarily
 hides another action's keyboard hint without moving focus; leaving restores the focused hint.
 Card checkbox clicks address parsed Markdown tasks, not fenced/indented examples or raw

package/docs/http-api.md

@@ -3,6 +3,37 @@
 REST endpoints for all canvas operations + an SSE event stream. Works from
 any language. Default base URL: `http://localhost:4313`.
 
+## Operation cancellation and progress (0.10)
+
+Registry-backed operation routes use the request's abort signal. Disconnecting
+stops supported AX waits, cancels webpage fetching and prevents later batch
+operations from starting. Completed writes remain. Cancellation is cooperative:
+external app builds/runtime calls and local WebView captures cannot be interrupted
+mid-call. A standalone cancelled operation returns HTTP 499 with
+`{ "ok": false, "cancelled": true, "error": "Operation cancelled." }` when the
+connection still permits a response. An interrupted batch retains completed
+`results` and `refs` in its partial-failure body and adds `cancelled: true`.
+Disconnected clients must inspect state before retrying; they may never receive
+that body. Cancellation is not rollback.
+
+Send `Accept: application/x-ndjson` to opt into batch and supported AX wait progress
+over the operation response stream. Each newline-delimited JSON frame is one of:
+
+```json
+{"type":"progress","progress":{"progress":1,"total":3,"message":"node.add"}}
+{"type":"result","status":200,"body":{"ok":true,"results":[],"refs":{}}}
+```
+
+The examples show frame shapes, not one complete batch. The terminal `result`
+frame carries the ordinary operation status and body; the stream's HTTP 200 does
+not establish operation success. Without this header, routes keep their ordinary
+JSON status/body. Early validation errors may still be ordinary JSON. The
+in-process and HTTP operation invokers accept optional `{ signal, onProgress }`;
+the HTTP invoker negotiates this stream only when given a progress callback.
+
+AX wait routes accept `timeoutMs` as well as the direct-HTTP `waitMs` parameter;
+`timeoutMs` takes precedence when both are supplied.
+
 ## Knowledge lifecycle data (plan 017 slice 1)
 
 The slice-1 data contract now also drives the workbench, due engine and qualified agent context.