pmx-canvas 0.10.0 → 0.12.0

package/src/server/file-watcher.ts

@@ -10,6 +10,7 @@ import { watch, existsSync, statSync } from 'node:fs';
 import type { FSWatcher } from 'node:fs';
 import { canvasState } from './canvas-state.js';
 import { applyFileContentToNodeData, readFileNodeContent } from './file-content.js';
+import { createBoardLocal } from './board-local.js';
 
 function logFileWatcherWarning(action: string, error: unknown, details?: Record<string, unknown>): void {
   console.warn(`[file-watcher] ${action}`, { error, ...(details ?? {}) });
@@ -22,7 +23,22 @@ interface WatchedFile {
   lastMtime: number;
 }
 
-const watched = new Map<string, WatchedFile>();
+const watcherSets = new Set<Map<string, WatchedFile>>();
+function stopWatching(watched: Map<string, WatchedFile>): void {
+  for (const entry of watched.values()) entry.watcher.close();
+  watched.clear();
+}
+const boardWatchers = createBoardLocal(
+  () => {
+    const watched = new Map<string, WatchedFile>();
+    watcherSets.add(watched);
+    return watched;
+  },
+  (watched) => {
+    stopWatching(watched);
+    watcherSets.delete(watched);
+  },
+);
 let onFileChanged: ((nodeId: string) => void) | null = null;
 
 /** Register a callback for when a watched file changes. */
@@ -34,6 +50,7 @@ export function onFileNodeChanged(cb: (nodeId: string) => void): void {
 export function watchFileForNode(nodeId: string, filePath: string): void {
   if (!filePath || !existsSync(filePath)) return;
 
+  const watched = boardWatchers.current;
   const existing = watched.get(filePath);
   if (existing) {
     existing.nodeIds.add(nodeId);
@@ -42,10 +59,14 @@ export function watchFileForNode(nodeId: string, filePath: string): void {
 
   try {
     const stat = statSync(filePath);
-    const watcher = watch(filePath, { persistent: false }, (eventType) => {
-      if (eventType !== 'change') return;
-      handleFileChange(filePath);
-    });
+    const watcher = watch(
+      filePath,
+      { persistent: false },
+      canvasState.bindBoard((eventType) => {
+        if (eventType !== 'change') return;
+        handleFileChange(filePath);
+      }),
+    );
 
     watched.set(filePath, {
       path: filePath,
@@ -60,6 +81,7 @@ export function watchFileForNode(nodeId: string, filePath: string): void {
 
 /** Stop watching a file for a given node. */
 export function unwatchFileForNode(nodeId: string, filePath?: string): void {
+  const watched = boardWatchers.current;
   for (const [path, entry] of watched) {
     if (filePath && path !== filePath) continue;
     entry.nodeIds.delete(nodeId);
@@ -72,14 +94,11 @@ export function unwatchFileForNode(nodeId: string, filePath?: string): void {
 
 /** Stop all watchers. */
 export function unwatchAll(): void {
-  for (const entry of watched.values()) {
-    entry.watcher.close();
-  }
-  watched.clear();
+  for (const watched of watcherSets) stopWatching(watched);
 }
 
 export function rewatchAllFileNodes(): void {
-  unwatchAll();
+  stopWatching(boardWatchers.current);
   for (const node of canvasState.getLayout().nodes) {
     if (node.type === 'file' && typeof node.data.path === 'string') {
       watchFileForNode(node.id, node.data.path);
@@ -88,6 +107,7 @@ export function rewatchAllFileNodes(): void {
 }
 
 function handleFileChange(filePath: string): void {
+  const watched = boardWatchers.current;
   const entry = watched.get(filePath);
   if (!entry) return;
 

package/src/server/html-primitives.ts

@@ -812,13 +812,12 @@ function page(input: {
   * { box-sizing: border-box; }
   body { margin: 0; padding: 22px; background: radial-gradient(circle at top left, color-mix(in srgb, var(--color-accent, #4a9eff) 18%, transparent), transparent 34rem), var(--color-bg, #0b0f14); color: var(--color-text, #e8edf2); font-family: var(--font-sans, ui-sans-serif, system-ui, sans-serif); }
   .shell { max-width: 1160px; margin: 0 auto; }
-  header.hero { display: grid; grid-template-columns: 1fr auto; gap: 16px; align-items: start; margin-bottom: 20px; }
+  header.hero { margin-bottom: 20px; }
   .kicker { color: var(--color-accent, #4a9eff); text-transform: uppercase; letter-spacing: .16em; font-size: 11px; font-weight: 800; }
   h1 { margin: 5px 0 8px; font-size: clamp(28px, 4vw, 46px); line-height: .95; letter-spacing: -.04em; }
   h2 { margin: 0 0 12px; font-size: 19px; letter-spacing: -.02em; }
   h3 { margin: 0 0 8px; font-size: 15px; }
   p { color: var(--color-text-secondary, #aeb8c2); margin: 0 0 12px; }
-  .actions { display: flex; gap: 8px; flex-wrap: wrap; justify-content: flex-end; }
   button { border: 1px solid var(--color-border, #263241); background: var(--color-panel, #111821); color: var(--color-text, #e8edf2); border-radius: 999px; padding: 8px 12px; font: inherit; cursor: pointer; }
   button:hover { border-color: var(--color-accent, #4a9eff); transform: translateY(-1px); }
   table { width: 100%; border-collapse: collapse; color: var(--color-text-secondary, #aeb8c2); font-size: 13px; }
@@ -861,20 +860,20 @@ function page(input: {
   .slide h2 { font-size: clamp(30px, 5vw, 58px); line-height: .95; }
   .preview { white-space: pre-wrap; min-height: 220px; }
   .figure svg { width: 100%; min-height: 220px; border-radius: 14px; background: color-mix(in srgb, var(--color-bg, #0b0f14) 86%, white); border: 1px solid var(--color-border, #263241); }
-  @media (max-width: 760px) { body { padding: 14px; } header.hero, .two, .three { grid-template-columns: 1fr; } .actions { justify-content: flex-start; } .sticky { position: static; } }
+  @media (max-width: 760px) { body { padding: 14px; } .two, .three { grid-template-columns: 1fr; } .sticky { position: static; } }
 </style>
 </head>
 <body>
 <div class="shell">
   <header class="hero">
     <div><div class="kicker">PMX HTML primitive / ${escapeHtml(input.kind)}</div><h1>${escapeHtml(input.title)}</h1><p>${escapeHtml(input.summary)}</p></div>
-    <div class="actions"><button type="button" data-copy-json>Copy JSON</button><button type="button" data-copy-prompt>Copy prompt</button></div>
   </header>
   ${input.body}
 </div>
 <script type="application/json" id="pmx-data">${safeJson(input.data)}</script>
 <script>
 const PMX_DATA = JSON.parse(document.getElementById('pmx-data').textContent);
+window.__pmxGetCopyJson = () => PMX_DATA;
 function fallbackCopy(text) {
   const el = document.createElement('textarea');
   el.value = text;
@@ -890,11 +889,6 @@ async function copyText(text) {
   if (navigator.clipboard && window.isSecureContext) await navigator.clipboard.writeText(text);
   else fallbackCopy(text);
 }
-document.querySelector('[data-copy-json]')?.addEventListener('click', () => {
-  const payload = typeof window.__pmxGetCopyJson === 'function' ? window.__pmxGetCopyJson() : PMX_DATA;
-  copyText(JSON.stringify(payload, null, 2));
-});
-document.querySelector('[data-copy-prompt]')?.addEventListener('click', () => copyText('Use this PMX Canvas HTML primitive output as context:\\n\\n' + JSON.stringify(PMX_DATA, null, 2)));
 ${input.script ?? ''}
 </script>
 </body>

package/src/server/html-surface.ts

@@ -61,6 +61,14 @@ const PMX_CANVAS_THEME_TOKEN = ${token};
 window.addEventListener('message', (event) => {
   const message = event.data;
   if (event.source !== window.parent || !message || message.source !== '${HTML_SURFACE_PUSH_SOURCE}' || message.token !== PMX_CANVAS_THEME_TOKEN) return;
+  if (message.type === 'copy-json' && PMX_CANVAS_THEME_TOKEN && typeof message.requestId === 'string') {
+    let json;
+    try {
+      if (typeof window.__pmxGetCopyJson === 'function') json = JSON.stringify(window.__pmxGetCopyJson(), null, 2);
+    } catch {}
+    window.parent.postMessage({ source: '${HTML_SURFACE_PUSH_SOURCE}', type: 'copy-json-result', token: PMX_CANVAS_THEME_TOKEN, requestId: message.requestId, json }, '*');
+    return;
+  }
   if (message.type === 'check-ready') {
     const reply = (type) => window.parent.postMessage({ source: '${HTML_SURFACE_PUSH_SOURCE}', type, token: PMX_CANVAS_THEME_TOKEN }, '*');
     reply('mounted');

package/src/server/human-presence.ts

@@ -1,12 +1,14 @@
 import { z } from 'zod';
 import {
   HUMAN_GRAB_TTL_MS,
+  HUMAN_NAME_MAX_LENGTH,
   HUMAN_PRESENCE_TTL_MS,
   type HumanPresence,
   type HumanPresenceSnapshot,
   MAX_HUMANS,
 } from '../shared/human-presence.js';
 import { OperationError } from './operations/types.js';
+import { canvasState } from './canvas-state.js';
 
 /**
  * Registry of open workbench tabs (rail-chrome-v2 phase 8). Fed by the
@@ -17,7 +19,7 @@ import { OperationError } from './operations/types.js';
  */
 export const HUMAN_PRESENCE_SHAPE = {
   clientId: z.string().min(1).max(64),
-  name: z.string().min(1).max(40).optional(),
+  name: z.string().min(1).max(HUMAN_NAME_MAX_LENGTH).optional(),
   cursor: z.object({ x: z.number().finite(), y: z.number().finite() }).nullable().optional(),
   grabbingNodeId: z.string().max(200).nullable().optional(),
   /** Explicit leave (tab closing): drop the presence now. */
@@ -26,6 +28,7 @@ export const HUMAN_PRESENCE_SHAPE = {
 const presenceSchema = z.object(HUMAN_PRESENCE_SHAPE);
 
 interface Stored extends HumanPresence {
+  boardId: string | null;
   lastSeenMs: number;
   grabSinceMs: number | null;
 }
@@ -57,6 +60,7 @@ export class HumanPresenceRegistry {
     }
     const existing = this.humans.get(input.clientId);
     const stored: Stored = existing ?? {
+      boardId: canvasState.activeBoardId,
       clientId: input.clientId,
       name: input.name ?? 'Human',
       cursor: null,
@@ -65,6 +69,11 @@ export class HumanPresenceRegistry {
       lastSeenMs: now,
       grabSinceMs: null,
     };
+    if (stored.boardId !== canvasState.activeBoardId) {
+      stored.boardId = canvasState.activeBoardId;
+      stored.grabbingNodeId = null;
+      stored.grabSinceMs = null;
+    }
     stored.lastSeenMs = now;
     stored.lastSeenAt = new Date(now).toISOString();
     if (input.name) stored.name = input.name;
@@ -91,9 +100,10 @@ export class HumanPresenceRegistry {
   }
 
   /** Nodes a human is holding right now → that human's name. The edit lock. */
-  lockedNodes(now = Date.now()): Map<string, string> {
+  lockedNodes(now = Date.now(), boardId = canvasState.activeBoardId): Map<string, string> {
     const locked = new Map<string, string>();
     for (const human of this.humans.values()) {
+      if (human.boardId !== boardId) continue;
       if (human.grabbingNodeId && human.grabSinceMs !== null && now - human.grabSinceMs <= HUMAN_GRAB_TTL_MS) {
         locked.set(human.grabbingNodeId, human.name);
       }
@@ -111,13 +121,16 @@ export class HumanPresenceRegistry {
   }
 
   private publicView(stored: Stored): HumanPresence {
-    const { lastSeenMs: _lastSeenMs, grabSinceMs, ...human } = stored;
+    const { lastSeenMs: _lastSeenMs, grabSinceMs, boardId, ...human } = stored;
     // An expired grab reads as released even before the sweep drops it.
     const grabbing =
-      human.grabbingNodeId && grabSinceMs !== null && Date.now() - grabSinceMs <= HUMAN_GRAB_TTL_MS
+      boardId === canvasState.activeBoardId &&
+      human.grabbingNodeId &&
+      grabSinceMs !== null &&
+      Date.now() - grabSinceMs <= HUMAN_GRAB_TTL_MS
         ? human.grabbingNodeId
         : null;
-    return { ...human, grabbingNodeId: grabbing };
+    return { ...human, cursor: boardId === canvasState.activeBoardId ? human.cursor : null, grabbingNodeId: grabbing };
   }
 
   private sweep(now = Date.now(), options: { emit?: boolean } = {}): void {

package/src/server/index.ts

@@ -1,5 +1,7 @@
 import { EventEmitter } from 'node:events';
-import type { Camera, Tour, TourStop } from '../shared/tour.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 {
   currentTour,
   exitTour,
@@ -8,9 +10,10 @@ import {
   type TourState,
   type TourStep,
   type TourStepResult,
+  type TourSuperseded,
 } from './tour-control.js';
-export type { Tour, TourStop } from '../shared/tour.js';
-export type { TourState, TourStep, TourStepResult } from './tour-control.js';
+export type { Tour, TourPresenter, TourStop } from '../shared/tour.js';
+export type { TourState, TourStep, TourStepResult, TourSuperseded } 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';
@@ -507,21 +510,19 @@ export class PmxCanvas extends EventEmitter {
     return (await executeOperation('edge.update', { id, ...patch }, { source: 'sdk' })) as CanvasEdge;
   }
 
-  addAnnotation(input: Omit<CanvasAnnotation, 'id' | 'createdAt'> & { id?: string; createdAt?: string }): string {
-    const id = input.id ?? `ann-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-    canvasState.addAnnotation({
-      ...input,
-      id,
-      createdAt: input.createdAt ?? new Date().toISOString(),
-    });
-    emitPrimaryWorkbenchEvent('canvas-layout-update', { layout: canvasState.getLayout() });
-    return id;
+  async addAnnotation(
+    input: Pick<CanvasAnnotation, 'points'> &
+      Partial<Pick<CanvasAnnotation, 'id' | 'type' | 'color' | 'width' | 'text' | 'label'>>,
+  ): Promise<string> {
+    const result = (await executeOperation('annotation.add', input, { source: 'sdk' })) as {
+      annotation: { id: string };
+    };
+    return result.annotation.id;
   }
 
-  removeAnnotation(id: string): boolean {
-    const removed = canvasState.removeAnnotation(id);
-    if (removed) emitPrimaryWorkbenchEvent('canvas-layout-update', { layout: canvasState.getLayout() });
-    return removed;
+  async removeAnnotation(id: string): Promise<boolean> {
+    const result = (await executeOperation('annotation.remove', { id }, { source: 'sdk' })) as { ok: boolean };
+    return result.ok;
   }
 
   removeEdge(id: string): void {
@@ -631,16 +632,25 @@ export 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 }): TourStepResult {
-    const result = goToTourStop(step);
-    emitPrimaryWorkbenchEvent('canvas-tour-step', { ...result, present: options?.present !== false });
+  goToTourStop(step: TourStep, options?: { present?: boolean; presenter?: undefined }): TourStepResult;
+  goToTourStop(
+    step: TourStep,
+    options: { present?: boolean; presenter?: TourPresenter },
+  ): TourStepResult | TourSuperseded;
+  goToTourStop(
+    step: TourStep,
+    options?: { present?: boolean; presenter?: TourPresenter },
+  ): TourStepResult | TourSuperseded {
+    const result = goToTourStop(step, options?.presenter);
+    if (!('superseded' in result))
+      emitPrimaryWorkbenchEvent('canvas-tour-step', { ...result, present: options?.present !== false });
     return result;
   }
 
   /** Leave presentation in every viewer. */
-  exitTour(): void {
-    exitTour();
-    emitPrimaryWorkbenchEvent('canvas-tour-exit', {});
+  exitTour(presenter?: TourPresenter): void {
+    const result = exitTour(presenter);
+    if (!('superseded' in result)) emitPrimaryWorkbenchEvent('canvas-tour-exit', { ...result });
   }
 
   /** Ease the camera to a node, world rect or viewport. Not recorded in undo history. */
@@ -754,7 +764,12 @@ export class PmxCanvas extends EventEmitter {
   }
 
   /** Undelivered steering for a consumer (loop-safe; excludes consumer-originated). */
-  getPendingSteering(options?: { consumer?: string; limit?: number }): PmxAxSteeringMessage[] {
+  getPendingSteering(options?: {
+    consumer?: string;
+    limit?: number;
+    addressedOnly?: boolean;
+    offset?: number;
+  }): PmxAxSteeringMessage[] {
     return canvasState.getPendingSteering(options ?? {});
   }
 
@@ -944,6 +959,15 @@ export class PmxCanvas extends EventEmitter {
     return (await executeOperation('board.create-from', input, { source: 'sdk' })) as Record<string, unknown>;
   }
 
+  /** Relocate identities atomically; preview is read-only and retries reuse the original receipt. */
+  async moveSelectionToNewBoard(
+    input: BoardMoveInput,
+  ): Promise<{ ok: true; preview: BoardMovePreview } | (BoardMoveResult & { ok: true; replayed: boolean })> {
+    return (await executeOperation('board.move-selection', input, { source: 'sdk' })) as
+      | { ok: true; preview: BoardMovePreview }
+      | (BoardMoveResult & { ok: true; replayed: boolean });
+  }
+
   async searchLibrary(query: string, limit?: number): Promise<Record<string, unknown>> {
     return (await executeOperation('search', { q: query, scope: 'library', limit }, { source: 'sdk' })) as Record<
       string,
@@ -960,7 +984,13 @@ export class PmxCanvas extends EventEmitter {
 
   /** Budgeted cross-board brief. Budget is measured in UTF-16 characters. */
   async getContextBrief(
-    options: { consumer?: string; since?: number; budget?: number } = {},
+    options: {
+      consumer?: string;
+      since?: number;
+      budget?: number;
+      contextDelivery?: boolean;
+      includeSteering?: boolean;
+    } = {},
   ): Promise<Record<string, unknown>> {
     return (await executeOperation('context.get', options, { source: 'sdk' })) as Record<string, unknown>;
   }

package/src/server/intent-registry.ts

@@ -25,6 +25,8 @@ import {
   type PmxAxIntentKind,
 } from '../shared/ax-intent.js';
 import { OperationError } from './operations/types.js';
+import { createBoardLocal } from './board-local.js';
+import { canvasState } from './canvas-state.js';
 
 type IntentEmitter = (event: string, payload: Record<string, unknown>) => void;
 const MAX_VETO_TOMBSTONES = 128;
@@ -103,11 +105,33 @@ function nextIntentId(): string {
 }
 
 export class IntentRegistry {
-  private readonly intents = new Map<string, PmxAxIntent>();
-  private readonly vetoedIntentIds = new Map<string, number>();
-  private readonly committingIntentIds = new Set<string>();
+  private readonly board = createBoardLocal(
+    () => ({
+      intents: new Map<string, PmxAxIntent>(),
+      vetoedIntentIds: new Map<string, number>(),
+      committingIntentIds: new Set<string>(),
+      sweepTimer: null as ReturnType<typeof setInterval> | null,
+    }),
+    (state) => {
+      if (state.sweepTimer) clearInterval(state.sweepTimer);
+    },
+  );
+  private get intents() {
+    return this.board.current.intents;
+  }
+  private get vetoedIntentIds() {
+    return this.board.current.vetoedIntentIds;
+  }
+  private get committingIntentIds() {
+    return this.board.current.committingIntentIds;
+  }
   private emit: IntentEmitter = () => {};
-  private sweepTimer: ReturnType<typeof setInterval> | null = null;
+  private get sweepTimer() {
+    return this.board.current.sweepTimer;
+  }
+  private set sweepTimer(value: ReturnType<typeof setInterval> | null) {
+    this.board.current.sweepTimer = value;
+  }
 
   /** Inject the workbench SSE emitter (server.ts wires this at module load). */
   setEmitter(emitter: IntentEmitter | null): void {
@@ -118,6 +142,17 @@ export class IntentRegistry {
     return [...this.intents.values()];
   }
 
+  /** The first write from Home adopts its ghosts and vetoes without opening on signal. */
+  moveHomeIntentsToBoard(boardId: string): void {
+    const home = this.board.current;
+    canvasState.withBoard(boardId, () => {
+      for (const [id, intent] of home.intents) this.intents.set(id, intent);
+      for (const [id, expires] of home.vetoedIntentIds) this.vetoedIntentIds.set(id, expires);
+      this.ensureSweeper();
+    });
+    this.reset();
+  }
+
   /** Signal a new (or replace an existing) intent. Returns the stored envelope. */
   signal(raw: unknown): PmxAxIntent {
     const input = parseOrThrow(intentSignalSchema, raw, 'intent');
@@ -335,7 +370,10 @@ export class IntentRegistry {
 
   private ensureSweeper(): void {
     if (this.sweepTimer || this.intents.size === 0) return;
-    this.sweepTimer = setInterval(() => this.sweep(), 1000);
+    this.sweepTimer = setInterval(
+      canvasState.bindBoard(() => this.sweep()),
+      1000,
+    );
     // Don't keep the process (or a test runner) alive just for ghost expiry.
     (this.sweepTimer as { unref?: () => void }).unref?.();
   }

package/src/server/knowledge-lifecycle.ts

@@ -4,6 +4,7 @@ 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 { CARD_HISTORY_CTE } from './card-relocation.js';
 import type { LifecycleQualification } from '../shared/lifecycle-status.js';
 import type { CanvasNodeState } from './canvas-state.js';
 import { RELATION_PRESETS, relationPresetSchema, type RelationPreset } from '../shared/relations.js';
@@ -281,15 +282,19 @@ export class KnowledgeLifecycle {
     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
+        `${CARD_HISTORY_CTE}
+       SELECT t.current_board AS boardId, t.node_id AS nodeId,
+         (SELECT value FROM review_records r JOIN history h
+          ON r.board_id = h.board_id AND r.node_id = h.node_id
+          AND r.sequence > h.review_after AND r.sequence <= h.review_through
+          WHERE h.current_board = t.current_board AND h.node_id = t.node_id
           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
+         (SELECT json_extract(value, '$.outcome') FROM review_records r JOIN history h
+          ON r.board_id = h.board_id AND r.node_id = h.node_id
+          AND r.sequence > h.review_after AND r.sequence <= h.review_through
+          WHERE h.current_board = t.current_board AND h.node_id = t.node_id
           AND ${retirementPredicate} ORDER BY sequence DESC LIMIT 1) AS retirement
-       FROM targets`,
+       FROM targets t`,
       )
       .all(JSON.stringify(targets));
     return new Map(
@@ -306,11 +311,29 @@ export class KnowledgeLifecycle {
     );
   }
 
+  /** Resolve a current card's location when evidence was recorded, without rewriting that evidence. */
+  locationAtReview(review: ReviewRecord, target: MemoryTarget): MemoryTarget {
+    const sequence = this.db()
+      .query<{ sequence: number }, [string, string, string]>(
+        "SELECT sequence FROM review_records WHERE board_id = ? AND node_id = ? AND json_extract(value, '$.id') = ?",
+      )
+      .get(review.boardId, review.nodeId, review.id)?.sequence;
+    if (sequence === undefined) return target;
+    const location = this.db()
+      .query<{ board_id: string }, [string, number, number]>(
+        `${CARD_HISTORY_CTE} SELECT board_id FROM history WHERE review_after < ? AND review_through >= ? LIMIT 1`,
+      )
+      .get(JSON.stringify([target]), sequence, sequence);
+    return location ? { ...target, boardId: location.board_id } : target;
+  }
+
   reviews(boardId: string, nodeId: string) {
     const records = (
       this.db()
-        .query('SELECT value FROM review_records WHERE board_id = ? AND node_id = ? ORDER BY sequence')
-        .all(boardId, nodeId) as { value: string }[]
+        .query(`${CARD_HISTORY_CTE} SELECT value FROM review_records r JOIN history h
+          ON r.board_id = h.board_id AND r.node_id = h.node_id
+          AND r.sequence > h.review_after AND r.sequence <= h.review_through ORDER BY sequence`)
+        .all(JSON.stringify([{ boardId, cardId: nodeId }])) as { value: string }[]
     ).map((r): ReviewRecord => {
       const record = JSON.parse(r.value) as ReviewRecord;
       return { ...record, contentRevision: record.contentRevision ?? null };

package/src/server/lifecycle-status.ts

@@ -11,6 +11,7 @@ const processStartedAt = Date.now();
 interface Source {
   key: string;
   target: MemoryTarget;
+  edge?: { owner: MemoryTarget; id: string };
   baseline?: number;
   kind: string;
   observedAt?: string;
@@ -179,6 +180,7 @@ export function lifecycleSnapshot(now = Date.now(), atUse: MemoryTarget[] = [],
       existing.push({
         key: JSON.stringify([board.id, edge.id, kind, memoryKey(target)]),
         target,
+        edge: { owner: from, id: edge.id },
         kind,
         baseline: edge.sourceRevision,
       });
@@ -219,13 +221,30 @@ export function lifecycleSnapshot(now = Date.now(), atUse: MemoryTarget[] = [],
       const current = cards.get(memoryKey(source.target));
       const revision = source.availability === 'unavailable' ? null : (current?.contentRevision ?? null);
       status.observations[source.key] = revision;
-      const observed = validation ? validation.sourceRevisions?.[source.key] : source.baseline;
+      let observed = validation ? validation.sourceRevisions?.[source.key] : source.baseline;
+      if (validation?.sourceRevisions && observed === undefined) {
+        const target = canvasState.knowledge.locationAtReview(validation, source.target);
+        const historicalKey = source.edge
+          ? JSON.stringify([
+              canvasState.knowledge.locationAtReview(validation, source.edge.owner).boardId,
+              source.edge.id,
+              source.kind,
+              memoryKey(target),
+            ])
+          : `provenance:${memoryKey(target)}`;
+        observed = validation.sourceRevisions[historicalKey];
+      }
       const title = current ? String(current.data.title ?? current.id) : 'Unavailable source';
+      const before = status.reasons.length;
       if (!current) status.reasons.push('A dependency source is unavailable; no fresh check.');
       else if (source.availability === 'unavailable')
         status.reasons.push(`${title}: source unavailable; cached content is not a fresh check.`);
       else if (observed !== revision || (!validation && ['contradicts', 'supersedes'].includes(source.kind)))
         status.reasons.push(`${source.kind}: ${title}${observed === undefined ? ' needs review' : ' changed'}.`);
+      if (status.reasons.length > before) {
+        status.sourceWarnings ??= {};
+        status.sourceWarnings[source.key] = status.reasons.slice(before);
+      }
     }
   }
   // Fixed point, not recursive traversal: cycles cannot overflow and unrelated links never propagate.
@@ -246,6 +265,15 @@ export function lifecycleSnapshot(now = Date.now(), atUse: MemoryTarget[] = [],
     }
   }
   for (const [key, status] of Object.entries(result)) {
+    for (const source of sources.get(key) ?? []) {
+      const upstream = result[memoryKey(source.target)];
+      if (upstream?.due || upstream?.retired) {
+        status.sourceWarnings ??= {};
+        status.sourceWarnings[source.key] ??= [
+          upstream.retired ? 'Source is retired.' : 'An explicit source needs review.',
+        ];
+      }
+    }
     const references: Source[] = [...(sources.get(key) ?? [])];
     const boardId = portals.get(key);
     if (boardId) {

package/src/server/mcp-app-runtime.ts

@@ -18,6 +18,7 @@ import { EXTENSION_ID, RESOURCE_MIME_TYPE } from '@modelcontextprotocol/ext-apps
 import type { McpUiClientCapabilities, McpUiResourceCsp, McpUiResourceMeta } from '@modelcontextprotocol/ext-apps';
 import { getToolUiResourceUri } from '@modelcontextprotocol/ext-apps/app-bridge';
 import { normalizeExtAppToolResult } from './ext-app-tool-result.js';
+import { canvasState } from './canvas-state.js';
 
 // A restriction follows async rehydration spawned by an embedded operation,
 // without disabling independent requests from the local workbench.
@@ -71,10 +72,12 @@ type RuntimeTransport = StdioClientTransport | StreamableHTTPClientTransport;
 
 interface McpAppSession {
   id: string;
+  board: object;
   serverName: string;
   client: Client;
   transport: RuntimeTransport;
   tools: Tool[];
+  unregisterBoardDispose: () => void;
 }
 
 const uiCapabilities: McpUiClientCapabilities = {
@@ -223,21 +226,35 @@ async function createSession(
   }
   const transport = buildTransport(transportConfig);
   const client = new Client({ name: 'pmx-canvas-app-host', version: '0.1.0' }, { capabilities: clientCapabilities });
-  await client.connect(transport, requestOptions(timeoutMs));
-
-  const toolList = await client.listTools(undefined, requestOptions(timeoutMs));
+  const id = randomId('mcp-app-session');
+  let disposed = false;
   const session: McpAppSession = {
-    id: randomId('mcp-app-session'),
+    id,
+    board: canvasState.boardIdentity,
     serverName: normalizeServerName(serverName, transportConfig),
     client,
     transport,
-    tools: toolList.tools,
+    tools: [],
+    unregisterBoardDispose: canvasState.onBoardDispose(() => {
+      disposed = true;
+      closeMcpAppSession(id);
+    }),
   };
   sessions.set(session.id, session);
-  return session;
+  try {
+    await client.connect(transport, requestOptions(timeoutMs));
+    const toolList = await client.listTools(undefined, requestOptions(timeoutMs));
+    if (disposed) throw new Error('The app board was deleted while connecting.');
+    session.tools = toolList.tools;
+    return session;
+  } catch (error) {
+    await closeSession(session);
+    throw error;
+  }
 }
 
 async function closeSession(session: McpAppSession): Promise<void> {
+  session.unregisterBoardDispose();
   sessions.delete(session.id);
   await session.transport.close();
 }
@@ -468,5 +485,7 @@ export function hasMcpAppSession(sessionId: string): boolean {
 }
 
 export function listMcpAppSessionIds(): string[] {
-  return [...sessions.keys()];
+  return [...sessions.values()]
+    .filter((session) => session.board === canvasState.boardIdentity)
+    .map((session) => session.id);
 }