pmx-canvas 0.9.2 → 0.9.3

package/src/client/state/canvas-store.ts

@@ -768,31 +768,19 @@ export function animateViewport(
   duration = 300,
   options: { recordHistory?: boolean } = {},
 ): void {
-  if (animationId !== null) cancelAnimationFrame(animationId);
-
   const from = { ...viewport.value };
-  const start = performance.now();
-
-  function tick(now: number) {
-    const elapsed = now - start;
-    const t = Math.min(1, elapsed / duration);
-    const e = easeOutCubic(t);
-
-    viewport.value = {
-      x: from.x + (target.x - from.x) * e,
-      y: from.y + (target.y - from.y) * e,
-      scale: from.scale + (target.scale - from.scale) * e,
-    };
-
-    if (t < 1) {
-      animationId = requestAnimationFrame(tick);
-    } else {
-      animationId = null;
-      commitViewport(target, options);
-    }
-  }
-
-  animationId = requestAnimationFrame(tick);
+  animateCameraPath(
+    (t) => {
+      const e = easeOutCubic(t);
+      return {
+        x: from.x + (target.x - from.x) * e,
+        y: from.y + (target.y - from.y) * e,
+        scale: from.scale + (target.scale - from.scale) * e,
+      };
+    },
+    duration,
+    () => commitViewport(target, options),
+  );
 }
 
 /**

package/src/client/state/intent-bridge.ts

@@ -1,7 +1,6 @@
 import { canvasArea, canvasFitInsets } from '../canvas/canvas-area';
 import { showToast } from './attention-bridge';
 import { isHostedWorkbench, workbenchFetch } from './workbench-transport';
-import type { AgentPresenceSnapshot } from '../../shared/agent-presence.js';
 import type { CanvasEdge, CanvasNodeState } from '../types';
 import { addEdge, canvasInteractionEpoch, nodes } from './canvas-store';
 import { activeBoardId, boardsLoaded } from './boards-store';
@@ -401,11 +400,6 @@ export async function fetchAxSurfaceState(): Promise<unknown> {
   return requestJson<unknown>('fetchAxSurfaceState', '/api/canvas/ax/surface-snapshot', null);
 }
 
-/** Connect-time agent-presence read; live updates arrive as `agent-presence` SSE frames. */
-export async function fetchAgentPresence(): Promise<Partial<AgentPresenceSnapshot> | null> {
-  return requestJson<Partial<AgentPresenceSnapshot> | null>('fetchAgentPresence', '/api/canvas/ax/presence', null);
-}
-
 /** Ask the server to open a node's surface in the system browser. */
 export async function openNodeInSystemBrowserRequest(
   nodeId: string,

package/src/client/state/presence-store.ts

@@ -12,9 +12,9 @@ import {
 } 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/src/client/state/sse-bridge.ts

@@ -14,7 +14,6 @@ import {
   axSurfaceState,
   bringToFront,
   cancelViewportAnimation,
-  commitViewport,
   canvasTheme,
   connectionStatus,
   contextPinsRevision,
@@ -50,12 +49,12 @@ import {
 import { applyContextStatus, refreshContextStatus } from './context-status-store';
 import { refreshContextChip } from './context-chip-store';
 import {
-  fetchAgentPresence,
   fetchAxSurfaceState,
   fetchCanvasState,
   reportClientViewportSize,
   requestJson,
   tabAgentKey,
+  updateViewportFromClient,
 } from './intent-bridge';
 import { agentActivity, applyPresenceSnapshot, sessionActive } from './presence-store';
 import { applyHumanSnapshot, humanClientId, startHumanPresence, stopHumanPresence } from './human-store';
@@ -577,9 +576,8 @@ function handleConnected(data: Record<string, unknown>): void {
   // Reconnect marker for holders of server-minted URLs (Finding S).
   workbenchConnectionEpoch.value += 1;
   reloadIfServerUpgraded(data.version, data.bundleStamp);
-  // Agent presence: read the snapshot on (re)connect; `agent-presence` frames
-  // keep it live from here on.
-  void fetchAgentPresence().then(applyPresenceSnapshot);
+  // Both transports send an ordered `agent-presence` connect snapshot, then
+  // live frames. A separate HTTP read can arrive late and overwrite newer state.
   void refreshContextStatus();
   refreshContextChip();
   // Human collaborators (phase 8): announce this tab and read who else is here.
@@ -1123,7 +1121,14 @@ function handleCanvasCameraMove(data: Record<string, unknown>): void {
   try {
     // The presentation camera is local; otherwise the end camera becomes the
     // board viewport — unrecorded, so a camera move is never an undo step.
-    playStop(stop.data, presenting.value ? undefined : (end) => commitViewport(end, { recordHistory: false }));
+    playStop(
+      stop.data,
+      presenting.value
+        ? undefined
+        : (end) => {
+            void updateViewportFromClient(end, { recordHistory: false });
+          },
+    );
   } catch {
     // Target not in this tab's layout yet: take the server's resolved camera.
     const fallback = cameraSchema.safeParse(data.viewport);

package/src/client/theme/global.css

@@ -4050,8 +4050,14 @@ kbd.toolbar-menu-hint {
 }
 
 /* ── Markdown reader mode (expanded view) ──────────────────── */
+.md-expanded-document {
+  display: flex;
+  flex-direction: column;
+}
+
 .md-reader {
-  height: 100%;
+  flex: 1;
+  min-height: 0;
   overflow-y: auto;
   display: flex;
   justify-content: center;
@@ -4205,11 +4211,11 @@ kbd.toolbar-menu-hint {
   background: var(--c-surface-subtle);
 }
 
-/* Source-mode FAB in expanded document view */
+/* Source stays below the scroll viewport, never over the document text. */
 .md-edit-fab {
-  position: absolute;
-  bottom: 16px;
-  right: 16px;
+  align-self: flex-end;
+  flex-shrink: 0;
+  margin: 16px;
   padding: 8px 18px;
   font-size: 13px;
   font-weight: 600;
@@ -5991,21 +5997,10 @@ html.is-node-resizing .ext-app-preview-catcher {
   /* Its sticky/backdrop-filter context must paint hints above the Source FAB. */
   z-index: 2;
 }
-.expanded-overlay-panel:has(.ax-step-dock) .md-expanded-document {
-  display: flex;
-  flex-direction: column;
-}
-.expanded-overlay-panel:has(.ax-step-dock) .md-reader {
-  flex: 1;
-  min-height: 0;
-}
 .expanded-overlay-panel:has(.ax-step-dock) .md-edit-fab {
   /* Keep Source and the document out of the bottom dock's hint area. */
-  position: static;
   order: -1;
-  align-self: flex-end;
-  flex-shrink: 0;
-  margin-bottom: 16px;
+  margin: 0 0 16px;
 }
 .ax-step-dock:has(.toolbar-tooltip-anchor:hover) .toolbar-tooltip-anchor:not(:hover) > :focus-visible + .toolbar-tooltip {
   /* Pointer exploration temporarily takes precedence without moving keyboard focus. */

package/src/server/canvas-state.ts

@@ -2863,6 +2863,16 @@ class CanvasStateManager {
     return node ? structuredClone(this.nodeForRead(node)) : undefined;
   }
 
+  /** Camera targets need geometry, not hydrated documents, frames or image blobs. */
+  nodeGeometry(): Array<Pick<CanvasNodeState, 'id' | 'type' | 'position' | 'size'>> {
+    return Array.from(this.nodes.values(), ({ id, type, position, size }) => ({
+      id,
+      type,
+      position: { ...position },
+      size: { ...size },
+    }));
+  }
+
   /** Who made and last edited each card, and its content revision — no content, no copies. */
   nodeStamps(): Array<Pick<CanvasNodeState, 'id' | 'createdBy' | 'lastEditedBy' | 'contentRevision'>> {
     return [...this.nodes.values()].map(({ id, createdBy, lastEditedBy, contentRevision }) => ({

package/src/server/index.ts

@@ -1,13 +1,13 @@
 import { EventEmitter } from 'node:events';
-import { derivedTour, type Camera, type Tour, type TourStop } from '../shared/tour.js';
-import { exitTour, goToTourStop, moveCamera, type TourStep, type TourStepResult } from './tour-control.js';
+import type { Camera, Tour, TourStop } from '../shared/tour.js';
+import { currentTour, exitTour, goToTourStop, moveCamera, 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 { agentPresence } from './agent-presence.js';
 import { checkFenceTarget, type FenceTarget } from './scope-fence.js';
 import type { AgentPhase, AgentPresence, AgentPresenceSnapshot } from '../shared/agent-presence.js';
-import { canvasState, IMAGE_MIME_MAP } from './canvas-state.js';
-import type { CanvasAnnotation, CanvasNodeState, CanvasEdge, CanvasLayout, ViewportState } from './canvas-state.js';
+import { canvasState } from './canvas-state.js';
+import type { CanvasAnnotation, CanvasNodeState, CanvasEdge, CanvasLayout } from './canvas-state.js';
 import { buildCanvasAxContext } from './ax-context.js';
 import { applyAxInteraction, type AxInteractionInput, type AxInteractionPublicResult } from './ax-interaction.js';
 import { intentRegistry } from './intent-registry.js';
@@ -46,12 +46,12 @@ import { workbenchToken } from './workbench-auth.js';
 import type { BackupFile, BackupStatus } from './backup.js';
 import type { ExportManifest } from './board-export.js';
 import { onFileNodeChanged } from './file-watcher.js';
-import { findOpenCanvasPosition, computeGroupBounds } from './placement.js';
+import { findOpenCanvasPosition } from './placement.js';
 import { overlapsAny } from '../shared/placement.js';
 import { buildSpatialContext } from './spatial-analysis.js';
 import { searchCanvasNodes } from './operations/ops/query.js';
 import { mutationHistory, diffLayouts, formatDiff } from './mutation-history.js';
-import { recomputeCodeGraph, buildCodeGraphSummary, formatCodeGraph } from './code-graph.js';
+import { buildCodeGraphSummary, formatCodeGraph } from './code-graph.js';
 import {
   addCanvasNode,
   addCanvasEdge,
@@ -90,12 +90,7 @@ import { validateCanvasLayout } from './canvas-validation.js';
 import { describeCanvasSchema, validateStructuredCanvasPayload } from './canvas-schema.js';
 import { serializeCanvasNode, type SerializedCanvasNode } from './canvas-serialization.js';
 import { contextReadFromPayload } from './context-reads.js';
-import {
-  buildHtmlPrimitive,
-  getHtmlPrimitiveSemanticMetadata,
-  isHtmlPrimitiveKind,
-  listHtmlPrimitiveDescriptors,
-} from './html-primitives.js';
+import { buildHtmlPrimitive, getHtmlPrimitiveSemanticMetadata } from './html-primitives.js';
 import type { HtmlPrimitiveKind } from './html-primitives.js';
 import {
   buildWebArtifactOnCanvas,
@@ -104,15 +99,7 @@ import {
 } from './web-artifacts.js';
 import { closeMcpAppSession, type ExternalMcpTransportConfig } from './mcp-app-runtime.js';
 import type { DiagramPresetOpenInput } from './diagram-presets.js';
-import {
-  buildGraphSpec,
-  GRAPH_NODE_SIZE,
-  JSON_RENDER_NODE_SIZE,
-  normalizeAndValidateJsonRenderSpec,
-  type GraphNodeInput,
-  type JsonRenderNodeInput,
-  type JsonRenderSpec,
-} from '../json-render/server.js';
+import type { GraphNodeInput, JsonRenderNodeInput, JsonRenderSpec } from '../json-render/server.js';
 import {
   startCanvasServer,
   stopCanvasServer,
@@ -126,15 +113,8 @@ import {
   screenshotCanvasAutomationWebView,
   emitPrimaryWorkbenchEvent,
   setPrimaryWorkbenchCanvasPromptHandler,
-  setPrimaryWorkbenchAutoOpenEnabled,
-  consumePrimaryWorkbenchIntents,
-} from './server.js';
-import type {
-  CanvasAutomationWebViewOptions,
-  CanvasAutomationWebViewStatus,
-  PrimaryWorkbenchCanvasPromptRequest,
-  PrimaryWorkbenchIntent,
 } from './server.js';
+import type { CanvasAutomationWebViewOptions, CanvasAutomationWebViewStatus } from './server.js';
 
 /**
  * Node object returned by the SDK's create/get methods. It is the fully
@@ -633,7 +613,7 @@ export class PmxCanvas extends EventEmitter {
   }
 
   getTour(): Tour {
-    return canvasState.getTour() ?? derivedTour(canvasState.getLayout().nodes);
+    return currentTour().tour;
   }
 
   setTour(tour: Tour | null): void {

package/src/server/knowledge-lifecycle.ts

@@ -1,6 +1,7 @@
 import type { Database } from 'bun:sqlite';
 import { z } from 'zod';
 import { normalizeBoardFolder } from '../shared/boards.js';
+import { memoryKey, type MemoryTarget } from '../shared/memory-graph.js';
 import { currentActor, type ActorAttribution } from './attribution.js';
 import { OperationError } from './operations/types.js';
 import type { LifecycleQualification } from '../shared/lifecycle-status.js';
@@ -47,6 +48,16 @@ export interface ReviewRecord {
   sourceRevisions?: Record<string, number | null>;
 }
 
+// SQLite trim defaults to ASCII space; match JavaScript evidence.trim(), including Unicode whitespace.
+const evidenceWhitespace =
+  '\u0009\u000a\u000b\u000c\u000d\u0020\u00a0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000\ufeff';
+const validationPredicate = `json_extract(value, '$.applied') = 1
+  AND json_extract(value, '$.outcome') IN ('retain', 'revise', 'externalize')
+  AND trim(json_extract(value, '$.evidence'), '${evidenceWhitespace}') <> ''`;
+const retirementPredicate = `(json_extract(value, '$.outcome') = 'restore'
+  OR (json_extract(value, '$.applied') = 1 AND json_extract(value, '$.outcome') = 'retire'))`;
+const indexedDatabases = new WeakSet<Database>();
+
 export type KnowledgeInput =
   | { action: 'list' }
   | { action: 'category-set'; category: KnowledgeCategory }
@@ -240,6 +251,61 @@ export class KnowledgeLifecycle {
     return resolved;
   }
 
+  private indexedDb(): Database {
+    const db = this.db();
+    if (!indexedDatabases.has(db)) {
+      db.exec(`CREATE INDEX IF NOT EXISTS review_latest_validation ON review_records
+        (board_id, node_id, sequence DESC) WHERE ${validationPredicate};
+        CREATE INDEX IF NOT EXISTS review_latest_retirement ON review_records
+        (board_id, node_id, sequence DESC) WHERE ${retirementPredicate};
+        CREATE INDEX IF NOT EXISTS lifecycle_incoming_sources ON edges (to_board_id, to_node)
+        WHERE COALESCE(kind, type) IN ('derived-from', 'contradicts', 'supersedes');`);
+      indexedDatabases.add(db);
+    }
+    return db;
+  }
+
+  /** Stored owners of semantic sources; the caller overlays the active board's unsaved edges. */
+  incomingSourceBoards(target: MemoryTarget, activeBoardId: string | null): string[] {
+    return this.indexedDb()
+      .query<{ board_id: string }, [string, string | null, string | null]>(
+        `SELECT DISTINCT board_id FROM edges WHERE to_board_id = ? AND to_node = ?
+       AND board_id IS NOT ? AND COALESCE(kind, type) IN ('derived-from', 'contradicts', 'supersedes')`,
+      )
+      .all(target.boardId, target.cardId ?? null, activeBoardId)
+      .map((row) => row.board_id);
+  }
+
+  /** One indexed latest validation and retirement per card, never its full audit history. */
+  reviewSummaries(targets: MemoryTarget[]): Map<string, { lastValidation: ReviewRecord | null; retired: boolean }> {
+    if (!targets.length) return new Map();
+    const rows = this.indexedDb()
+      .query<{ boardId: string; nodeId: string; validation: string | null; retirement: string | null }, [string]>(
+        `WITH targets AS (
+         SELECT json_extract(value, '$.boardId') AS boardId, json_extract(value, '$.cardId') AS nodeId
+         FROM json_each(?)
+       ) SELECT boardId, nodeId,
+         (SELECT value FROM review_records WHERE board_id = boardId AND node_id = nodeId
+          AND ${validationPredicate} ORDER BY sequence DESC LIMIT 1) AS validation,
+         (SELECT json_extract(value, '$.outcome') FROM review_records WHERE board_id = boardId AND node_id = nodeId
+          AND ${retirementPredicate} ORDER BY sequence DESC LIMIT 1) AS retirement
+       FROM targets`,
+      )
+      .all(JSON.stringify(targets));
+    return new Map(
+      rows.map((row) => {
+        const record: ReviewRecord | null = row.validation ? JSON.parse(row.validation) : null;
+        return [
+          memoryKey({ boardId: row.boardId, cardId: row.nodeId }),
+          {
+            lastValidation: record ? { ...record, contentRevision: record.contentRevision ?? null } : null,
+            retired: row.retirement === 'retire',
+          },
+        ];
+      }),
+    );
+  }
+
   reviews(boardId: string, nodeId: string) {
     const records = (
       this.db()

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));