@adhdev/daemon-core 0.9.82-rc.459 → 0.9.82-rc.460

package/src/mesh/mesh-reconcile-loop.ts

@@ -237,15 +237,124 @@ interface AckedHoldState {
     consecutiveReadFailures: number;
     transcriptIdleSinceMs?: number;
 }
+
+// T2 (B2b): acked-hold state persistence. The Map below is a process-local CACHE;
+// the SSOT is the mesh_inflight_hold table in MeshRuntimeStore. Every read goes
+// read-through (Map miss → load from store, then cache), every mutation goes
+// write-through (Map set → store upsert; Map delete → store delete). On daemon
+// boot the reconcile loop rehydrates the Map from the store per-mesh the first
+// time it touches that mesh (rehydrateAckedHoldsForMesh), so a hold established
+// before a restart survives it — closing the duplicate-emit / drop window the
+// PHASE-4 transcript synth backstop otherwise had to correct after the fact.
+//
+// Store row ↔ AckedHoldState mapping:
+//   hold_reason 'live'|'unconfirmed'  ↔ liveConfirmedSinceAck (boolean)
+//   read_failure_count                ↔ consecutiveReadFailures
+//   first_idle_since_ack              ↔ transcriptIdleSinceMs (undefined ⇒ NULL)
+//   mesh_id                            = the owning mesh (for listByMesh / prune)
+//   held_at                            = ms the hold was first created (store-managed)
 const inFlightAckedHoldState = new Map<string, AckedHoldState>();
+// Meshes whose store rows have already been rehydrated into the Map this process.
+// A restart resets this set, so the first touch of each mesh reloads from disk.
+const rehydratedHoldMeshes = new Set<string>();
 
 function inFlightSynthKey(meshId: string, taskId: string): string {
     return `${meshId}::${taskId}`;
 }
 
