pmx-canvas 0.10.0 → 0.12.0

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

@@ -98,6 +98,7 @@ export interface AxInteractionInput {
  * Injected so this module stays free of a runtime canvas-state import.
  */
 export interface AxInteractionManager {
+    readonly boardIdentity: object;
     getNode(id: string): CanvasNodeState | undefined;
     /** Canvas read for `ax.flow.materialize` (placement obstacles + stale flow sweep). */
     getLayout(): CanvasLayout;

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

@@ -41,9 +41,13 @@ export interface AxStateManagerDeps {
 }
 export declare class AxStateManager {
     private readonly deps;
+    private readonly host;
     private _axState;
-    private _axHostCapability;
-    constructor(deps: AxStateManagerDeps);
+    constructor(deps: AxStateManagerDeps, host?: {
+        capability: PmxAxHostCapability | null;
+    });
+    private get _axHostCapability();
+    private set _axHostCapability(value);
     private normalizeForCurrentNodes;
     private applyAxState;
     /** Reset the canvas-bound partition to empty (used by clear() and applyPersistedState()). */
@@ -269,6 +273,8 @@ export declare class AxStateManager {
     getPendingSteering(options?: {
         consumer?: string;
         limit?: number;
+        addressedOnly?: boolean;
+        offset?: number;
     }): PmxAxSteeringMessage[];
     /**
      * NEWEST undelivered steering first, for the compact AX context lead block (report
@@ -278,6 +284,8 @@ export declare class AxStateManager {
     getPendingSteeringForContext(options?: {
         consumer?: string;
         limit?: number;
+        addressedOnly?: boolean;
+        offset?: number;
     }): PmxAxSteeringMessage[];
     /** Total undelivered steering for a consumer (loop-safe), for the context backlog counts. */
     getPendingSteeringCount(consumer?: string): number;

package/dist/types/server/board-local.d.ts

@@ -0,0 +1,4 @@
+/** Board-owned runtime state, discarded with its owner rather than on navigation. */
+export declare function createBoardLocal<T>(create: () => T, dispose?: (value: T) => void): {
+    readonly current: T;
+};

package/dist/types/server/board-move.d.ts

@@ -0,0 +1,38 @@
+import type { ActorAttribution } from './attribution.js';
+import type { CanvasBoard, PersistedCanvasState } from './canvas-db.js';
+import type { DocumentImport } from './document-import.js';
+export interface BoardMoveInput {
+    sourceBoardId: string;
+    nodeIds: string[];
+    name: string;
+    expectedRevision: number;
+    requestId: string;
+    preview?: boolean;
+}
+export interface BoardMovePreview {
+    sourceBoardId: string;
+    nodeIds: string[];
+    affectedBoardIds: string[];
+    readmeNodeId: string | null;
+    pinnedNodeIds: string[];
+    liveTaskNodeIds: string[];
+    attachmentIds: string[];
+    blockers: string[];
+    notices: string[];
+}
+export interface BoardMoveResult {
+    sourceBoardId: string;
+    destinationBoardId: string;
+    portalId: string;
+    nodeIds: string[];
+    affectedBoardIds: string[];
+}
+export interface MoveBoard {
+    board: CanvasBoard;
+    state: PersistedCanvasState;
+}
+/** Pure relocation plan. Preview and commit run the same checks on a consistent library view. */
+export declare function prepareBoardMove(input: BoardMoveInput, library: Map<string, MoveBoard>, destinationId: string, portalId: string, imports: DocumentImport[], runtimeBlockers: ReadonlyMap<string, string>, actor: ActorAttribution, at: string): {
+    preview: BoardMovePreview;
+    states: Map<string, PersistedCanvasState>;
+};

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

@@ -14,6 +14,10 @@ import { type PmxAxState, type PmxAxEvent, type PmxAxEvidence, type PmxAxSteerin
 export type CanvasTheme = CanvasThemeName;
 export declare function normalizeCanvasTheme(value: unknown, fallback?: CanvasTheme): CanvasTheme;
 export interface PersistedCanvasState {
+    /** Optimistic storage baseline, independent of content/read/review clocks. New boards start at zero. */
+    storageVersion?: number;
+    /** Snapshot restore boundary, not an authored content version. */
+    moveBoundary?: string | null;
     tour?: Tour;
     version: number;
     theme?: CanvasTheme;
@@ -70,8 +74,10 @@ export declare function finalizeCanvasDbForClose(db: Database): void;
 /** The theme is workspace-wide: it is saved even while no board is open. */
 export declare function saveThemeToDB(db: Database, theme: CanvasTheme | undefined): void;
 export declare function readThemeFromDB(db: Database): CanvasTheme | undefined;
-/** Saves one board's state; every other board's rows are untouched. */
-export declare function saveStateToDB(db: Database, boardId: string, state: PersistedCanvasState): void;
+export declare function boardStorageVersion(db: Database, boardId: string): number;
+export declare function assertBoardStorageVersion(db: Database, boardId: string, expected: number): void;
+/** Save one board, returning its new baseline. Publish the baseline only after the outer transaction commits. */
+export declare function saveStateToDB(db: Database, boardId: string, state: PersistedCanvasState): number;
 /** Loads one board (the open board when `boardId` is omitted); null when there is no such board. */
 export declare function loadStateFromDB(db: Database, boardId?: string): PersistedCanvasState | null;
 export interface CanvasBoard {
@@ -161,6 +167,8 @@ export declare function loadAxSteeringFromDB(db: Database, q?: AxTimelineQuery &
 export declare function loadPendingAxSteeringFromDB(db: Database, options?: {
     consumer?: string;
     limit?: number;
+    addressedOnly?: boolean;
+    offset?: number;
 }): PmxAxSteeringMessage[];
 /**
  * NEWEST undelivered steering first (report #57) for the compact AX context lead
@@ -173,6 +181,8 @@ export declare function loadPendingAxSteeringFromDB(db: Database, options?: {
 export declare function loadNewestPendingAxSteeringFromDB(db: Database, options?: {
     consumer?: string;
     limit?: number;
+    addressedOnly?: boolean;
+    offset?: number;
 }): PmxAxSteeringMessage[];
 /** Total undelivered steering for a consumer (loop-safe — excludes the consumer's own; target-scoped). */
 export declare function countPendingAxSteeringFromDB(db: Database, consumer?: string): number;

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

@@ -206,16 +206,15 @@ export declare function restoreCanvasSnapshot(idOrName: string): Promise<{
     ok: boolean;
 }>;
 /**
- * Open a board (or Home for null): the state layer saves the current board and
- * loads the next, and everything else that holds the old board in memory is
- * reset — undo closures, pending intents, file watchers, app sessions and the
- * code graph (the trace chain restarts itself when its last node is gone).
- * Agent and human presence are kept: they belong to the people and agents,
- * not to a board.
+ * Open a board (or Home for null), retaining other live boards and their
+ * undo history, intents, watchers and app sessions for background operations.
  */
 export declare function openCanvasBoard(id: string | null): {
     ok: boolean;
 };
+export declare function startBoardRuntime(options?: {
+    forceRehydrateExtApps?: boolean;
+}): void;
 /**
  * Restore the whole library from a backup file (the current file is kept as
  * `<db>.before-restore`); the restored library opens on its last open board.

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

@@ -8,9 +8,9 @@ declare const observedSourceSchema: z.ZodObject<{
     contentRevision: z.ZodOptional<z.ZodNumber>;
     observedAt: z.ZodOptional<z.ZodISODateTime>;
     availability: z.ZodOptional<z.ZodEnum<{
+        unavailable: "unavailable";
         live: "live";
         cached: "cached";
-        unavailable: "unavailable";
     }>>;
 }, z.core.$strip>;
 declare const recipeSchema: z.ZodObject<{

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

@@ -28,6 +28,7 @@ export interface CanvasAnnotationSummary {
 export interface CanvasAnnotationContextSummary {
     id: string;
     label: string | null;
+    text?: string;
     bounds: CanvasAnnotation['bounds'];
     targetNodeIds: string[];
     targetNodeTitles: string[];

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

@@ -11,6 +11,7 @@
  * `.pmx-canvas-snapshots/`, loose blob files) are no longer imported as of 0.4.0 —
  * the one-shot boot migration into SQLite was retired.
  */
+import { type BoardMoveInput, type BoardMovePreview, type BoardMoveResult } from './board-move.js';
 import { type WorkspaceSettings } from '../shared/workspace-settings.js';
 import { KnowledgeLifecycle, type Lifecycle } from './knowledge-lifecycle.js';
 import { type Tour } from '../shared/tour.js';
@@ -170,6 +171,7 @@ export interface CanvasNodeUpdate {
         height: number;
     };
     collapsed?: boolean;
+    zIndex?: number;
 }
 export type CanvasChangeType = 'pins' | 'nodes' | 'ax' | 'ax-timeline';
 /** Name for a board nobody named yet: when it was made, to the minute. */
@@ -189,20 +191,60 @@ interface ApplyUpdatesOptions {
     skipGroupChildTranslation?: boolean;
 }
 declare class CanvasStateManager {
-    private nodes;
-    private edges;
-    private annotations;
-    private _viewport;
-    private _tour;
+    private readonly boardExecution;
+    private readonly liveBoards;
+    private nextGeneration;
+    private navigationGeneration;
+    private readonly hostState;
+    private visibleBoard;
+    private get boardState();
+    /** Identity for board-owned runtime caches. Never shared by a replacement board. */
+    get boardIdentity(): object;
+    onBoardDispose(cleanup: () => void): () => void;
+    private disposeBoardRuntime;
+    /** The human's navigation target, independent of the calling operation's board. */
+    get visibleBoardId(): string | null;
+    get visibleBoardGeneration(): number;
+    get isBackgroundBoard(): boolean;
+    /** Execute on a live board without activating it, retaining ownership across awaits. */
+    withBoard<T>(id: string, fn: () => T): T;
+    /** Bind callbacks to their board, rather than the context of whoever invokes them. */
+    bindBoard<T extends unknown[], R>(fn: (...args: T) => R): (...args: T) => R;
+    /** Viewer/global projections must not inherit the producer's board scope. */
+    withVisibleBoard<T>(fn: () => T): T;
+    /** Sweep resident runtime owners without loading the entire stored library. */
+    forEachLiveBoard(fn: () => void): void;
+    private loadBoardState;
+    private createBoardState;
+    private get nodes();
+    private get edges();
+    private get annotations();
+    private get _viewport();
+    private set _viewport(value);
+    private get _tour();
+    private set _tour(value);
+    private get _contextPinnedNodeIds();
+    private set _contextPinnedNodeIds(value);
+    private get _contextPinMeta();
+    private set _contextPinMeta(value);
+    private get _storageVersion();
+    private set _storageVersion(value);
+    private get _contentRevision();
+    private set _contentRevision(value);
+    private get _revisionFloor();
+    private set _revisionFloor(value);
+    private get _deletionTombstones();
+    private set _deletionTombstones(value);
+    private get _boardGeneration();
+    private set _boardGeneration(value);
+    private get _saveTimer();
+    private set _saveTimer(value);
+    private get _lastPersistenceError();
+    private set _lastPersistenceError(value);
+    private get ax();
     private _theme;
-    private _contextPinnedNodeIds;
-    /** Who pinned each pin, when and why; kept only for ids in `_contextPinnedNodeIds`. */
-    private _contextPinMeta;
     private _workspaceRoot;
-    private _contentRevision;
-    private _revisionFloor;
-    private _deletionTombstones;
-    private readonly ax;
+    private moveRuntimeBlockers;
     private _changeListeners;
     /**
      * Register a listener for state changes. Used by MCP server to emit resource
@@ -237,6 +279,12 @@ declare class CanvasStateManager {
     private applyResolvedGroupBounds;
     private getGroupSnapshot;
     private normalizeNode;
+    private refreshLiveWorkCards;
+    private refreshCurrentLiveWorkCards;
+    /** Reconcile a stored display cache and its cursor clock in the same SQLite transaction. */
+    private readProjectedBoard;
+    /** Call before capturing a context snapshot, never from per-node getters used during writes. */
+    refreshContextWorkCards(): void;
     private nextContentRevision;
     private revisionState;
     /**
@@ -253,7 +301,6 @@ declare class CanvasStateManager {
     private compactGroupChildren;
     private _db;
     private _dbPath;
-    private _saveTimer;
     readonly knowledge: KnowledgeLifecycle;
     /** Workspace root backing persistence and workspace-relative path resolution. */
     get workspaceRoot(): string;
@@ -288,11 +335,12 @@ declare class CanvasStateManager {
      * layout) on the board it had open last.
      */
     replaceDatabase(file: string): void;
-    private _activeBoardId;
-    private _boardGeneration;
+    private get _activeBoardId();
+    private set _activeBoardId(value);
     /** Invalidates asynchronous work whenever the loaded board state is replaced. */
     get boardGeneration(): number;
-    /** The open board, or null on Home. */
+    get boardLifetimeGeneration(): number;
+    /** The execution board, or the open board outside a scoped operation. */
     get activeBoardId(): string | null;
     getActiveBoard(): CanvasBoard | null;
     /** Synchronous, owner-controlled static creation. No board activation or runtime hydration. */
@@ -302,6 +350,10 @@ declare class CanvasStateManager {
     createStoredEdge(boardId: string, requestId: string | undefined, fingerprint: string, build: (nodes: CanvasNodeState[]) => CanvasEdge): CanvasEdge;
     /** Stored creations share one durable receipt/commit boundary, never a temporary board switch. */
     private createStoredCreation;
+    /** Called inside a transaction: publish no storage clocks until it commits. */
+    private stageLiveBoards;
+    /** A stored multi-board write retains each live owner's runtime and camera. */
+    private reconcileStoredBoards;
     /** Read a board without activating it. This projection is not a write payload. */
     readBoard(id: string, includeBlobs?: boolean): {
         board: CanvasBoard;
@@ -336,6 +388,14 @@ declare class CanvasStateManager {
     advanceContextBriefCursor(boardId: string, consumer: string, revision: number): void;
     /** Creates a board without opening it. */
     createBoard(name: string, folder?: string | null): CanvasBoard | null;
+    /** The host supplies runtime ownership, not another copy of board state. */
+    setMoveRuntimeBlockers(read: () => ReadonlyMap<string, string>): void;
+    moveSelectionToNewBoard(input: BoardMoveInput): {
+        preview: BoardMovePreview;
+    } | {
+        result: BoardMoveResult;
+        replayed: boolean;
+    };
     updateBoard(id: string, patch: Pick<Parameters<typeof updateBoardInDB>[2], 'name' | 'folder' | 'mapPosition' | 'relationVocabulary'>): boolean;
     setBoardReadme(id: string, nodeId: string | null): boolean;
     /**
@@ -357,9 +417,8 @@ declare class CanvasStateManager {
     /** Deletes a board and its snapshots; deleting the open board returns to Home first. */
     deleteBoard(id: string): boolean;
     /**
-     * Save the open board, then open `id` (or Home for null). The canvas state is
-     * replaced wholesale; callers own the runtime side (undo history, app
-     * sessions, watchers, SSE) — see `openCanvasBoard` in canvas-operations.
+     * Save pending boards, then select the visible owner. Existing partitions
+     * remain live; canvas-operations starts the selected board's runtime/SSE.
      */
     switchBoard(id: string | null): boolean;
     /**
@@ -374,7 +433,6 @@ declare class CanvasStateManager {
     private persistedState;
     /** Write current state to SQLite immediately. */
     private saveToDisk;
-    private _lastPersistenceError;
     /** Health view of state persistence: ok until a save fails, ok again after the next success. */
     get persistenceHealth(): {
         ok: boolean;
@@ -399,6 +457,8 @@ declare class CanvasStateManager {
     gcSnapshots(options?: CanvasSnapshotGcOptions): CanvasSnapshotGcResult;
     /** Restore canvas state from a snapshot. */
     restoreSnapshot(idOrName: string): boolean;
+    /** Old snapshots stay readable, but neither whole-board nor one-card restore crosses a move. */
+    assertSnapshotRestorable(idOrName: string): void;
     /** Read a snapshot's data without restoring it (for diff). Resolves by ID or name. */
     getSnapshotData(idOrName: string): {
         name: string;
@@ -496,6 +556,7 @@ declare class CanvasStateManager {
     }): PmxAxFocusState;
     clearAxFocus(): PmxAxFocusState;
     getWorkItems(): PmxAxWorkItem[];
+    getWorkItemsOnBoard(boardId: string): PmxAxWorkItem[];
     addWorkItem(input: {
         title: string;
         status?: PmxAxWorkItemStatus;
@@ -674,10 +735,14 @@ declare class CanvasStateManager {
     getPendingSteering(options?: {
         consumer?: string;
         limit?: number;
+        addressedOnly?: boolean;
+        offset?: number;
     }): PmxAxSteeringMessage[];
     getPendingSteeringForContext(options?: {
         consumer?: string;
         limit?: number;
+        addressedOnly?: boolean;
+        offset?: number;
     }): PmxAxSteeringMessage[];
     getPendingSteeringCount(consumer?: string): number;
     getAxTimelineSummary(): PmxAxTimelineSummary;
@@ -740,4 +805,5 @@ declare class CanvasStateManager {
     releaseGroupChildren(groupId: string): boolean;
     clear(): void;
 }
+export declare const boardCatalogEpoch: `${string}-${string}-${string}-${string}-${string}`;
 export declare const canvasState: CanvasStateManager;

package/dist/types/server/card-relocation.d.ts

@@ -0,0 +1,6 @@
+import type { Database } from 'bun:sqlite';
+/** JSON target list parameter; event ranges prevent a reused old ID inheriting the moved card's history. */
+export declare const CARD_HISTORY_CTE = "WITH RECURSIVE\n  targets AS (SELECT json_extract(value, '$.boardId') AS current_board,\n                     json_extract(value, '$.cardId') AS node_id FROM json_each(?)),\n  history(current_board, node_id, board_id, review_after, review_through, read_after, read_through, move_before) AS (\n    SELECT current_board, node_id, current_board,\n      COALESCE((SELECT MAX(review_through) FROM card_relocations r WHERE (r.from_board = t.current_board OR r.to_board = t.current_board) AND r.node_id = t.node_id), 0),\n      9223372036854775807,\n      COALESCE((SELECT MAX(read_through) FROM card_relocations r WHERE (r.from_board = t.current_board OR r.to_board = t.current_board) AND r.node_id = t.node_id), 0),\n      9223372036854775807, 9223372036854775807 FROM targets t\n    UNION ALL\n    SELECT h.current_board, h.node_id, r.from_board, r.review_after, r.review_through,\n      r.read_after, r.read_through, r.sequence\n    FROM history h JOIN card_relocations r ON r.to_board = h.board_id AND r.node_id = h.node_id\n    AND r.sequence = (SELECT MAX(sequence) FROM card_relocations prior\n      WHERE (prior.to_board = h.board_id OR prior.from_board = h.board_id)\n      AND prior.node_id = h.node_id AND prior.sequence < h.move_before)\n  )";
+/** Record locations, not new reads or validations. Called inside the move transaction. */
+export declare function recordCardRelocation(db: Database, requestId: string, from: string, to: string, nodeIds: string[]): void;
+export declare function boardMoveBoundary(db: Database, boardId: string): string | null;

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

@@ -32,6 +32,8 @@ export interface ContextRead {
     boardId: string | null;
 }
 export type ContextReadInput = Omit<ContextRead, 'seq' | 'id' | 'at' | 'boardId' | 'readNodes' | 'seenLinks'> & {
+    /** Stable adapter receipt identity. Retries record this delivery once per consumer and board. */
+    deliveryId?: string;
     /** Explicit read target, captured before asynchronous formatting/proxy work. */
     boardId?: string | null;
     /** Ids of every serialized node in what the reader received; the server keeps those on the board. */
@@ -83,7 +85,7 @@ export declare function contextReadFromPayload(base: Omit<ContextReadInput, 'del
 export declare function pinnedBoardReads(base: Omit<ContextReadInput, 'deliveredNodeIds' | 'bytes' | 'readNodeIds' | 'pinnedNodeIds' | 'boardId'>, payload: unknown): ContextReadInput[];
 /** Graph summaries are seen on their own boards, never full-content reads or a board switch. */
 export declare function graphReads(base: Pick<ContextReadInput, 'channel' | 'resource' | 'source' | 'consumer' | 'agentId'>, graph: MemoryGraph): ContextReadInput[];
-export declare const CONTEXT_READS_SCHEMA_SQL = "\n  CREATE TABLE IF NOT EXISTS context_reads (\n    seq INTEGER PRIMARY KEY AUTOINCREMENT,\n    id TEXT NOT NULL UNIQUE,\n    at TEXT NOT NULL,\n    channel TEXT NOT NULL,\n    resource TEXT NOT NULL,\n    source TEXT NOT NULL,\n    consumer TEXT,\n    agent_id TEXT,\n    pinned_node_ids TEXT NOT NULL DEFAULT '[]',\n    delivered_node_ids TEXT NOT NULL DEFAULT '[]',\n    bytes INTEGER NOT NULL DEFAULT 0,\n    board_id TEXT,\n    read_nodes TEXT NOT NULL DEFAULT '{}',\n    seen_links TEXT NOT NULL DEFAULT '{}'\n  );\n";
+export declare const CONTEXT_READS_SCHEMA_SQL = "\n  CREATE TABLE IF NOT EXISTS context_read_receipts (id TEXT PRIMARY KEY);\n  CREATE TABLE IF NOT EXISTS context_reads (\n    seq INTEGER PRIMARY KEY AUTOINCREMENT,\n    id TEXT NOT NULL UNIQUE,\n    at TEXT NOT NULL,\n    channel TEXT NOT NULL,\n    resource TEXT NOT NULL,\n    source TEXT NOT NULL,\n    consumer TEXT,\n    agent_id TEXT,\n    pinned_node_ids TEXT NOT NULL DEFAULT '[]',\n    delivered_node_ids TEXT NOT NULL DEFAULT '[]',\n    bytes INTEGER NOT NULL DEFAULT 0,\n    board_id TEXT,\n    read_nodes TEXT NOT NULL DEFAULT '{}',\n    seen_links TEXT NOT NULL DEFAULT '{}'\n  );\n";
 export declare function appendContextReadToDB(db: Database, input: ContextReadInput, boardId: string | null, readNodes?: Record<string, number>, seenLinks?: Record<string, number>): ContextRead;
 /** Per node on a board, the latest agent read that delivered its content (newest row wins). */
 export declare function loadNodeReadStatusFromDB(db: Database, boardId: string): NodeReadStatus[];

package/dist/types/server/human-presence.d.ts

@@ -28,7 +28,7 @@ export declare class HumanPresenceRegistry {
     set(raw: unknown, now?: number): HumanPresence | null;
     snapshot(now?: number): HumanPresenceSnapshot;
     /** Nodes a human is holding right now → that human's name. The edit lock. */
-    lockedNodes(now?: number): Map<string, string>;
+    lockedNodes(now?: number, boardId?: string | null): Map<string, string>;
     reset(): void;
     private publicView;
     private sweep;

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

@@ -1,8 +1,10 @@
 import { EventEmitter } from 'node:events';
-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 { TourState, TourStep, TourStepResult } from './tour-control.js';
+import type { BoardMoveInput, BoardMovePreview, BoardMoveResult } from './board-move.js';
+export type { BoardMoveInput, BoardMovePreview, BoardMoveResult } from './board-move.js';
+import type { Camera, Tour, TourPresenter, TourStop } from '../shared/tour.js';
+import { type TourState, type TourStep, type TourStepResult, type TourSuperseded } from './tour-control.js';
+export type { Tour, TourPresenter, TourStop } from '../shared/tour.js';
+export type { TourState, TourStep, TourStepResult, TourSuperseded } 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';
@@ -130,11 +132,8 @@ export declare class PmxCanvas extends EventEmitter {
         animated?: boolean;
     }): string;
     updateEdge(id: string, patch: Partial<Pick<CanvasEdge, 'type' | 'kind' | 'reason' | 'label' | 'style' | 'animated'>>): Promise<CanvasEdge>;
-    addAnnotation(input: Omit<CanvasAnnotation, 'id' | 'createdAt'> & {
-        id?: string;
-        createdAt?: string;
-    }): string;
-    removeAnnotation(id: string): boolean;
+    addAnnotation(input: Pick<CanvasAnnotation, 'points'> & Partial<Pick<CanvasAnnotation, 'id' | 'type' | 'color' | 'width' | 'text' | 'label'>>): Promise<string>;
+    removeAnnotation(id: string): Promise<boolean>;
     removeEdge(id: string): void;
     /**
      * Create a group node and optionally add child nodes to it.
@@ -168,9 +167,14 @@ export declare class PmxCanvas extends EventEmitter {
     /** Present a tour stop (index, `next` or `previous`) in the workbench. Not recorded in undo history. */
     goToTourStop(step: TourStep, options?: {
         present?: boolean;
+        presenter?: undefined;
     }): TourStepResult;
+    goToTourStop(step: TourStep, options: {
+        present?: boolean;
+        presenter?: TourPresenter;
+    }): TourStepResult | TourSuperseded;
     /** Leave presentation in every viewer. */
-    exitTour(): void;
+    exitTour(presenter?: TourPresenter): void;
     /** Ease the camera to a node, world rect or viewport. Not recorded in undo history. */
     moveCamera(stop: TourStop): {
         viewport: Camera;
@@ -224,6 +228,8 @@ export declare class PmxCanvas extends EventEmitter {
     getPendingSteering(options?: {
         consumer?: string;
         limit?: number;
+        addressedOnly?: boolean;
+        offset?: number;
     }): PmxAxSteeringMessage[];
     /**
      * Submit a node-originated AX interaction (plan-004 Phase 1). Validates the
@@ -284,6 +290,14 @@ export declare class PmxCanvas extends EventEmitter {
         includeStructure?: boolean;
         preview?: boolean;
     }): Promise<Record<string, unknown>>;
+    /** Relocate identities atomically; preview is read-only and retries reuse the original receipt. */
+    moveSelectionToNewBoard(input: BoardMoveInput): Promise<{
+        ok: true;
+        preview: BoardMovePreview;
+    } | (BoardMoveResult & {
+        ok: true;
+        replayed: boolean;
+    })>;
     searchLibrary(query: string, limit?: number): Promise<Record<string, unknown>>;
     /** Same projection as Home Graph. Discovery summaries never count as full-content reads. */
     getMemoryGraph(options?: {
@@ -296,6 +310,8 @@ export declare class PmxCanvas extends EventEmitter {
         consumer?: string;
         since?: number;
         budget?: number;
+        contextDelivery?: boolean;
+        includeSteering?: boolean;
     }): Promise<Record<string, unknown>>;
     /** Open a board, or Home with null. */
     openBoard(id: string | null): Promise<void>;

package/dist/types/server/intent-registry.d.ts

@@ -1,14 +1,18 @@
 import { type PmxAxIntent, type PmxAxIntentKind } from '../shared/ax-intent.js';
 type IntentEmitter = (event: string, payload: Record<string, unknown>) => void;
 export declare class IntentRegistry {
-    private readonly intents;
-    private readonly vetoedIntentIds;
-    private readonly committingIntentIds;
+    private readonly board;
+    private get intents();
+    private get vetoedIntentIds();
+    private get committingIntentIds();
     private emit;
-    private sweepTimer;
+    private get sweepTimer();
+    private set sweepTimer(value);
     /** Inject the workbench SSE emitter (server.ts wires this at module load). */
     setEmitter(emitter: IntentEmitter | null): void;
     list(): PmxAxIntent[];
+    /** The first write from Home adopts its ghosts and vetoes without opening on signal. */
+    moveHomeIntentsToBoard(boardId: string): void;
     /** Signal a new (or replace an existing) intent. Returns the stored envelope. */
     signal(raw: unknown): PmxAxIntent;
     /** Patch a live intent (position/label/reason/confidence/seq) and bump its TTL. */

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

@@ -183,7 +183,7 @@ export declare class KnowledgeLifecycle {
             cadenceDays?: number | undefined;
         } | null;
         lifecycleSourceFolder: string | null;
-        lifecycleSource: "card" | "unknown" | "folder";
+        lifecycleSource: "unknown" | "card" | "folder";
     };
     resolveCard(folderPath: string | null, node: Pick<CanvasNodeState, 'type' | 'data'>, catalog?: {
         categories: KnowledgeCategory[];
@@ -209,7 +209,7 @@ export declare class KnowledgeLifecycle {
             cadenceDays?: number | undefined;
         } | null;
         lifecycleSourceFolder: string | null;
-        lifecycleSource: "card" | "unknown" | "folder";
+        lifecycleSource: "unknown" | "card" | "folder";
     };
     private indexedDb;
     /** Stored owners of semantic sources; the caller overlays the active board's unsaved edges. */
@@ -219,6 +219,8 @@ export declare class KnowledgeLifecycle {
         lastValidation: ReviewRecord | null;
         retired: boolean;
     }>;
+    /** Resolve a current card's location when evidence was recorded, without rewriting that evidence. */
+    locationAtReview(review: ReviewRecord, target: MemoryTarget): MemoryTarget;
     reviews(boardId: string, nodeId: string): {
         records: ReviewRecord[];
         retired: boolean;

package/dist/types/server/mutation-history.d.ts

@@ -71,11 +71,13 @@ export interface SnapshotDiffResult {
     }[];
 }
 declare class MutationHistory {
-    private entries;
-    /** Index of the last applied mutation. -1 means nothing applied / all undone. */
-    private cursor;
-    /** When true, mutations triggered by undo/redo are not recorded. */
-    private _replaying;
+    private readonly board;
+    private get entries();
+    private set entries(value);
+    private get cursor();
+    private set cursor(value);
+    private get _replaying();
+    private set _replaying(value);
     get isReplaying(): boolean;
     /**
      * Record a new mutation. Truncates any redo-able future, then appends.

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

@@ -1,6 +1,5 @@
 import { type CanvasLayout } from '../../canvas-state.js';
 import { type Operation } from '../types.js';
-export declare const boardCatalogEpoch: `${string}-${string}-${string}-${string}-${string}`;
 export declare function boardsPayload(reloaded?: boolean): Record<string, unknown>;
 /** Read a board without opening it. Omitted board preserves the active-board contract. */
 export declare function readTargetBoard(boardId?: unknown, includeBlobs?: boolean): {

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

@@ -39,5 +39,7 @@ export interface ExecuteOperationMeta extends OperationExecutionOptions {
      */
     proxiedRead?: boolean;
 }
+/** Also used by batch's internal node path, which does not dispatch an operation. */
+export declare function validateOperationTarget(name: string, input: Record<string, unknown>): string | undefined;
 export declare function executeOperation(name: string, rawInput: unknown, meta?: ExecuteOperationMeta): Promise<unknown>;
 export {};

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

@@ -8,13 +8,21 @@
  *
  * This module must never import server.ts or index.ts.
  */
-import { type Camera, type Tour, type TourStop } from '../shared/tour.js';
+import { type Camera, type Tour, type TourPresenter, type TourStop } from '../shared/tour.js';
 export type TourStep = number | 'next' | 'previous';
-export interface TourStepResult {
+export interface TourDelivery {
+    catalogEpoch: string;
+    boardGeneration: number;
+    sequence: number;
+}
+export interface TourStepResult extends TourDelivery {
     index: number;
     total: number;
     stop: TourStop;
 }
+export interface TourSuperseded {
+    superseded: true;
+}
 export interface TourState {
     tour: Tour;
     derived: boolean;
@@ -23,7 +31,9 @@ export interface TourState {
 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;
+export declare function goToTourStop(step: TourStep, presenter: TourPresenter | undefined): TourStepResult | TourSuperseded;
+export declare function exitTour(): TourDelivery;
+export declare function exitTour(presenter: TourPresenter | undefined): TourDelivery | TourSuperseded;
 /**
  * Resolve an eased camera move and store its end camera as the board viewport
  * (unrecorded). The size is the last window a browser reported, so this is the

package/dist/types/server/trace-manager.d.ts

@@ -12,6 +12,7 @@ declare class TraceManager {
     private traceOrigin;
     private chainIndex;
     get enabled(): boolean;
+    get ownedNodeIds(): readonly string[];
     setEnabled(value: boolean): void;
     onToolStart(payload: {
         name: string;

package/dist/types/shared/ax-kinds.d.ts

@@ -4,6 +4,12 @@
  * silently render unrecognized on the other.
  */
 export type AxWorkItemStatus = 'todo' | 'in-progress' | 'blocked' | 'done' | 'cancelled';
+/** Authored work cards use the task vocabulary without creating an AX task. */
+export declare const WORK_CARD_STATES: Record<AxWorkItemStatus, {
+    label: string;
+    glyph: string;
+}>;
+export declare function isWorkCardState(value: unknown): value is AxWorkItemStatus;
 /** `held` = auto-held by the unattended-approval policy: the action did NOT proceed. */
 export type AxApprovalStatus = 'pending' | 'approved' | 'rejected' | 'held';
 export type AxEventKind = 'prompt' | 'assistant-message' | 'tool-start' | 'tool-result' | 'failure' | 'approval' | 'steering' | 'command' | 'note' | 'policy'