pmx-canvas 0.9.1 → 0.9.3

package/src/server/lifecycle-status.ts

@@ -25,8 +25,70 @@ export function lifecycleQualifications(
   return lifecycleSnapshot(now, atUse).cards;
 }
 
+/** A card being inspected is in use, including its transitive sources and portal contents. */
+export function lifecycleQualification(target: MemoryTarget, now = Date.now()): LifecycleQualification | undefined {
+  return lifecycleSnapshot(now, [target], target).cards[memoryKey(target)];
+}
+
+/** Read closure boards once; never activate them or flush the active board to discover edges. */
+function dependencyClosure(target: MemoryTarget) {
+  const reads = new Map<string, ReturnType<typeof canvasState.readBoard>>();
+  const nodes = new Map<string, CanvasNodeState>();
+  const dependencies = new Map<string, MemoryTarget[]>();
+  const selected = new Set<string>();
+  const queue: MemoryTarget[] = [target];
+  const read = (boardId: string) => {
+    if (!reads.has(boardId)) {
+      const board = canvasState.readBoard(boardId, false);
+      reads.set(boardId, board);
+      for (const node of board?.layout.nodes ?? []) nodes.set(memoryKey({ boardId, cardId: node.id }), node);
+      for (const edge of board?.layout.edges ?? []) {
+        const end = relationSourceEnd(edge);
+        if (!end) continue;
+        const from = { boardId, cardId: edge.from };
+        const to = { boardId: edge.toBoardId ?? boardId, cardId: edge.to };
+        const key = memoryKey(end === 'from' ? to : from);
+        const sources = dependencies.get(key) ?? [];
+        sources.push(end === 'from' ? from : to);
+        dependencies.set(key, sources);
+      }
+    }
+    return reads.get(boardId);
+  };
+  const activeBoardId = canvasState.activeBoardId;
+  const incomingActive = new Set(
+    canvasState
+      .getEdges()
+      .flatMap((edge) =>
+        edge.toBoardId && relationSourceEnd(edge) === 'from'
+          ? [memoryKey({ boardId: edge.toBoardId, cardId: edge.to })]
+          : [],
+      ),
+  );
+  for (const current of queue) {
+    const key = memoryKey(current);
+    if (selected.has(key)) continue;
+    selected.add(key);
+    const board = read(current.boardId);
+    if (!current.cardId) {
+      for (const node of board?.layout.nodes ?? []) queue.push({ boardId: current.boardId, cardId: node.id });
+      continue;
+    }
+    const node = nodes.get(key);
+    if (!node) continue;
+    const provenance = normalizeCanvasNodeData(node.type, node.data).provenance as CanvasNodeProvenance | undefined;
+    queue.push(...(provenance?.sources ?? []).map(({ boardId, cardId }) => ({ boardId, cardId })));
+    if (node.type === 'board' && typeof node.data.boardId === 'string') queue.push({ boardId: node.data.boardId });
+    const owners = new Set([current.boardId, ...canvasState.knowledge.incomingSourceBoards(current, activeBoardId)]);
+    if (activeBoardId && incomingActive.has(key)) owners.add(activeBoardId);
+    for (const owner of owners) read(owner);
+    queue.push(...(dependencies.get(key) ?? []));
+  }
+  return { reads, selected };
+}
+
 /** Compact queue metadata and qualifications come from the same authoritative read. */