-// Test hook: clear the in-flight acked-hold state between cases.
+// Extract the taskId back out of a `${meshId}::${taskId}` synth key. The meshId
+// prefix can itself contain '::' only if the caller passed one (mesh ids are
+// config-derived and never do), so split on the FIRST '::' and treat the remainder
+// as the taskId.
+function taskIdFromSynthKey(meshId: string, synthKey: string): string {
+    const prefix = `${meshId}::`;
+    return synthKey.startsWith(prefix) ? synthKey.slice(prefix.length) : synthKey;
+}
+
+function holdStore(): MeshRuntimeStore | undefined {
+    try { return MeshRuntimeStore.getInstance(); } catch { return undefined; }
+}
+
+// Read-through: Map hit returns the cached state; a miss consults the store and,
+// when a row exists, hydrates the Map from it before returning. A store failure
+// degrades to Map-only (returns undefined on a miss) — identical to the pre-T2
+// in-memory behavior, never worse.
+function getHoldState(synthKey: string, meshId: string): AckedHoldState | undefined {
+    const cached = inFlightAckedHoldState.get(synthKey);
+    if (cached) return cached;
+    const store = holdStore();
+    if (!store) return undefined;
+    let row;
+    try { row = store.getInflightHold(taskIdFromSynthKey(meshId, synthKey)); } catch { return undefined; }
+    if (!row) return undefined;
+    const state: AckedHoldState = {
+        liveConfirmedSinceAck: row.holdReason === 'live',
+        consecutiveReadFailures: row.readFailureCount ?? 0,
+        ...(row.firstIdleSinceAck !== null && row.firstIdleSinceAck !== undefined
+            ? { transcriptIdleSinceMs: row.firstIdleSinceAck }
+            : {}),
+    };
+    inFlightAckedHoldState.set(synthKey, state);
+    return state;
+}
+
+// Write-through: update the Map cache AND the store row. A store failure leaves the
+// Map authoritative for this process (degrade, never crash the tick).
+function setHoldState(synthKey: string, meshId: string, state: AckedHoldState): void {
+    inFlightAckedHoldState.set(synthKey, state);
+    const store = holdStore();
+    if (!store) return;
+    try {
+        store.upsertInflightHold({
+            taskId: taskIdFromSynthKey(meshId, synthKey),
+            meshId,
+            holdReason: state.liveConfirmedSinceAck ? 'live' : 'unconfirmed',
+            firstIdleSinceAck: state.transcriptIdleSinceMs ?? null,
+            readFailureCount: state.consecutiveReadFailures,
+        });
+    } catch { /* degrade to Map-only */ }
+}
+
+// Write-through delete: drop the Map entry AND the store row.
+function deleteHoldState(synthKey: string, meshId: string): void {
+    inFlightAckedHoldState.delete(synthKey);
+    const store = holdStore();
+    if (!store) return;
+    try { store.deleteInflightHold(taskIdFromSynthKey(meshId, synthKey)); } catch { /* degrade */ }
+}
+
+// Restart rehydration: on the first touch of a mesh this process, pull its persisted
+// acked-hold rows from the store into the Map cache so a hold that outlived a daemon
+// restart is honored again. Idempotent per process via rehydratedHoldMeshes. A store
+// failure just skips rehydration (Map starts empty for the mesh — pre-T2 behavior).
+function rehydrateAckedHoldsForMesh(meshId: string): void {
+    if (rehydratedHoldMeshes.has(meshId)) return;
+    rehydratedHoldMeshes.add(meshId);
+    const store = holdStore();
+    if (!store) return;
+    let rows;
+    try { rows = store.listInflightHoldsByMesh(meshId); } catch { return; }
+    for (const row of rows) {
+        const synthKey = inFlightSynthKey(meshId, row.taskId);
+        if (inFlightAckedHoldState.has(synthKey)) continue; // a live tick already set fresher state
+        inFlightAckedHoldState.set(synthKey, {
+            liveConfirmedSinceAck: row.holdReason === 'live',
+            consecutiveReadFailures: row.readFailureCount ?? 0,
+            ...(row.firstIdleSinceAck !== null && row.firstIdleSinceAck !== undefined
+                ? { transcriptIdleSinceMs: row.firstIdleSinceAck }
+                : {}),
+        });
+    }
+    if (rows.length > 0) {
+        LOG.info('MeshReconcile', `Rehydrated ${rows.length} persisted acked-hold row(s) for mesh ${meshId} after (re)start`);
+    }
+}
+
+// Test hook: clear the in-flight acked-hold state between cases (both the Map cache
+// and the per-mesh rehydrate guard, so each case starts from a clean read-through).
 export function __resetReconcileInFlightSynthDebounceForTests(): void {
     inFlightAckedHoldState.clear();
+    rehydratedHoldMeshes.clear();
 }
 
 interface LiveCoordinator {
@@ -1836,21 +1945,42 @@ async function reconcileUnterminatedDirectDispatches(
     localDaemonId: string | undefined,
 ): Promise<void> {
     const dispatches = getActiveDirectDispatches(mesh.id);
-    if (dispatches.length === 0) return; // cheap exit — nothing dispatched, nothing to reconcile
 
-    // Prune the in-flight acked-hold map to the tasks still active in THIS mesh, so a
-    // completed/pruned task's state is dropped (the map never grows without bound).
+    // T2 (B2b): restart rehydration. Reload this mesh's persisted acked-hold rows into
+    // the Map cache the first time this process touches the mesh — a hold established
+    // before a daemon restart is honored again. Must run BEFORE the prune below so a
+    // rehydrated hold for a still-active task is not seen as absent-from-cache and lost.
+    rehydrateAckedHoldsForMesh(mesh.id);
+
+    // Prune the in-flight acked-hold state to the tasks still active in THIS mesh, so a
+    // completed/pruned task's state is dropped (both the Map cache AND the store row —
+    // the persisted table never grows without bound). Runs even when there are zero
+    // active dispatches so a restart that landed after every task terminated still
+    // reaps orphaned store rows. Iterate the union of Map keys and store rows so a row
+    // that exists ONLY on disk (not yet cached) is pruned too.
     const activeTaskKeys = new Set(
         dispatches
             .map(d => readNonEmptyString(d.taskId))
             .filter(Boolean)
             .map(taskId => inFlightSynthKey(mesh.id, taskId)),
     );
+    const heldKeys = new Set<string>();
     for (const key of inFlightAckedHoldState.keys()) {
-        if (key.startsWith(`${mesh.id}::`) && !activeTaskKeys.has(key)) {
-            inFlightAckedHoldState.delete(key);
-        }
+        if (key.startsWith(`${mesh.id}::`)) heldKeys.add(key);
     }
+    const store = holdStore();
+    if (store) {
+        try {
+            for (const row of store.listInflightHoldsByMesh(mesh.id)) {
+                heldKeys.add(inFlightSynthKey(mesh.id, row.taskId));
+            }
+        } catch { /* degrade — prune only what's in the Map */ }
+    }
+    for (const key of heldKeys) {
+        if (!activeTaskKeys.has(key)) deleteHoldState(key, mesh.id);
+    }
+
+    if (dispatches.length === 0) return; // nothing left to reconcile after the prune
 
     const dispatchMeshCommand = components.dispatchMeshCommand;
     const nodeById = new Map(mesh.nodes.map(n => [n.id, n] as const));
@@ -1918,12 +2048,12 @@ async function reconcileUnterminatedDirectDispatches(
             // we only record the death observation and STOP holding so those nets can take over,
             // rather than pinning the row on an indefinite hold for a session that is already gone.
             if (isAcked) {
-                const prior = inFlightAckedHoldState.get(synthKey);
+                const prior = getHoldState(synthKey, mesh.id);
                 const failures = (prior?.consecutiveReadFailures ?? 0) + 1;
                 const liveConfirmedSinceAck = prior?.liveConfirmedSinceAck ?? false;
                 // A read failure breaks the idle-with-final-assistant run → reset the fast-track streak
                 // (transcriptIdleSinceMs cleared by omission) so it must re-accumulate from scratch.
-                inFlightAckedHoldState.set(synthKey, { liveConfirmedSinceAck, consecutiveReadFailures: failures });
+                setHoldState(synthKey, mesh.id, { liveConfirmedSinceAck, consecutiveReadFailures: failures });
                 if (liveConfirmedSinceAck && failures >= ACKED_DEATH_CONSECUTIVE_READ_FAILURES) {
                     LOG.warn('MeshReconcile', `Acked-hold death signal: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read_chat failed ${failures}x consecutively after a live-confirmed ack — worker session presumed gone mid-turn; releasing the indefinite synth hold to the stranded-reclaim / orphan-prune nets`);
                 }
@@ -1936,8 +2066,8 @@ async function reconcileUnterminatedDirectDispatches(
         // as a genuine liveness loss (backstop a) rather than a node that was never reachable. The
         // fast-track idle streak (transcriptIdleSinceMs) is PRESERVED across this reset — it is
         // managed below where the idle + final-assistant signal is actually evaluated.
-        const priorHoldState = inFlightAckedHoldState.get(synthKey);
-        inFlightAckedHoldState.set(synthKey, {
+        const priorHoldState = getHoldState(synthKey, mesh.id);
+        setHoldState(synthKey, mesh.id, {
             liveConfirmedSinceAck: true,
             consecutiveReadFailures: 0,
             ...(priorHoldState?.transcriptIdleSinceMs !== undefined ? { transcriptIdleSinceMs: priorHoldState.transcriptIdleSinceMs } : {}),
@@ -1951,7 +2081,7 @@ async function reconcileUnterminatedDirectDispatches(
             // Not idle → the worker is genuinely mid-turn (a clear live signal). Keep the
             // live-confirmed flag set (above) but RESET the fast-track idle streak: a turn that
             // resumed generating proves the prior idle was a mid-turn blip, not a settled turn-end.
-            inFlightAckedHoldState.set(synthKey, { liveConfirmedSinceAck: true, consecutiveReadFailures: 0 });
+            setHoldState(synthKey, mesh.id, { liveConfirmedSinceAck: true, consecutiveReadFailures: 0 });
             continue;
         }
 
@@ -1989,12 +2119,12 @@ async function reconcileUnterminatedDirectDispatches(
             // ACKED-HOLD-IDLE-OVERTRUST fast-track. Maintain the continuous idle-with-final-assistant
             // streak. The streak starts (or continues) only while a final visible assistant message is
             // present; a tick with idle-but-no-assistant breaks it (the answer is not yet rendered).
-            const holdState = inFlightAckedHoldState.get(synthKey);
+            const holdState = getHoldState(synthKey, mesh.id);
             let fastTrackReady = false;
             if (evidence.finalSummary) {
                 const idleSinceMs = holdState?.transcriptIdleSinceMs ?? nowMs;
                 if (holdState && holdState.transcriptIdleSinceMs === undefined) {
-                    inFlightAckedHoldState.set(synthKey, { ...holdState, transcriptIdleSinceMs: idleSinceMs });
+                    setHoldState(synthKey, mesh.id, { ...holdState, transcriptIdleSinceMs: idleSinceMs });
                 }
                 const fastTrackGraceMs = resolveAckedTranscriptFastTrackGraceMs();
                 const idleHeldMs = nowMs - idleSinceMs;
@@ -2004,7 +2134,7 @@ async function reconcileUnterminatedDirectDispatches(
                 }
             } else if (holdState?.transcriptIdleSinceMs !== undefined) {
                 // Idle but no final assistant yet → not a turn-end; reset the streak.
-                inFlightAckedHoldState.set(synthKey, { ...holdState, transcriptIdleSinceMs: undefined });
+                setHoldState(synthKey, mesh.id, { ...holdState, transcriptIdleSinceMs: undefined });
             }
 
             // Hold indefinitely UNLESS the fast-track grace was met OR the absolute death deadline is
@@ -2027,7 +2157,7 @@ async function reconcileUnterminatedDirectDispatches(
         // never-acked path and the post-death-deadline acked synth from racing an emit caught in
         // flight at synth-commit time.
         if (realTerminalEmitPendingForTask(mesh.id, taskId)) {
-            inFlightAckedHoldState.delete(synthKey);
+            deleteHoldState(synthKey, mesh.id);
             LOG.info('MeshReconcile', `Worker-emit priority: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) has a real terminal completion already queued — yielding synth to the worker's own emit`);
             continue;
         }
@@ -2070,7 +2200,7 @@ async function reconcileUnterminatedDirectDispatches(
         // turn); it stays as a final live-state guard at synth-commit time.
         const reprobeStatus = await reprobeWorkerStatus(components, { isLocalNode, nodeDaemonId, readArgs });
         if (reprobeStatus && reprobeStatus !== 'idle') {
-            inFlightAckedHoldState.delete(synthKey);
+            deleteHoldState(synthKey, mesh.id);
             LOG.info('MeshReconcile', `Live re-probe defer: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read '${reprobeStatus}' at synth-commit time — worker resumed generating; deferring synth to a later tick`);
             continue;
         }

package/src/mesh/mesh-runtime-store.ts

@@ -21,6 +21,19 @@ function safeMeshId(meshId: string): string {
     return meshId.replace(/[^a-zA-Z0-9_-]/g, '_');
 }
 
+// T2 (B2b): a persisted acked-hold record for one in-flight direct dispatch. The
+// reconcile loop keeps a Map cache of these but this row is the SSOT so the hold
+// survives a daemon restart. See the mesh_inflight_hold table comment.
+export interface MeshInflightHoldRow {
+    taskId: string;
+    meshId: string | null;
+    holdReason: string | null;
+    heldAt: number | null;
+    firstIdleSinceAck: number | null;
+    readFailureCount: number | null;
+    updatedAt: number | null;
+}
+
 function legacyQueuePath(meshId: string): string {
     return join(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
 }
@@ -280,7 +293,18 @@ export class MeshRuntimeStore {
                 fingerprint TEXT,
                 queued_at INTEGER NOT NULL,
                 drained INTEGER NOT NULL DEFAULT 0,
-                drained_at INTEGER
+                drained_at INTEGER,
+                -- v2 protocol envelope (B2a). All nullable so pre-v2 rows and events
+                -- emitted before a coordinator identity is known coexist as v1. The
+                -- authoritative copy of each also rides inside the payload column; these
+                -- columns exist for queryable idempotency (event_id) and scope-based drain
+                -- filtering without JSON-parsing every row. dispatched_by / intended_for
+                -- hold the JSON-serialized CoordinatorIdentity.
+                protocol_version TEXT,
+                event_id TEXT,
+                scope TEXT,
+                dispatched_by TEXT,
+                intended_for TEXT
             );
 
             CREATE INDEX IF NOT EXISTS idx_mesh_pending_events_mesh_drained
@@ -316,6 +340,38 @@ export class MeshRuntimeStore {
                 mesh_id TEXT PRIMARY KEY,
                 cursor INTEGER NOT NULL DEFAULT 0
             );
+
+            -- T2 (B2b): persistent acked-hold state for in-flight direct dispatches.
+            -- The reconcile loop's PHASE-4 acked-hold (death-consequence counter,
+            -- fast-track idle streak, live-confirmed flag) used to live only in a
+            -- process-local Map (mesh-reconcile-loop.ts inFlightAckedHoldState), so a
+            -- daemon restart lost it — re-opening the door to the duplicate-emit / drop
+            -- window that the PHASE-4 transcript synth backstop then had to correct after
+            -- the fact. Persisting it lets the state survive a restart: the loop
+            -- rehydrates the Map from this table on first touch and stays read-through /
+            -- write-through against it thereafter. Keyed by task_id (one hold per
+            -- in-flight dispatch); mesh_id is carried for per-mesh listing / prune.
+            --   hold_reason         — 'live' once a conclusive read confirmed the session
+            --                         reachable since the ack, else 'unconfirmed' (drives
+            --                         the death-backstop's liveConfirmedSinceAck gate).
+            --   held_at             — ms epoch the hold row was first created.
+            --   first_idle_since_ack — ms epoch of the FIRST tick in the current continuous
+            --                         idle-with-final-assistant run (fast-track streak); NULL
+            --                         when the streak is broken / not yet started.
+            --   read_failure_count  — consecutive read_chat failures since the last
+            --                         conclusive read (death backstop (a)).
+            CREATE TABLE IF NOT EXISTS mesh_inflight_hold (
+                task_id TEXT PRIMARY KEY,
+                mesh_id TEXT,
+                hold_reason TEXT,
+                held_at INTEGER,
+                first_idle_since_ack INTEGER,
+                read_failure_count INTEGER,
+                updated_at INTEGER
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_mesh_inflight_hold_mesh
+                ON mesh_inflight_hold(mesh_id);
         `);
         this.migrateMeshIsolationColumns();
     }
@@ -383,6 +439,26 @@ export class MeshRuntimeStore {
             if (!missionCols.has('source')) {
                 this.db.exec(`ALTER TABLE mesh_missions ADD COLUMN source TEXT`);
             }
+
+            // 4. mesh_pending_events v2 envelope columns (B2a). A pre-v2 DB has the
+            //    table (CREATE IF NOT EXISTS is a no-op) without these columns, so add
+            //    each missing one. All nullable — legacy rows read back as v1 events
+            //    (protocol_version NULL) with no reader change. Idempotent: the column
+            //    check short-circuits once present, and every ADD COLUMN is guarded.
+            const pendingCols = this.tableColumns('mesh_pending_events');
+            for (const col of ['protocol_version', 'event_id', 'scope', 'dispatched_by', 'intended_for'] as const) {
+                if (!pendingCols.has(col)) {
+                    this.db.exec(`ALTER TABLE mesh_pending_events ADD COLUMN ${col} TEXT`);
+                }
+            }
+            // Idempotency index on event_id (partial: only stamped v2 rows). Created
+            // unconditionally — IF NOT EXISTS makes it a no-op once present, and the
+            // event_id column is guaranteed to exist by the loop above.
+            this.db.exec(`
+                CREATE INDEX IF NOT EXISTS idx_mesh_pending_events_event_id
+                    ON mesh_pending_events(mesh_id, event_id)
+                    WHERE event_id IS NOT NULL
+            `);
         } catch (err: any) {
             // Best-effort: a failed isolation migration must not brick the store. The
             // CREATE-TABLE definitions above already carry the new schema for fresh DBs;
@@ -650,6 +726,78 @@ export class MeshRuntimeStore {
         });
     }
 
+    // ── Acked-Hold State (T2 / B2b) ──────────────────────────────────────────
+    //
+    // Persistent mirror of the reconcile loop's inFlightAckedHoldState Map. Keyed
+    // by task_id (one in-flight dispatch = one hold). These are plain read/write/
+    // delete/list accessors; the read-through/write-through cache and the restart
+    // rehydrate live in mesh-reconcile-loop.ts.
+
+    private mapInflightHoldRow(r: Record<string, unknown> | undefined): MeshInflightHoldRow | null {
+        if (!r) return null;
+        return {
+            taskId: r.task_id as string,
+            meshId: (r.mesh_id as string | null) ?? null,
+            holdReason: (r.hold_reason as string | null) ?? null,
+            heldAt: (r.held_at as number | null) ?? null,
+            firstIdleSinceAck: (r.first_idle_since_ack as number | null) ?? null,
+            readFailureCount: (r.read_failure_count as number | null) ?? null,
+            updatedAt: (r.updated_at as number | null) ?? null,
+        };
+    }
+
+    upsertInflightHold(entry: {
+        taskId: string;
+        meshId?: string | null;
+        holdReason?: string | null;
+        heldAt?: number | null;
+        firstIdleSinceAck?: number | null;
+        readFailureCount?: number | null;
+    }): void {
+        const now = Date.now();
+        // Preserve held_at across an upsert (it marks when the hold was first created);
+        // only set it from the incoming value when the row is new. All other fields are
+        // overwritten with the latest state — the caller passes the full current state.
+        this.db.prepare(`
+            INSERT INTO mesh_inflight_hold
+                (task_id, mesh_id, hold_reason, held_at, first_idle_since_ack, read_failure_count, updated_at)
+            VALUES (@taskId, @meshId, @holdReason, @heldAt, @firstIdleSinceAck, @readFailureCount, @updatedAt)
+            ON CONFLICT(task_id) DO UPDATE SET
+                mesh_id = excluded.mesh_id,
+                hold_reason = excluded.hold_reason,
+                first_idle_since_ack = excluded.first_idle_since_ack,
+                read_failure_count = excluded.read_failure_count,
+                updated_at = excluded.updated_at
+        `).run({
+            taskId: entry.taskId,
+            meshId: entry.meshId ?? null,
+            holdReason: entry.holdReason ?? null,
+            heldAt: entry.heldAt ?? now,
+            firstIdleSinceAck: entry.firstIdleSinceAck ?? null,
+            readFailureCount: entry.readFailureCount ?? null,
+            updatedAt: now,
+        });
+        this.maybeCheckpointWal();
+    }
+
+    getInflightHold(taskId: string): MeshInflightHoldRow | null {
+        const row = this.db.prepare(
+            'SELECT * FROM mesh_inflight_hold WHERE task_id = ?'
+        ).get(taskId) as Record<string, unknown> | undefined;
+        return this.mapInflightHoldRow(row);
+    }
+
+    listInflightHoldsByMesh(meshId: string): MeshInflightHoldRow[] {
+        const rows = this.db.prepare(
+            'SELECT * FROM mesh_inflight_hold WHERE mesh_id = ?'
+        ).all(meshId) as Array<Record<string, unknown>>;
+        return rows.map(r => this.mapInflightHoldRow(r)).filter((r): r is MeshInflightHoldRow => r !== null);
+    }
+
+    deleteInflightHold(taskId: string): void {
+        this.db.prepare('DELETE FROM mesh_inflight_hold WHERE task_id = ?').run(taskId);
+    }
+
     /**
      * Count active (status='assigned') tasks on a (node, provider) combination,
      * matched by the assignedProviderType stamped on the payload at claim time.
@@ -1652,11 +1800,19 @@ export class MeshRuntimeStore {
         payload?: unknown;
         fingerprint?: string | null;
         queuedAt: number;
+        // v2 envelope columns (B2a) — all optional so v1 callers/rows are unaffected.
+        // dispatchedBy / intendedFor are pre-serialized CoordinatorIdentity JSON.
+        protocolVersion?: string | null;
+        eventId?: string | null;
+        scope?: string | null;
+        dispatchedBy?: string | null;
+        intendedFor?: string | null;
     }): boolean {
         const result = this.db.prepare(
             `INSERT OR IGNORE INTO mesh_pending_events
-             (id, mesh_id, coordinator_daemon_id, event, payload, fingerprint, queued_at)
-             VALUES (?, ?, ?, ?, ?, ?, ?)`
+             (id, mesh_id, coordinator_daemon_id, event, payload, fingerprint, queued_at,
+              protocol_version, event_id, scope, dispatched_by, intended_for)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
         ).run(
             event.id,
             event.meshId,
@@ -1665,6 +1821,11 @@ export class MeshRuntimeStore {
             JSON.stringify(event.payload ?? {}),
             event.fingerprint ?? null,
             event.queuedAt,
+            event.protocolVersion ?? null,
+            event.eventId ?? null,
+            event.scope ?? null,
+            event.dispatchedBy ?? null,
+            event.intendedFor ?? null,
         );
         this.maybeCheckpointWal();
         return result.changes > 0;