pmx-canvas 0.11.0 → 0.12.0

package/src/server/operations/ops/ax-timeline.ts

@@ -289,7 +289,17 @@ const axTimelineGetOperation = defineOperation<z.infer<typeof axTimelineGetSchem
 const axDeliveryPendingShape = {
   consumer: z.unknown().optional().describe('Consumer/source label to exclude from results (e.g. copilot, mcp).'),
   limit: z.unknown().optional().describe('Max steering messages to return.'),
+  offset: z.coerce
+    .number()
+    .int()
+    .nonnegative()
+    .optional()
+    .describe('Skip this many matching pending messages. Restart at zero after an empty page.'),
   order: z.unknown().optional().describe('"oldest" (FIFO, default) or "newest" first.'),
+  addressedOnly: z
+    .boolean()
+    .optional()
+    .describe('Only messages addressed to consumer, excluding broadcasts before applying the limit.'),
   timeoutMs: z
     .unknown()
     .optional()
@@ -310,10 +320,13 @@ const axDeliveryPendingOperation = defineOperation<z.infer<typeof axDeliveryPend
     // consumer arrives or the timeout elapses. Custom readInput replaces the
     // default query merge, so re-read the standard params here too.
     readInput: (_req, params, url) => {
-      const raw = Number(url.searchParams.get('waitMs') ?? '');
+      const raw = Number(url.searchParams.get('timeoutMs') ?? url.searchParams.get('waitMs') ?? '');
       return {
         ...Object.fromEntries(url.searchParams),
         ...params,
+        ...(url.searchParams.has('addressedOnly')
+          ? { addressedOnly: url.searchParams.get('addressedOnly') === 'true' }
+          : {}),
         timeoutMs: Number.isFinite(raw) && raw > 0 ? raw : 0,
       };
     },
@@ -353,7 +366,13 @@ const axDeliveryPendingOperation = defineOperation<z.infer<typeof axDeliveryPend
     // can't bury the human's current action behind stale undelivered rows. Both
     // queries apply the same loop-safe consumer filter before the limit.
     const newest = input.order === 'newest';
-    const scope = { ...(consumer ? { consumer } : {}), ...(limit ? { limit } : {}) };
+    if (input.addressedOnly && !consumer) throw new OperationError('addressedOnly requires consumer.', 400);
+    const scope = {
+      ...(consumer ? { consumer } : {}),
+      ...(limit ? { limit } : {}),
+      addressedOnly: input.addressedOnly,
+      offset: input.offset,
+    };
     const readPending = () =>
       newest ? canvasState.getPendingSteeringForContext(scope) : canvasState.getPendingSteering(scope);
     let pending = readPending();
@@ -495,6 +514,12 @@ const axReadsListOperation = defineOperation<z.infer<typeof axReadsListSchema>,
 });
 
 const axReadsRecordShape = {
+  deliveryId: z
+    .string()
+    .min(1)
+    .max(200)
+    .optional()
+    .describe('Idempotent adapter receipt ID, scoped to source, consumer and board.'),
   channel: z.enum(CONTEXT_READ_CHANNELS).describe('How the read reached the agent.'),
   resource: z.string().min(1).describe('Resource URI or operation name that was read.'),
   consumer: z.string().nullable().optional().describe('Reader identity (MCP client name, adapter host).'),
@@ -532,6 +557,7 @@ const axReadsRecordOperation = defineOperation<z.infer<typeof axReadsRecordSchem
   handler: (input) => {
     const read = canvasState.recordContextRead(
       {
+        deliveryId: input.deliveryId,
         channel: input.channel,
         resource: input.resource,
         source: input.source ?? 'api',

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

@@ -26,7 +26,8 @@ import { z } from 'zod';
 import { canvasState } from '../../canvas-state.js';
 import { serializeCanvasNode, serializeCanvasNodeCompact } from '../../canvas-serialization.js';
 import { addCanvasNode } from '../../canvas-operations.js';
-import { executeOperation, runWithSuppressedEmits } from '../registry.js';
+import { currentActor } from '../../attribution.js';
+import { executeOperation, runWithSuppressedEmits, validateOperationTarget } from '../registry.js';
 import { defineOperation, type Operation, type OperationContext } from '../types.js';
 import { readJsonValue } from '../http.js';
 import { isRecord } from './nodes.js';
@@ -57,6 +58,8 @@ const SUPPORTED_BATCH_OPS = new Set([
   'group.create',
   'group.add',
   'group.remove',
+  'annotation.add',
+  'annotation.remove',
   'pin.set',
   'pin.add',
   'pin.remove',
@@ -224,6 +227,7 @@ function shapeBatchEntry(op: string, result: unknown, creationReceipt = false):
 async function runBatch(operations: BatchEntry[], ctx: OperationContext): Promise<BatchEnvelope> {
   const refs: Record<string, unknown> = {};
   const results: Array<Record<string, unknown>> = [];
+  const actor = currentActor('api');
 
   for (let index = 0; index < operations.length; index++) {
     const operation = operations[index]!;
@@ -233,6 +237,7 @@ async function runBatch(operations: BatchEntry[], ctx: OperationContext): Promis
     }
     try {
       ctx.signal?.throwIfAborted();
+      validateOperationTarget(operation.op, args);
       if (ctx.onProgress) {
         const boardGeneration = canvasState.boardGeneration;
         await ctx.onProgress({ progress: index, total: operations.length, message: operation.op });
@@ -268,14 +273,19 @@ async function runBatch(operations: BatchEntry[], ctx: OperationContext): Promis
       // Batch churn is exempt from auto-ghosts (matches the skill's explicit
       // ghost-cursor exemption for batch operations). No `fromWorkbench`: the
       // browser never issues batches, so inner writes are agent writes and the
-      // scope fence applies to each of them.
-      const pending = executeOperation(dispatch.name, dispatch.args, {
-        suppressAutoGhost: true,
-        signal: ctx.signal,
-        onProgress: ctx.onProgress
-          ? (progress) => ctx.onProgress!({ progress: index, total: operations.length, message: progress.message })
-          : undefined,
-      });
+      // scope fence applies to each of them using the original writer identity.
+      const pending = executeOperation(
+        dispatch.name,
+        { agentId: actor.agentId, ...dispatch.args },
+        {
+          source: actor.source,
+          suppressAutoGhost: true,
+          signal: ctx.signal,
+          onProgress: ctx.onProgress
+            ? (progress) => ctx.onProgress!({ progress: index, total: operations.length, message: progress.message })
+            : undefined,
+        },
+      );
       // The first write may synchronously open a board from Home. Capture after
       // dispatch, then refuse to continue a partially completed batch elsewhere.
       const boardGeneration = canvasState.boardGeneration;
@@ -319,6 +329,7 @@ const batchShape = {
       }),
     )
     .describe('Ordered array of batch operations'),
+  agentId: z.string().optional().describe('Default writer identity for entries without their own agentId'),
   full: z
     .boolean()
     .optional()
@@ -404,13 +415,16 @@ const batchOperation = defineOperation<z.infer<typeof batchSchema>, BatchEnvelop
         : isRecord(body) && Array.isArray(body.operations)
           ? body.operations
           : [];
-      return { operations };
+      return {
+        operations,
+        ...(isRecord(body) ? { agentId: body.agentId, targetBoardId: body.targetBoardId } : {}),
+      };
     },
   },
   mcp: {
     toolName: 'canvas_batch',
     description:
-      'Run a non-atomic batch of canvas operations with optional assigned references. Use assign to name a result, then reference it later as "$name" for the created node id or "$name.id" for a specific result field. On failure, earlier successful operations remain applied and the response includes ok:false, failedIndex, error, results, and refs. Supports node.add, node.update, node.remove, graph.add, edge.add, edge.remove, group.create, group.add, group.remove, pin.set/add/remove, snapshot.save, and arrange.',
+      'Run a non-atomic batch of canvas operations with optional assigned references. Use assign to name a result, then reference it later as "$name" for the created node id or "$name.id" for a specific result field. On failure, earlier successful operations remain applied and the response includes ok:false, failedIndex, error, results, and refs. Supports node.add, node.update, node.remove, graph.add, edge.add, edge.remove, group.create, group.add, group.remove, annotation.add, annotation.remove, pin.set/add/remove, snapshot.save, and arrange.',
     formatResult: (result, input) => {
       const envelope = result as BatchEnvelope;
       const payload = wantsFullBatch(input) ? envelope : compactBatchResult(envelope);

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

@@ -17,6 +17,7 @@ import { normalizeBoardFolder } from '../../../shared/boards.js';
 import { relationVocabularySchema } from '../../../shared/relations.js';
 import { boardCatalogEpoch, canvasState, type CanvasLayout } from '../../canvas-state.js';
 import { openCanvasBoard } from '../../canvas-operations.js';
+import { rewatchAllFileNodes } from '../../file-watcher.js';
 import { summarizeNodeForAgentContext } from '../../../shared/agent-context.js';
 import { BRIEF_SUMMARY_LENGTH } from '../../context-brief.js';
 import { memoryGraph, boardConnections } from '../../memory-graph.js';
@@ -66,8 +67,8 @@ export function boardsPayload(reloaded = false): Record<string, unknown> {
     catalogEpoch: boardCatalogEpoch,
     catalogRevision: revision,
     reloadRevision,
-    boardGeneration: canvasState.boardGeneration,
-    activeBoardId: canvasState.activeBoardId,
+    boardGeneration: canvasState.visibleBoardGeneration,
+    activeBoardId: canvasState.visibleBoardId,
     boards: boards.map((board) => {
       const read = canvasState.readBoard(board.id, true);
       const readme = read?.layout.nodes.find((node) => node.id === board.readmeNodeId && node.type === 'markdown');
@@ -216,7 +217,8 @@ const boardGetOperation = defineOperation<z.infer<typeof getSchema>, Record<stri
     const id = typeof input.id === 'string' && input.id.trim() ? input.id.trim() : canvasState.activeBoardId;
     const board = id ? canvasState.listBoards().find((entry) => entry.id === id) : undefined;
     if (!board) throw new OperationError(id ? `Board "${id}" not found.` : 'No board is open.', 404);
-    return { ok: true, board, open: board.id === canvasState.activeBoardId };
+    const contentRevision = canvasState.readBoard(board.id, false)!.state.revisionState?.revision ?? 0;
+    return { ok: true, board, contentRevision, open: board.id === canvasState.activeBoardId };
   },
 });
 
@@ -404,6 +406,44 @@ const boardCreateFromOperation = defineOperation<z.infer<typeof fromSchema>, Rec
   },
 });
 
+const moveShape = {
+  sourceBoardId: z.string().min(1),
+  nodeIds: z.array(z.string().min(1)).min(1),
+  name: z.string().trim().min(1).max(120),
+  expectedRevision: z.number().int().nonnegative(),
+  requestId: z.string().trim().min(1).max(200),
+  preview: z.boolean().optional(),
+};
+const moveSchema = z.object(moveShape);
+const boardMoveOperation = defineOperation<z.infer<typeof moveSchema>, Record<string, unknown>>({
+  name: 'board.move-selection',
+  // Own validation precedes activation, and preview must never emit mutation/intent events.
+  mutates: false,
+  input: moveSchema,
+  inputShape: moveShape,
+  http: { method: 'POST', path: '/api/canvas/boards/move-selection' },
+  mcp: {
+    toolName: 'canvas_move_selection_to_board',
+    description:
+      'Preview or atomically move selected cards/group descendants to a new board, preserving identities and leaving a portal. Requires explicit sourceBoardId, expectedRevision and a durable requestId. Retry with identical input; never opens the destination. Preview lists unsafe bindings and the Undo/snapshot boundary.',
+    formatResult: jsonResult,
+  },
+  handler: (input, ctx) => {
+    const outcome = canvasState.moveSelectionToNewBoard(input);
+    if ('preview' in outcome) return { ok: true, ...outcome };
+    if (!outcome.replayed) {
+      rewatchAllFileNodes();
+      emitBoardsChanged(ctx);
+      ctx.emit('context-pins-changed', {
+        count: canvasState.contextPinnedNodeIds.size,
+        nodeIds: [...canvasState.contextPinnedNodeIds],
+      });
+      ctx.emit('ax-state-changed', {});
+    }
+    return { ok: true, ...outcome.result, replayed: outcome.replayed };
+  },
+});
+
 // ── board.pin / board.unpin ───────────────────────────────────
 // A pinned board joins the agent's working set: its README and pinned cards
 // travel in the brief whichever board is open. Pinning is context, never a
@@ -490,6 +530,7 @@ export const boardOperations: Operation[] = [
   boardGetOperation,
   boardCreateOperation,
   boardCreateFromOperation,
+  boardMoveOperation,
   boardUpdateOperation,
   boardPinOperation,
   boardUnpinOperation,

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

@@ -32,6 +32,7 @@ import {
 } from '../../canvas-operations.js';
 import { resolveCreateGeometry, resolvePatchGeometry, validateCanvasNodePatch } from '../../canvas-geometry.js';
 import { normalizeNodeAxCapabilities } from '../../ax-interaction.js';
+import { isWorkCardState } from '../../../shared/ax-kinds.js';
 import { applyFileContentToNodeData, readFileNodeContent } from '../../file-content.js';
 import { unwatchFileForNode, watchFileForNode } from '../../file-watcher.js';
 import {
@@ -327,6 +328,21 @@ export function createdNodePayloadFromNode(
 
 // ── Operation cores (the SDK wraps these directly) ────────────
 
+function validateWorkCardData(data: Record<string, unknown> | undefined): void {
+  if (!data || data.workState === undefined) return;
+  if (!isWorkCardState(data.workState))
+    throw new OperationError('workState must be todo, in-progress, blocked, done or cancelled.');
+  if (data.detail !== undefined && typeof data.detail !== 'string')
+    throw new OperationError('Work card detail must be a string.');
+  if (
+    data.progress !== undefined &&
+    data.progress !== null &&
+    (typeof data.progress !== 'number' || !Number.isFinite(data.progress) || data.progress < 0 || data.progress > 100)
+  ) {
+    throw new OperationError('Work card progress must be a number from 0 to 100, or null to clear it.');
+  }
+}
+
 /**
  * Create a basic (non-webpage / non-group / non-primitive) node. Union of the
  * legacy handleCanvasAddNode generic branch; the SDK passes fileMode 'path',
@@ -338,6 +354,34 @@ export function createBasicCanvasNode(
 ): { node: CanvasNodeState; needsCodeGraphRecompute: boolean; sizeAdjustment?: CanvasSizeAdjustment } {
   const type = typeof body.type === 'string' ? body.type : '';
   const extraData = isRecord(body.data) ? body.data : undefined;
+  if (type === 'status' && extraData?.workItemId !== undefined) {
+    if (body.boardId !== undefined || options.prepareOnlyNodes)
+      throw new OperationError('Live work cards must be created on the active board.');
+    const owner = extraData.workItemBoardId ?? canvasState.activeBoardId;
+    if (
+      typeof extraData.workItemId !== 'string' ||
+      (owner !== null && typeof owner !== 'string') ||
+      !(owner === null ? canvasState.getWorkItems() : canvasState.getWorkItemsOnBoard(owner)).some(
+        (item) => item.id === extraData.workItemId,
+      )
+    )
+      throw new OperationError('Live work card requires an existing work item on its owning board.');
+    if (
+      ['title', 'content'].some((key) => body[key] !== undefined) ||
+      [
+        'title',
+        'content',
+        'workState',
+        'detail',
+        'progress',
+        'axWorkStatus',
+        'liveWorkAvailable',
+        'liveWorkSource',
+      ].some((key) => key in extraData)
+    )
+      throw new OperationError('Live work card fields are read-only; update the work item instead.');
+  }
+  if (type === 'status') validateWorkCardData(extraData);
   if (
     extraData &&
     ('attachmentId' in extraData || (isRecord(extraData.source) && 'attachmentId' in extraData.source))
@@ -415,6 +459,9 @@ export function createBasicCanvasNode(
           : {}),
       ...(typeof content === 'string' ? { content } : {}),
       ...(htmlMergedData && Object.keys(htmlMergedData).length > 0 ? { data: htmlMergedData } : {}),
+      ...(type === 'status' && typeof extraData?.workItemId === 'string'
+        ? { data: { ...extraData, workItemBoardId: extraData.workItemBoardId ?? canvasState.activeBoardId } }
+        : {}),
       ...(type === 'trace' && typeof body.toolName === 'string' ? { toolName: body.toolName } : {}),
       ...(type === 'trace' && typeof body.category === 'string' ? { category: body.category } : {}),
       ...(type === 'trace' && typeof body.status === 'string' ? { status: body.status } : {}),
@@ -446,6 +493,28 @@ export function buildNodePatch(
   body: Record<string, unknown>,
 ): { patch: Partial<CanvasNodeState>; groupChildIds?: string[] } {
   if (body.type !== undefined && body.type !== existing.type) throw new OperationError('Node type is immutable.');
+  if (existing.type === 'status') {
+    const data = isRecord(body.data) ? body.data : {};
+    if (
+      'workItemId' in data ||
+      'workItemBoardId' in data ||
+      (typeof existing.data.workItemId === 'string' &&
+        (body.title !== undefined ||
+          body.content !== undefined ||
+          [
+            'title',
+            'content',
+            'workState',
+            'detail',
+            'progress',
+            'axWorkStatus',
+            'liveWorkAvailable',
+            'liveWorkSource',
+          ].some((key) => key in data)))
+    ) {
+      throw new OperationError('Live work cards are read-only; create a presentation or update the work item instead.');
+    }
+  }
   if (
     existing.type === 'file' &&
     typeof existing.data.attachmentId === 'string' &&
@@ -561,6 +630,7 @@ export function buildNodePatch(
     }
     patch.data = existing.type === 'trace' ? mergeTraceNodeDataFields(data, body) : data;
   }
+  if (existing.type === 'status' && isRecord(patch.data)) validateWorkCardData(patch.data);
   const error = validateCanvasNodePatch({
     ...(patch.position ? { position: patch.position as { x: number; y: number } } : {}),
     ...(patch.size ? { size: patch.size as { width: number; height: number } } : {}),

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

@@ -284,6 +284,11 @@ const contextShape = {
   consumer: z.unknown().optional().describe('Stable consumer id used for the durable board-scoped cursor'),
   since: z.unknown().optional().describe('Explicit content revision; bypasses the durable consumer cursor'),
   budget: z.unknown().optional().describe('Maximum response size in UTF-16 code units'),
+  contextDelivery: z
+    .boolean()
+    .optional()
+    .describe('False prepares a brief without recording delivery or advancing a cursor.'),
+  includeSteering: z.boolean().optional().describe('False omits steering for hosts that deliver it separately.'),
 };
 const contextSchema = z.looseObject(contextShape);
 
@@ -292,8 +297,20 @@ const contextOperation = defineOperation<z.infer<typeof contextSchema>, Record<s
   mutates: false,
   input: contextSchema,
   inputShape: contextShape,
-  http: { method: 'GET', path: '/api/canvas/context' },
+  http: {
+    method: 'GET',
+    path: '/api/canvas/context',
+    readInput: (_req, params, url) => {
+      const input: Record<string, unknown> = { ...Object.fromEntries(url.searchParams), ...params };
+      for (const key of ['contextDelivery', 'includeSteering']) {
+        if (input[key] === 'false') input[key] = false;
+        else if (input[key] === 'true') input[key] = true;
+      }
+      return input;
+    },
+  },
   handler: (input) => {
+    canvasState.refreshContextWorkCards();
     const active = canvasState.getActiveBoard();
     if (!active) throw new OperationError('Open a board before requesting its context.', 409);
     const consumer =
@@ -507,7 +524,10 @@ const contextOperation = defineOperation<z.infer<typeof contextSchema>, Record<s
         })),
     );
     entries.push(
-      ...canvasState.getPendingSteering({ consumer: consumer ?? undefined, limit: 50 }).map((item) => ({
+      ...(input.includeSteering === false
+        ? []
+        : canvasState.getPendingSteering({ consumer: consumer ?? undefined, limit: 50 })
+      ).map((item) => ({
         sourceBoardId: active.id,
         nodeId: `steering:${item.id}`,
         reason: 'steer' as const,
@@ -553,7 +573,14 @@ const contextOperation = defineOperation<z.infer<typeof contextSchema>, Record<s
       entries,
       budget,
     });
-    if (consumer && !explicitSince && result.document && result.nextCursor !== null && !result.invalidCursor) {
+    if (
+      input.contextDelivery !== false &&
+      consumer &&
+      !explicitSince &&
+      result.document &&
+      result.nextCursor !== null &&
+      !result.invalidCursor
+    ) {
       canvasState.advanceContextBriefCursor(active.id, consumer, result.nextCursor);
     }
     return (result.document ?? {
@@ -634,6 +661,7 @@ const undoOperation = defineOperation<z.infer<typeof undoRedoSchema>, Record<str
       count: canvasState.contextPinnedNodeIds.size,
       nodeIds: Array.from(canvasState.contextPinnedNodeIds),
     });
+    ctx.emit('ax-state-changed', {});
     return { ok: true, description: `Undid: ${entry.description}` };
   },
 });
@@ -662,6 +690,7 @@ const redoOperation = defineOperation<z.infer<typeof undoRedoSchema>, Record<str
       count: canvasState.contextPinnedNodeIds.size,
       nodeIds: Array.from(canvasState.contextPinnedNodeIds),
     });
+    ctx.emit('ax-state-changed', {});
     return { ok: true, description: `Redid: ${entry.description}` };
   },
 });

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

@@ -364,6 +364,7 @@ const snapshotRestoreNodeOperation = defineOperation<
   handler: ({ id, nodeId, preserveHumanEdits }) => {
     const snapshot = canvasState.getSnapshotData(id ?? '');
     if (!snapshot) throw new OperationError('Snapshot not found', 404);
+    canvasState.assertSnapshotRestorable(id ?? '');
     const current = canvasState.getNode(nodeId ?? '');
     const earlier = snapshot.nodes.find((node) => node.id === nodeId);
     if (!current || !earlier)

package/src/server/operations/registry.ts

@@ -359,6 +359,7 @@ function notePresence(
 ): void {
   if (!isPresenceWrite(op) || meta.suppressAutoGhost) return;
   const input = asRecord(rawInput);
+  if (name === 'board.move-selection' && (input.preview === true || asRecord(result).replayed === true)) return;
   // Delivery plumbing (claim/mark) must not book an anonymous transport
   // writer nor spam the timeline: attribute it to the consumer that marked,
   // and record no activity row — the Steer row flipping to delivered IS the
@@ -388,11 +389,52 @@ function notePresence(
   }
 }
 
+const operationTarget = new AsyncLocalStorage<{ boardId: string; agentId?: string }>();
+
+/** Also used by batch's internal node path, which does not dispatch an operation. */
+export function validateOperationTarget(name: string, input: Record<string, unknown>): string | undefined {
+  const inherited = operationTarget.getStore();
+  const target = input.targetBoardId === undefined ? inherited?.boardId : input.targetBoardId;
+  if (target === undefined) return undefined;
+  if (typeof target !== 'string' || !target.trim())
+    throw new OperationError('targetBoardId must be an existing board ID.');
+  if (
+    inherited &&
+    (target !== inherited.boardId || (input.agentId !== undefined && input.agentId !== inherited.agentId))
+  )
+    throw new OperationError('Nested operations must retain their board and agent identity.', 409);
+  if (name === 'board.update' && input.id !== target)
+    throw new OperationError('Board id conflicts with targetBoardId. Rebind before editing another board.', 409);
+  for (const key of [
+    'board',
+    'expectedBoardId',
+    'destinationBoardId',
+    ...(name === 'board.move-selection' ? ['sourceBoardId'] : []),
+  ]) {
+    if (input[key] !== undefined && input[key] !== target)
+      throw new OperationError(`${key} conflicts with targetBoardId. Rebind before targeting another board.`, 409);
+  }
+  if (['board.open', 'board.delete', 'backup.restore'].includes(name) || name.startsWith('webview.'))
+    throw new OperationError('This operation controls the shared view or workspace, not a scoped board.', 409);
+  return target;
+}
+
 export async function executeOperation(
   name: string,
   rawInput: unknown,
   meta: ExecuteOperationMeta = {},
 ): Promise<unknown> {
+  const input = asRecord(rawInput);
+  const target = validateOperationTarget(name, input);
+  if (target === undefined) return executeOnCurrentBoard(name, rawInput, meta);
+  const agentId =
+    operationTarget.getStore()?.agentId ?? (typeof input.agentId === 'string' ? input.agentId : undefined);
+  return operationTarget.run({ boardId: target, agentId }, () =>
+    canvasState.withBoard(target, () => executeOnCurrentBoard(name, { ...input, agentId }, meta)),
+  );
+}
+
+async function executeOnCurrentBoard(name: string, rawInput: unknown, meta: ExecuteOperationMeta): Promise<unknown> {
   // Check before attribution, board auto-open, ghosts, or any handler writes.
   meta.signal?.throwIfAborted();
   // Attribution follows this call chain across awaits and nested operations.
@@ -406,7 +448,8 @@ export async function executeOperation(
     async () => {
       const input = asRecord(rawInput);
       const deliversContext =
-        name !== 'node.get' || (input.contextDelivery !== false && input.contextDelivery !== 'false');
+        !['node.get', 'context.get'].includes(name) ||
+        (input.contextDelivery !== false && input.contextDelivery !== 'false');
       const recordRead = CONTEXT_READ_OPS.has(name) && deliversContext && !meta.fromWorkbench && !meta.proxiedRead;
       const requestedBoard =
         recordRead && 'board' in getOperation(name).inputShape && isString(input.board) && input.board.trim()
@@ -510,7 +553,8 @@ async function executeOperationInner(name: string, rawInput: unknown, meta: Exec
   const rawExpectedBoard = asRecord(rawInput).expectedBoardId;
   // HTTP DELETE query values are strings, including Home's JSON null.
   const expectedBoard = rawExpectedBoard === 'null' ? null : rawExpectedBoard;
-  if (expectedBoard !== undefined && expectedBoard !== canvasState.activeBoardId) {
+  // Relocations check their durable receipt first, then their explicit source board.
+  if (name !== 'board.move-selection' && expectedBoard !== undefined && expectedBoard !== canvasState.activeBoardId) {
     throw new OperationError('The active board changed. Refresh before retrying this action.', 409);
   }
   // File drops carry their captured board through the HTTP round trip. Check
@@ -638,8 +682,9 @@ async function executeOperationInner(name: string, rawInput: unknown, meta: Exec
   }
 
   const beforeBoard = canvasState.activeBoardId;
-  const beforeRevision =
-    name === 'board.create-from' || name === 'board.delete' ? canvasState.getContentRevision().revision : null;
+  const beforeRevision = ['board.create-from', 'board.delete', 'board.move-selection'].includes(name)
+    ? canvasState.getContentRevision().revision
+    : null;
   meta.signal?.throwIfAborted();
   const result = await op.execute(rawInput, operationContext);
   // Library writes can invalidate relations on the open board without being