-export function lifecycleSnapshot(now = Date.now(), atUse: MemoryTarget[] = []) {
+export function lifecycleSnapshot(now = Date.now(), atUse: MemoryTarget[] = [], only?: MemoryTarget) {
   const result: Record<string, LifecycleQualification> = {};
   const cards = new Map<string, CanvasNodeState>();
   const validations = new Map<string, ReviewRecord | null>();
@@ -34,26 +96,36 @@ export function lifecycleSnapshot(now = Date.now(), atUse: MemoryTarget[] = [])
   const portals = new Map<string, string>();
   const policies = new Map<string, Lifecycle | null>();
   const used = new Set<string>();
-  const reads = canvasState.listBoards().map((board) => ({ board, read: canvasState.readBoard(board.id, false) }));
+  const boards = canvasState.listBoards();
+  const closure = only ? dependencyClosure(only) : null;
+  const reads = boards
+    .filter((board) => !closure || closure.reads.has(board.id))
+    .map((board) => ({
+      board,
+      read: closure ? closure.reads.get(board.id) : canvasState.readBoard(board.id, false),
+    }));
+  const targets = reads
+    .flatMap(({ board, read }) => (read?.layout.nodes ?? []).map((node) => ({ boardId: board.id, cardId: node.id })))
+    .filter((target) => !closure || closure.selected.has(memoryKey(target)));
+  const summaries = canvasState.databasePath ? canvasState.knowledge.reviewSummaries(targets) : null;
   const catalog = canvasState.databasePath
     ? canvasState.knowledge.list()
     : { categories: [], folders: [], relationPresets: [] };
   const session =
     agentPresence.reviewSessionStartedAt() ??
     Date.parse(
-      reads.find(({ board }) => board.id === canvasState.activeBoardId)?.board.lastOpenedAt ??
+      boards.find((board) => board.id === canvasState.activeBoardId)?.lastOpenedAt ??
         new Date(processStartedAt).toISOString(),
     );
   for (const { board, read } of reads) {
     const seen = new Map(canvasState.getNodeReadStatus(board.id).map((status) => [status.nodeId, status]));
     for (const node of read?.layout.nodes ?? []) {
       const key = memoryKey({ boardId: board.id, cardId: node.id });
+      if (closure && !closure.selected.has(key)) continue;
       cards.set(key, node);
       const { lifecycle } = canvasState.knowledge.resolveCard(board.folder, node, catalog);
       policies.set(key, lifecycle);
-      const { lastValidation, retired } = canvasState.databasePath
-        ? canvasState.knowledge.reviews(board.id, node.id)
-        : { lastValidation: null, retired: false };
+      const { lastValidation, retired } = summaries?.get(key) ?? { lastValidation: null, retired: false };
       validations.set(key, lastValidation);
       const lastRead = seen.get(node.id);
       const pinned = read!.state.contextPins.includes(node.id);
@@ -218,7 +290,7 @@ export function lifecycleSnapshot(now = Date.now(), atUse: MemoryTarget[] = [])
   for (const { board, read } of reads) {
     for (const node of read?.layout.nodes ?? []) {
       const status = result[memoryKey({ boardId: board.id, cardId: node.id })];
-      if (status.retired || !(status.due || status.sources.length)) continue;
+      if (!status || status.retired || !(status.due || status.sources.length)) continue;
       reviewCards.push({
         boardId: board.id,
         cardId: node.id,

package/src/server/operations/ops/lifecycle.ts

@@ -3,8 +3,7 @@ import { canvasState } from '../../canvas-state.js';
 import { categorySchema, folderPropertiesSchema, lifecycleSchema } from '../../knowledge-lifecycle.js';
 import { defineOperation, OperationError, type Operation } from '../types.js';
 import { readTargetBoard } from './boards.js';
-import { lifecycleQualifications, lifecycleSnapshot } from '../../lifecycle-status.js';
-import { memoryKey } from '../../../shared/memory-graph.js';
+import { lifecycleQualification, lifecycleSnapshot } from '../../lifecycle-status.js';
 import { folderAncestors } from '../../../shared/boards.js';
 import { relationPresetSchema } from '../../../shared/relations.js';
 
@@ -155,9 +154,7 @@ export const lifecycleOperations: Operation[] = [
         contentRevision: node.contentRevision ?? 0,
         ...canvasState.knowledge.resolveCard(folder, node),
         ...canvasState.knowledge.reviews(read.boardId, input.id),
-        qualification: lifecycleQualifications(Date.now(), [{ boardId: read.boardId, cardId: input.id }])[
-          memoryKey({ boardId: read.boardId, cardId: input.id })
-        ],
+        qualification: lifecycleQualification({ boardId: read.boardId, cardId: input.id }),
       };
     },
   }),
@@ -216,8 +213,7 @@ export const lifecycleOperations: Operation[] = [
       if (!canvasState.getNode(input.id) || !canvasState.activeBoardId)
         throw new OperationError('Card not found.', 404);
       const observations =
-        lifecycleQualifications()[memoryKey({ boardId: canvasState.activeBoardId, cardId: input.id })]?.observations ??
-        {};
+        lifecycleQualification({ boardId: canvasState.activeBoardId, cardId: input.id })?.observations ?? {};
       const validates =
         input.applied && input.evidence.trim() && ['retain', 'revise', 'externalize'].includes(input.outcome);
       if (validates) {

package/src/server/operations/ops/nodes.ts

@@ -55,8 +55,7 @@ import {
 import { WEBPAGE_NODE_DEFAULT_SIZE, normalizeWebpageUrl } from '../../webpage-node.js';
 import { defineOperation, OperationError, type Operation, type OperationContext } from '../types.js';
 import { readTargetBoard } from './boards.js';
-import { lifecycleQualifications } from '../../lifecycle-status.js';
-import { memoryKey } from '../../../shared/memory-graph.js';
+import { lifecycleQualification } from '../../lifecycle-status.js';
 
 // ── Node types ────────────────────────────────────────────────
 // Single definition site for the basic node-type list: drives the HTTP type
@@ -1005,9 +1004,7 @@ const nodeGetOperation = defineOperation<z.infer<typeof nodeGetSchema>, Serializ
     const full = includeBlobs === true || includeBlobs === 'true';
     const qualify = (node: CanvasNodeState, boardId: string | null) => ({
       ...(full ? serializeCanvasNode(node) : serializeCanvasNodeWithBlobSummaries(node)),
-      qualification: boardId
-        ? lifecycleQualifications(Date.now(), [{ boardId, cardId: id }])[memoryKey({ boardId, cardId: id })]
-        : undefined,
+      qualification: boardId ? lifecycleQualification({ boardId, cardId: id }) : undefined,
     });
     if (typeof board === 'string' && board.trim()) {
       const target = readTargetBoard(board, full);

package/src/server/operations/ops/viewport.ts

@@ -13,7 +13,7 @@
  * This module must never import server.ts or index.ts.
  */
 import { z } from 'zod';
-import { tourSchema, derivedTour, rectSchema, cameraSchema, tourStopSchema } from '../../../shared/tour.js';
+import { tourSchema, rectSchema, cameraSchema, tourStopSchema } from '../../../shared/tour.js';
 import { canvasState } from '../../canvas-state.js';
 import {
   arrangeCanvasNodes,
@@ -23,7 +23,7 @@ import {
   setClientViewportSize,
 } from '../../canvas-operations.js';
 import { validateCanvasLayout } from '../../canvas-validation.js';
-import { exitTour, goToTourStop, moveCamera, tourPosition } from '../../tour-control.js';
+import { currentTour, exitTour, goToTourStop, moveCamera } from '../../tour-control.js';
 import { defineOperation, OperationError, type Operation } from '../types.js';
 import { closeNodeAppSession, isRecord } from './nodes.js';
 
@@ -329,11 +329,7 @@ const tourGetOperation = defineOperation({
     toolName: 'canvas_get_tour',
     description: 'Read the board tour, deriving groups in reading order when absent.',
   },
-  handler: () => ({
-    tour: canvasState.getTour() ?? derivedTour(canvasState.getLayout().nodes),
-    derived: !canvasState.getTour(),
-    position: tourPosition(),
-  }),
+  handler: () => currentTour(),
 });
 
 // ── tour.go / tour.exit / camera.move ────────────────────────

package/src/server/server.ts

@@ -2483,16 +2483,19 @@ async function handleRender(req: Request): Promise<Response> {
   // The editor sends its draft through this same endpoint. Only changed/unsaved
   // text may resolve titles; persisted text must replay even unresolved bindings.
   const persisted = node?.type === 'markdown' && node.data.content === markdown;
-  const initializedRefs =
-    node?.type === 'markdown' && node.data.wikiLinks !== undefined && typeof node.data.content === 'string'
-      ? wikiReferences(node.data.content)
-      : [];
-  const refs = wikiReferences(markdown).filter(
-    (ref) => !initializedRefs.includes(ref) || previous.some((link) => link.ref === ref),
-  );
-  const needsResolution = !persisted && refs.some((ref) => !previous.some((link) => link.ref === ref && link.target));
-  const catalog = needsResolution ? canvasState.wikiCatalog() : [];
-  const links = persisted ? previous : refs.map((ref) => resolveWikiLinks(`[[${ref}]]`, previous, catalog)[0]);
+  let links = previous;
+  if (!persisted) {
+    const initializedRefs =
+      node?.type === 'markdown' && node.data.wikiLinks !== undefined && typeof node.data.content === 'string'
+        ? wikiReferences(node.data.content)
+        : [];
+    const refs = wikiReferences(markdown).filter(
+      (ref) => !initializedRefs.includes(ref) || previous.some((link) => link.ref === ref),
+    );
+    const needsResolution = refs.some((ref) => !previous.some((link) => link.ref === ref && link.target));
+    const catalog = needsResolution ? canvasState.wikiCatalog() : [];
+    links = refs.map((ref) => resolveWikiLinks(`[[${ref}]]`, previous, catalog)[0]);
+  }
   const targets = new Map<string, ReturnType<typeof canvasState.readBoard>>();
   const html = renderWikiMarkdown(normalizeMarkdownExternalUrls(markdown), links, (target) => {
     if (!targets.has(target.boardId)) targets.set(target.boardId, canvasState.readBoard(target.boardId, false));

package/src/server/tour-control.ts

@@ -21,14 +21,22 @@ export interface TourStepResult {
   stop: TourStop;
 }
 
+export interface TourState {
+  tour: Tour;
+  derived: boolean;
+  position: number | null;
+}
+
 let cursor: { boardGeneration: number; tour: string; index: number } | null = null;
 
-export function currentTour(): Tour {
-  return canvasState.getTour() ?? derivedTour(canvasState.getLayout().nodes);
+export function currentTour(): TourState {
+  const saved = canvasState.getTour();
+  const tour = saved ?? derivedTour(canvasState.nodeGeometry());
+  return { tour, derived: !saved, position: tourPosition(tour) };
 }
 
 /** The stop the tour is on for the active board, or null when not touring. */
-export function tourPosition(tour: Tour = currentTour()): number | null {
+function tourPosition(tour: Tour): number | null {
   if (cursor && (cursor.boardGeneration !== canvasState.boardGeneration || cursor.tour !== JSON.stringify(tour))) {
     cursor = null;
   }
@@ -37,9 +45,8 @@ export function tourPosition(tour: Tour = currentTour()): number | null {
 
 /** Move the shared cursor. `next`/`previous` clamp at the ends; an explicit index must exist. */
 export function goToTourStop(step: TourStep): TourStepResult {
-  const tour = currentTour();
+  const { tour, position: at } = currentTour();
   const { stops } = tour;
-  const at = tourPosition(tour);
   if (stops.length === 0) {
     throw new OperationError('This board has no tour stops. Save a tour or add groups.', 400);
   }
@@ -67,13 +74,15 @@ export function moveCamera(input: unknown): { stop: TourStop; viewport: Camera }
     throw new OperationError('Give exactly one of nodeId, rect {x,y,width,height} or viewport {x,y,scale}.', 400);
   }
   const stop = parsed.data;
-  if ('nodeId' in stop.target && !canvasState.getNode(stop.target.nodeId)) {
-    throw new OperationError(`Node "${stop.target.nodeId}" not found.`, 404);
+  const nodes = 'nodeId' in stop.target ? canvasState.nodeGeometry() : [];
+  const target = stop.target;
+  if ('nodeId' in target && !nodes.some((node) => node.id === target.nodeId)) {
+    throw new OperationError(`Node "${target.nodeId}" not found.`, 404);
   }
   const size = getClientViewportSize() ?? { width: 1440, height: 900 };
   let viewport: Camera;
   try {
-    viewport = resolveStop(stop, canvasState.getLayout().nodes, size.width, size.height);
+    viewport = resolveStop(stop, nodes, size.width, size.height);
   } catch (error) {
     throw new OperationError(error instanceof Error ? error.message : String(error), 400);
   }