pmx-canvas 0.4.7 → 0.5.0

package/src/server/canvas-db.ts

@@ -65,7 +65,6 @@ const SCHEMA_SQL = `
     z_index INTEGER NOT NULL DEFAULT 0,
     collapsed INTEGER NOT NULL DEFAULT 0,
     pinned INTEGER NOT NULL DEFAULT 0,
-    dock_position TEXT,
     data TEXT NOT NULL
   );
 
@@ -119,7 +118,6 @@ const SCHEMA_SQL = `
     z_index INTEGER NOT NULL DEFAULT 0,
     collapsed INTEGER NOT NULL DEFAULT 0,
     pinned INTEGER NOT NULL DEFAULT 0,
-    dock_position TEXT,
     data TEXT NOT NULL,
     PRIMARY KEY (snapshot_id, id)
   );
@@ -209,6 +207,13 @@ const SCHEMA_SQL = `
   );
   CREATE INDEX IF NOT EXISTS idx_ax_steering_seq ON ax_steering (seq);
 
+  CREATE TABLE IF NOT EXISTS ax_steering_deliveries (
+    steering_id TEXT NOT NULL,
+    consumer TEXT NOT NULL,
+    at TEXT NOT NULL,
+    PRIMARY KEY (steering_id, consumer)
+  );
+
   CREATE TABLE IF NOT EXISTS ax_host_capabilities (
     host TEXT PRIMARY KEY,
     reported_at TEXT NOT NULL,
@@ -273,7 +278,13 @@ export function openCanvasDb(dbPath: string): Database {
 
   const db = new Database(dbPath);
   db.exec('PRAGMA journal_mode=WAL');
-  db.exec('PRAGMA synchronous=NORMAL');
+  // FULL, not NORMAL: under WAL, NORMAL lets a host/OS-level crash lose the most
+  // recent commits (a clean process exit loses nothing either way). The reporter of
+  // issue #22 declined FULL specifically because a save rewrote the whole board, so
+  // an fsync per commit scaled with board size. Saves are incremental now — a
+  // typical save is a row or two — so that objection is gone and the durability is
+  // worth the fsync.
+  db.exec('PRAGMA synchronous=FULL');
   db.exec('PRAGMA busy_timeout=5000');
   db.exec(SCHEMA_SQL);
 
@@ -295,38 +306,116 @@ export function checkpointCanvasDb(db: Database): void {
   db.exec('PRAGMA wal_checkpoint(TRUNCATE)');
 }
 
+/**
+ * Delete blob rows nothing references any more. Blobs are content-addressed and
+ * written with INSERT OR IGNORE, so editing a node's html supersedes its old blob
+ * and leaves it orphaned — without this, `canvas.db` (which is git-committable)
+ * would grow without bound once externalization applies to ordinary html nodes.
+ *
+ * References are collected by scanning the raw persisted JSON for sha256 fields
+ * rather than parsing every node. That deliberately OVER-approximates: a stray
+ * 64-hex string keeps a blob alive that could have been dropped, which wastes a
+ * little space. The opposite error would delete live content, so the scan is
+ * biased to the safe side on purpose. Snapshot rows are scanned too — a snapshot
+ * restore must still find its blobs.
+ */
+export function gcBlobsInDB(db: Database): number {
+  const referenced = new Set<string>();
+  const collect = (sql: string): void => {
+    for (const row of db.query<{ data: string }, []>(sql).all()) {
+      if (!row.data) continue;
+      for (const match of row.data.matchAll(/"sha256"\s*:\s*"([0-9a-f]{64})"/g)) referenced.add(match[1]);
+    }
+  };
+  collect('SELECT data FROM nodes');
+  collect('SELECT data FROM snapshot_nodes');
+
+  const all = db.query<{ sha256: string }, []>('SELECT sha256 FROM blobs').all();
+  const orphans = all.filter((row) => !referenced.has(row.sha256));
+  if (orphans.length === 0) return 0;
+  const remove = db.prepare('DELETE FROM blobs WHERE sha256 = ?');
+  const transaction = db.transaction(() => {
+    for (const row of orphans) remove.run(row.sha256);
+  });
+  transaction();
+  return orphans.length;
+}
+
 export function finalizeCanvasDbForClose(db: Database): void {
   checkpointCanvasDb(db);
-  db.exec('PRAGMA journal_mode=DELETE');
+  // The WAL→DELETE switch takes an exclusive lock, so it succeeds only when no
+  // other connection has the DB open — and that makes it the GC gate. GC deletes
+  // blob rows a second live process may still depend on: its in-memory nodes
+  // hold content-addressed refs, not content, so a GC'd blob is unrecoverable
+  // once that process re-saves (review of #22, reproduced). Locked ⇒ someone
+  // else is on this canvas: leave WAL in place and keep every blob.
+  try {
+    db.exec('PRAGMA journal_mode=DELETE');
+  } catch {
+    return;
+  }
+  gcBlobsInDB(db);
 }
 
 // ── State Persistence ───────────────────────────────────────────
 
+/**
+ * Drop rows whose id is no longer in the live state. Reads only the id column
+ * (index-only scan) so it stays cheap on large boards.
+ */
+function deleteMissingRows(
+  db: Database,
+  table: 'nodes' | 'edges' | 'annotations' | 'context_pins',
+  idColumn: 'id' | 'node_id',
+  keep: Set<string>,
+): void {
+  const rows = db.query<{ id: string }, []>(`SELECT ${idColumn} AS id FROM ${table}`).all();
+  if (rows.length === 0) return;
+  const remove = db.prepare(`DELETE FROM ${table} WHERE ${idColumn} = ?`);
+  for (const row of rows) {
+    if (!keep.has(row.id)) remove.run(row.id);
+  }
+}
+
 export function saveStateToDB(db: Database, state: PersistedCanvasState): void {
   const transaction = db.transaction(() => {
-    // Clear current state tables
-    db.run('DELETE FROM nodes');
-    db.run('DELETE FROM edges');
-    db.run('DELETE FROM annotations');
-    db.run('DELETE FROM context_pins');
-    db.run('DELETE FROM ax_state');
-
-    // Save viewport and UI preferences
-    db.run('INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)', ['theme', normalizeCanvasTheme(state.theme)]);
-    db.run('INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)', ['viewport_x', String(state.viewport.x)]);
-    db.run('INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)', ['viewport_y', String(state.viewport.y)]);
-    db.run('INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)', ['viewport_scale', String(state.viewport.scale)]);
-
+    // Rows are upserted only when a column actually differs, and rows that are
+    // gone are deleted by id. This used to be DELETE-all + INSERT-all, which
+    // rewrote every row on every debounced save: dragging one node rewrote the
+    // whole board, multi-MB html payloads included, so the write cost scaled
+    // with board size instead of change size (issue #22). The
+    // `WHERE ... IS NOT excluded....` guard makes an unchanged row a true
+    // no-op — SQLite performs no update, so no page is written. The comparison
+    // is against the DB itself rather than an in-memory cache, so nothing can
+    // go stale and silently skip a write that was actually needed.
+    const upsertMeta = db.prepare(
+      `INSERT INTO meta (key, value) VALUES (?, ?)
+       ON CONFLICT(key) DO UPDATE SET value = excluded.value
+       WHERE value IS NOT excluded.value`,
+    );
+    upsertMeta.run('theme', normalizeCanvasTheme(state.theme));
+    upsertMeta.run('viewport_x', String(state.viewport.x));
+    upsertMeta.run('viewport_y', String(state.viewport.y));
+    upsertMeta.run('viewport_scale', String(state.viewport.scale));
     // Mark DB as populated (for migration detection)
-    db.run('INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)', ['state_populated', '1']);
+    upsertMeta.run('state_populated', '1');
 
     // Save nodes
-    const insertNode = db.prepare(
-      `INSERT INTO nodes (id, type, pos_x, pos_y, width, height, z_index, collapsed, pinned, dock_position, data)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    const upsertNode = db.prepare(
+      `INSERT INTO nodes (id, type, pos_x, pos_y, width, height, z_index, collapsed, pinned, data)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         type = excluded.type, pos_x = excluded.pos_x, pos_y = excluded.pos_y,
+         width = excluded.width, height = excluded.height, z_index = excluded.z_index,
+         collapsed = excluded.collapsed, pinned = excluded.pinned, data = excluded.data
+       WHERE type IS NOT excluded.type OR pos_x IS NOT excluded.pos_x
+          OR pos_y IS NOT excluded.pos_y OR width IS NOT excluded.width
+          OR height IS NOT excluded.height OR z_index IS NOT excluded.z_index
+          OR collapsed IS NOT excluded.collapsed OR pinned IS NOT excluded.pinned
+          OR data IS NOT excluded.data`,
     );
     for (const node of state.nodes) {
-      insertNode.run(
+      upsertNode.run(
         node.id,
         node.type,
         node.position.x,
@@ -336,18 +425,24 @@ export function saveStateToDB(db: Database, state: PersistedCanvasState): void {
         node.zIndex,
         node.collapsed ? 1 : 0,
         node.pinned ? 1 : 0,
-        node.dockPosition,
         JSON.stringify(node.data),
       );
     }
+    deleteMissingRows(db, 'nodes', 'id', new Set(state.nodes.map((node) => node.id)));
 
     // Save edges
-    const insertEdge = db.prepare(
+    const upsertEdge = db.prepare(
       `INSERT INTO edges (id, from_node, to_node, type, label, style, animated)
-       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+       VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         from_node = excluded.from_node, to_node = excluded.to_node, type = excluded.type,
+         label = excluded.label, style = excluded.style, animated = excluded.animated
+       WHERE from_node IS NOT excluded.from_node OR to_node IS NOT excluded.to_node
+          OR type IS NOT excluded.type OR label IS NOT excluded.label
+          OR style IS NOT excluded.style OR animated IS NOT excluded.animated`,
     );
     for (const edge of state.edges) {
-      insertEdge.run(
+      upsertEdge.run(
         edge.id,
         edge.from,
         edge.to,
@@ -357,14 +452,24 @@ export function saveStateToDB(db: Database, state: PersistedCanvasState): void {
         edge.animated ? 1 : 0,
       );
     }
+    deleteMissingRows(db, 'edges', 'id', new Set(state.edges.map((edge) => edge.id)));
 
     // Save annotations
-    const insertAnnotation = db.prepare(
+    const annotations = state.annotations ?? [];
+    const upsertAnnotation = db.prepare(
       `INSERT INTO annotations (id, type, points, bounds, color, width, text, label, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         type = excluded.type, points = excluded.points, bounds = excluded.bounds,
+         color = excluded.color, width = excluded.width, text = excluded.text,
+         label = excluded.label, created_at = excluded.created_at
+       WHERE type IS NOT excluded.type OR points IS NOT excluded.points
+          OR bounds IS NOT excluded.bounds OR color IS NOT excluded.color
+          OR width IS NOT excluded.width OR text IS NOT excluded.text
+          OR label IS NOT excluded.label OR created_at IS NOT excluded.created_at`,
     );
-    for (const annotation of state.annotations ?? []) {
-      insertAnnotation.run(
+    for (const annotation of annotations) {
+      upsertAnnotation.run(
         annotation.id,
         annotation.type,
         JSON.stringify(annotation.points),
@@ -376,17 +481,21 @@ export function saveStateToDB(db: Database, state: PersistedCanvasState): void {
         annotation.createdAt,
       );
     }
+    deleteMissingRows(db, 'annotations', 'id', new Set(annotations.map((annotation) => annotation.id)));
 
-    // Save context pins
-    const insertPin = db.prepare('INSERT INTO context_pins (node_id) VALUES (?)');
+    // Save context pins (node_id is the whole row — nothing to update)
+    const insertPin = db.prepare('INSERT OR IGNORE INTO context_pins (node_id) VALUES (?)');
     for (const pinId of state.contextPins) {
       insertPin.run(pinId);
     }
+    deleteMissingRows(db, 'context_pins', 'node_id', new Set(state.contextPins));
 
-    db.run('INSERT INTO ax_state (key, value) VALUES (?, ?)', [
-      'state',
-      JSON.stringify(state.ax ?? createEmptyAxState()),
-    ]);
+    db.run(
+      `INSERT INTO ax_state (key, value) VALUES (?, ?)
+       ON CONFLICT(key) DO UPDATE SET value = excluded.value
+       WHERE value IS NOT excluded.value`,
+      ['state', JSON.stringify(state.ax ?? createEmptyAxState())],
+    );
   });
 
   transaction();
@@ -429,7 +538,6 @@ export function loadStateFromDB(db: Database): PersistedCanvasState | null {
     z_index: number;
     collapsed: number;
     pinned: number;
-    dock_position: string | null;
     data: string;
   }
   const nodeRows = db.query<NodeRow, []>('SELECT * FROM nodes').all();
@@ -441,7 +549,6 @@ export function loadStateFromDB(db: Database): PersistedCanvasState | null {
     zIndex: row.z_index,
     collapsed: row.collapsed === 1,
     pinned: row.pinned === 1,
-    dockPosition: row.dock_position as CanvasNodeState['dockPosition'],
     data: JSON.parse(row.data) as Record<string, unknown>,
   }));
 
@@ -549,8 +656,8 @@ export function saveSnapshotToDB(db: Database, snapshot: CanvasSnapshot, state:
 
     // Insert snapshot nodes
     const insertNode = db.prepare(
-      `INSERT INTO snapshot_nodes (snapshot_id, id, type, pos_x, pos_y, width, height, z_index, collapsed, pinned, dock_position, data)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      `INSERT INTO snapshot_nodes (snapshot_id, id, type, pos_x, pos_y, width, height, z_index, collapsed, pinned, data)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
     );
     for (const node of state.nodes) {
       insertNode.run(
@@ -564,7 +671,6 @@ export function saveSnapshotToDB(db: Database, snapshot: CanvasSnapshot, state:
         node.zIndex,
         node.collapsed ? 1 : 0,
         node.pinned ? 1 : 0,
-        node.dockPosition,
         JSON.stringify(node.data),
       );
     }
@@ -674,7 +780,6 @@ export function loadSnapshotFromDB(
     z_index: number;
     collapsed: number;
     pinned: number;
-    dock_position: string | null;
     data: string;
   }
   const nodeRows = db
@@ -688,7 +793,6 @@ export function loadSnapshotFromDB(
     zIndex: row.z_index,
     collapsed: row.collapsed === 1,
     pinned: row.pinned === 1,
-    dockPosition: row.dock_position as CanvasNodeState['dockPosition'],
     data: JSON.parse(row.data) as Record<string, unknown>,
   }));
 
@@ -812,6 +916,10 @@ export function listSnapshotsFromDB(db: Database, options: CanvasSnapshotListOpt
   }));
 }
 
+export function renameSnapshotInDB(db: Database, id: string, name: string): boolean {
+  return db.run('UPDATE snapshots SET name = ? WHERE id = ?', [name, id]).changes > 0;
+}
+
 export function deleteSnapshotFromDB(db: Database, id: string): boolean {
   const transaction = db.transaction(() => {
     db.run('DELETE FROM snapshot_nodes WHERE snapshot_id = ?', [id]);
@@ -873,6 +981,9 @@ function trimAxTable(db: Database, table: 'ax_events' | 'ax_evidence' | 'ax_stee
   db.run(`DELETE FROM ${table} WHERE seq <= (SELECT seq FROM ${table} ORDER BY seq DESC LIMIT 1 OFFSET ?)`, [
     AX_TIMELINE_RETENTION,
   ]);
+  if (table === 'ax_steering') {
+    db.run('DELETE FROM ax_steering_deliveries WHERE steering_id NOT IN (SELECT id FROM ax_steering)');
+  }
 }
 
 function readLastSeq(db: Database, table: 'ax_events' | 'ax_evidence' | 'ax_steering'): number {
@@ -930,10 +1041,28 @@ export function appendAxSteeringToDB(db: Database, s: Omit<PmxAxSteeringMessage,
   return { ...s, seq };
 }
 
-export function markAxSteeringDeliveredInDB(db: Database, id: string): boolean {
-  // Compare-and-set: true ONLY on the undelivered→delivered transition. Two
-  // adapters racing the same steer see exactly one true — the loser (and any
-  // re-mark) gets false and must not treat the message as its own delivery.
+export function markAxSteeringDeliveredInDB(db: Database, id: string, consumer?: string | null): boolean {
+  // ADDRESSED steer (target set): global compare-and-set as before — one
+  // legitimate recipient, true only on the undelivered→delivered transition.
+  // BROADCAST + consumer: per-consumer delivery ("all workers: stop" must
+  // reach every worker) — the mark records THIS consumer's pickup and the
+  // message stays pending for everyone else; true iff this consumer had not
+  // marked it before. BROADCAST without a consumer: the legacy anonymous ack
+  // (global CAS) that hides it from all consumers.
+  const row = db.query<{ target: string | null }, [string]>('SELECT target FROM ax_steering WHERE id = ?').get(id);
+  if (!row) return false;
+  // An addressed steer belongs to its target. A different named consumer marking
+  // it delivered would silently swallow the human's instruction (the target then
+  // never sees it). A consumer-less mark is still the single legitimate host ack.
+  if (row.target !== null && consumer && consumer !== row.target) return false;
+  if (row.target === null && consumer) {
+    const r = db.run('INSERT OR IGNORE INTO ax_steering_deliveries (steering_id, consumer, at) VALUES (?, ?, ?)', [
+      id,
+      consumer,
+      new Date().toISOString(),
+    ]);
+    return r.changes > 0;
+  }
   const r = db.run('UPDATE ax_steering SET delivered = 1 WHERE id = ? AND delivered = 0', [id]);
   return r.changes > 0;
 }
@@ -1006,6 +1135,18 @@ interface AxSteeringRow {
   target: string | null;
 }
 
+/**
+ * Broadcasts age out of PENDING (they stay on the timeline): per-consumer
+ * delivery otherwise means every broadcast greets every FUTURE consumer key
+ * forever — a brand-new pump inherited two-day-old "all workers" calls.
+ * Addressed steers never expire here; they wait for their named consumer.
+ */
+export const BROADCAST_PENDING_TTL_MS = 15 * 60_000;
+
+function broadcastCutoffIso(): string {
+  return new Date(Date.now() - BROADCAST_PENDING_TTL_MS).toISOString();
+}
+
 function mapAxSteeringRow(r: AxSteeringRow): PmxAxSteeringMessage | null {
   return normalizeAxSteeringMessage({
     ...r,
@@ -1023,7 +1164,27 @@ export function loadAxSteeringFromDB(
     ? 'SELECT * FROM ax_steering WHERE delivered = 0 ORDER BY seq DESC LIMIT ?'
     : 'SELECT * FROM ax_steering ORDER BY seq DESC LIMIT ?';
   const rows = db.query<AxSteeringRow, [number]>(sql).all(clampTimelineLimit(q.limit));
-  return rows.map(mapAxSteeringRow).filter((s): s is PmxAxSteeringMessage => s !== null);
+  const deliveredTo = new Map<string, string[]>();
+  for (const row of db
+    .query<{ steering_id: string; consumer: string }, []>('SELECT steering_id, consumer FROM ax_steering_deliveries')
+    .all()) {
+    if (!deliveredTo.has(row.steering_id)) deliveredTo.set(row.steering_id, []);
+    deliveredTo.get(row.steering_id)!.push(row.consumer);
+  }
+  return rows
+    .map((row) => {
+      const mapped = mapAxSteeringRow(row);
+      if (!mapped) return null;
+      const pickups = deliveredTo.get(mapped.id) ?? [];
+      // A broadcast reads as delivered once ANY consumer picked it up; the
+      // per-consumer list is exposed for fleet UIs ("picked up by 3").
+      return {
+        ...mapped,
+        delivered: mapped.delivered || pickups.length > 0,
+        ...(pickups.length > 0 ? { deliveredTo: pickups } : {}),
+      };
+    })
+    .filter((s): s is PmxAxSteeringMessage => s !== null);
 }
 
 export function loadPendingAxSteeringFromDB(
@@ -1036,13 +1197,20 @@ export function loadPendingAxSteeringFromDB(
   const limit = clampTimelineLimit(options.limit);
   const rows = options.consumer
     ? db
-        .query<AxSteeringRow, [string, string, string, number]>(
-          'SELECT * FROM ax_steering WHERE delivered = 0 AND (source IS NULL OR source != ?) AND (agent_id IS NULL OR agent_id != ?) AND (target IS NULL OR target = ?) ORDER BY seq ASC LIMIT ?',
+        .query<AxSteeringRow, [string, string, string, string, string, number]>(
+          // A broadcast stays pending PER CONSUMER: it leaves this consumer's
+          // queue only once THIS consumer marked it (or an anonymous global ack
+          // set delivered).
+          'SELECT * FROM ax_steering s WHERE s.delivered = 0 AND (s.source IS NULL OR s.source != ?) AND (s.agent_id IS NULL OR s.agent_id != ?) AND (s.target IS NULL OR s.target = ?) AND (s.target IS NOT NULL OR s.created_at > ?) AND NOT EXISTS (SELECT 1 FROM ax_steering_deliveries d WHERE d.steering_id = s.id AND d.consumer = ?) ORDER BY s.seq ASC LIMIT ?',
         )
-        .all(options.consumer, options.consumer, options.consumer, limit)
+        .all(options.consumer, options.consumer, options.consumer, broadcastCutoffIso(), options.consumer, limit)
     : db
-        .query<AxSteeringRow, [number]>('SELECT * FROM ax_steering WHERE delivered = 0 ORDER BY seq ASC LIMIT ?')
-        .all(limit);
+        .query<AxSteeringRow, [string, number]>(
+          // No consumer given: only broadcasts — addressed steering is claimable
+          // solely by the consumer it names.
+          'SELECT * FROM ax_steering WHERE delivered = 0 AND target IS NULL AND created_at > ? ORDER BY seq ASC LIMIT ?',
+        )
+        .all(broadcastCutoffIso(), limit);
   return rows.map(mapAxSteeringRow).filter((s): s is PmxAxSteeringMessage => s !== null);
 }
 
@@ -1061,25 +1229,33 @@ export function loadNewestPendingAxSteeringFromDB(
   const limit = clampTimelineLimit(options.limit);
   const rows = options.consumer
     ? db
-        .query<AxSteeringRow, [string, string, string, number]>(
-          'SELECT * FROM ax_steering WHERE delivered = 0 AND (source IS NULL OR source != ?) AND (agent_id IS NULL OR agent_id != ?) AND (target IS NULL OR target = ?) ORDER BY seq DESC LIMIT ?',
+        .query<AxSteeringRow, [string, string, string, string, string, number]>(
+          'SELECT * FROM ax_steering s WHERE s.delivered = 0 AND (s.source IS NULL OR s.source != ?) AND (s.agent_id IS NULL OR s.agent_id != ?) AND (s.target IS NULL OR s.target = ?) AND (s.target IS NOT NULL OR s.created_at > ?) AND NOT EXISTS (SELECT 1 FROM ax_steering_deliveries d WHERE d.steering_id = s.id AND d.consumer = ?) ORDER BY s.seq DESC LIMIT ?',
         )
-        .all(options.consumer, options.consumer, options.consumer, limit)
+        .all(options.consumer, options.consumer, options.consumer, broadcastCutoffIso(), options.consumer, limit)
     : db
-        .query<AxSteeringRow, [number]>('SELECT * FROM ax_steering WHERE delivered = 0 ORDER BY seq DESC LIMIT ?')
+        .query<AxSteeringRow, [number]>(
+          'SELECT * FROM ax_steering WHERE delivered = 0 AND target IS NULL ORDER BY seq DESC LIMIT ?',
+        )
         .all(limit);
   return rows.map(mapAxSteeringRow).filter((s): s is PmxAxSteeringMessage => s !== null);
 }
 
 /** Total undelivered steering for a consumer (loop-safe — excludes the consumer's own; target-scoped). */
 export function countPendingAxSteeringFromDB(db: Database, consumer?: string): number {
+  // Must mirror loadPendingAxSteeringFromDB exactly (per-consumer deliveries,
+  // broadcast TTL) — the roster shows this as "what would this consumer claim".
   const n = consumer
     ? db
-        .query<{ n: number }, [string, string, string]>(
-          'SELECT COUNT(*) AS n FROM ax_steering WHERE delivered = 0 AND (source IS NULL OR source != ?) AND (agent_id IS NULL OR agent_id != ?) AND (target IS NULL OR target = ?)',
+        .query<{ n: number }, [string, string, string, string, string]>(
+          'SELECT COUNT(*) AS n FROM ax_steering s WHERE s.delivered = 0 AND (s.source IS NULL OR s.source != ?) AND (s.agent_id IS NULL OR s.agent_id != ?) AND (s.target IS NULL OR s.target = ?) AND (s.target IS NOT NULL OR s.created_at > ?) AND NOT EXISTS (SELECT 1 FROM ax_steering_deliveries d WHERE d.steering_id = s.id AND d.consumer = ?)',
+        )
+        .get(consumer, consumer, consumer, broadcastCutoffIso(), consumer)?.n
+    : db
+        .query<{ n: number }, [string]>(
+          'SELECT COUNT(*) AS n FROM ax_steering WHERE delivered = 0 AND target IS NULL AND created_at > ?',
         )
-        .get(consumer, consumer, consumer)?.n
-    : db.query<{ n: number }, []>('SELECT COUNT(*) AS n FROM ax_steering WHERE delivered = 0').get()?.n;
+        .get(broadcastCutoffIso())?.n;
   return Number(n ?? 0);
 }
 

package/src/server/canvas-operations.ts

@@ -946,7 +946,6 @@ export function addCanvasNode(input: CanvasAddNodeInput): {
     zIndex: 1,
     collapsed: false,
     pinned: false,
-    dockPosition: null,
     data,
   };
 
@@ -1133,7 +1132,7 @@ export function removeCanvasNode(id: string): {
 }
 
 function isArrangeLocked(node: CanvasNodeState): boolean {
-  return node.pinned || node.dockPosition !== null || node.data.arrangeLocked === true;
+  return node.pinned || node.data.arrangeLocked === true;
 }
 
 function collectArrangeExcludedNodeIds(nodes: CanvasNodeState[]): Set<string> {
@@ -1219,7 +1218,7 @@ function rectsOverlap(a: ArrangeObstacleRect, b: ArrangeObstacleRect): boolean {
 
 function collectGridArrangeObstacles(nodes: CanvasNodeState[], excludedIds: Set<string>): ArrangeObstacleRect[] {
   return nodes
-    .filter((node) => excludedIds.has(node.id) && node.dockPosition === null)
+    .filter((node) => excludedIds.has(node.id))
     .map((node) => ({
       id: node.id,
       position: { ...node.position },
@@ -1247,7 +1246,7 @@ function shiftGridUpdatesBelowObstacles(
 ): CanvasNodeUpdate[] {
   if (updates.length === 0 || obstacles.length === 0) return updates;
 
-  // Grid arrange only sees movable nodes, so preserved locked/docked-group frames
+  // Grid arrange only sees movable nodes, so preserved locked-group frames
   // need a separate obstacle pass before applying the planned positions.
   const nodesById = new Map(nodes.map((node) => [node.id, node]));
   let shifted = updates;
@@ -1465,6 +1464,20 @@ export function addCanvasEdge(input: {
   return edge;
 }
 
+export function updateCanvasEdge(
+  id: string,
+  patch: Partial<Pick<CanvasEdge, 'type' | 'label' | 'style' | 'animated'>>,
+): CanvasEdge {
+  if (!canvasState.getEdges().some((edge) => edge.id === id)) {
+    throw new Error(`Edge "${id}" not found.`);
+  }
+  const updated = canvasState.updateEdge(id, patch);
+  if (!updated) {
+    throw new Error('Retyping would duplicate an existing edge.');
+  }
+  return updated;
+}
+
 export function removeCanvasEdge(id: string): { removed: boolean } {
   return { removed: canvasState.removeEdge(id) };
 }
@@ -1512,7 +1525,6 @@ export function createCanvasGroup(input: CanvasCreateGroupInput): { id: string;
     zIndex: 0,
     collapsed: false,
     pinned: false,
-    dockPosition: null,
     data,
   });
 
@@ -1583,7 +1595,6 @@ export function createCanvasJsonRenderNode(input: JsonRenderNodeInput): {
     zIndex: 1,
     collapsed: false,
     pinned: false,
-    dockPosition: null,
     data: createJsonRenderNodeData(id, input.title?.trim() || inferJsonRenderNodeTitle(spec), spec, {
       viewerType: 'json-render',
       ...(input.strictSize ? { strictSize: true } : {}),
@@ -1627,7 +1638,6 @@ export function createCanvasStreamingJsonRenderNode(input: {
     zIndex: 1,
     collapsed: false,
     pinned: false,
-    dockPosition: null,
     data: createJsonRenderNodeData(id, input.title?.trim() || 'Streaming', spec, {
       viewerType: 'json-render',
       streamStatus: 'open',
@@ -1703,7 +1713,6 @@ export function createCanvasGraphNode(input: GraphNodeInput): {
     zIndex: 1,
     collapsed: false,
     pinned: false,
-    dockPosition: null,
     data: createJsonRenderNodeData(id, title, spec, {
       viewerType: 'graph',
       graphConfig: buildGraphConfig(input),