pmx-canvas 0.8.2 → 0.9.0

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

@@ -6,6 +6,7 @@
  * recording never notifies (a read must not trigger more reads).
  */
 import type { Database } from 'bun:sqlite';
+import type { MemoryGraph } from '../shared/memory-graph.js';
 export declare const CONTEXT_READ_RETENTION = 5000;
 export declare const CONTEXT_READ_CHANNELS: readonly ["operation", "mcp-resource", "mcp-prompt", "adapter"];
 export type ContextReadChannel = (typeof CONTEXT_READ_CHANNELS)[number];
@@ -24,15 +25,21 @@ export interface ContextRead {
     deliveredNodeIds: string[];
     /** Every node on the read board whose content was delivered, with its content revision at read time. */
     readNodes: Record<string, number>;
+    /** Every node on the read board that arrived with its relations (summaries count), with its links revision then. */
+    seenLinks: Record<string, number>;
     bytes: number;
     /** The board open when the read happened (null on Home). */
     boardId: string | null;
 }
-export type ContextReadInput = Omit<ContextRead, 'seq' | 'id' | 'at' | 'boardId' | 'readNodes'> & {
+export type ContextReadInput = Omit<ContextRead, 'seq' | 'id' | 'at' | 'boardId' | 'readNodes' | 'seenLinks'> & {
     /** 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. */
     readNodeIds?: string[];
+    /** Ids of every node that arrived, summaries included; defaults to readNodeIds. */
+    seenNodeIds?: string[];
+    /** Exact link clocks captured in the delivered projection, before asynchronous transport work. */
+    seenLinkRevisions?: Record<string, number>;
 };
 /** One node's read state on a board: the latest agent read that delivered its content. */
 export interface NodeReadStatus {
@@ -58,16 +65,35 @@ export interface ContextReadConsumerSummary {
  * `nodeId` with its text) in what the reader received. A bare id list, a
  * title, or a clipped-off node does not count — the agent got the node's
  * name, not its content. Non-node ids (edges, intents) are dropped by the
- * caller against the board's nodes.
+ * caller against the board's nodes. A summary is "seen", not "read": `read`
+ * holds only nodes pulled in full and `reached` adds the summaries. Content
+ * delivery alone never establishes that the card's relations were delivered.
  */
-export declare function deliveredIds(payloadText: string): Set<string>;
-/** Pinned nodes whose content is in what the reader received (see `deliveredIds`). */
-export declare function deliveredPinnedIds(pinnedNodeIds: string[], payloadText: string): string[];
+export declare function deliveredIds(payloadText: string): {
+    read: Set<string>;
+    reached: Set<string>;
+};
 export declare function contextReadFromPayload(base: Omit<ContextReadInput, 'deliveredNodeIds' | 'bytes' | 'readNodeIds'>, payload: unknown): 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  );\n";
-export declare function appendContextReadToDB(db: Database, input: ContextReadInput, boardId: string | null, readNodes?: Record<string, number>): ContextRead;
+/**
+ * Reads a `context.get` brief made on pinned boards (vision move 0a): one per
+ * pinned board whose map arrived, so the board shows as read. Its cards came as
+ * summaries, which mark nothing read until the agent pulls them; only summaries
+ * with complete, unclipped relations count as links seen on that board.
+ */
+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 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[];
+/** The latest agent read on a board, of any kind (a brief, a pinned-board map, a pull), or null. */
+export declare function loadBoardLastReadFromDB(db: Database, boardId: string): {
+    lastReadAt: string;
+    lastReadBy: string;
+} | null;
+/** Per node on a board, the newest links revision any agent read has carried (connection marks). */
+export declare function loadSeenLinksFromDB(db: Database, boardId: string): Record<string, number>;
 /** Every node on a board whose content an agent read at or after `since` (ISO). */
 export declare function loadReadNodeIdsSince(db: Database, boardId: string, since: string): string[];
 /** Newest first. The summary covers every retained row, not just the returned page. */

package/dist/types/server/edit-summary.d.ts

@@ -0,0 +1,20 @@
+import type { CanvasNodeState } from './canvas-state.js';
+/** "See change" shows this much of each side, centred on the first difference. */
+export declare const CHANGE_EXCERPT = 1200;
+export declare function cardText(node: CanvasNodeState): string;
+/**
+ * What an agent's edit did to a card, in a few words, from the card before
+ * the session and now (AgentContext.dc.html: "rewrote the second paragraph").
+ * Paragraphs are aligned on their shared start and end, so a paragraph added
+ * at the top reads as added, not as everything rewritten.
+ */
+export declare function describeEdit(before: CanvasNodeState, after: CanvasNodeState): string;
+/**
+ * Before and after for "See change": each side cut to CHANGE_EXCERPT around
+ * the first character that differs, with "…" where text was cut, so a change
+ * deep in a long card is what shows.
+ */
+export declare function changeExcerpts(was: string, now: string): {
+    before: string;
+    after: string;
+};

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

@@ -1,6 +1,8 @@
 import { EventEmitter } from 'node:events';
-import { type Tour } from '../shared/tour.js';
+import { type Camera, type Tour, type TourStop } from '../shared/tour.js';
+import { type TourStep, type TourStepResult } from './tour-control.js';
 export type { Tour, TourStop } from '../shared/tour.js';
+export type { 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';
@@ -8,10 +10,10 @@ import { type AxInteractionInput, type AxInteractionPublicResult } from './ax-in
 import type { PmxAxIntent } from '../shared/ax-intent.js';
 import type { PmxAxActivityKind, PmxAxApprovalGate, PmxAxCommandDescriptor, PmxAxContext, PmxAxElicitation, PmxAxEvent, PmxAxEvidence, PmxAxEvidenceKind, PmxAxFocusState, PmxAxHostCapability, PmxAxMode, PmxAxModeRequest, PmxAxPolicy, PmxAxReviewAnchorType, PmxAxReviewAnnotation, PmxAxReviewKind, PmxAxReviewRegion, PmxAxReviewSeverity, PmxAxReviewStatus, PmxAxSource, PmxAxState, PmxAxSteeringMessage, PmxAxWorkItem, PmxAxWorkItemStatus } from './ax-state.js';
 import type { AxTimelineQuery, CanvasBoard } from './canvas-db.js';
+import type { MemoryGraph } from '../shared/memory-graph.js';
 import type { Attachment, DocumentImport, ImportSection } from './document-import.js';
 import type { BackupFile, BackupStatus } from './backup.js';
 import type { ExportManifest } from './board-export.js';
-import { searchNodes } from './spatial-analysis.js';
 import { diffLayouts } from './mutation-history.js';
 import { fitCanvasView, gcCanvasSnapshots, listCanvasSnapshots } from './canvas-operations.js';
 import { type OpenMcpAppCoreResult } from './operations/index.js';
@@ -58,10 +60,14 @@ export declare class PmxCanvas extends EventEmitter {
      * or keep the whole node — both work. (Previously returned a bare id string.)
      */
     addNode(input: {
+        destinationBoardId?: string;
+        requestId?: string;
+        expectedBoardId?: string | null;
         intentId?: string;
         type: CanvasNodeState['type'];
         title?: string;
         content?: string;
+        data?: Record<string, unknown>;
         children?: string[];
         childIds?: string[];
         childLayout?: 'grid' | 'column' | 'flow';
@@ -107,16 +113,23 @@ export declare class PmxCanvas extends EventEmitter {
         intentId?: string;
     }): void;
     addEdge(input: {
+        destinationBoardId?: string;
+        requestId?: string;
+        expectedBoardId?: string | null;
         intentId?: string;
         from?: string;
         to?: string;
+        toBoardId?: string;
         fromSearch?: string;
         toSearch?: string;
         type: CanvasEdge['type'];
+        kind?: string;
+        reason?: string;
         label?: string;
         style?: CanvasEdge['style'];
         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;
@@ -128,6 +141,9 @@ export declare class PmxCanvas extends EventEmitter {
      * If childIds are provided, the group auto-sizes to contain them with padding.
      */
     createGroup(input: {
+        destinationBoardId?: string;
+        requestId?: string;
+        expectedBoardId?: string | null;
         intentId?: string;
         title?: string;
         childIds?: string[];
@@ -149,6 +165,16 @@ export declare class PmxCanvas extends EventEmitter {
     }): boolean;
     getTour(): Tour;
     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?: {
+        present?: boolean;
+    }): TourStepResult;
+    /** Leave presentation in every viewer. */
+    exitTour(): void;
+    /** Ease the camera to a node, world rect or viewport. Not recorded in undo history. */
+    moveCamera(stop: TourStop): {
+        viewport: Camera;
+    };
     clear(): void;
     arrange(layout?: 'grid' | 'column' | 'flow'): void;
     focusNode(id: string, options?: {
@@ -239,23 +265,32 @@ export declare class PmxCanvas extends EventEmitter {
         import: DocumentImport;
         nodeIds: string[];
     }>;
-    createBoard(name: string, category?: string): Promise<CanvasBoard>;
-    /** Rename a board and/or file it under a category (`category: null` removes it). */
-    updateBoard(id: string, patch: {
-        name?: string;
-        category?: string | null;
-    }): Promise<void>;
+    createBoard(name: string, folder?: string): Promise<CanvasBoard>;
+    /** Workspace category and folder actions do not open a board. */
+    knowledge<T extends import('./knowledge-lifecycle.js').KnowledgeInput>(input: T): Promise<import('./knowledge-lifecycle.js').KnowledgeResults[T['action']]>;
+    lifecycle<T extends import('./knowledge-lifecycle.js').LifecycleInput>(input: T): Promise<import('./knowledge-lifecycle.js').LifecycleResults[T['action']]>;
+    /** Rename a board and/or file it under a folder (`folder: null` unfiles it). */
+    updateBoard(id: string, patch: Parameters<typeof canvasState.updateBoard>[1]): Promise<void>;
     setBoardReadme(id: string, readmeNodeId: string | null): Promise<void>;
+    /** Pin a board into the agent's working set (its README and pinned cards reach every brief). */
+    pinBoard(id: string, reason?: string): Promise<void>;
+    unpinBoard(id: string): Promise<void>;
     createBoardFrom(input: {
         sourceBoardId: string;
         name: string;
-        category?: string;
+        folder?: string;
         nodeIds?: string[];
         includeReadme?: boolean;
         includeStructure?: boolean;
         preview?: boolean;
     }): Promise<Record<string, unknown>>;
     searchLibrary(query: string, limit?: number): Promise<Record<string, unknown>>;
+    /** Same projection as Home Graph. Discovery summaries never count as full-content reads. */
+    getMemoryGraph(options?: {
+        focus?: string;
+        depth?: number;
+        projection?: 'full' | 'boards';
+    }): Promise<MemoryGraph>;
     /** Budgeted cross-board brief. Budget is measured in UTF-16 characters. */
     getContextBrief(options?: {
         consumer?: string;
@@ -297,6 +332,8 @@ export declare class PmxCanvas extends EventEmitter {
     getContextReads(limit?: number): ReturnType<typeof canvasState.getContextReads>;
     /** Per node on a board: when an agent last read its content, who, and the content revision it read. */
     getNodeReadStatus(board?: string): ReturnType<typeof canvasState.getNodeReadStatus>;
+    /** A board's latest agent read of any kind (a pinned board's map counts), or null. */
+    getBoardLastRead(board?: string): ReturnType<typeof canvasState.getBoardLastRead>;
     listWorkItems(): PmxAxWorkItem[];
     addWorkItem(input: {
         title: string;
@@ -492,7 +529,21 @@ export declare class PmxCanvas extends EventEmitter {
     getNode(id: string, options?: {
         board?: string;
     }): SdkCanvasNode | undefined;
-    search(query: string): ReturnType<typeof searchNodes>;
+    search(query: string, options?: {
+        scope?: 'active' | 'library';
+        boardId?: string;
+        folder?: string;
+        limit?: number;
+    }): {
+        qualification?: import("../shared/lifecycle-status.js").LifecycleQualification | undefined;
+        boardId: string | null;
+        cardId: string;
+        id: string;
+        type: string;
+        title: string | null;
+        snippet: string;
+        score: number;
+    }[];
     getSpatialContext(): import("./spatial-analysis.js").SpatialContext;
     undo(): Promise<{
         ok: boolean;
@@ -533,6 +584,15 @@ export declare class PmxCanvas extends EventEmitter {
     restoreSnapshot(id: string): Promise<{
         ok: boolean;
     }>;
+    /** Put one card back to its content in a snapshot (the receipt's Undo on an edit). */
+    restoreSnapshotNode(snapshotId: string, nodeId: string, options?: {
+        preserveHumanEdits?: boolean;
+    }): Promise<{
+        ok: boolean;
+        id: string;
+        restored: boolean;
+        skipped?: 'human-edit';
+    }>;
     deleteSnapshot(id: string): {
         ok: boolean;
     };
@@ -714,3 +774,4 @@ export type { HtmlPrimitiveKind, HtmlPrimitiveDescriptor, HtmlPrimitiveInput, Ht
 export { traceManager } from './trace-manager.js';
 export type { PmxAxApprovalGate, PmxAxApprovalStatus, PmxAxCommandDescriptor, PmxAxContext, PmxAxEvent, PmxAxElicitation, PmxAxElicitationStatus, PmxAxEventKind, PmxAxEvidence, PmxAxEvidenceKind, PmxAxFocusState, PmxAxHostCapability, PmxAxMode, PmxAxModeRequest, PmxAxModeRequestStatus, PmxAxPolicy, PmxAxReviewAnchorType, PmxAxReviewAnnotation, PmxAxReviewKind, PmxAxReviewRegion, PmxAxReviewSeverity, PmxAxReviewStatus, PmxAxSource, PmxAxState, PmxAxSteeringMessage, PmxAxTimelineSummary, PmxAxWorkItem, PmxAxWorkItemStatus, } from './ax-state.js';
 export type { AxTimelineQuery } from './canvas-db.js';
+export type { Lifecycle, KnowledgeCategory, FolderProperties, ReviewRecord, KnowledgeInput, KnowledgeResults, LifecycleInput, LifecycleResults, } from './knowledge-lifecycle.js';

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

@@ -0,0 +1,221 @@
+import type { Database } from 'bun:sqlite';
+import { z } from 'zod';
+import { type ActorAttribution } from './attribution.js';
+import type { LifecycleQualification } from '../shared/lifecycle-status.js';
+import type { CanvasNodeState } from './canvas-state.js';
+import { type RelationPreset } from '../shared/relations.js';
+import { type KnowledgeCategory, type Lifecycle } from '../shared/knowledge-lifecycle.js';
+export { categorySchema, lifecycleSchema, type KnowledgeCategory, type Lifecycle, } from '../shared/knowledge-lifecycle.js';
+export interface ReviewCardSummary {
+    boardId: string;
+    cardId: string;
+    boardTitle: string;
+    folder: string | null;
+    title: string;
+}
+export declare const folderPropertiesSchema: z.ZodObject<{
+    path: z.ZodString;
+    categoryId: z.ZodNullable<z.ZodString>;
+    lifecycleOverride: z.ZodNullable<z.ZodObject<{
+        decayType: z.ZodEnum<{
+            reality: "reality";
+            decision: "decision";
+            dependency: "dependency";
+            relevance: "relevance";
+        }>;
+        rate: z.ZodEnum<{
+            fast: "fast";
+            medium: "medium";
+            slow: "slow";
+            durable: "durable";
+        }>;
+        triggers: z.ZodArray<z.ZodString>;
+        revalidationMethod: z.ZodString;
+        cadenceDays: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+export type FolderProperties = z.infer<typeof folderPropertiesSchema>;
+export interface ReviewRecord {
+    id: string;
+    boardId: string;
+    nodeId: string;
+    outcome: 'retain' | 'revise' | 'externalize' | 'retire' | 'unresolved' | 'restore';
+    evidence: string;
+    applied: boolean;
+    who: ActorAttribution;
+    when: string;
+    /** Exact semantic version reviewed; old unversioned records remain unknown. */
+    contentRevision: number | null;
+    sourceRevisions?: Record<string, number | null>;
+}
+export type KnowledgeInput = {
+    action: 'list';
+} | {
+    action: 'category-set';
+    category: KnowledgeCategory;
+} | {
+    action: 'category-remove';
+    id: string;
+} | {
+    action: 'relation-preset-set';
+    preset: RelationPreset;
+} | {
+    action: 'relation-preset-remove';
+    id: string;
+} | ({
+    action: 'folder-set';
+} & FolderProperties);
+export interface KnowledgeResults {
+    list: {
+        ok: true;
+        categories: KnowledgeCategory[];
+        folders: FolderProperties[];
+        relationPresets: RelationPreset[];
+        cards: Record<string, LifecycleQualification>;
+        reviewCards: ReviewCardSummary[];
+        resolvedFolders: Record<string, ReturnType<KnowledgeLifecycle['resolve']>>;
+    };
+    'category-set': {
+        ok: true;
+        category: KnowledgeCategory;
+    };
+    'category-remove': {
+        ok: true;
+        id: string;
+    };
+    'relation-preset-set': {
+        ok: true;
+        preset: RelationPreset;
+    };
+    'relation-preset-remove': {
+        ok: true;
+        id: string;
+    };
+    'folder-set': {
+        ok: true;
+        folder: FolderProperties;
+    };
+}
+export type LifecycleInput = {
+    action: 'get';
+    id: string;
+    board?: string;
+} | {
+    action: 'set';
+    id: string;
+    expectedBoardId?: string | null;
+    lifecycleOverride: Lifecycle | null;
+} | {
+    action: 'review';
+    id: string;
+    expectedBoardId?: string | null;
+    outcome: Exclude<ReviewRecord['outcome'], 'restore'>;
+    evidence: string;
+    applied: boolean;
+    expectedContentRevision?: number;
+    expectedSources?: Record<string, number | null>;
+} | {
+    action: 'restore';
+    id: string;
+    expectedBoardId?: string | null;
+    evidence: string;
+};
+export interface LifecycleResults {
+    get: {
+        ok: true;
+        boardId: string;
+        nodeId: string;
+        contentRevision: number;
+        qualification: LifecycleQualification;
+    } & ReturnType<KnowledgeLifecycle['resolve']> & ReturnType<KnowledgeLifecycle['reviews']>;
+    set: {
+        ok: true;
+    };
+    review: {
+        ok: true;
+        record: ReviewRecord;
+    };
+    restore: {
+        ok: true;
+        record: ReviewRecord;
+    };
+}
+/** Workspace-owned data, deliberately outside board snapshots and read clocks. */
+export declare class KnowledgeLifecycle {
+    private readonly getDb;
+    private readonly changed;
+    private readonly getContentRevision;
+    private readonly flush;
+    constructor(getDb: () => Database | null, changed: () => void, getContentRevision: (boardId: string, nodeId: string) => number, flush: () => void);
+    private db;
+    list(): {
+        categories: KnowledgeCategory[];
+        folders: FolderProperties[];
+        relationPresets: RelationPreset[];
+    };
+    setRelationPreset(value: RelationPreset): RelationPreset;
+    removeRelationPreset(id: string): string;
+    setCategory(value: KnowledgeCategory): KnowledgeCategory;
+    removeCategory(id: string): string;
+    setFolder(value: FolderProperties): FolderProperties;
+    resolve(folderPath: string | null, override?: Lifecycle | null, catalog?: {
+        categories: KnowledgeCategory[];
+        folders: FolderProperties[];
+        relationPresets: RelationPreset[];
+    }): {
+        category: {
+            decayType: "reality" | "decision" | "dependency" | "relevance";
+            rate: "fast" | "medium" | "slow" | "durable";
+            triggers: string[];
+            revalidationMethod: string;
+            id: string;
+            name: string;
+            glyph: string;
+            cadenceDays?: number | undefined;
+        } | null;
+        categorySourceFolder: string | null;
+        lifecycle: {
+            decayType: "reality" | "decision" | "dependency" | "relevance";
+            rate: "fast" | "medium" | "slow" | "durable";
+            triggers: string[];
+            revalidationMethod: string;
+            cadenceDays?: number | undefined;
+        } | null;
+        lifecycleSourceFolder: string | null;
+        lifecycleSource: "unknown" | "card" | "folder";
+    };
+    resolveCard(folderPath: string | null, node: Pick<CanvasNodeState, 'type' | 'data'>, catalog?: {
+        categories: KnowledgeCategory[];
+        folders: FolderProperties[];
+        relationPresets: RelationPreset[];
+    }): {
+        category: {
+            decayType: "reality" | "decision" | "dependency" | "relevance";
+            rate: "fast" | "medium" | "slow" | "durable";
+            triggers: string[];
+            revalidationMethod: string;
+            id: string;
+            name: string;
+            glyph: string;
+            cadenceDays?: number | undefined;
+        } | null;
+        categorySourceFolder: string | null;
+        lifecycle: {
+            decayType: "reality" | "decision" | "dependency" | "relevance";
+            rate: "fast" | "medium" | "slow" | "durable";
+            triggers: string[];
+            revalidationMethod: string;
+            cadenceDays?: number | undefined;
+        } | null;
+        lifecycleSourceFolder: string | null;
+        lifecycleSource: "unknown" | "card" | "folder";
+    };
+    reviews(boardId: string, nodeId: string): {
+        records: ReviewRecord[];
+        retired: boolean;
+        lastValidation: ReviewRecord | null;
+    };
+    record(boardId: string, nodeId: string, input: Pick<ReviewRecord, 'outcome' | 'evidence' | 'applied'> & {
+        expectedContentRevision?: number;
+    }, sourceRevisions?: Record<string, number | null>): ReviewRecord;
+}

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

@@ -0,0 +1,10 @@
+import { type MemoryTarget } from '../shared/memory-graph.js';
+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>;
+/** Compact queue metadata and qualifications come from the same authoritative read. */
+export declare function lifecycleSnapshot(now?: number, atUse?: MemoryTarget[]): {
+    cards: Record<string, LifecycleQualification>;
+    reviewCards: ReviewCardSummary[];
+};

package/dist/types/server/memory-graph.d.ts

@@ -0,0 +1,9 @@
+import { type MemoryGraph, type MemoryGraphEdge } from '../shared/memory-graph.js';
+/** One library projection for Home, backlinks, brief discovery and agent exploration. No writes. */
+export declare function memoryGraph(projection?: 'full' | 'boards'): MemoryGraph;
+/** Keep original qualified endpoints and missing evidence, without card summaries or membership. */
+export declare function boardMemoryGraph(graph: MemoryGraph): MemoryGraph;
+/** Board-level connections are a collapse of the SAME edges, not another link scanner. */
+export declare function boardConnections(graph: MemoryGraph): MemoryGraphEdge[];
+/** Undirected exploration. Membership is a hop too; focus accepts a board ID, qualified key, or pins. */
+export declare function localMemoryGraph(graph: MemoryGraph, focus: string | null, depth: number): MemoryGraph;

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

@@ -59,12 +59,14 @@ export interface SnapshotDiffResult {
         id: string;
         from: string;
         to: string;
+        toBoardId?: string;
         type: string;
     }[];
     removedEdges: {
         id: string;
         from: string;
         to: string;
+        toBoardId?: string;
         type: string;
     }[];
 }

package/dist/types/server/operations/ops/ax-shared.d.ts

@@ -14,10 +14,10 @@ import type { PmxAxSource } from '../../ax-state.js';
 export declare const AX_SOURCES: readonly ["agent", "amp", "api", "browser", "cli", "codex", "copilot", "mcp", "sdk", "system"];
 /** Zod schema for the optional `source` field shared by AX MCP tool shapes. */
 export declare const AX_SOURCE_SHAPE: z.ZodOptional<z.ZodEnum<{
-    amp: "amp";
     agent: "agent";
     system: "system";
     sdk: "sdk";
+    amp: "amp";
     api: "api";
     browser: "browser";
     cli: "cli";

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

@@ -1,6 +1,7 @@
 import { type CanvasLayout } from '../../canvas-state.js';
 import { type Operation } from '../types.js';
-export declare function boardsPayload(): Record<string, unknown>;
+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): {
     boardId: string | null;

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

@@ -0,0 +1,2 @@
+import { type Operation } from '../types.js';
+export declare const lifecycleOperations: Operation[];

package/dist/types/server/operations/ops/memory-graph.d.ts

@@ -0,0 +1,2 @@
+import { type Operation } from '../types.js';
+export declare const memoryGraphOperations: Operation[];

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

@@ -7,6 +7,8 @@ export declare function defaultNodeSize(type: string): {
     width: number;
     height: number;
 };
+/** Parent traversal in a relative path, using the path implementation's separator. */
+export declare function isParentTraversal(path: string, separator: string): boolean;
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
 export declare function pickFiniteNumber(record: Record<string, unknown>, key: string): number | undefined;
 export declare function getRecord(value: unknown): Record<string, unknown> | undefined;
@@ -33,6 +35,7 @@ export declare function createdNodePayloadFromNode(node: CanvasNodeState, option
  */
 export declare function createBasicCanvasNode(body: Record<string, unknown>, options: {
     fileMode: 'auto' | 'path';
+    prepareOnlyNodes?: CanvasNodeState[];
 }): {
     node: CanvasNodeState;
     needsCodeGraphRecompute: boolean;
@@ -55,4 +58,6 @@ export declare function buildNodePatch(existing: CanvasNodeState, body: Record<s
 export declare function removeNodeCore(id: string): {
     needsCodeGraphRecompute: boolean;
 };
+/** Explicit creation identity is opt-in, not content-based deduplication. */
+export declare function createDestinationNode(body: Record<string, unknown>): CanvasNodeState;
 export declare const nodeOperations: Operation[];

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

@@ -1,4 +1,27 @@
 import { type Operation } from '../types.js';
+/**
+ * The brief's page size in UTF-16 characters (canvas://context?budget=N). It is
+ * not shown to the human: a brief longer than one page continues on the next read.
+ */
 export declare const DEFAULT_CONTEXT_BRIEF_BUDGET = 16000;
 export declare const MAX_CONTEXT_BRIEF_BUDGET = 100000;
+/** Search without opening boards; HTTP, MCP and SDK share discovery and ranking. */
+export declare function searchCanvasNodes(q: string, options?: {
+    scope?: 'active' | 'library';
+    boardId?: string;
+    folder?: string;
+    limit?: number | string;
+}): {
+    results: {
+        qualification?: import("../../../shared/lifecycle-status.js").LifecycleQualification | undefined;
+        boardId: string | null;
+        cardId: string;
+        id: string;
+        type: string;
+        title: string | null;
+        snippet: string;
+        score: number;
+    }[];
+    query: string;
+};
 export declare const queryOperations: Operation[];

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

@@ -4,6 +4,7 @@ export declare function getOperation(name: string): Operation;
 export declare function listOperations(): Operation[];
 type OperationEventEmitter = (event: string, payload: Record<string, unknown>) => void;
 export declare function setOperationEventEmitter(emitter: OperationEventEmitter | null): void;
+export declare function getOperationEventEmitter(): OperationEventEmitter | null;
 /** True while operation SSE emits are being suppressed (inside a meta-op such as
  * canvas.batch). Ops whose effect depends on a live SSE emit firing — e.g.
  * mcpapp.open, whose canvas node is created as a side-effect of `ext-app-open` —

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

@@ -2,6 +2,13 @@ import { type CanvasPlacementRect } from '../shared/placement.js';
 export { findOpenCanvasPosition, type CanvasPlacementRect } from '../shared/placement.js';
 export declare const GROUP_PAD = 56;
 export declare const GROUP_TITLEBAR_HEIGHT = 32;
+/** Pack members inside an explicitly sized frame without changing that frame. */
+export declare function computeManualGroupLayout<T extends CanvasPlacementRect & {
+    id: string;
+}>(children: T[], frame: CanvasPlacementRect, layout: 'grid' | 'column' | 'flow'): Map<string, {
+    x: number;
+    y: number;
+}>;
 /**
  * Compute bounding box for a group that should contain the given child rects.
  * Returns position and size with padding, or null if no valid children.

package/dist/types/server/scope-fence.d.ts

@@ -24,6 +24,7 @@
  * authentication boundary.
  */
 import { type FenceRect } from '../shared/scope-fence.js';
+import { type PmxAxPolicy } from './ax-state.js';
 import type { Operation } from './operations/types.js';
 /** Bounding box of the fenced nodes plus padding; null when none of them exist. */
 export declare function scopeFenceRect(fence: {
@@ -47,7 +48,7 @@ export interface FenceTarget {
     unknown?: string;
 }
 /** Returns a human-readable refusal, or null when the target is inside the fence. */
-export declare function checkFenceTarget(target: FenceTarget, opName: string, writerKey?: string): string | null;
+export declare function checkFenceTarget(target: FenceTarget, opName: string, writerKey?: string, policy?: PmxAxPolicy): string | null;
 /** Describe what a registry op would write, in fence terms. */
 export declare function describeOpTarget(op: Operation, rawInput: unknown): FenceTarget;
 /** Registry entry point: refusal text or null. Only call for mutating, agent-originated ops. */