@origintrail-official/dkg-node-ui 10.0.12 → 10.0.14

package/dist/db.js

@@ -1,8 +1,8 @@
 import Database from 'better-sqlite3';
 import { join } from 'node:path';
-import { RESPONSE_CACHE_BYTES, parseContextGraphJoinPolicyRecord, } from '@origintrail-official/dkg-core';
+import { RESPONSE_CACHE_BYTES, parseContextGraphJoinPolicyRecord, DEFAULT_SYNC_CHECKPOINT_TTL_MS, isValidSyncCheckpointEntry, transitionSyncCheckpointManifestOffset, transitionSyncCheckpointOffset, transitionSyncCheckpointResponderSession, withoutSyncCheckpointResponderSession, } from '@origintrail-official/dkg-core';
 export { SqliteChainEventCursorStore, SqliteContextGraphRegistryScanCursorStore, } from './chain-cursor-stores.js';
-const SCHEMA_VERSION = 31;
+export const SCHEMA_VERSION = 34;
 // Default operator retention. Lowered from 90 → 14 days on V15 (2026-05) after
 // a production incident in which the `logs` table + its FTS5 shadow tables
 // grew to ~9 GB on a 12-day-old node and corrupted the SQLite page (header
@@ -138,44 +138,44 @@ export class DashboardDB {
     migrate() {
         const version = this.db.pragma('user_version', { simple: true });
         const upgradedExistingDb = version > 0 && version < SCHEMA_VERSION;
-        const ensureJoinPolicyAuditCapTrigger = () => this.db.exec(`
-      CREATE TRIGGER IF NOT EXISTS cap_cg_join_policy_audit_rows
-      AFTER INSERT ON context_graph_join_policy_audit
-      BEGIN
-        DELETE FROM context_graph_join_policy_audit
-        WHERE id <= NEW.id - 100000
-          AND event_type NOT IN (
-            'join_admission_committed',
-            'join_policy_changed'
-          );
-      END;
+        const ensureJoinPolicyAuditCapTrigger = () => this.db.exec(`
+      CREATE TRIGGER IF NOT EXISTS cap_cg_join_policy_audit_rows
+      AFTER INSERT ON context_graph_join_policy_audit
+      BEGIN
+        DELETE FROM context_graph_join_policy_audit
+        WHERE id <= NEW.id - 100000
+          AND event_type NOT IN (
+            'join_admission_committed',
+            'join_policy_changed'
+          );
+      END;
     `);
         const ensureJoinApprovalRepairMarker = () => {
-            const table = this.db.prepare(`
-        SELECT 1 AS found FROM sqlite_master
-        WHERE type = 'table' AND name = 'context_graph_join_approval_ledger'
+            const table = this.db.prepare(`
+        SELECT 1 AS found FROM sqlite_master
+        WHERE type = 'table' AND name = 'context_graph_join_approval_ledger'
       `).get();
             if (!table)
                 return;
             const columns = this.db.pragma('table_info(context_graph_join_approval_ledger)');
             if (!columns.some((column) => column.name === 'repair_pending')) {
-                this.db.exec(`
-          ALTER TABLE context_graph_join_approval_ledger
-          ADD COLUMN repair_pending INTEGER NOT NULL DEFAULT 0
-            CHECK (repair_pending IN (0, 1));
+                this.db.exec(`
+          ALTER TABLE context_graph_join_approval_ledger
+          ADD COLUMN repair_pending INTEGER NOT NULL DEFAULT 0
+            CHECK (repair_pending IN (0, 1));
         `);
             }
-            this.db.exec(`
-        CREATE INDEX IF NOT EXISTS idx_cg_join_approval_ledger_repair
-          ON context_graph_join_approval_ledger(
-            context_graph_id, request_digest, repair_pending, reserved_at DESC
-          );
+            this.db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_cg_join_approval_ledger_repair
+          ON context_graph_join_approval_ledger(
+            context_graph_id, request_digest, repair_pending, reserved_at DESC
+          );
       `);
         };
-        const ensureSyncCheckpointResponderSessionColumns = () => {
-            const table = this.db.prepare(`
-        SELECT 1 AS found FROM sqlite_master
-        WHERE type = 'table' AND name = 'sync_checkpoints'
+        const ensureSyncCheckpointResumeColumns = () => {
+            const table = this.db.prepare(`
+        SELECT 1 AS found FROM sqlite_master
+        WHERE type = 'table' AND name = 'sync_checkpoints'
       `).get();
             if (!table)
                 return;
@@ -187,6 +187,18 @@ export class DashboardDB {
             if (!columns.has('responder_session_expires_at')) {
                 this.db.exec(`ALTER TABLE sync_checkpoints ADD COLUMN responder_session_expires_at INTEGER;`);
             }
+            if (!columns.has('responder_session_offset')) {
+                this.db.exec(`ALTER TABLE sync_checkpoints ADD COLUMN responder_session_offset INTEGER;`);
+            }
+            if (!columns.has('manifest_digest')) {
+                this.db.exec(`ALTER TABLE sync_checkpoints ADD COLUMN manifest_digest TEXT;`);
+            }
+            if (!columns.has('manifest_prefix_digest')) {
+                this.db.exec(`ALTER TABLE sync_checkpoints ADD COLUMN manifest_prefix_digest TEXT;`);
+            }
+            if (!columns.has('terminal')) {
+                this.db.exec(`ALTER TABLE sync_checkpoints ADD COLUMN terminal INTEGER NOT NULL DEFAULT 0 CHECK (terminal IN (0, 1));`);
+            }
         };
         if (version > SCHEMA_VERSION)
             return;
@@ -194,122 +206,122 @@ export class DashboardDB {
             // Repair restored/development databases that carry the current version
             // but lost an idempotent schema adjunct.
             ensureJoinApprovalRepairMarker();
-            ensureSyncCheckpointResponderSessionColumns();
+            ensureSyncCheckpointResumeColumns();
             ensureJoinPolicyAuditCapTrigger();
             return;
         }
         if (version < 1) {
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS metric_snapshots (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          ts INTEGER NOT NULL,
-          cpu_percent REAL,
-          mem_used_bytes INTEGER,
-          mem_total_bytes INTEGER,
-          disk_used_bytes INTEGER,
-          disk_total_bytes INTEGER,
-          heap_used_bytes INTEGER,
-          uptime_seconds INTEGER,
-          peer_count INTEGER,
-          direct_peers INTEGER,
-          relayed_peers INTEGER,
-          mesh_peers INTEGER,
-          contextGraph_count INTEGER,
-          total_triples INTEGER,
-          total_kcs INTEGER,
-          total_kas INTEGER,
-          store_bytes INTEGER,
-          confirmed_kcs INTEGER,
-          tentative_kcs INTEGER,
-          rpc_latency_ms INTEGER,
-          rpc_healthy INTEGER,
-          relay_capacity INTEGER,
-          relay_reservation_count INTEGER,
-          relay_active_circuits INTEGER,
-          relay_bytes_in INTEGER,
-          relay_bytes_out INTEGER
-        );
-        CREATE INDEX IF NOT EXISTS idx_snapshots_ts ON metric_snapshots(ts);
-
-        CREATE TABLE IF NOT EXISTS operations (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          operation_id TEXT NOT NULL,
-          operation_name TEXT NOT NULL,
-          started_at INTEGER NOT NULL,
-          duration_ms INTEGER,
-          status TEXT DEFAULT 'in_progress',
-          peer_id TEXT,
-          contextGraph_id TEXT,
-          triple_count INTEGER,
-          error_message TEXT,
-          details TEXT
-        );
-        CREATE INDEX IF NOT EXISTS idx_ops_operation_id ON operations(operation_id);
-        CREATE INDEX IF NOT EXISTS idx_ops_started_at ON operations(started_at);
-        CREATE INDEX IF NOT EXISTS idx_ops_name ON operations(operation_name);
-
-        CREATE TABLE IF NOT EXISTS logs (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          ts INTEGER NOT NULL,
-          level TEXT NOT NULL,
-          operation_name TEXT,
-          operation_id TEXT,
-          module TEXT,
-          message TEXT NOT NULL
-        );
-        CREATE INDEX IF NOT EXISTS idx_logs_ts ON logs(ts);
-        CREATE INDEX IF NOT EXISTS idx_logs_operation_id ON logs(operation_id);
-        CREATE INDEX IF NOT EXISTS idx_logs_level ON logs(level);
-
-        -- NOTE: Earlier schema versions (V1..V14) also created an FTS5
-        -- virtual table "logs_fts" plus AFTER INSERT/DELETE triggers to
-        -- keep it in sync with "logs". That fed a free-text search path
-        -- behind /api/logs?q=... The FTS5 index turned out to dominate
-        -- on-disk size (multi-GB shadow tables on long-lived nodes) and
-        -- the corresponding HTTP route had no production consumer
-        -- (the dashboard log viewer is file-backed via /api/node-log).
-        -- V15 drops it for fresh installs; the migration below cleans
-        -- it up for in-place upgrades.
-
-        CREATE TABLE IF NOT EXISTS query_history (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          ts INTEGER NOT NULL,
-          sparql TEXT NOT NULL,
-          duration_ms INTEGER,
-          result_count INTEGER,
-          error TEXT
-        );
-        CREATE INDEX IF NOT EXISTS idx_qhist_ts ON query_history(ts);
-
-        CREATE TABLE IF NOT EXISTS saved_queries (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          name TEXT NOT NULL,
-          description TEXT,
-          sparql TEXT NOT NULL,
-          created_at INTEGER NOT NULL,
-          updated_at INTEGER NOT NULL
-        );
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS metric_snapshots (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          ts INTEGER NOT NULL,
+          cpu_percent REAL,
+          mem_used_bytes INTEGER,
+          mem_total_bytes INTEGER,
+          disk_used_bytes INTEGER,
+          disk_total_bytes INTEGER,
+          heap_used_bytes INTEGER,
+          uptime_seconds INTEGER,
+          peer_count INTEGER,
+          direct_peers INTEGER,
+          relayed_peers INTEGER,
+          mesh_peers INTEGER,
+          contextGraph_count INTEGER,
+          total_triples INTEGER,
+          total_kcs INTEGER,
+          total_kas INTEGER,
+          store_bytes INTEGER,
+          confirmed_kcs INTEGER,
+          tentative_kcs INTEGER,
+          rpc_latency_ms INTEGER,
+          rpc_healthy INTEGER,
+          relay_capacity INTEGER,
+          relay_reservation_count INTEGER,
+          relay_active_circuits INTEGER,
+          relay_bytes_in INTEGER,
+          relay_bytes_out INTEGER
+        );
+        CREATE INDEX IF NOT EXISTS idx_snapshots_ts ON metric_snapshots(ts);
+
+        CREATE TABLE IF NOT EXISTS operations (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          operation_id TEXT NOT NULL,
+          operation_name TEXT NOT NULL,
+          started_at INTEGER NOT NULL,
+          duration_ms INTEGER,
+          status TEXT DEFAULT 'in_progress',
+          peer_id TEXT,
+          contextGraph_id TEXT,
+          triple_count INTEGER,
+          error_message TEXT,
+          details TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_ops_operation_id ON operations(operation_id);
+        CREATE INDEX IF NOT EXISTS idx_ops_started_at ON operations(started_at);
+        CREATE INDEX IF NOT EXISTS idx_ops_name ON operations(operation_name);
+
+        CREATE TABLE IF NOT EXISTS logs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          ts INTEGER NOT NULL,
+          level TEXT NOT NULL,
+          operation_name TEXT,
+          operation_id TEXT,
+          module TEXT,
+          message TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_logs_ts ON logs(ts);
+        CREATE INDEX IF NOT EXISTS idx_logs_operation_id ON logs(operation_id);
+        CREATE INDEX IF NOT EXISTS idx_logs_level ON logs(level);
+
+        -- NOTE: Earlier schema versions (V1..V14) also created an FTS5
+        -- virtual table "logs_fts" plus AFTER INSERT/DELETE triggers to
+        -- keep it in sync with "logs". That fed a free-text search path
+        -- behind /api/logs?q=... The FTS5 index turned out to dominate
+        -- on-disk size (multi-GB shadow tables on long-lived nodes) and
+        -- the corresponding HTTP route had no production consumer
+        -- (the dashboard log viewer is file-backed via /api/node-log).
+        -- V15 drops it for fresh installs; the migration below cleans
+        -- it up for in-place upgrades.
+
+        CREATE TABLE IF NOT EXISTS query_history (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          ts INTEGER NOT NULL,
+          sparql TEXT NOT NULL,
+          duration_ms INTEGER,
+          result_count INTEGER,
+          error TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_qhist_ts ON query_history(ts);
+
+        CREATE TABLE IF NOT EXISTS saved_queries (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          name TEXT NOT NULL,
+          description TEXT,
+          sparql TEXT NOT NULL,
+          created_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL
+        );
       `);
         }
         if (version < 2) {
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS operation_phases (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          operation_id TEXT NOT NULL,
-          phase TEXT NOT NULL,
-          started_at INTEGER NOT NULL,
-          duration_ms INTEGER,
-          status TEXT DEFAULT 'in_progress',
-          details TEXT
-        );
-        CREATE INDEX IF NOT EXISTS idx_phases_op ON operation_phases(operation_id);
-
-        ALTER TABLE operations ADD COLUMN gas_used INTEGER;
-        ALTER TABLE operations ADD COLUMN gas_price_gwei REAL;
-        ALTER TABLE operations ADD COLUMN gas_cost_eth REAL;
-        ALTER TABLE operations ADD COLUMN trac_cost REAL;
-        ALTER TABLE operations ADD COLUMN tx_hash TEXT;
-        ALTER TABLE operations ADD COLUMN chain_id INTEGER;
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS operation_phases (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          operation_id TEXT NOT NULL,
+          phase TEXT NOT NULL,
+          started_at INTEGER NOT NULL,
+          duration_ms INTEGER,
+          status TEXT DEFAULT 'in_progress',
+          details TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_phases_op ON operation_phases(operation_id);
+
+        ALTER TABLE operations ADD COLUMN gas_used INTEGER;
+        ALTER TABLE operations ADD COLUMN gas_price_gwei REAL;
+        ALTER TABLE operations ADD COLUMN gas_cost_eth REAL;
+        ALTER TABLE operations ADD COLUMN trac_cost REAL;
+        ALTER TABLE operations ADD COLUMN tx_hash TEXT;
+        ALTER TABLE operations ADD COLUMN chain_id INTEGER;
       `);
         }
         if (version < 3) {
@@ -319,42 +331,42 @@ export class DashboardDB {
             // column + the partial unique index in one step; the V11 block
             // below idempotently adds the column to nodes that upgraded
             // through versions 3..10 first.
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS chat_messages (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          ts INTEGER NOT NULL,
-          direction TEXT NOT NULL,
-          peer TEXT NOT NULL,
-          peer_name TEXT,
-          text TEXT NOT NULL,
-          delivered INTEGER,
-          message_id TEXT
-        );
-        CREATE INDEX IF NOT EXISTS idx_chat_ts ON chat_messages(ts);
-        CREATE INDEX IF NOT EXISTS idx_chat_peer ON chat_messages(peer);
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS chat_messages (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          ts INTEGER NOT NULL,
+          direction TEXT NOT NULL,
+          peer TEXT NOT NULL,
+          peer_name TEXT,
+          text TEXT NOT NULL,
+          delivered INTEGER,
+          message_id TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_chat_ts ON chat_messages(ts);
+        CREATE INDEX IF NOT EXISTS idx_chat_peer ON chat_messages(peer);
       `);
         }
         if (version < 4) {
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS chat_persistence_jobs (
-          turn_id TEXT PRIMARY KEY,
-          session_id TEXT NOT NULL,
-          user_message TEXT NOT NULL,
-          assistant_reply TEXT NOT NULL,
-          tool_calls_json TEXT,
-          status TEXT NOT NULL,
-          attempts INTEGER NOT NULL DEFAULT 0,
-          max_attempts INTEGER NOT NULL DEFAULT 3,
-          next_attempt_at INTEGER NOT NULL,
-          queued_at INTEGER NOT NULL,
-          updated_at INTEGER NOT NULL,
-          store_ms INTEGER,
-          error_message TEXT
-        );
-        CREATE INDEX IF NOT EXISTS idx_chat_persist_status_next
-          ON chat_persistence_jobs(status, next_attempt_at);
-        CREATE INDEX IF NOT EXISTS idx_chat_persist_session
-          ON chat_persistence_jobs(session_id);
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS chat_persistence_jobs (
+          turn_id TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          user_message TEXT NOT NULL,
+          assistant_reply TEXT NOT NULL,
+          tool_calls_json TEXT,
+          status TEXT NOT NULL,
+          attempts INTEGER NOT NULL DEFAULT 0,
+          max_attempts INTEGER NOT NULL DEFAULT 3,
+          next_attempt_at INTEGER NOT NULL,
+          queued_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL,
+          store_ms INTEGER,
+          error_message TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_chat_persist_status_next
+          ON chat_persistence_jobs(status, next_attempt_at);
+        CREATE INDEX IF NOT EXISTS idx_chat_persist_session
+          ON chat_persistence_jobs(session_id);
       `);
         }
         if (version < 5) {
@@ -363,77 +375,77 @@ export class DashboardDB {
             // fresh-install CREATE so new nodes get the column + its index in one
             // step; the V16 block below idempotently adds it to nodes that upgraded
             // through versions 5..15 first (same pattern as `message_id` in V3/V11).
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS notifications (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          ts INTEGER NOT NULL,
-          type TEXT NOT NULL,
-          title TEXT NOT NULL,
-          message TEXT NOT NULL,
-          source TEXT,
-          peer TEXT,
-          read INTEGER NOT NULL DEFAULT 0,
-          meta TEXT,
-          context_graph_id TEXT
-        );
-        CREATE INDEX IF NOT EXISTS idx_notif_ts ON notifications(ts);
-        CREATE INDEX IF NOT EXISTS idx_notif_read ON notifications(read);
-        CREATE INDEX IF NOT EXISTS idx_notif_cg ON notifications(context_graph_id);
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS notifications (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          ts INTEGER NOT NULL,
+          type TEXT NOT NULL,
+          title TEXT NOT NULL,
+          message TEXT NOT NULL,
+          source TEXT,
+          peer TEXT,
+          read INTEGER NOT NULL DEFAULT 0,
+          meta TEXT,
+          context_graph_id TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_notif_ts ON notifications(ts);
+        CREATE INDEX IF NOT EXISTS idx_notif_read ON notifications(read);
+        CREATE INDEX IF NOT EXISTS idx_notif_cg ON notifications(context_graph_id);
       `);
         }
         if (version < 6) {
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS settings (
-          key TEXT PRIMARY KEY,
-          value TEXT NOT NULL
-        );
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS settings (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        );
       `);
         }
         if (version < 7) {
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS context_graph_subscriptions (
-          context_graph_id TEXT PRIMARY KEY,
-          name TEXT,
-          subscribed INTEGER NOT NULL,
-          synced INTEGER NOT NULL,
-          meta_synced INTEGER,
-          on_chain_id TEXT,
-          sync_scoped INTEGER NOT NULL DEFAULT 1,
-          updated_at INTEGER NOT NULL
-        );
-        CREATE INDEX IF NOT EXISTS idx_cg_subs_sync_scoped
-          ON context_graph_subscriptions(sync_scoped);
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS context_graph_subscriptions (
+          context_graph_id TEXT PRIMARY KEY,
+          name TEXT,
+          subscribed INTEGER NOT NULL,
+          synced INTEGER NOT NULL,
+          meta_synced INTEGER,
+          on_chain_id TEXT,
+          sync_scoped INTEGER NOT NULL DEFAULT 1,
+          updated_at INTEGER NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_cg_subs_sync_scoped
+          ON context_graph_subscriptions(sync_scoped);
       `);
         }
         if (version < 8) {
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS context_graph_memberships (
-          context_graph_id TEXT NOT NULL,
-          principal_type TEXT NOT NULL,
-          principal_id TEXT NOT NULL,
-          role TEXT,
-          status TEXT NOT NULL,
-          source TEXT,
-          display_name TEXT,
-          metadata TEXT,
-          first_seen_at INTEGER NOT NULL,
-          updated_at INTEGER NOT NULL,
-          PRIMARY KEY (context_graph_id, principal_type, principal_id)
-        );
-        CREATE INDEX IF NOT EXISTS idx_cg_members_context
-          ON context_graph_memberships(context_graph_id);
-        CREATE INDEX IF NOT EXISTS idx_cg_members_principal
-          ON context_graph_memberships(principal_type, principal_id);
-        CREATE INDEX IF NOT EXISTS idx_cg_members_status
-          ON context_graph_memberships(status);
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS context_graph_memberships (
+          context_graph_id TEXT NOT NULL,
+          principal_type TEXT NOT NULL,
+          principal_id TEXT NOT NULL,
+          role TEXT,
+          status TEXT NOT NULL,
+          source TEXT,
+          display_name TEXT,
+          metadata TEXT,
+          first_seen_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL,
+          PRIMARY KEY (context_graph_id, principal_type, principal_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_cg_members_context
+          ON context_graph_memberships(context_graph_id);
+        CREATE INDEX IF NOT EXISTS idx_cg_members_principal
+          ON context_graph_memberships(principal_type, principal_id);
+        CREATE INDEX IF NOT EXISTS idx_cg_members_status
+          ON context_graph_memberships(status);
       `);
         }
         if (version < 9) {
             const columns = this.db.prepare('PRAGMA table_info(context_graph_subscriptions)').all();
             if (!columns.some((column) => column.name === 'shared_memory_synced')) {
-                this.db.exec(`
-          ALTER TABLE context_graph_subscriptions
-            ADD COLUMN shared_memory_synced INTEGER;
+                this.db.exec(`
+          ALTER TABLE context_graph_subscriptions
+            ADD COLUMN shared_memory_synced INTEGER;
         `);
             }
         }
@@ -502,10 +514,10 @@ export class DashboardDB {
             if (!chatCols.has('message_id')) {
                 this.db.exec(`ALTER TABLE chat_messages ADD COLUMN message_id TEXT;`);
             }
-            this.db.exec(`
-        CREATE UNIQUE INDEX IF NOT EXISTS idx_chat_msgid
-          ON chat_messages(peer, direction, message_id)
-          WHERE message_id IS NOT NULL;
+            this.db.exec(`
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_chat_msgid
+          ON chat_messages(peer, direction, message_id)
+          WHERE message_id IS NOT NULL;
       `);
         }
         if (version < 12) {
@@ -561,33 +573,33 @@ export class DashboardDB {
             // `message_id` is enforced via `message_idempotency` instead.
             // V13 will also preserve `chat_messages.message_id` as
             // nullable + unwritten for rollback safety.
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS message_idempotency (
-          peer_id TEXT NOT NULL,
-          protocol TEXT NOT NULL,
-          message_id TEXT NOT NULL,
-          direction TEXT NOT NULL CHECK (direction IN ('in', 'out')),
-          response_blob BLOB,
-          response_size INTEGER NOT NULL DEFAULT 0,
-          ts INTEGER NOT NULL,
-          PRIMARY KEY (peer_id, protocol, message_id, direction)
-        );
-        CREATE INDEX IF NOT EXISTS idx_idem_ts ON message_idempotency(ts);
-
-        CREATE TABLE IF NOT EXISTS protocol_outbox (
-          peer_id TEXT NOT NULL,
-          protocol TEXT NOT NULL,
-          message_id TEXT NOT NULL,
-          payload BLOB NOT NULL,
-          attempts INTEGER NOT NULL DEFAULT 0,
-          first_failure_at INTEGER NOT NULL,
-          last_attempt_at INTEGER NOT NULL,
-          next_attempt_at INTEGER NOT NULL,
-          last_error TEXT,
-          PRIMARY KEY (peer_id, protocol, message_id)
-        );
-        CREATE INDEX IF NOT EXISTS idx_outbox_next_attempt
-          ON protocol_outbox(next_attempt_at);
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS message_idempotency (
+          peer_id TEXT NOT NULL,
+          protocol TEXT NOT NULL,
+          message_id TEXT NOT NULL,
+          direction TEXT NOT NULL CHECK (direction IN ('in', 'out')),
+          response_blob BLOB,
+          response_size INTEGER NOT NULL DEFAULT 0,
+          ts INTEGER NOT NULL,
+          PRIMARY KEY (peer_id, protocol, message_id, direction)
+        );
+        CREATE INDEX IF NOT EXISTS idx_idem_ts ON message_idempotency(ts);
+
+        CREATE TABLE IF NOT EXISTS protocol_outbox (
+          peer_id TEXT NOT NULL,
+          protocol TEXT NOT NULL,
+          message_id TEXT NOT NULL,
+          payload BLOB NOT NULL,
+          attempts INTEGER NOT NULL DEFAULT 0,
+          first_failure_at INTEGER NOT NULL,
+          last_attempt_at INTEGER NOT NULL,
+          next_attempt_at INTEGER NOT NULL,
+          last_error TEXT,
+          PRIMARY KEY (peer_id, protocol, message_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_outbox_next_attempt
+          ON protocol_outbox(next_attempt_at);
       `);
         }
         if (version < 13) {
@@ -612,8 +624,8 @@ export class DashboardDB {
             // table rebuild on downgrade.
             //
             // No data migration. No new tables. Pure DROP INDEX.
-            this.db.exec(`
-        DROP INDEX IF EXISTS idx_chat_msgid;
+            this.db.exec(`
+        DROP INDEX IF EXISTS idx_chat_msgid;
       `);
         }
         if (version < 14) {
@@ -654,10 +666,10 @@ export class DashboardDB {
             // operation-correlated log views (`getOperation`,
             // `getFailedOperations`). Substring/text search moves to
             // /api/node-log, which already supports `?q=`.
-            this.db.exec(`
-        DROP TRIGGER IF EXISTS logs_ai;
-        DROP TRIGGER IF EXISTS logs_ad;
-        DROP TABLE   IF EXISTS logs_fts;
+            this.db.exec(`
+        DROP TRIGGER IF EXISTS logs_ai;
+        DROP TRIGGER IF EXISTS logs_ad;
+        DROP TABLE   IF EXISTS logs_fts;
       `);
             // VACUUM cannot run inside a transaction; better-sqlite3 wraps
             // multi-statement exec() in implicit BEGIN/COMMIT, so we issue
@@ -721,23 +733,23 @@ export class DashboardDB {
             // re-parsing the daemon log. One row per decision point (sweep / fetch /
             // promote / already / defer / cursor-advance / core-fill). Pruned by `ts`
             // like the other event tables.
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS replication_events (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          ts INTEGER NOT NULL,
-          context_graph_id TEXT NOT NULL,
-          on_chain_cg_id TEXT,
-          action TEXT NOT NULL,
-          ual TEXT,
-          ordinal INTEGER,
-          ka_id TEXT,
-          from_watermark INTEGER,
-          to_watermark INTEGER,
-          head INTEGER,
-          reconciled INTEGER,
-          pending INTEGER,
-          detail TEXT
-        );
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS replication_events (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          ts INTEGER NOT NULL,
+          context_graph_id TEXT NOT NULL,
+          on_chain_cg_id TEXT,
+          action TEXT NOT NULL,
+          ual TEXT,
+          ordinal INTEGER,
+          ka_id TEXT,
+          from_watermark INTEGER,
+          to_watermark INTEGER,
+          head INTEGER,
+          reconciled INTEGER,
+          pending INTEGER,
+          detail TEXT
+        );
       `);
             this.db.exec(`CREATE INDEX IF NOT EXISTS idx_repl_ts ON replication_events(ts);`);
             this.db.exec(`CREATE INDEX IF NOT EXISTS idx_repl_cg ON replication_events(context_graph_id, ts);`);
@@ -776,54 +788,60 @@ export class DashboardDB {
             // the 2^63 INTEGER max and under the uint96 on-chain field. Like
             // `protocol_outbox`, this state is durable and is NEVER pruned —
             // reclaiming a number could mint a duplicate kaId.
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS ka_numbers (
-          author_address TEXT PRIMARY KEY,
-          next_number INTEGER NOT NULL
-        );
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS ka_numbers (
+          author_address TEXT PRIMARY KEY,
+          next_number INTEGER NOT NULL
+        );
       `);
         }
         if (version < 21) {
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS sync_checkpoints (
-          key TEXT PRIMARY KEY,
-          offset INTEGER NOT NULL CHECK (offset >= 0),
-          updated_at INTEGER NOT NULL,
-          expires_at INTEGER NOT NULL
-        );
-        CREATE INDEX IF NOT EXISTS idx_sync_checkpoints_expires_at
-          ON sync_checkpoints(expires_at);
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS sync_checkpoints (
+          key TEXT PRIMARY KEY,
+          offset INTEGER NOT NULL CHECK (offset >= 0),
+          updated_at INTEGER NOT NULL,
+          expires_at INTEGER NOT NULL,
+          responder_session_id TEXT,
+          responder_session_expires_at INTEGER,
+          responder_session_offset INTEGER CHECK (responder_session_offset >= 0),
+          manifest_digest TEXT,
+          manifest_prefix_digest TEXT,
+          terminal INTEGER NOT NULL DEFAULT 0 CHECK (terminal IN (0, 1))
+        );
+        CREATE INDEX IF NOT EXISTS idx_sync_checkpoints_expires_at
+          ON sync_checkpoints(expires_at);
       `);
         }
         if (version < 22) {
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS runtime_cursors (
-          namespace TEXT NOT NULL,
-          scope TEXT NOT NULL,
-          key TEXT NOT NULL,
-          value INTEGER NOT NULL CHECK (value > 0),
-          updated_at INTEGER NOT NULL,
-          PRIMARY KEY (namespace, scope, key)
-        );
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS runtime_cursors (
+          namespace TEXT NOT NULL,
+          scope TEXT NOT NULL,
+          key TEXT NOT NULL,
+          value INTEGER NOT NULL CHECK (value > 0),
+          updated_at INTEGER NOT NULL,
+          PRIMARY KEY (namespace, scope, key)
+        );
       `);
-            this.db.exec(`
-        CREATE INDEX IF NOT EXISTS idx_runtime_cursors_namespace_scope
-          ON runtime_cursors(namespace, scope);
+            this.db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_runtime_cursors_namespace_scope
+          ON runtime_cursors(namespace, scope);
       `);
         }
         if (version < 23) {
             // OT-RFC-59 SC5: durable per-(peer, contextGraph) changelog cursor. NEVER
             // pruned (see SqliteChangelogCursorStore) — a TTL would defeat the O(delta)
             // cross-restart catch-up this table exists for.
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS changelog_cursors (
-          peer_id TEXT NOT NULL,
-          context_graph_id TEXT NOT NULL,
-          era TEXT NOT NULL,
-          seq INTEGER NOT NULL CHECK (seq >= 0),
-          updated_at INTEGER NOT NULL,
-          PRIMARY KEY (peer_id, context_graph_id)
-        );
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS changelog_cursors (
+          peer_id TEXT NOT NULL,
+          context_graph_id TEXT NOT NULL,
+          era TEXT NOT NULL,
+          seq INTEGER NOT NULL CHECK (seq >= 0),
+          updated_at INTEGER NOT NULL,
+          PRIMARY KEY (peer_id, context_graph_id)
+        );
       `);
         }
         if (version < 24) {
@@ -832,39 +850,39 @@ export class DashboardDB {
             // `store.nq` restore does NOT roll back with the RDF store. node-ui.db
             // survives such a restore, so a rollback under the same era rotates the era
             // (forcing peers to full-resync instead of silently skipping). Single row.
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS changelog_era (
-          id INTEGER PRIMARY KEY CHECK (id = 1),
-          era TEXT NOT NULL,
-          high_seq INTEGER NOT NULL CHECK (high_seq >= 0),
-          updated_at INTEGER NOT NULL
-        );
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS changelog_era (
+          id INTEGER PRIMARY KEY CHECK (id = 1),
+          era TEXT NOT NULL,
+          high_seq INTEGER NOT NULL CHECK (high_seq >= 0),
+          updated_at INTEGER NOT NULL
+        );
       `);
         }
         if (version < 25) {
             // Durable security audit for private-CG open enrollment. V25/V26 also
             // used this table as admission state; V27 projects those legacy rows into
             // the typed operational ledger below.
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS context_graph_join_policy_audit (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          ts INTEGER NOT NULL,
-          context_graph_id TEXT NOT NULL,
-          event_type TEXT NOT NULL,
-          actor TEXT,
-          agent_address TEXT,
-          outcome TEXT NOT NULL,
-          reason TEXT,
-          request_digest TEXT,
-          policy_version INTEGER,
-          details TEXT
-        );
-        CREATE INDEX IF NOT EXISTS idx_cg_join_policy_audit_ts
-          ON context_graph_join_policy_audit(ts);
-        CREATE INDEX IF NOT EXISTS idx_cg_join_policy_audit_cg_ts
-          ON context_graph_join_policy_audit(context_graph_id, ts);
-        CREATE INDEX IF NOT EXISTS idx_cg_join_policy_audit_event_ts
-          ON context_graph_join_policy_audit(event_type, ts);
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS context_graph_join_policy_audit (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          ts INTEGER NOT NULL,
+          context_graph_id TEXT NOT NULL,
+          event_type TEXT NOT NULL,
+          actor TEXT,
+          agent_address TEXT,
+          outcome TEXT NOT NULL,
+          reason TEXT,
+          request_digest TEXT,
+          policy_version INTEGER,
+          details TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_cg_join_policy_audit_ts
+          ON context_graph_join_policy_audit(ts);
+        CREATE INDEX IF NOT EXISTS idx_cg_join_policy_audit_cg_ts
+          ON context_graph_join_policy_audit(context_graph_id, ts);
+        CREATE INDEX IF NOT EXISTS idx_cg_join_policy_audit_event_ts
+          ON context_graph_join_policy_audit(event_type, ts);
       `);
         }
         if (version < 26) {
@@ -883,108 +901,108 @@ export class DashboardDB {
             // Operational admission state is deliberately separate from the audit
             // stream. Audit retention and event naming must never alter rate-limit,
             // epoch, or commit-idempotency behaviour.
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS context_graph_join_approval_ledger (
-          context_graph_id TEXT NOT NULL,
-          request_digest TEXT NOT NULL,
-          policy_epoch INTEGER NOT NULL,
-          reserved_at INTEGER NOT NULL,
-          state TEXT NOT NULL CHECK (state IN ('reserved', 'committed')),
-          committed_at INTEGER,
-          actor TEXT NOT NULL,
-          agent_address TEXT NOT NULL,
-          policy_version INTEGER NOT NULL,
-          PRIMARY KEY (context_graph_id, request_digest, policy_epoch),
-          CHECK (length(context_graph_id) > 0),
-          CHECK (length(request_digest) > 0),
-          CHECK (typeof(policy_epoch) = 'integer'),
-          CHECK (typeof(reserved_at) = 'integer'),
-          CHECK (committed_at IS NULL OR typeof(committed_at) = 'integer'),
-          CHECK (typeof(policy_version) = 'integer'),
-          CHECK (
-            (state = 'reserved' AND committed_at IS NULL)
-            OR (state = 'committed' AND committed_at IS NOT NULL)
-          )
-        );
-        CREATE INDEX IF NOT EXISTS idx_cg_join_approval_ledger_reserved_at
-          ON context_graph_join_approval_ledger(reserved_at);
-        CREATE INDEX IF NOT EXISTS idx_cg_join_approval_ledger_cg_reserved_at
-          ON context_graph_join_approval_ledger(context_graph_id, reserved_at);
-        CREATE INDEX IF NOT EXISTS idx_cg_join_approval_ledger_digest_reserved_at
-          ON context_graph_join_approval_ledger(context_graph_id, request_digest, reserved_at DESC);
-        CREATE INDEX IF NOT EXISTS idx_cg_join_approval_ledger_committed_at
-          ON context_graph_join_approval_ledger(committed_at);
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS context_graph_join_approval_ledger (
+          context_graph_id TEXT NOT NULL,
+          request_digest TEXT NOT NULL,
+          policy_epoch INTEGER NOT NULL,
+          reserved_at INTEGER NOT NULL,
+          state TEXT NOT NULL CHECK (state IN ('reserved', 'committed')),
+          committed_at INTEGER,
+          actor TEXT NOT NULL,
+          agent_address TEXT NOT NULL,
+          policy_version INTEGER NOT NULL,
+          PRIMARY KEY (context_graph_id, request_digest, policy_epoch),
+          CHECK (length(context_graph_id) > 0),
+          CHECK (length(request_digest) > 0),
+          CHECK (typeof(policy_epoch) = 'integer'),
+          CHECK (typeof(reserved_at) = 'integer'),
+          CHECK (committed_at IS NULL OR typeof(committed_at) = 'integer'),
+          CHECK (typeof(policy_version) = 'integer'),
+          CHECK (
+            (state = 'reserved' AND committed_at IS NULL)
+            OR (state = 'committed' AND committed_at IS NOT NULL)
+          )
+        );
+        CREATE INDEX IF NOT EXISTS idx_cg_join_approval_ledger_reserved_at
+          ON context_graph_join_approval_ledger(reserved_at);
+        CREATE INDEX IF NOT EXISTS idx_cg_join_approval_ledger_cg_reserved_at
+          ON context_graph_join_approval_ledger(context_graph_id, reserved_at);
+        CREATE INDEX IF NOT EXISTS idx_cg_join_approval_ledger_digest_reserved_at
+          ON context_graph_join_approval_ledger(context_graph_id, request_digest, reserved_at DESC);
+        CREATE INDEX IF NOT EXISTS idx_cg_join_approval_ledger_committed_at
+          ON context_graph_join_approval_ledger(committed_at);
       `);
             // Best-effort one-time projection for V25/V26 databases. Invalid legacy
             // JSON cannot abort startup; only rows with a typed numeric epoch can be
             // authoritative operational state. For duplicate audit reservations,
             // retain the newest row for each (CG, digest, epoch).
-            this.db.exec(`
-        WITH raw_reservations AS (
-          SELECT
-            id,
-            context_graph_id,
-            request_digest,
-            CASE
-              WHEN json_valid(details)
-                AND json_type(details, '$.policyEpoch') IN ('integer', 'real')
-                THEN CAST(json_extract(details, '$.policyEpoch') AS INTEGER)
-              ELSE NULL
-            END AS policy_epoch,
-            ts AS reserved_at,
-            COALESCE(actor, '') AS actor,
-            COALESCE(agent_address, '') AS agent_address,
-            COALESCE(policy_version, 1) AS policy_version
-          FROM context_graph_join_policy_audit
-          WHERE event_type = 'join_auto_reservation'
-            AND outcome = 'reserved'
-            AND request_digest IS NOT NULL
-        ),
-        ranked_reservations AS (
-          SELECT *, ROW_NUMBER() OVER (
-            PARTITION BY context_graph_id, request_digest, policy_epoch
-            ORDER BY reserved_at DESC, id DESC
-          ) AS rank
-          FROM raw_reservations
-          WHERE policy_epoch IS NOT NULL
-        ),
-        raw_commits AS (
-          SELECT
-            context_graph_id,
-            request_digest,
-            CASE
-              WHEN json_valid(details)
-                AND json_type(details, '$.policyEpoch') IN ('integer', 'real')
-                THEN CAST(json_extract(details, '$.policyEpoch') AS INTEGER)
-              ELSE NULL
-            END AS policy_epoch,
-            MIN(ts) AS committed_at
-          FROM context_graph_join_policy_audit
-          WHERE event_type = 'join_admission_committed'
-            AND outcome = 'approved'
-            AND request_digest IS NOT NULL
-          GROUP BY context_graph_id, request_digest, policy_epoch
-        )
-        INSERT OR IGNORE INTO context_graph_join_approval_ledger (
-          context_graph_id, request_digest, policy_epoch, reserved_at,
-          state, committed_at, actor, agent_address, policy_version
-        )
-        SELECT
-          reservation.context_graph_id,
-          reservation.request_digest,
-          reservation.policy_epoch,
-          reservation.reserved_at,
-          CASE WHEN commit_row.committed_at IS NULL THEN 'reserved' ELSE 'committed' END,
-          commit_row.committed_at,
-          reservation.actor,
-          reservation.agent_address,
-          reservation.policy_version
-        FROM ranked_reservations AS reservation
-        LEFT JOIN raw_commits AS commit_row
-          ON commit_row.context_graph_id = reservation.context_graph_id
-         AND commit_row.request_digest = reservation.request_digest
-         AND commit_row.policy_epoch = reservation.policy_epoch
-        WHERE reservation.rank = 1;
+            this.db.exec(`
+        WITH raw_reservations AS (
+          SELECT
+            id,
+            context_graph_id,
+            request_digest,
+            CASE
+              WHEN json_valid(details)
+                AND json_type(details, '$.policyEpoch') IN ('integer', 'real')
+                THEN CAST(json_extract(details, '$.policyEpoch') AS INTEGER)
+              ELSE NULL
+            END AS policy_epoch,
+            ts AS reserved_at,
+            COALESCE(actor, '') AS actor,
+            COALESCE(agent_address, '') AS agent_address,
+            COALESCE(policy_version, 1) AS policy_version
+          FROM context_graph_join_policy_audit
+          WHERE event_type = 'join_auto_reservation'
+            AND outcome = 'reserved'
+            AND request_digest IS NOT NULL
+        ),
+        ranked_reservations AS (
+          SELECT *, ROW_NUMBER() OVER (
+            PARTITION BY context_graph_id, request_digest, policy_epoch
+            ORDER BY reserved_at DESC, id DESC
+          ) AS rank
+          FROM raw_reservations
+          WHERE policy_epoch IS NOT NULL
+        ),
+        raw_commits AS (
+          SELECT
+            context_graph_id,
+            request_digest,
+            CASE
+              WHEN json_valid(details)
+                AND json_type(details, '$.policyEpoch') IN ('integer', 'real')
+                THEN CAST(json_extract(details, '$.policyEpoch') AS INTEGER)
+              ELSE NULL
+            END AS policy_epoch,
+            MIN(ts) AS committed_at
+          FROM context_graph_join_policy_audit
+          WHERE event_type = 'join_admission_committed'
+            AND outcome = 'approved'
+            AND request_digest IS NOT NULL
+          GROUP BY context_graph_id, request_digest, policy_epoch
+        )
+        INSERT OR IGNORE INTO context_graph_join_approval_ledger (
+          context_graph_id, request_digest, policy_epoch, reserved_at,
+          state, committed_at, actor, agent_address, policy_version
+        )
+        SELECT
+          reservation.context_graph_id,
+          reservation.request_digest,
+          reservation.policy_epoch,
+          reservation.reserved_at,
+          CASE WHEN commit_row.committed_at IS NULL THEN 'reserved' ELSE 'committed' END,
+          commit_row.committed_at,
+          reservation.actor,
+          reservation.agent_address,
+          reservation.policy_version
+        FROM ranked_reservations AS reservation
+        LEFT JOIN raw_commits AS commit_row
+          ON commit_row.context_graph_id = reservation.context_graph_id
+         AND commit_row.request_digest = reservation.request_digest
+         AND commit_row.policy_epoch = reservation.policy_epoch
+        WHERE reservation.rank = 1;
       `);
             // V26's trigger protected live reservation audit rows because they were
             // operational state. The ledger makes that coupling obsolete, so replace
@@ -1002,46 +1020,81 @@ export class DashboardDB {
         // idempotent and keeps the audit bound fail-closed on every open.
         ensureJoinPolicyAuditCapTrigger();
         if (version < 29) {
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS vm_reconcile_negative_cache (
-          cache_key TEXT PRIMARY KEY,
-          context_graph_id TEXT NOT NULL,
-          failures INTEGER NOT NULL,
-          next_retry_at INTEGER NOT NULL,
-          swm_gen TEXT NOT NULL,
-          candidate_namespaces TEXT NOT NULL,
-          peer_topology_key TEXT NOT NULL,
-          updated_at INTEGER NOT NULL
-        );
-        CREATE INDEX IF NOT EXISTS idx_vm_reconcile_negative_cg
-          ON vm_reconcile_negative_cache(context_graph_id);
-        CREATE INDEX IF NOT EXISTS idx_vm_reconcile_negative_retry
-          ON vm_reconcile_negative_cache(next_retry_at);
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS vm_reconcile_negative_cache (
+          cache_key TEXT PRIMARY KEY,
+          context_graph_id TEXT NOT NULL,
+          failures INTEGER NOT NULL,
+          next_retry_at INTEGER NOT NULL,
+          swm_gen TEXT NOT NULL,
+          candidate_namespaces TEXT NOT NULL,
+          peer_topology_key TEXT NOT NULL,
+          updated_at INTEGER NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS idx_vm_reconcile_negative_cg
+          ON vm_reconcile_negative_cache(context_graph_id);
+        CREATE INDEX IF NOT EXISTS idx_vm_reconcile_negative_retry
+          ON vm_reconcile_negative_cache(next_retry_at);
       `);
         }
         if (version < 30) {
             // OFFSET pagination is scoped to an immutable responder row list. Keep
             // the opaque responder token beside the verified offset so a requester
             // restart can resume that same list instead of discarding durable work.
-            ensureSyncCheckpointResponderSessionColumns();
+            ensureSyncCheckpointResumeColumns();
         }
         if (version < 31) {
-            this.db.exec(`
-        CREATE TABLE IF NOT EXISTS snapshot_page_indexes (
-          snapshot_digest TEXT PRIMARY KEY,
-          format_version INTEGER NOT NULL CHECK (format_version > 0),
-          stride INTEGER NOT NULL CHECK (stride > 0),
-          snapshot_file_size INTEGER NOT NULL CHECK (snapshot_file_size >= 0),
-          modification_fingerprint TEXT NOT NULL,
-          offset_count INTEGER NOT NULL CHECK (offset_count > 0),
-          offsets BLOB NOT NULL,
-          checksum TEXT NOT NULL,
-          CHECK (length(snapshot_digest) > 0),
-          CHECK (length(modification_fingerprint) > 0),
-          CHECK (length(offsets) = offset_count * 8),
-          CHECK (length(checksum) > 0)
-        );
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS snapshot_page_indexes (
+          snapshot_digest TEXT PRIMARY KEY,
+          format_version INTEGER NOT NULL CHECK (format_version > 0),
+          stride INTEGER NOT NULL CHECK (stride > 0),
+          snapshot_file_size INTEGER NOT NULL CHECK (snapshot_file_size >= 0),
+          modification_fingerprint TEXT NOT NULL,
+          offset_count INTEGER NOT NULL CHECK (offset_count > 0),
+          offsets BLOB NOT NULL,
+          checksum TEXT NOT NULL,
+          CHECK (length(snapshot_digest) > 0),
+          CHECK (length(modification_fingerprint) > 0),
+          CHECK (length(offsets) = offset_count * 8),
+          CHECK (length(checksum) > 0)
+        );
       `);
+        }
+        if (version < 32) {
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS selected_vm_reconcile_cursors (
+          deployment_id TEXT NOT NULL CHECK (length(trim(deployment_id)) > 0),
+          context_graph_id TEXT NOT NULL,
+          on_chain_context_graph_id TEXT NOT NULL,
+          name_hash TEXT NOT NULL,
+          watermark INTEGER NOT NULL CHECK (watermark >= 0),
+          updated_at INTEGER NOT NULL,
+          PRIMARY KEY (deployment_id, context_graph_id, on_chain_context_graph_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_selected_vm_reconcile_cursor_cg
+          ON selected_vm_reconcile_cursors(deployment_id, context_graph_id);
+      `);
+        }
+        if (version < 33) {
+            // A durable DATA offset is reusable only with cryptographic proof of the
+            // canonical META generation and verified descriptor prefix that gave it
+            // meaning. Persist both digests beside the offset/session so production
+            // SQLite checkpoints have the same safety contract as the in-memory
+            // requester store and survive daemon restarts.
+            ensureSyncCheckpointResumeColumns();
+        }
+        if (version < 34) {
+            // The V33 manifest-bound continuation must not share a key with V32,
+            // which interpreted OFFSET as an unverified raw responder coordinate.
+            // Drop every pre-versioned durable DATA row before new code starts using
+            // the `|checkpoint:v2` namespace, so a later rollback also fails closed.
+            ensureSyncCheckpointResumeColumns();
+            this.db.prepare(`
+        DELETE FROM sync_checkpoints
+         WHERE key LIKE '%|durable|data%'
+           AND key NOT LIKE '%|durable|data|checkpoint:v2%'
+      `).run();
         }
         this.db.pragma(`user_version = ${SCHEMA_VERSION}`);
         if (upgradedExistingDb && !this.explicitRetentionDays) {
@@ -1080,10 +1133,10 @@ export class DashboardDB {
         // not depend on whether the corresponding audit rows still exist. Preserve
         // the historical retention envelope for durable commit idempotency while
         // allowing fully expired reservation/commit state to age out.
-        this.db.prepare(`
-      DELETE FROM context_graph_join_approval_ledger
-      WHERE reserved_at < ?
-        AND (committed_at IS NULL OR committed_at < ?)
+        this.db.prepare(`
+      DELETE FROM context_graph_join_approval_ledger
+      WHERE reserved_at < ?
+        AND (committed_at IS NULL OR committed_at < ?)
     `).run(cutoff, cutoff);
         this.db.prepare(`DELETE FROM sync_checkpoints WHERE expires_at < ?`).run(Date.now());
         // Reconcile negatives are accelerators, never historical records. Once the
@@ -1136,16 +1189,16 @@ export class DashboardDB {
                         : 'done',
             };
         }
-        const deleted = this.db.prepare(`
-      DELETE FROM logs
-      WHERE id IN (
-        SELECT id
-        FROM logs
-        WHERE id <= @cutoff
-          AND level NOT IN ('warn', 'error')
-        ORDER BY id ASC
-        LIMIT @batchRows
-      )
+        const deleted = this.db.prepare(`
+      DELETE FROM logs
+      WHERE id IN (
+        SELECT id
+        FROM logs
+        WHERE id <= @cutoff
+          AND level NOT IN ('warn', 'error')
+        ORDER BY id ASC
+        LIMIT @batchRows
+      )
     `).run({
             cutoff: overflowCutoff,
             batchRows: this.logVolumePruneBatchRows,
@@ -1171,12 +1224,12 @@ export class DashboardDB {
         };
     }
     routineLogOverflowCutoff() {
-        const row = this.db.prepare(`
-      SELECT id
-      FROM logs
-      WHERE level NOT IN ('warn', 'error')
-      ORDER BY id DESC
-      LIMIT 1 OFFSET ?
+        const row = this.db.prepare(`
+      SELECT id
+      FROM logs
+      WHERE level NOT IN ('warn', 'error')
+      ORDER BY id DESC
+      LIMIT 1 OFFSET ?
     `).get(this.routineLogRowCap);
         return row?.id ?? null;
     }
@@ -1277,50 +1330,50 @@ export class DashboardDB {
     }
     // --- Metric snapshots ---
     insertSnapshot(snap) {
-        this.stmt('insertSnapshot', `
-      INSERT INTO metric_snapshots (
-        ts, cpu_percent, mem_used_bytes, mem_total_bytes,
-        disk_used_bytes, disk_total_bytes, heap_used_bytes, uptime_seconds,
-        peer_count, direct_peers, relayed_peers, mesh_peers, contextGraph_count,
-        total_triples, total_kcs, total_kas, store_bytes,
-        confirmed_kcs, tentative_kcs, rpc_latency_ms, rpc_healthy,
-        relay_capacity, relay_reservation_count, relay_active_circuits,
-        relay_bytes_in, relay_bytes_out
-      ) VALUES (
-        @ts, @cpu_percent, @mem_used_bytes, @mem_total_bytes,
-        @disk_used_bytes, @disk_total_bytes, @heap_used_bytes, @uptime_seconds,
-        @peer_count, @direct_peers, @relayed_peers, @mesh_peers, @contextGraph_count,
-        @total_triples, @total_kcs, @total_kas, @store_bytes,
-        @confirmed_kcs, @tentative_kcs, @rpc_latency_ms, @rpc_healthy,
-        @relay_capacity, @relay_reservation_count, @relay_active_circuits,
-        @relay_bytes_in, @relay_bytes_out
-      )
+        this.stmt('insertSnapshot', `
+      INSERT INTO metric_snapshots (
+        ts, cpu_percent, mem_used_bytes, mem_total_bytes,
+        disk_used_bytes, disk_total_bytes, heap_used_bytes, uptime_seconds,
+        peer_count, direct_peers, relayed_peers, mesh_peers, contextGraph_count,
+        total_triples, total_kcs, total_kas, store_bytes,
+        confirmed_kcs, tentative_kcs, rpc_latency_ms, rpc_healthy,
+        relay_capacity, relay_reservation_count, relay_active_circuits,
+        relay_bytes_in, relay_bytes_out
+      ) VALUES (
+        @ts, @cpu_percent, @mem_used_bytes, @mem_total_bytes,
+        @disk_used_bytes, @disk_total_bytes, @heap_used_bytes, @uptime_seconds,
+        @peer_count, @direct_peers, @relayed_peers, @mesh_peers, @contextGraph_count,
+        @total_triples, @total_kcs, @total_kas, @store_bytes,
+        @confirmed_kcs, @tentative_kcs, @rpc_latency_ms, @rpc_healthy,
+        @relay_capacity, @relay_reservation_count, @relay_active_circuits,
+        @relay_bytes_in, @relay_bytes_out
+      )
     `).run(snap);
     }
     getLatestSnapshot() {
         return this.db.prepare('SELECT * FROM metric_snapshots ORDER BY ts DESC LIMIT 1').get();
     }
     upsertContextGraphSubscription(record) {
-        this.stmt('upsertContextGraphSubscription', `
-      INSERT INTO context_graph_subscriptions (
-        context_graph_id, name, subscribed, synced, shared_memory_synced, meta_synced,
-        on_chain_id, on_chain_hash, last_reconciled_ordinal, core_hosted, sync_scoped, updated_at
-      ) VALUES (
-        @context_graph_id, @name, @subscribed, @synced, @shared_memory_synced, @meta_synced,
-        @on_chain_id, @on_chain_hash, @last_reconciled_ordinal, @core_hosted, @sync_scoped, @updated_at
-      )
-      ON CONFLICT(context_graph_id) DO UPDATE SET
-        name = excluded.name,
-        subscribed = excluded.subscribed,
-        synced = excluded.synced,
-        shared_memory_synced = excluded.shared_memory_synced,
-        meta_synced = excluded.meta_synced,
-        on_chain_id = excluded.on_chain_id,
-        on_chain_hash = excluded.on_chain_hash,
-        last_reconciled_ordinal = excluded.last_reconciled_ordinal,
-        core_hosted = excluded.core_hosted,
-        sync_scoped = excluded.sync_scoped,
-        updated_at = excluded.updated_at
+        this.stmt('upsertContextGraphSubscription', `
+      INSERT INTO context_graph_subscriptions (
+        context_graph_id, name, subscribed, synced, shared_memory_synced, meta_synced,
+        on_chain_id, on_chain_hash, last_reconciled_ordinal, core_hosted, sync_scoped, updated_at
+      ) VALUES (
+        @context_graph_id, @name, @subscribed, @synced, @shared_memory_synced, @meta_synced,
+        @on_chain_id, @on_chain_hash, @last_reconciled_ordinal, @core_hosted, @sync_scoped, @updated_at
+      )
+      ON CONFLICT(context_graph_id) DO UPDATE SET
+        name = excluded.name,
+        subscribed = excluded.subscribed,
+        synced = excluded.synced,
+        shared_memory_synced = excluded.shared_memory_synced,
+        meta_synced = excluded.meta_synced,
+        on_chain_id = excluded.on_chain_id,
+        on_chain_hash = excluded.on_chain_hash,
+        last_reconciled_ordinal = excluded.last_reconciled_ordinal,
+        core_hosted = excluded.core_hosted,
+        sync_scoped = excluded.sync_scoped,
+        updated_at = excluded.updated_at
     `).run({
             context_graph_id: record.context_graph_id,
             name: record.name ?? null,
@@ -1418,37 +1471,37 @@ export class DashboardDB {
         transition();
     }
     appendContextGraphJoinPolicyAudit(event) {
-        this.stmt('appendContextGraphJoinPolicyAudit', `
-      INSERT INTO context_graph_join_policy_audit (
-        ts, context_graph_id, event_type, actor, agent_address, outcome,
-        reason, request_digest, policy_version, details
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        this.stmt('appendContextGraphJoinPolicyAudit', `
+      INSERT INTO context_graph_join_policy_audit (
+        ts, context_graph_id, event_type, actor, agent_address, outcome,
+        reason, request_digest, policy_version, details
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `).run(event.timestamp, event.contextGraphId, event.eventType, event.actor ?? null, event.agentAddress ?? null, event.outcome, event.reason ?? null, event.requestDigest ?? null, event.policyVersion ?? null, event.details ? JSON.stringify(event.details) : null);
     }
     reserveContextGraphAutomaticApproval(input) {
         const reserve = this.db.transaction(() => {
             const since = input.timestamp - 60 * 60 * 1000;
-            const cgRow = this.stmt('countContextGraphAutomaticApprovalReservations', `
-        SELECT COUNT(*) AS count
-        FROM context_graph_join_approval_ledger
-        WHERE context_graph_id = ?
-          AND reserved_at >= ?
+            const cgRow = this.stmt('countContextGraphAutomaticApprovalReservations', `
+        SELECT COUNT(*) AS count
+        FROM context_graph_join_approval_ledger
+        WHERE context_graph_id = ?
+          AND reserved_at >= ?
       `).get(input.contextGraphId, since);
-            const nodeRow = this.stmt('countNodeAutomaticApprovalReservations', `
-        SELECT COUNT(*) AS count
-        FROM context_graph_join_approval_ledger
-        WHERE reserved_at >= ?
+            const nodeRow = this.stmt('countNodeAutomaticApprovalReservations', `
+        SELECT COUNT(*) AS count
+        FROM context_graph_join_approval_ledger
+        WHERE reserved_at >= ?
       `).get(since);
             const contextGraphCount = Number(cgRow?.count ?? 0);
             const nodeCount = Number(nodeRow?.count ?? 0);
-            const existing = this.stmt('findContextGraphAutomaticApprovalReservation', `
-        SELECT 1 AS found
-        FROM context_graph_join_approval_ledger
-        WHERE context_graph_id = ?
-          AND request_digest = ?
-          AND policy_epoch = ?
-          AND reserved_at >= ?
-        LIMIT 1
+            const existing = this.stmt('findContextGraphAutomaticApprovalReservation', `
+        SELECT 1 AS found
+        FROM context_graph_join_approval_ledger
+        WHERE context_graph_id = ?
+          AND request_digest = ?
+          AND policy_epoch = ?
+          AND reserved_at >= ?
+        LIMIT 1
       `).get(input.contextGraphId, input.requestDigest, input.policyEpoch, since);
             if (existing) {
                 return {
@@ -1478,16 +1531,16 @@ export class DashboardDB {
             // reservation without durable operational state. An expired replay of
             // the same digest+epoch refreshes its reservation timestamp and consumes
             // the rolling-window quota again, matching the former append-only model.
-            this.stmt('upsertContextGraphAutomaticApprovalReservation', `
-        INSERT INTO context_graph_join_approval_ledger (
-          context_graph_id, request_digest, policy_epoch, reserved_at,
-          state, committed_at, actor, agent_address, policy_version
-        ) VALUES (?, ?, ?, ?, 'reserved', NULL, ?, ?, ?)
-        ON CONFLICT(context_graph_id, request_digest, policy_epoch) DO UPDATE SET
-          reserved_at = excluded.reserved_at,
-          actor = excluded.actor,
-          agent_address = excluded.agent_address,
-          policy_version = excluded.policy_version
+            this.stmt('upsertContextGraphAutomaticApprovalReservation', `
+        INSERT INTO context_graph_join_approval_ledger (
+          context_graph_id, request_digest, policy_epoch, reserved_at,
+          state, committed_at, actor, agent_address, policy_version
+        ) VALUES (?, ?, ?, ?, 'reserved', NULL, ?, ?, ?)
+        ON CONFLICT(context_graph_id, request_digest, policy_epoch) DO UPDATE SET
+          reserved_at = excluded.reserved_at,
+          actor = excluded.actor,
+          agent_address = excluded.agent_address,
+          policy_version = excluded.policy_version
       `).run(input.contextGraphId, input.requestDigest, input.policyEpoch, input.timestamp, input.actor, input.agentAddress, input.policyVersion);
             this.appendContextGraphJoinPolicyAudit({
                 timestamp: input.timestamp,
@@ -1513,26 +1566,26 @@ export class DashboardDB {
         return reserve();
     }
     markContextGraphAutomaticApprovalRepairPending(input) {
-        const marked = this.stmt('markContextGraphAutomaticApprovalRepairPending', `
-      UPDATE context_graph_join_approval_ledger
-      SET repair_pending = 1
-      WHERE context_graph_id = ?
-        AND request_digest = ?
-        AND policy_epoch = ?
-        AND state = 'reserved'
+        const marked = this.stmt('markContextGraphAutomaticApprovalRepairPending', `
+      UPDATE context_graph_join_approval_ledger
+      SET repair_pending = 1
+      WHERE context_graph_id = ?
+        AND request_digest = ?
+        AND policy_epoch = ?
+        AND state = 'reserved'
     `).run(input.contextGraphId, input.requestDigest, input.policyEpoch);
         return marked.changes === 1;
     }
     getContextGraphAutomaticApprovalRepair(contextGraphId, requestDigest) {
-        const repair = this.stmt('getContextGraphAutomaticApprovalRepair', `
-      SELECT policy_epoch, actor, agent_address
-      FROM context_graph_join_approval_ledger
-      WHERE context_graph_id = ?
-        AND request_digest = ?
-        AND state = 'reserved'
-        AND repair_pending = 1
-      ORDER BY reserved_at DESC
-      LIMIT 1
+        const repair = this.stmt('getContextGraphAutomaticApprovalRepair', `
+      SELECT policy_epoch, actor, agent_address
+      FROM context_graph_join_approval_ledger
+      WHERE context_graph_id = ?
+        AND request_digest = ?
+        AND state = 'reserved'
+        AND repair_pending = 1
+      ORDER BY reserved_at DESC
+      LIMIT 1
     `).get(contextGraphId, requestDigest);
         return repair
             ? {
@@ -1544,26 +1597,26 @@ export class DashboardDB {
     }
     commitContextGraphAutomaticApproval(input) {
         const commit = this.db.transaction(() => {
-            const reservation = this.stmt('findExactContextGraphAutomaticApprovalReservation', `
-        SELECT context_graph_id, request_digest, policy_epoch, reserved_at,
-               state, committed_at, actor, agent_address, policy_version
-        FROM context_graph_join_approval_ledger
-        WHERE context_graph_id = ?
-          AND request_digest = ?
-          AND policy_epoch = ?
-        LIMIT 1
+            const reservation = this.stmt('findExactContextGraphAutomaticApprovalReservation', `
+        SELECT context_graph_id, request_digest, policy_epoch, reserved_at,
+               state, committed_at, actor, agent_address, policy_version
+        FROM context_graph_join_approval_ledger
+        WHERE context_graph_id = ?
+          AND request_digest = ?
+          AND policy_epoch = ?
+        LIMIT 1
       `).get(input.contextGraphId, input.requestDigest, input.policyEpoch);
             if (!reservation)
                 return false;
             if (reservation.state === 'committed')
                 return true;
-            const updated = this.stmt('commitContextGraphAutomaticApprovalReservation', `
-        UPDATE context_graph_join_approval_ledger
-        SET state = 'committed', committed_at = ?, repair_pending = 0
-        WHERE context_graph_id = ?
-          AND request_digest = ?
-          AND policy_epoch = ?
-          AND state = 'reserved'
+            const updated = this.stmt('commitContextGraphAutomaticApprovalReservation', `
+        UPDATE context_graph_join_approval_ledger
+        SET state = 'committed', committed_at = ?, repair_pending = 0
+        WHERE context_graph_id = ?
+          AND request_digest = ?
+          AND policy_epoch = ?
+          AND state = 'reserved'
       `).run(input.timestamp, reservation.context_graph_id, reservation.request_digest, reservation.policy_epoch);
             if (updated.changes !== 1)
                 return false;
@@ -1587,48 +1640,48 @@ export class DashboardDB {
     }
     getContextGraphAutomaticApprovalUsage(contextGraphId, timestamp) {
         const since = timestamp - 60 * 60 * 1000;
-        const contextGraphApprovalsLastHour = Number(this.stmt('getContextGraphAutomaticApprovalUsage', `
-      SELECT COUNT(*) AS count
-      FROM context_graph_join_approval_ledger
-      WHERE context_graph_id = ?
-        AND reserved_at >= ?
+        const contextGraphApprovalsLastHour = Number(this.stmt('getContextGraphAutomaticApprovalUsage', `
+      SELECT COUNT(*) AS count
+      FROM context_graph_join_approval_ledger
+      WHERE context_graph_id = ?
+        AND reserved_at >= ?
     `).get(contextGraphId, since)?.count ?? 0);
-        const nodeApprovalsLastHour = Number(this.stmt('getNodeAutomaticApprovalUsage', `
-      SELECT COUNT(*) AS count
-      FROM context_graph_join_approval_ledger
-      WHERE reserved_at >= ?
+        const nodeApprovalsLastHour = Number(this.stmt('getNodeAutomaticApprovalUsage', `
+      SELECT COUNT(*) AS count
+      FROM context_graph_join_approval_ledger
+      WHERE reserved_at >= ?
     `).get(since)?.count ?? 0);
         return { contextGraphApprovalsLastHour, nodeApprovalsLastHour };
     }
     listContextGraphJoinPolicyAudit(contextGraphId) {
-        return this.stmt('listContextGraphJoinPolicyAudit', `
-      SELECT id, ts, context_graph_id, event_type, actor, agent_address,
-             outcome, reason, request_digest, policy_version, details
-      FROM context_graph_join_policy_audit
-      WHERE context_graph_id = ?
-      ORDER BY id ASC
+        return this.stmt('listContextGraphJoinPolicyAudit', `
+      SELECT id, ts, context_graph_id, event_type, actor, agent_address,
+             outcome, reason, request_digest, policy_version, details
+      FROM context_graph_join_policy_audit
+      WHERE context_graph_id = ?
+      ORDER BY id ASC
     `).all(contextGraphId);
     }
     contextGraphJoinPolicyKey(contextGraphId) {
         return `contextGraphJoinPolicy:${contextGraphId}`;
     }
     upsertVmReconcileNegative(record) {
-        this.stmt('upsertVmReconcileNegative', `
-      INSERT INTO vm_reconcile_negative_cache (
-        cache_key, context_graph_id, failures, next_retry_at, swm_gen,
-        candidate_namespaces, peer_topology_key, updated_at
-      ) VALUES (
-        @cache_key, @context_graph_id, @failures, @next_retry_at, @swm_gen,
-        @candidate_namespaces, @peer_topology_key, @updated_at
-      )
-      ON CONFLICT(cache_key) DO UPDATE SET
-        context_graph_id = excluded.context_graph_id,
-        failures = excluded.failures,
-        next_retry_at = excluded.next_retry_at,
-        swm_gen = excluded.swm_gen,
-        candidate_namespaces = excluded.candidate_namespaces,
-        peer_topology_key = excluded.peer_topology_key,
-        updated_at = excluded.updated_at
+        this.stmt('upsertVmReconcileNegative', `
+      INSERT INTO vm_reconcile_negative_cache (
+        cache_key, context_graph_id, failures, next_retry_at, swm_gen,
+        candidate_namespaces, peer_topology_key, updated_at
+      ) VALUES (
+        @cache_key, @context_graph_id, @failures, @next_retry_at, @swm_gen,
+        @candidate_namespaces, @peer_topology_key, @updated_at
+      )
+      ON CONFLICT(cache_key) DO UPDATE SET
+        context_graph_id = excluded.context_graph_id,
+        failures = excluded.failures,
+        next_retry_at = excluded.next_retry_at,
+        swm_gen = excluded.swm_gen,
+        candidate_namespaces = excluded.candidate_namespaces,
+        peer_topology_key = excluded.peer_topology_key,
+        updated_at = excluded.updated_at
     `).run(record);
     }
     getVmReconcileNegative(cacheKey) {
@@ -1640,6 +1693,29 @@ export class DashboardDB {
     deleteVmReconcileNegativesForContextGraph(contextGraphId) {
         this.stmt('deleteVmReconcileNegativesForContextGraph', 'DELETE FROM vm_reconcile_negative_cache WHERE context_graph_id = ?').run(contextGraphId);
     }
+    upsertSelectedVmReconcileCursor(record) {
+        this.stmt('upsertSelectedVmReconcileCursor', `
+      INSERT INTO selected_vm_reconcile_cursors (
+        deployment_id, context_graph_id, on_chain_context_graph_id,
+        name_hash, watermark, updated_at
+      ) VALUES (
+        @deployment_id, @context_graph_id, @on_chain_context_graph_id,
+        @name_hash, @watermark, @updated_at
+      )
+      ON CONFLICT(deployment_id, context_graph_id, on_chain_context_graph_id) DO UPDATE SET
+        name_hash = excluded.name_hash,
+        watermark = excluded.watermark,
+        updated_at = excluded.updated_at
+    `).run(record);
+    }
+    getSelectedVmReconcileCursor(deploymentId, contextGraphId, onChainContextGraphId) {
+        return this.stmt('getSelectedVmReconcileCursor', `
+      SELECT * FROM selected_vm_reconcile_cursors
+      WHERE deployment_id = ?
+        AND context_graph_id = ?
+        AND on_chain_context_graph_id = ?
+    `).get(deploymentId, contextGraphId, onChainContextGraphId);
+    }
     // --- Phase F: chain-driven VM reconciliation telemetry ---
     /**
      * Persist one {@link ReplicationEvent} (best-effort sink target). `ordinal`,
@@ -1647,14 +1723,14 @@ export class DashboardDB {
      * coerced defensively so a malformed event can never abort the insert.
      */
     insertReplicationEvent(ev) {
-        this.stmt('insertReplicationEvent', `
-      INSERT INTO replication_events (
-        ts, context_graph_id, on_chain_cg_id, action, ual, ordinal, ka_id,
-        from_watermark, to_watermark, head, reconciled, pending, detail
-      ) VALUES (
-        @ts, @context_graph_id, @on_chain_cg_id, @action, @ual, @ordinal, @ka_id,
-        @from_watermark, @to_watermark, @head, @reconciled, @pending, @detail
-      )
+        this.stmt('insertReplicationEvent', `
+      INSERT INTO replication_events (
+        ts, context_graph_id, on_chain_cg_id, action, ual, ordinal, ka_id,
+        from_watermark, to_watermark, head, reconciled, pending, detail
+      ) VALUES (
+        @ts, @context_graph_id, @on_chain_cg_id, @action, @ual, @ordinal, @ka_id,
+        @from_watermark, @to_watermark, @head, @reconciled, @pending, @detail
+      )
     `).run({
             ts: ev.ts,
             context_graph_id: ev.context_graph_id,
@@ -1701,15 +1777,15 @@ export class DashboardDB {
         // and inflate the reported latency. fetch/promote for one version always
         // share the same ordinal, so this pairs them exactly; a fast-path promote
         // with no fetch for its ordinal correctly contributes a 0ms latency.
-        const latencyRows = this.db.prepare(`
-      SELECT p.ts AS promote_ts,
-             (SELECT MAX(f.ts) FROM replication_events f
-                WHERE f.action = 'fetch'
-                  AND f.context_graph_id = p.context_graph_id
-                  AND f.ordinal = p.ordinal
-                  AND f.ts <= p.ts AND f.ts >= ?) AS fetch_ts
-      FROM replication_events p
-      WHERE p.action = 'promote' AND p.ts >= ? AND p.ordinal IS NOT NULL
+        const latencyRows = this.db.prepare(`
+      SELECT p.ts AS promote_ts,
+             (SELECT MAX(f.ts) FROM replication_events f
+                WHERE f.action = 'fetch'
+                  AND f.context_graph_id = p.context_graph_id
+                  AND f.ordinal = p.ordinal
+                  AND f.ts <= p.ts AND f.ts >= ?) AS fetch_ts
+      FROM replication_events p
+      WHERE p.action = 'promote' AND p.ts >= ? AND p.ordinal IS NOT NULL
     `).all(cutoff, cutoff);
         const latencies = latencyRows
             .map((r) => (r.fetch_ts != null ? r.promote_ts - r.fetch_ts : 0))
@@ -1739,20 +1815,20 @@ export class DashboardDB {
     }
     _computeReplicationPerCg(periodMs) {
         const cutoff = Date.now() - periodMs;
-        return this.db.prepare(`
-      SELECT context_graph_id,
-             on_chain_cg_id,
-             SUM(CASE WHEN action = 'promote' THEN 1 ELSE 0 END) AS promotes,
-             SUM(CASE WHEN action = 'fetch'   THEN 1 ELSE 0 END) AS fetches,
-             SUM(CASE WHEN action = 'defer'   THEN 1 ELSE 0 END) AS defers,
-             SUM(CASE WHEN action = 'cursor-advance' THEN 1 ELSE 0 END) AS cursor_advances,
-             MAX(to_watermark) AS last_watermark,
-             MAX(head) AS last_head,
-             MAX(ts) AS last_event_ts
-      FROM replication_events
-      WHERE ts >= ?
-      GROUP BY context_graph_id, on_chain_cg_id
-      ORDER BY last_event_ts DESC
+        return this.db.prepare(`
+      SELECT context_graph_id,
+             on_chain_cg_id,
+             SUM(CASE WHEN action = 'promote' THEN 1 ELSE 0 END) AS promotes,
+             SUM(CASE WHEN action = 'fetch'   THEN 1 ELSE 0 END) AS fetches,
+             SUM(CASE WHEN action = 'defer'   THEN 1 ELSE 0 END) AS defers,
+             SUM(CASE WHEN action = 'cursor-advance' THEN 1 ELSE 0 END) AS cursor_advances,
+             MAX(to_watermark) AS last_watermark,
+             MAX(head) AS last_head,
+             MAX(ts) AS last_event_ts
+      FROM replication_events
+      WHERE ts >= ?
+      GROUP BY context_graph_id, on_chain_cg_id
+      ORDER BY last_event_ts DESC
     `).all(cutoff);
     }
     /**
@@ -1771,16 +1847,16 @@ export class DashboardDB {
         const cutoff = Date.now() - opts.periodMs;
         const bucket = Math.max(1, Math.floor(opts.bucketMs));
         const where = opts.contextGraphId ? 'AND context_graph_id = @cg' : '';
-        return this.db.prepare(`
-      SELECT (ts / @bucket) * @bucket AS bucket,
-             SUM(CASE WHEN action = 'promote' THEN 1 ELSE 0 END) AS promotes,
-             SUM(CASE WHEN action = 'fetch'   THEN 1 ELSE 0 END) AS fetches,
-             SUM(CASE WHEN action = 'defer'   THEN 1 ELSE 0 END) AS defers,
-             COUNT(*) AS total
-      FROM replication_events
-      WHERE ts >= @cutoff ${where}
-      GROUP BY bucket
-      ORDER BY bucket ASC
+        return this.db.prepare(`
+      SELECT (ts / @bucket) * @bucket AS bucket,
+             SUM(CASE WHEN action = 'promote' THEN 1 ELSE 0 END) AS promotes,
+             SUM(CASE WHEN action = 'fetch'   THEN 1 ELSE 0 END) AS fetches,
+             SUM(CASE WHEN action = 'defer'   THEN 1 ELSE 0 END) AS defers,
+             COUNT(*) AS total
+      FROM replication_events
+      WHERE ts >= @cutoff ${where}
+      GROUP BY bucket
+      ORDER BY bucket ASC
     `).all({ cutoff, bucket, cg: opts.contextGraphId ?? null });
     }
     /**
@@ -1792,13 +1868,13 @@ export class DashboardDB {
         const safeLimit = Number.isFinite(limit)
             ? Math.max(1, Math.min(1000, Math.trunc(limit)))
             : 100;
-        return this.db.prepare(`
-      SELECT ts, context_graph_id, on_chain_cg_id, action, ual, ordinal, ka_id,
-             from_watermark, to_watermark, head, reconciled, pending, detail
-      FROM replication_events
-      WHERE context_graph_id = ?
-      ORDER BY ts DESC
-      LIMIT ?
+        return this.db.prepare(`
+      SELECT ts, context_graph_id, on_chain_cg_id, action, ual, ordinal, ka_id,
+             from_watermark, to_watermark, head, reconciled, pending, detail
+      FROM replication_events
+      WHERE context_graph_id = ?
+      ORDER BY ts DESC
+      LIMIT ?
     `).all(contextGraphId, safeLimit);
     }
     /**
@@ -1807,38 +1883,38 @@ export class DashboardDB {
      * on-disk truth the Replication tab's cursor inspector renders.
      */
     getReplicationCursors() {
-        return this.db.prepare(`
-      SELECT s.context_graph_id            AS context_graph_id,
-             s.on_chain_id                 AS on_chain_id,
-             s.last_reconciled_ordinal     AS last_reconciled_ordinal,
-             s.core_hosted                 AS core_hosted,
-             s.subscribed                  AS subscribed,
-             (SELECT MAX(head) FROM replication_events e
-                WHERE e.context_graph_id = s.context_graph_id) AS last_head,
-             (SELECT MAX(ts) FROM replication_events e
-                WHERE e.context_graph_id = s.context_graph_id) AS last_event_ts
-      FROM context_graph_subscriptions s
-      ORDER BY s.context_graph_id ASC
+        return this.db.prepare(`
+      SELECT s.context_graph_id            AS context_graph_id,
+             s.on_chain_id                 AS on_chain_id,
+             s.last_reconciled_ordinal     AS last_reconciled_ordinal,
+             s.core_hosted                 AS core_hosted,
+             s.subscribed                  AS subscribed,
+             (SELECT MAX(head) FROM replication_events e
+                WHERE e.context_graph_id = s.context_graph_id) AS last_head,
+             (SELECT MAX(ts) FROM replication_events e
+                WHERE e.context_graph_id = s.context_graph_id) AS last_event_ts
+      FROM context_graph_subscriptions s
+      ORDER BY s.context_graph_id ASC
     `).all();
     }
     upsertContextGraphMember(record) {
         const firstSeenAt = record.first_seen_at ?? record.updated_at;
-        this.stmt('upsertContextGraphMember', `
-      INSERT INTO context_graph_memberships (
-        context_graph_id, principal_type, principal_id, role, status, source,
-        display_name, metadata, first_seen_at, updated_at
-      ) VALUES (
-        @context_graph_id, @principal_type, @principal_id, @role, @status, @source,
-        @display_name, @metadata, @first_seen_at, @updated_at
-      )
-      ON CONFLICT(context_graph_id, principal_type, principal_id) DO UPDATE SET
-        role = excluded.role,
-        status = excluded.status,
-        source = excluded.source,
-        display_name = excluded.display_name,
-        metadata = excluded.metadata,
-        first_seen_at = context_graph_memberships.first_seen_at,
-        updated_at = excluded.updated_at
+        this.stmt('upsertContextGraphMember', `
+      INSERT INTO context_graph_memberships (
+        context_graph_id, principal_type, principal_id, role, status, source,
+        display_name, metadata, first_seen_at, updated_at
+      ) VALUES (
+        @context_graph_id, @principal_type, @principal_id, @role, @status, @source,
+        @display_name, @metadata, @first_seen_at, @updated_at
+      )
+      ON CONFLICT(context_graph_id, principal_type, principal_id) DO UPDATE SET
+        role = excluded.role,
+        status = excluded.status,
+        source = excluded.source,
+        display_name = excluded.display_name,
+        metadata = excluded.metadata,
+        first_seen_at = context_graph_memberships.first_seen_at,
+        updated_at = excluded.updated_at
     `).run({
             context_graph_id: record.context_graph_id,
             principal_type: record.principal_type,
@@ -1854,15 +1930,15 @@ export class DashboardDB {
     }
     listContextGraphMembers(contextGraphId) {
         if (contextGraphId) {
-            return this.db.prepare(`
-        SELECT * FROM context_graph_memberships
-        WHERE context_graph_id = ?
-        ORDER BY principal_type ASC, principal_id ASC
+            return this.db.prepare(`
+        SELECT * FROM context_graph_memberships
+        WHERE context_graph_id = ?
+        ORDER BY principal_type ASC, principal_id ASC
       `).all(contextGraphId);
         }
-        return this.db.prepare(`
-      SELECT * FROM context_graph_memberships
-      ORDER BY context_graph_id ASC, principal_type ASC, principal_id ASC
+        return this.db.prepare(`
+      SELECT * FROM context_graph_memberships
+      ORDER BY context_graph_id ASC, principal_type ASC, principal_id ASC
     `).all();
     }
     deleteContextGraphMember(contextGraphId, principalType, principalId) {
@@ -1874,18 +1950,18 @@ export class DashboardDB {
             return this.db.prepare('SELECT * FROM metric_snapshots WHERE ts >= ? AND ts <= ? ORDER BY ts').all(from, to);
         }
         const step = Math.ceil(total.c / maxPoints);
-        return this.db.prepare(`
-      SELECT * FROM (
-        SELECT *, ROW_NUMBER() OVER (ORDER BY ts) as rn
-        FROM metric_snapshots WHERE ts >= ? AND ts <= ?
-      ) WHERE rn % ? = 0 ORDER BY ts
+        return this.db.prepare(`
+      SELECT * FROM (
+        SELECT *, ROW_NUMBER() OVER (ORDER BY ts) as rn
+        FROM metric_snapshots WHERE ts >= ? AND ts <= ?
+      ) WHERE rn % ? = 0 ORDER BY ts
     `).all(from, to, step);
     }
     // --- Operations ---
     insertOperation(op) {
-        this.stmt('insertOp', `
-      INSERT INTO operations (operation_id, operation_name, started_at, status, peer_id, contextGraph_id, details)
-      VALUES (@operation_id, @operation_name, @started_at, 'in_progress', @peer_id, @contextGraph_id, @details)
+        this.stmt('insertOp', `
+      INSERT INTO operations (operation_id, operation_name, started_at, status, peer_id, contextGraph_id, details)
+      VALUES (@operation_id, @operation_name, @started_at, 'in_progress', @peer_id, @contextGraph_id, @details)
     `).run({
             operation_id: op.operation_id,
             operation_name: op.operation_name,
@@ -1896,10 +1972,10 @@ export class DashboardDB {
         });
     }
     completeOperation(op) {
-        this.stmt('completeOp', `
-      UPDATE operations SET status = 'success', duration_ms = @duration_ms,
-        triple_count = @triple_count, details = COALESCE(@details, details)
-      WHERE operation_id = @operation_id AND status = 'in_progress'
+        this.stmt('completeOp', `
+      UPDATE operations SET status = 'success', duration_ms = @duration_ms,
+        triple_count = @triple_count, details = COALESCE(@details, details)
+      WHERE operation_id = @operation_id AND status = 'in_progress'
     `).run({
             operation_id: op.operation_id,
             duration_ms: op.duration_ms,
@@ -1914,10 +1990,10 @@ export class DashboardDB {
         this.finishOperation({ ...op, status: 'cancelled' });
     }
     finishOperation(op) {
-        this.stmt('finishOperation', `
-      UPDATE operations SET status = @status, duration_ms = @duration_ms,
-        error_message = @error_message
-      WHERE operation_id = @operation_id AND status = 'in_progress'
+        this.stmt('finishOperation', `
+      UPDATE operations SET status = @status, duration_ms = @duration_ms,
+        error_message = @error_message
+      WHERE operation_id = @operation_id AND status = 'in_progress'
     `).run(op);
     }
     getOperations(opts = {}) {
@@ -1974,22 +2050,22 @@ export class DashboardDB {
     }
     getErrorHotspots(periodMs = 7 * 86_400_000) {
         const cutoff = Date.now() - periodMs;
-        return this.db.prepare(`
-      SELECT
-        p.phase,
-        o.operation_name,
-        COUNT(*) as error_count,
-        (SELECT p2.details FROM operation_phases p2
-         JOIN operations o2 ON o2.operation_id = p2.operation_id
-         WHERE p2.phase = p.phase AND o2.operation_name = o.operation_name
-           AND p2.status = 'error' AND p2.started_at >= ?
-         ORDER BY p2.started_at DESC LIMIT 1) as last_error,
-        MAX(p.started_at) as last_occurred
-      FROM operation_phases p
-      JOIN operations o ON o.operation_id = p.operation_id
-      WHERE p.status = 'error' AND p.started_at >= ?
-      GROUP BY p.phase, o.operation_name
-      ORDER BY error_count DESC
+        return this.db.prepare(`
+      SELECT
+        p.phase,
+        o.operation_name,
+        COUNT(*) as error_count,
+        (SELECT p2.details FROM operation_phases p2
+         JOIN operations o2 ON o2.operation_id = p2.operation_id
+         WHERE p2.phase = p.phase AND o2.operation_name = o.operation_name
+           AND p2.status = 'error' AND p2.started_at >= ?
+         ORDER BY p2.started_at DESC LIMIT 1) as last_error,
+        MAX(p.started_at) as last_occurred
+      FROM operation_phases p
+      JOIN operations o ON o.operation_id = p.operation_id
+      WHERE p.status = 'error' AND p.started_at >= ?
+      GROUP BY p.phase, o.operation_name
+      ORDER BY error_count DESC
     `).all(cutoff, cutoff);
     }
     getFailedOperations(opts = {}) {
@@ -2011,17 +2087,17 @@ export class DashboardDB {
             params.push(like, like, like);
         }
         params.push(limit);
-        const rows = this.db.prepare(`
-      SELECT
-        o.*,
-        p.phase AS phase,
-        p.details AS phase_error,
-        p.started_at AS phase_started_at
-      FROM operation_phases p
-      JOIN operations o ON o.operation_id = p.operation_id
-      WHERE ${where}
-      ORDER BY p.started_at DESC
-      LIMIT ?
+        const rows = this.db.prepare(`
+      SELECT
+        o.*,
+        p.phase AS phase,
+        p.details AS phase_error,
+        p.started_at AS phase_started_at
+      FROM operation_phases p
+      JOIN operations o ON o.operation_id = p.operation_id
+      WHERE ${where}
+      ORDER BY p.started_at DESC
+      LIMIT ?
     `).all(...params);
         const operations = rows.map(row => {
             const logs = this.db.prepare('SELECT * FROM logs WHERE operation_id = ? ORDER BY ts DESC LIMIT 20').all(row.operation_id);
@@ -2038,15 +2114,15 @@ export class DashboardDB {
     }
     // --- Operation phases ---
     insertPhase(op) {
-        this.stmt('insertPhase', `
-      INSERT INTO operation_phases (operation_id, phase, started_at, status)
-      VALUES (@operation_id, @phase, @started_at, 'in_progress')
+        this.stmt('insertPhase', `
+      INSERT INTO operation_phases (operation_id, phase, started_at, status)
+      VALUES (@operation_id, @phase, @started_at, 'in_progress')
     `).run(op);
     }
     completePhase(op) {
-        this.stmt('completePhase', `
-      UPDATE operation_phases SET status = 'success', duration_ms = @duration_ms
-      WHERE operation_id = @operation_id AND phase = @phase AND status = 'in_progress'
+        this.stmt('completePhase', `
+      UPDATE operation_phases SET status = 'success', duration_ms = @duration_ms
+      WHERE operation_id = @operation_id AND phase = @phase AND status = 'in_progress'
     `).run(op);
     }
     failPhase(op) {
@@ -2056,30 +2132,30 @@ export class DashboardDB {
         this.finishPhase({ ...op, status: 'cancelled' });
     }
     finishPhase(op) {
-        this.stmt('finishPhase', `
-      UPDATE operation_phases SET status = @status, duration_ms = @duration_ms,
-        details = @error_message
-      WHERE operation_id = @operation_id AND phase = @phase AND status = 'in_progress'
+        this.stmt('finishPhase', `
+      UPDATE operation_phases SET status = @status, duration_ms = @duration_ms,
+        details = @error_message
+      WHERE operation_id = @operation_id AND phase = @phase AND status = 'in_progress'
     `).run(op);
     }
     failAllPhases(op) {
-        this.stmt('failAllPhases', `
-      UPDATE operation_phases SET status = 'error', duration_ms = @duration_ms,
-        details = @error_message
-      WHERE operation_id = @operation_id AND status = 'in_progress'
+        this.stmt('failAllPhases', `
+      UPDATE operation_phases SET status = 'error', duration_ms = @duration_ms,
+        details = @error_message
+      WHERE operation_id = @operation_id AND status = 'in_progress'
     `).run(op);
     }
     // --- Operation cost & tx ---
     setOperationCost(op) {
-        this.stmt('setCost', `
-      UPDATE operations SET
-        gas_used = COALESCE(@gas_used, gas_used),
-        gas_price_gwei = COALESCE(@gas_price_gwei, gas_price_gwei),
-        gas_cost_eth = COALESCE(@gas_cost_eth, gas_cost_eth),
-        trac_cost = COALESCE(@trac_cost, trac_cost),
-        tx_hash = COALESCE(@tx_hash, tx_hash),
-        chain_id = COALESCE(@chain_id, chain_id)
-      WHERE operation_id = @operation_id
+        this.stmt('setCost', `
+      UPDATE operations SET
+        gas_used = COALESCE(@gas_used, gas_used),
+        gas_price_gwei = COALESCE(@gas_price_gwei, gas_price_gwei),
+        gas_cost_eth = COALESCE(@gas_cost_eth, gas_cost_eth),
+        trac_cost = COALESCE(@trac_cost, trac_cost),
+        tx_hash = COALESCE(@tx_hash, tx_hash),
+        chain_id = COALESCE(@chain_id, chain_id)
+      WHERE operation_id = @operation_id
     `).run({
             operation_id: op.operation_id,
             gas_used: op.gas_used ?? null,
@@ -2097,18 +2173,18 @@ export class DashboardDB {
         const params = [cutoff];
         if (opts.name)
             params.push(opts.name);
-        const summaryRow = this.db.prepare(`
-      SELECT
-        COUNT(*) as totalCount,
-        SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as successCount,
-        SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END) as errorCount,
-        SUM(CASE WHEN status IN ('success', 'error') THEN 1 ELSE 0 END) as healthCount,
-        AVG(CASE WHEN status = 'success' THEN duration_ms END) as avgDurationMs,
-        AVG(gas_cost_eth) as avgGasCostEth,
-        SUM(gas_cost_eth) as totalGasCostEth,
-        AVG(trac_cost) as avgTracCost,
-        SUM(trac_cost) as totalTracCost
-      FROM operations WHERE started_at >= ? ${nameFilter}
+        const summaryRow = this.db.prepare(`
+      SELECT
+        COUNT(*) as totalCount,
+        SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as successCount,
+        SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END) as errorCount,
+        SUM(CASE WHEN status IN ('success', 'error') THEN 1 ELSE 0 END) as healthCount,
+        AVG(CASE WHEN status = 'success' THEN duration_ms END) as avgDurationMs,
+        AVG(gas_cost_eth) as avgGasCostEth,
+        SUM(gas_cost_eth) as totalGasCostEth,
+        AVG(trac_cost) as avgTracCost,
+        SUM(trac_cost) as totalTracCost
+      FROM operations WHERE started_at >= ? ${nameFilter}
     `).get(...params);
         const summary = {
             totalCount: summaryRow.totalCount ?? 0,
@@ -2127,18 +2203,18 @@ export class DashboardDB {
         const tsParams = [bucketSize, cutoff];
         if (opts.name)
             tsParams.push(opts.name);
-        const timeSeries = this.db.prepare(`
-      SELECT
-        (CAST(started_at / ? AS INTEGER) * ?) as bucket,
-        COUNT(*) as count,
-        SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as successCount,
-        SUM(CASE WHEN status IN ('success', 'error') THEN 1 ELSE 0 END) as healthCount,
-        AVG(CASE WHEN status = 'success' THEN duration_ms END) as avgDurationMs,
-        AVG(gas_cost_eth) as avgGasCostEth,
-        SUM(gas_cost_eth) as totalGasCostEth
-      FROM operations
-      WHERE started_at >= ? ${nameFilter}
-      GROUP BY bucket ORDER BY bucket
+        const timeSeries = this.db.prepare(`
+      SELECT
+        (CAST(started_at / ? AS INTEGER) * ?) as bucket,
+        COUNT(*) as count,
+        SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as successCount,
+        SUM(CASE WHEN status IN ('success', 'error') THEN 1 ELSE 0 END) as healthCount,
+        AVG(CASE WHEN status = 'success' THEN duration_ms END) as avgDurationMs,
+        AVG(gas_cost_eth) as avgGasCostEth,
+        SUM(gas_cost_eth) as totalGasCostEth
+      FROM operations
+      WHERE started_at >= ? ${nameFilter}
+      GROUP BY bucket ORDER BY bucket
     `).all(bucketSize, bucketSize, ...params);
         return {
             summary,
@@ -2155,17 +2231,17 @@ export class DashboardDB {
     // --- Per-type time series ---
     getPerTypeTimeSeries(opts) {
         const cutoff = Date.now() - opts.periodMs;
-        const rows = this.db.prepare(`
-      SELECT
-        (CAST(started_at / ? AS INTEGER) * ?) as bucket,
-        operation_name as type,
-        COUNT(*) as count,
-        AVG(CASE WHEN status = 'success' THEN duration_ms END) as avgMs,
-        SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as successCount,
-        SUM(CASE WHEN status IN ('success', 'error') THEN 1 ELSE 0 END) as healthCount,
-        SUM(gas_cost_eth) as gasCostEth
-      FROM operations WHERE started_at >= ?
-      GROUP BY bucket, operation_name ORDER BY bucket
+        const rows = this.db.prepare(`
+      SELECT
+        (CAST(started_at / ? AS INTEGER) * ?) as bucket,
+        operation_name as type,
+        COUNT(*) as count,
+        AVG(CASE WHEN status = 'success' THEN duration_ms END) as avgMs,
+        SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as successCount,
+        SUM(CASE WHEN status IN ('success', 'error') THEN 1 ELSE 0 END) as healthCount,
+        SUM(gas_cost_eth) as gasCostEth
+      FROM operations WHERE started_at >= ?
+      GROUP BY bucket, operation_name ORDER BY bucket
     `).all(opts.bucketMs, opts.bucketMs, cutoff);
         const bucketSet = new Set();
         const typeSet = new Set();
@@ -2195,15 +2271,15 @@ export class DashboardDB {
     // --- Success rates by operation type ---
     getSuccessRatesByType(periodMs) {
         const cutoff = Date.now() - periodMs;
-        return this.db.prepare(`
-      SELECT
-        operation_name as type,
-        COUNT(*) as total,
-        SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as success,
-        SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END) as error,
-        AVG(CASE WHEN status = 'success' THEN duration_ms END) as avgMs
-      FROM operations WHERE started_at >= ?
-      GROUP BY operation_name ORDER BY total DESC
+        return this.db.prepare(`
+      SELECT
+        operation_name as type,
+        COUNT(*) as total,
+        SUM(CASE WHEN status = 'success' THEN 1 ELSE 0 END) as success,
+        SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END) as error,
+        AVG(CASE WHEN status = 'success' THEN duration_ms END) as avgMs
+      FROM operations WHERE started_at >= ?
+      GROUP BY operation_name ORDER BY total DESC
     `).all(cutoff).map(r => ({
             ...r,
             rate: r.success + r.error > 0 ? r.success / (r.success + r.error) : 0,
@@ -2226,16 +2302,16 @@ export class DashboardDB {
             // on-chain (Verifiable Memory commits) are counted, so the publish
             // count and the TRAC total are consistent. Free SWM/local/testnet
             // publishes record trac_cost = 0 and are intentionally excluded.
-            const row = this.db.prepare(`
-        SELECT
-          SUM(CASE WHEN trac_cost > 0 THEN 1 ELSE 0 END) as publishCount,
-          SUM(CASE WHEN status = 'success' AND trac_cost > 0 THEN 1 ELSE 0 END) as successCount,
-          COALESCE(SUM(gas_cost_eth), 0) as totalGasEth,
-          COALESCE(SUM(trac_cost), 0) as totalTrac,
-          COALESCE(AVG(CASE WHEN trac_cost > 0 THEN gas_cost_eth END), 0) as avgGasEth,
-          COALESCE(AVG(CASE WHEN trac_cost > 0 THEN trac_cost END), 0) as avgTrac
-        FROM operations
-        WHERE operation_name = 'publish' AND trac_cost > 0 AND started_at >= ?
+            const row = this.db.prepare(`
+        SELECT
+          SUM(CASE WHEN trac_cost > 0 THEN 1 ELSE 0 END) as publishCount,
+          SUM(CASE WHEN status = 'success' AND trac_cost > 0 THEN 1 ELSE 0 END) as successCount,
+          COALESCE(SUM(gas_cost_eth), 0) as totalGasEth,
+          COALESCE(SUM(trac_cost), 0) as totalTrac,
+          COALESCE(AVG(CASE WHEN trac_cost > 0 THEN gas_cost_eth END), 0) as avgGasEth,
+          COALESCE(AVG(CASE WHEN trac_cost > 0 THEN trac_cost END), 0) as avgTrac
+        FROM operations
+        WHERE operation_name = 'publish' AND trac_cost > 0 AND started_at >= ?
       `).get(cutoff);
             results.periods.push({
                 label: p.label,
@@ -2270,9 +2346,9 @@ export class DashboardDB {
      * still throw — pinned by db.test.ts.
      */
     insertChatMessage(msg) {
-        const info = this.stmt('insertChat', `
-      INSERT INTO chat_messages (ts, direction, peer, peer_name, text, delivered, message_id)
-      VALUES (@ts, @direction, @peer, @peer_name, @text, @delivered, @message_id)
+        const info = this.stmt('insertChat', `
+      INSERT INTO chat_messages (ts, direction, peer, peer_name, text, delivered, message_id)
+      VALUES (@ts, @direction, @peer, @peer_name, @text, @delivered, @message_id)
     `).run({
             ts: msg.ts,
             direction: msg.direction,
@@ -2363,16 +2439,16 @@ export class DashboardDB {
         return this.db.prepare('SELECT * FROM chat_persistence_jobs WHERE turn_id = ?').get(turnId);
     }
     insertChatPersistenceJob(job) {
-        this.stmt('insertChatPersistenceJob', `
-      INSERT INTO chat_persistence_jobs (
-        turn_id, session_id, user_message, assistant_reply, tool_calls_json,
-        status, attempts, max_attempts, next_attempt_at, queued_at, updated_at,
-        store_ms, error_message
-      ) VALUES (
-        @turn_id, @session_id, @user_message, @assistant_reply, @tool_calls_json,
-        @status, @attempts, @max_attempts, @next_attempt_at, @queued_at, @updated_at,
-        @store_ms, @error_message
-      )
+        this.stmt('insertChatPersistenceJob', `
+      INSERT INTO chat_persistence_jobs (
+        turn_id, session_id, user_message, assistant_reply, tool_calls_json,
+        status, attempts, max_attempts, next_attempt_at, queued_at, updated_at,
+        store_ms, error_message
+      ) VALUES (
+        @turn_id, @session_id, @user_message, @assistant_reply, @tool_calls_json,
+        @status, @attempts, @max_attempts, @next_attempt_at, @queued_at, @updated_at,
+        @store_ms, @error_message
+      )
     `).run({
             ...job,
             tool_calls_json: job.tool_calls_json ?? null,
@@ -2381,46 +2457,46 @@ export class DashboardDB {
         });
     }
     markChatPersistenceInProgress(turnId, attempts, updatedAt) {
-        this.stmt('markChatPersistenceInProgress', `
-      UPDATE chat_persistence_jobs
-      SET status = 'in_progress', attempts = ?, updated_at = ?, error_message = NULL
-      WHERE turn_id = ?
+        this.stmt('markChatPersistenceInProgress', `
+      UPDATE chat_persistence_jobs
+      SET status = 'in_progress', attempts = ?, updated_at = ?, error_message = NULL
+      WHERE turn_id = ?
     `).run(attempts, updatedAt, turnId);
     }
     markChatPersistenceStored(turnId, storeMs, updatedAt) {
-        this.stmt('markChatPersistenceStored', `
-      UPDATE chat_persistence_jobs
-      SET status = 'stored', store_ms = ?, updated_at = ?, error_message = NULL
-      WHERE turn_id = ?
+        this.stmt('markChatPersistenceStored', `
+      UPDATE chat_persistence_jobs
+      SET status = 'stored', store_ms = ?, updated_at = ?, error_message = NULL
+      WHERE turn_id = ?
     `).run(storeMs, updatedAt, turnId);
     }
     markChatPersistencePendingRetry(turnId, attempts, nextAttemptAt, updatedAt, errorMessage) {
-        this.stmt('markChatPersistencePendingRetry', `
-      UPDATE chat_persistence_jobs
-      SET status = 'pending', attempts = ?, next_attempt_at = ?, updated_at = ?, error_message = ?
-      WHERE turn_id = ?
+        this.stmt('markChatPersistencePendingRetry', `
+      UPDATE chat_persistence_jobs
+      SET status = 'pending', attempts = ?, next_attempt_at = ?, updated_at = ?, error_message = ?
+      WHERE turn_id = ?
     `).run(attempts, nextAttemptAt, updatedAt, errorMessage, turnId);
     }
     markChatPersistenceFailed(turnId, attempts, updatedAt, errorMessage) {
-        this.stmt('markChatPersistenceFailed', `
-      UPDATE chat_persistence_jobs
-      SET status = 'failed', attempts = ?, updated_at = ?, error_message = ?
-      WHERE turn_id = ?
+        this.stmt('markChatPersistenceFailed', `
+      UPDATE chat_persistence_jobs
+      SET status = 'failed', attempts = ?, updated_at = ?, error_message = ?
+      WHERE turn_id = ?
     `).run(attempts, updatedAt, errorMessage, turnId);
     }
     recoverInProgressChatPersistenceJobs(now) {
-        this.stmt('recoverInProgressChatPersistenceJobs', `
-      UPDATE chat_persistence_jobs
-      SET status = 'pending', next_attempt_at = ?, updated_at = ?
-      WHERE status = 'in_progress'
+        this.stmt('recoverInProgressChatPersistenceJobs', `
+      UPDATE chat_persistence_jobs
+      SET status = 'pending', next_attempt_at = ?, updated_at = ?
+      WHERE status = 'in_progress'
     `).run(now, now);
     }
     getRunnableChatPersistenceJobs(now, limit = 10) {
-        return this.db.prepare(`
-      SELECT * FROM chat_persistence_jobs
-      WHERE status = 'pending' AND next_attempt_at <= ?
-      ORDER BY next_attempt_at ASC, queued_at ASC
-      LIMIT ?
+        return this.db.prepare(`
+      SELECT * FROM chat_persistence_jobs
+      WHERE status = 'pending' AND next_attempt_at <= ?
+      ORDER BY next_attempt_at ASC, queued_at ASC
+      LIMIT ?
     `).all(now, limit);
     }
     getNextPendingChatPersistenceAt() {
@@ -2428,19 +2504,19 @@ export class DashboardDB {
         return row?.next_at ?? null;
     }
     getChatPersistenceHealth(now) {
-        const counts = this.db.prepare(`
-      SELECT
-        SUM(CASE WHEN status = 'pending' THEN 1 ELSE 0 END) AS pending_count,
-        SUM(CASE WHEN status = 'in_progress' THEN 1 ELSE 0 END) AS in_progress_count,
-        SUM(CASE WHEN status = 'stored' THEN 1 ELSE 0 END) AS stored_count,
-        SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) AS failed_count,
-        SUM(CASE WHEN status = 'pending' AND next_attempt_at < ? THEN 1 ELSE 0 END) AS overdue_pending_count
-      FROM chat_persistence_jobs
+        const counts = this.db.prepare(`
+      SELECT
+        SUM(CASE WHEN status = 'pending' THEN 1 ELSE 0 END) AS pending_count,
+        SUM(CASE WHEN status = 'in_progress' THEN 1 ELSE 0 END) AS in_progress_count,
+        SUM(CASE WHEN status = 'stored' THEN 1 ELSE 0 END) AS stored_count,
+        SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) AS failed_count,
+        SUM(CASE WHEN status = 'pending' AND next_attempt_at < ? THEN 1 ELSE 0 END) AS overdue_pending_count
+      FROM chat_persistence_jobs
     `).get(now);
-        const oldest = this.db.prepare(`
-      SELECT MIN(queued_at) AS oldest_pending_queued_at
-      FROM chat_persistence_jobs
-      WHERE status = 'pending'
+        const oldest = this.db.prepare(`
+      SELECT MIN(queued_at) AS oldest_pending_queued_at
+      FROM chat_persistence_jobs
+      WHERE status = 'pending'
     `).get();
         return {
             pending_count: counts?.pending_count ?? 0,
@@ -2453,9 +2529,9 @@ export class DashboardDB {
     }
     // --- Logs ---
     insertLog(entry) {
-        this.stmt('insertLog', `
-      INSERT INTO logs (ts, level, operation_name, operation_id, module, message)
-      VALUES (@ts, @level, @operation_name, @operation_id, @module, @message)
+        this.stmt('insertLog', `
+      INSERT INTO logs (ts, level, operation_name, operation_id, module, message)
+      VALUES (@ts, @level, @operation_name, @operation_id, @module, @message)
     `).run({
             ts: entry.ts,
             level: entry.level,
@@ -2510,9 +2586,9 @@ export class DashboardDB {
     }
     // --- Query history ---
     insertQueryHistory(entry) {
-        this.stmt('insertQueryHistory', `
-      INSERT INTO query_history (ts, sparql, duration_ms, result_count, error)
-      VALUES (@ts, @sparql, @duration_ms, @result_count, @error)
+        this.stmt('insertQueryHistory', `
+      INSERT INTO query_history (ts, sparql, duration_ms, result_count, error)
+      VALUES (@ts, @sparql, @duration_ms, @result_count, @error)
     `).run({
             ts: Date.now(),
             sparql: entry.sparql,
@@ -2556,9 +2632,9 @@ export class DashboardDB {
     }
     // --- Notifications ---
     insertNotification(n) {
-        const result = this.stmt('insertNotif', `
-      INSERT INTO notifications (ts, type, title, message, source, peer, read, meta, context_graph_id)
-      VALUES (@ts, @type, @title, @message, @source, @peer, 0, @meta, @contextGraphId)
+        const result = this.stmt('insertNotif', `
+      INSERT INTO notifications (ts, type, title, message, source, peer, read, meta, context_graph_id)
+      VALUES (@ts, @type, @title, @message, @source, @peer, 0, @meta, @contextGraphId)
     `).run({
             ts: n.ts,
             type: n.type,
@@ -2594,8 +2670,8 @@ export class DashboardDB {
         if (cgIds.length === 0)
             return [];
         const placeholders = cgIds.map(() => '?').join(',');
-        return this.db.prepare(`SELECT * FROM notifications
-        WHERE context_graph_id IN (${placeholders})
+        return this.db.prepare(`SELECT * FROM notifications
+        WHERE context_graph_id IN (${placeholders})
         ORDER BY ts DESC LIMIT ?`).all(...cgIds, limit);
     }
     /**
@@ -2626,8 +2702,8 @@ export class DashboardDB {
         if (types.length === 0)
             return [];
         const placeholders = types.map(() => '?').join(',');
-        return this.db.prepare(`SELECT * FROM notifications
-        WHERE type IN (${placeholders})
+        return this.db.prepare(`SELECT * FROM notifications
+        WHERE type IN (${placeholders})
         ORDER BY ts DESC LIMIT ?`).all(...types, limit);
     }
     /**
@@ -2647,9 +2723,9 @@ export class DashboardDB {
         const wallet = walletAddress.trim().toLowerCase();
         if (!wallet)
             return [];
-        return this.db.prepare(`SELECT * FROM notifications
-        WHERE type = 'pca_cost_covered'
-          AND lower(json_extract(meta, '$.publisherAddress')) = ?
+        return this.db.prepare(`SELECT * FROM notifications
+        WHERE type = 'pca_cost_covered'
+          AND lower(json_extract(meta, '$.publisherAddress')) = ?
         ORDER BY ts DESC LIMIT ?`).all(wallet, limit);
     }
     markNotificationsRead(ids) {
@@ -2679,10 +2755,10 @@ export class DashboardDB {
             return [];
         const windowStart = parsed.windowBucket * ACTIVITY_DIGEST_WINDOW_MS;
         const windowEnd = windowStart + ACTIVITY_DIGEST_WINDOW_MS;
-        const rows = this.db.prepare(`SELECT id FROM notifications
-        WHERE context_graph_id = ?
-          AND type = ?
-          AND ts >= ? AND ts < ?
+        const rows = this.db.prepare(`SELECT id FROM notifications
+        WHERE context_graph_id = ?
+          AND type = ?
+          AND ts >= ? AND ts < ?
           AND json_extract(meta, '$.kind') = ?`).all(parsed.contextGraphId, ASSERTION_ACTIVITY_TYPE, windowStart, windowEnd, parsed.kind);
         return rows.map((r) => r.id);
     }
@@ -2691,7 +2767,6 @@ export class DashboardDB {
     }
 }
 // --- Sync requester checkpoints (issue #1138 A3) ---
-const DEFAULT_SYNC_CHECKPOINT_TTL_MS = 24 * 60 * 60 * 1000;
 export class SqliteSyncCheckpointStore {
     db;
     clock;
@@ -2701,73 +2776,128 @@ export class SqliteSyncCheckpointStore {
         this.clock = options.clock ?? (() => Date.now());
         this.ttlMs = options.ttlMs ?? DEFAULT_SYNC_CHECKPOINT_TTL_MS;
     }
-    get(key) {
-        const now = this.clock();
-        const row = this.db.prepare(`SELECT offset, updated_at, expires_at,
-              responder_session_id, responder_session_expires_at
+    readRow(key) {
+        const row = this.db.prepare(`SELECT offset, updated_at, expires_at,
+              responder_session_id, responder_session_expires_at, responder_session_offset,
+              manifest_digest, manifest_prefix_digest, terminal
          FROM sync_checkpoints WHERE key = ?`).get(key);
         if (!row)
             return undefined;
-        if (row.expires_at < now) {
-            this.delete(key);
-            return undefined;
-        }
-        const hasFreshResponderSession = Boolean(row.responder_session_id)
-            && Number.isSafeInteger(row.responder_session_expires_at)
-            && (row.responder_session_expires_at ?? 0) > now;
-        if (row.responder_session_id && !hasFreshResponderSession) {
-            this.clearResponderSession(key);
-        }
         return {
             offset: row.offset,
             updatedAtMs: row.updated_at,
             expiresAtMs: row.expires_at,
-            ...(hasFreshResponderSession
-                ? {
-                    responderSessionId: row.responder_session_id,
-                    responderSessionExpiresAtMs: row.responder_session_expires_at,
-                }
+            ...(row.terminal === 1 ? { terminal: true } : {}),
+            ...(row.manifest_digest ? { manifestDigest: row.manifest_digest } : {}),
+            ...(row.manifest_prefix_digest
+                ? { manifestPrefixDigest: row.manifest_prefix_digest }
+                : {}),
+            // Preserve each nullable session column independently so the shared
+            // validator can distinguish an absent session from a torn/malformed
+            // persisted session. Collapsing a partial row to no session fields would
+            // turn corrupt durable state into an apparently valid ordinary offset.
+            ...(row.responder_session_id !== null
+                ? { responderSessionId: row.responder_session_id }
+                : {}),
+            ...(row.responder_session_expires_at !== null
+                ? { responderSessionExpiresAtMs: row.responder_session_expires_at }
+                : {}),
+            ...(row.responder_session_offset !== null
+                ? { responderSessionOffset: row.responder_session_offset }
                 : {}),
         };
     }
-    set(key, value, nowMs = this.clock()) {
-        if (!Number.isSafeInteger(value) || value < 0) {
-            throw new Error(`Invalid sync checkpoint offset for ${key}: ${value}`);
+    get(key, now = this.clock()) {
+        const entry = this.readRow(key);
+        if (!entry)
+            return undefined;
+        if (!isValidSyncCheckpointEntry(entry) || entry.expiresAtMs < now) {
+            this.delete(key);
+            return undefined;
         }
-        this.db.prepare(`
-      INSERT INTO sync_checkpoints (key, offset, updated_at, expires_at)
-      VALUES (?, ?, ?, ?)
-      ON CONFLICT(key) DO UPDATE SET
-        offset = excluded.offset,
-        updated_at = excluded.updated_at,
-        expires_at = excluded.expires_at
-    `).run(key, value, nowMs, nowMs + this.ttlMs);
+        if (entry.responderSessionId
+            && (entry.responderSessionExpiresAtMs ?? 0) <= now) {
+            const withoutExpiredSession = withoutSyncCheckpointResponderSession(entry);
+            this.writeEntry(key, withoutExpiredSession);
+            return withoutExpiredSession;
+        }
+        return entry;
+    }
+    writeEntry(key, entry) {
+        this.db.prepare(`
+      INSERT INTO sync_checkpoints (
+        key, offset, updated_at, expires_at,
+        responder_session_id, responder_session_expires_at, responder_session_offset,
+        manifest_digest, manifest_prefix_digest, terminal
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(key) DO UPDATE SET
+        offset = excluded.offset,
+        updated_at = excluded.updated_at,
+        expires_at = excluded.expires_at,
+        responder_session_id = excluded.responder_session_id,
+        responder_session_expires_at = excluded.responder_session_expires_at,
+        responder_session_offset = excluded.responder_session_offset,
+        manifest_digest = excluded.manifest_digest,
+        manifest_prefix_digest = excluded.manifest_prefix_digest,
+        terminal = excluded.terminal
+    `).run(key, entry.offset, entry.updatedAtMs, entry.expiresAtMs, entry.responderSessionId ?? null, entry.responderSessionExpiresAtMs ?? null, entry.responderSessionOffset ?? null, entry.manifestDigest ?? null, entry.manifestPrefixDigest ?? null, entry.terminal ? 1 : 0);
+    }
+    set(key, value, nowMs = this.clock(), responderSessionOffset) {
+        const transition = this.db.transaction(() => {
+            this.writeEntry(key, transitionSyncCheckpointOffset({
+                key,
+                existing: this.get(key, nowMs),
+                value,
+                nowMs,
+                ttlMs: this.ttlMs,
+                responderSessionOffset,
+            }));
+        });
+        transition();
     }
-    setResponderSession(key, sessionId, expiresAtMs, nowMs = this.clock()) {
-        if (!sessionId || !Number.isSafeInteger(expiresAtMs)) {
-            throw new Error(`Invalid sync responder session for ${key}`);
-        }
+    setManifestBoundOffset(key, value, manifestDigest, nowMs = this.clock(), manifestPrefixDigest, terminal = false, responderSessionOffset) {
+        const transition = this.db.transaction(() => {
+            this.writeEntry(key, transitionSyncCheckpointManifestOffset({
+                key,
+                existing: this.get(key, nowMs),
+                value,
+                manifestDigest,
+                nowMs,
+                ttlMs: this.ttlMs,
+                manifestPrefixDigest,
+                terminal,
+                responderSessionOffset,
+            }));
+        });
+        transition();
+    }
+    setResponderSession(key, sessionId, expiresAtMs, nowMs = this.clock(), manifestDigest, manifestPrefixDigest, responderSessionOffset) {
         if (expiresAtMs <= nowMs) {
             this.clearResponderSession(key);
             return;
         }
-        this.db.prepare(`
-      INSERT INTO sync_checkpoints (
-        key, offset, updated_at, expires_at,
-        responder_session_id, responder_session_expires_at
-      ) VALUES (?, 0, ?, ?, ?, ?)
-      ON CONFLICT(key) DO UPDATE SET
-        responder_session_id = excluded.responder_session_id,
-        responder_session_expires_at = excluded.responder_session_expires_at
-    `).run(key, nowMs, nowMs + this.ttlMs, sessionId, expiresAtMs);
+        const transition = this.db.transaction(() => {
+            this.writeEntry(key, transitionSyncCheckpointResponderSession({
+                key,
+                existing: this.get(key, nowMs),
+                sessionId,
+                expiresAtMs,
+                nowMs,
+                ttlMs: this.ttlMs,
+                manifestDigest,
+                manifestPrefixDigest,
+                responderSessionOffset,
+            }));
+        });
+        transition();
     }
     clearResponderSession(key) {
-        this.db.prepare(`
-      UPDATE sync_checkpoints
-         SET responder_session_id = NULL,
-             responder_session_expires_at = NULL
-       WHERE key = ?
-    `).run(key);
+        const transition = this.db.transaction(() => {
+            const existing = this.readRow(key);
+            if (existing)
+                this.writeEntry(key, withoutSyncCheckpointResponderSession(existing));
+        });
+        transition();
     }
     delete(key) {
         this.db.prepare(`DELETE FROM sync_checkpoints WHERE key = ?`).run(key);
@@ -2800,13 +2930,13 @@ export class SqliteChangelogCursorStore {
         if (!Number.isSafeInteger(seq) || seq < 0) {
             throw new Error(`Invalid changelog cursor seq for ${peerId}/${contextGraphId}: ${seq}`);
         }
-        this.db.prepare(`
-      INSERT INTO changelog_cursors (peer_id, context_graph_id, era, seq, updated_at)
-      VALUES (?, ?, ?, ?, ?)
-      ON CONFLICT(peer_id, context_graph_id) DO UPDATE SET
-        era = excluded.era,
-        seq = excluded.seq,
-        updated_at = excluded.updated_at
+        this.db.prepare(`
+      INSERT INTO changelog_cursors (peer_id, context_graph_id, era, seq, updated_at)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(peer_id, context_graph_id) DO UPDATE SET
+        era = excluded.era,
+        seq = excluded.seq,
+        updated_at = excluded.updated_at
     `).run(peerId, contextGraphId, era, seq, nowMs);
     }
 }
@@ -2834,13 +2964,13 @@ export class SqliteChangelogEraGuard {
         if (!Number.isSafeInteger(highSeq) || highSeq < 0) {
             throw new Error(`Invalid changelog era high_seq: ${highSeq}`);
         }
-        this.db.prepare(`
-      INSERT INTO changelog_era (id, era, high_seq, updated_at)
-      VALUES (1, ?, ?, ?)
-      ON CONFLICT(id) DO UPDATE SET
-        era = excluded.era,
-        high_seq = excluded.high_seq,
-        updated_at = excluded.updated_at
+        this.db.prepare(`
+      INSERT INTO changelog_era (id, era, high_seq, updated_at)
+      VALUES (1, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        era = excluded.era,
+        high_seq = excluded.high_seq,
+        updated_at = excluded.updated_at
     `).run(era, highSeq, this.clock());
     }
 }
@@ -2874,7 +3004,7 @@ export class SqliteMessageIdempotencyStore {
     }
     check(peer, protocol, messageId, direction) {
         const row = this.db
-            .prepare(`SELECT response_blob FROM message_idempotency
+            .prepare(`SELECT response_blob FROM message_idempotency
          WHERE peer_id = ? AND protocol = ? AND message_id = ? AND direction = ?`)
             .get(peer, protocol, messageId, direction);
         if (!row)
@@ -2904,9 +3034,9 @@ export class SqliteMessageIdempotencyStore {
         // SqliteError so the substrate's bug doesn't disguise itself as
         // a normal duplicate.
         this.db
-            .prepare(`INSERT INTO message_idempotency
-           (peer_id, protocol, message_id, direction, response_blob, response_size, ts)
-         VALUES (?, ?, ?, ?, ?, ?, ?)
+            .prepare(`INSERT INTO message_idempotency
+           (peer_id, protocol, message_id, direction, response_blob, response_size, ts)
+         VALUES (?, ?, ?, ?, ?, ?, ?)
          ON CONFLICT (peer_id, protocol, message_id, direction) DO NOTHING`)
             .run(peer, protocol, messageId, direction, blob, responseSize, this.clock());
     }
@@ -2931,15 +3061,15 @@ export class SqliteProtocolOutboxStore {
     }
     enqueue(peer, protocol, messageId, payload, error, now) {
         const existing = this.db
-            .prepare(`SELECT * FROM protocol_outbox
+            .prepare(`SELECT * FROM protocol_outbox
          WHERE peer_id = ? AND protocol = ? AND message_id = ?`)
             .get(peer, protocol, messageId);
         if (existing) {
             const newAttempts = existing.attempts + 1;
             const nextAttemptAt = now + this.backoffFor(newAttempts);
             this.db
-                .prepare(`UPDATE protocol_outbox
-           SET attempts = ?, last_attempt_at = ?, next_attempt_at = ?, last_error = ?
+                .prepare(`UPDATE protocol_outbox
+           SET attempts = ?, last_attempt_at = ?, next_attempt_at = ?, last_error = ?
            WHERE peer_id = ? AND protocol = ? AND message_id = ?`)
                 .run(newAttempts, now, nextAttemptAt, error, peer, protocol, messageId);
             return {
@@ -2958,9 +3088,9 @@ export class SqliteProtocolOutboxStore {
         const nextAttemptAt = now + this.backoffFor(attempts);
         const blob = Buffer.from(payload);
         this.db
-            .prepare(`INSERT INTO protocol_outbox
-           (peer_id, protocol, message_id, payload, attempts,
-            first_failure_at, last_attempt_at, next_attempt_at, last_error)
+            .prepare(`INSERT INTO protocol_outbox
+           (peer_id, protocol, message_id, payload, attempts,
+            first_failure_at, last_attempt_at, next_attempt_at, last_error)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
             .run(peer, protocol, messageId, blob, attempts, now, now, nextAttemptAt, error);
         return {
@@ -2977,14 +3107,14 @@ export class SqliteProtocolOutboxStore {
     }
     markDelivered(peer, protocol, messageId) {
         const result = this.db
-            .prepare(`DELETE FROM protocol_outbox
+            .prepare(`DELETE FROM protocol_outbox
          WHERE peer_id = ? AND protocol = ? AND message_id = ?`)
             .run(peer, protocol, messageId);
         return result.changes > 0;
     }
     hasEntry(peer, protocol, messageId) {
         const row = this.db
-            .prepare(`SELECT 1 FROM protocol_outbox
+            .prepare(`SELECT 1 FROM protocol_outbox
          WHERE peer_id = ? AND protocol = ? AND message_id = ? LIMIT 1`)
             .get(peer, protocol, messageId);
         return row !== undefined;
@@ -2994,27 +3124,27 @@ export class SqliteProtocolOutboxStore {
     }
     pendingFor(peer) {
         const rows = this.db
-            .prepare(`SELECT * FROM protocol_outbox
-         WHERE peer_id = ?
+            .prepare(`SELECT * FROM protocol_outbox
+         WHERE peer_id = ?
          ORDER BY first_failure_at ASC, protocol ASC, message_id ASC`)
             .all(peer);
         return rows.map(SqliteProtocolOutboxStore.rowToEntry);
     }
     due(now) {
         const rows = this.db
-            .prepare(`SELECT * FROM protocol_outbox
-         WHERE next_attempt_at <= ?
-         ORDER BY next_attempt_at ASC, first_failure_at ASC,
+            .prepare(`SELECT * FROM protocol_outbox
+         WHERE next_attempt_at <= ?
+         ORDER BY next_attempt_at ASC, first_failure_at ASC,
                   peer_id ASC, protocol ASC, message_id ASC`)
             .all(now);
         return rows.map(SqliteProtocolOutboxStore.rowToEntry);
     }
     duePage(now, limit) {
         const rows = this.db
-            .prepare(`SELECT * FROM protocol_outbox
-         WHERE next_attempt_at <= ?
-         ORDER BY next_attempt_at ASC, first_failure_at ASC,
-                  peer_id ASC, protocol ASC, message_id ASC
+            .prepare(`SELECT * FROM protocol_outbox
+         WHERE next_attempt_at <= ?
+         ORDER BY next_attempt_at ASC, first_failure_at ASC,
+                  peer_id ASC, protocol ASC, message_id ASC
          LIMIT ?`)
             .all(now, limit);
         return rows.map(SqliteProtocolOutboxStore.rowToEntry);
@@ -3104,9 +3234,9 @@ export class SqliteKaNumberStore {
         // `safeIntegers(true)` opts INTO bigint returns so the counter is
         // exact past `Number.MAX_SAFE_INTEGER` (codex PR #976 F6).
         const row = this.db
-            .prepare(`INSERT INTO ka_numbers (author_address, next_number)
-         VALUES (?, 1)
-         ON CONFLICT(author_address) DO UPDATE SET next_number = next_number + 1
+            .prepare(`INSERT INTO ka_numbers (author_address, next_number)
+         VALUES (?, 1)
+         ON CONFLICT(author_address) DO UPDATE SET next_number = next_number + 1
          RETURNING next_number - 1 AS number`)
             .safeIntegers(true)
             .get(author);
@@ -3118,9 +3248,9 @@ export class SqliteKaNumberStore {
         // `excluded.next_number` is the proposed floor from the VALUES row.
         // `better-sqlite3` accepts bigint statement parameters natively.
         this.db
-            .prepare(`INSERT INTO ka_numbers (author_address, next_number)
-         VALUES (?, ?)
-         ON CONFLICT(author_address) DO UPDATE SET
+            .prepare(`INSERT INTO ka_numbers (author_address, next_number)
+         VALUES (?, ?)
+         ON CONFLICT(author_address) DO UPDATE SET
            next_number = MAX(next_number, excluded.next_number)`)
             .run(author, nextNumberFloor);
     }