@adhdev/daemon-core 0.9.82-rc.195 → 0.9.82-rc.197

package/src/index.ts

@@ -232,6 +232,10 @@ export { buildMeshHostRequiredFailure, createDefaultMeshHostMetadata, isMeshHost
 export { triggerMeshQueue, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, queuePendingMeshCoordinatorEvent, reconcileDirectDispatchCompletionFromTranscript } from './mesh/mesh-events.js';
 export type { PendingMeshCoordinatorEvent } from './mesh/mesh-events.js';
 
+// ── Mesh Delivery Policy ──
+export { resolveDeliveryDecision, createSessionDelivery, updateSessionDeliveryStatus, getActiveSessionDeliveries, recordCompletionConflict, getRecentCompletionConflicts } from './mesh/mesh-delivery-policy.js';
+export type { MeshSessionDeliveryStatus, MeshSessionDeliveryKind, MeshDeliveryDecision, MeshDeliveryPolicyResult, SessionDeliveryRecord } from './mesh/mesh-delivery-policy.js';
+
 // ── Mesh P2P Relay Failure Classification ──
 export {
   P2pRelayFailureError,

package/src/mesh/contracts.ts

@@ -16,7 +16,7 @@
  *   - Session identifier keys diverged across stores: targetSessionId /
  *     assignedSessionId / instanceId / runtimeSessionId / providerSessionId.
  *     resolveEventSessionId() tried four fallbacks per call.
- *   - No protocol version on the JSONL ledger or BeadsDB. Schema
+ *   - No protocol version on the JSONL ledger or MeshRuntimeStore. Schema
  *     evolutions had no guard rail.
  *   - mesh_reconcile_ledger existed as a routine recovery tool, not as
  *     an incident-response escape hatch. That itself signals the routing

package/src/mesh/mesh-active-work.ts

@@ -70,7 +70,7 @@ export interface BuildMeshActiveWorkOptions {
     queue?: MeshWorkQueueEntry[];
     ledgerEntries?: MeshLedgerEntry[];
     /**
-     * Active direct dispatches from BeadsDB. When provided, these are used instead of
+     * Active direct dispatches from MeshRuntimeStore. When provided, these are used instead of
      * scanning ledger entries for direct dispatches — eliminates the O(n_ledger) scan.
      * Falls back to ledger scanning when not provided.
      */
@@ -224,9 +224,9 @@ export function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): { activeW
         });
     }
 
-    // When BeadsDB direct dispatches are provided, use them for LOCAL dispatches (O(1) indexed).
-    // ALSO scan ledger for remote dispatches (P2P) whose taskIds are not in BeadsDB — these
-    // are never written to the local BeadsDB since they're dispatched from a remote daemon.
+    // When MeshRuntimeStore direct dispatches are provided, use them for LOCAL dispatches (O(1) indexed).
+    // ALSO scan ledger for remote dispatches (P2P) whose taskIds are not in MeshRuntimeStore — these
+    // are never written to the local MeshRuntimeStore since they're dispatched from a remote daemon.
     if (opts.directDispatches !== undefined) {
         const dbTaskIds = new Set(opts.directDispatches.map(d => d.taskId));
         for (const dispatch of opts.directDispatches) {
@@ -274,13 +274,13 @@ export function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): { activeW
             }
             records.push(record);
         }
-        // Also scan ledger for remote dispatches (via p2p_direct) whose taskIds are NOT in BeadsDB.
-        // Remote daemons write their own local BeadsDB; this coordinator's BeadsDB only has local dispatches.
+        // Also scan ledger for remote dispatches (via p2p_direct) whose taskIds are NOT in MeshRuntimeStore.
+        // Remote daemons write their own local MeshRuntimeStore; this coordinator's MeshRuntimeStore only has local dispatches.
         const ledgerEntries = (opts.ledgerEntries || []).slice().sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
         const terminals = ledgerEntries.filter(entry => TERMINAL_LEDGER_KINDS.has(entry.kind) || entry.kind === 'task_approval_needed');
         for (const dispatch of ledgerEntries.filter(isDirectDispatch)) {
             const taskId = directDispatchTaskId(dispatch);
-            if (dbTaskIds.has(taskId)) continue; // already covered by BeadsDB path above
+            if (dbTaskIds.has(taskId)) continue; // already covered by MeshRuntimeStore path above
             const terminal = terminals
                 .filter(entry => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime())
                 .find(entry => terminalMatchesDispatch(entry, dispatch, taskId));
@@ -329,7 +329,7 @@ export function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): { activeW
             records.push(record);
         }
     } else {
-        // Full ledger scan: no BeadsDB direct dispatches available (standalone mode or empty).
+        // Full ledger scan: no MeshRuntimeStore direct dispatches available (standalone mode or empty).
         const ledgerEntries = (opts.ledgerEntries || []).slice().sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
         const terminals = ledgerEntries.filter(entry => TERMINAL_LEDGER_KINDS.has(entry.kind) || entry.kind === 'task_approval_needed');
         for (const dispatch of ledgerEntries.filter(isDirectDispatch)) {

package/src/mesh/mesh-delivery-policy.ts

@@ -0,0 +1,298 @@
+import { randomUUID } from 'crypto';
+import { MeshRuntimeStore } from './mesh-runtime-store.js';
+
+/**
+ * Possible delivery statuses for a session delivery record.
+ */
+export type MeshSessionDeliveryStatus =
+    | 'queued'
+    | 'delivering'
+    | 'delivered'
+    | 'acked'
+    | 'completed'
+    | 'failed'
+    | 'expired'
+    | 'cancelled';
+
+/**
+ * Kind of delivery — controls priority and policy handling.
+ */
+export type MeshSessionDeliveryKind =
+    | 'task'
+    | 'followup'
+    | 'approval'
+    | 'recovery'
+    | 'system_notice';
+
+/**
+ * A session delivery decision — what to do when a task arrives for a session.
+ */
+export type MeshDeliveryDecision =
+    | 'immediate'     // Session is idle: deliver now, create an 'acked' delivery record
+    | 'queued'        // Session is busy: hold delivery until session becomes idle
+    | 'rejected';     // Session is terminal or unknown: cannot deliver
+
+export interface MeshDeliveryPolicyResult {
+    decision: MeshDeliveryDecision;
+    reason: string;
+    /** When decision='queued', estimated deliver-after ISO timestamp if known. */
+    deliverAfter?: string;
+    /** Human-readable explanation for coordinator/operator. */
+    message: string;
+}
+
+/**
+ * Session statuses where immediate delivery is allowed.
+ * The session is ready to accept new work.
+ */
+const IMMEDIATE_DELIVERY_STATUSES = new Set([
+    'idle',
+    'waiting_input',
+    'ready',
+]);
+
+/**
+ * Session statuses that indicate the session is busy but still alive.
+ * Delivery is queued rather than attempted immediately.
+ */
+const BUSY_DELIVERY_STATUSES = new Set([
+    'generating',
+    'running',
+    'streaming',
+    'busy',
+    'starting',
+    'initializing',
+    'waiting_approval',
+]);
+
+/**
+ * Session statuses that indicate the session is permanently unavailable.
+ * Delivery should be rejected.
+ */
+const TERMINAL_DELIVERY_STATUSES = new Set([
+    'stopped',
+    'failed',
+    'terminated',
+    'exited',
+    'closed',
+    'deleted',
+    'error',
+]);
+
+/**
+ * Determine whether to deliver immediately, queue, or reject based on session status.
+ *
+ * This is a pure function — it does not write to any store.
+ */
+export function resolveDeliveryDecision(
+    sessionStatus: string | undefined,
+    opts?: {
+        kind?: MeshSessionDeliveryKind;
+        /** When true, busy session immediate injection is allowed (provider-specific capability). */
+        allowBusyInjection?: boolean;
+    },
+): MeshDeliveryPolicyResult {
+    const status = (sessionStatus || '').trim().toLowerCase();
+
+    if (!status) {
+        return {
+            decision: 'rejected',
+            reason: 'unknown_session_status',
+            message: 'Session status is unknown. Delivery rejected (fail-closed). Use mesh_launch_session to start a fresh session.',
+        };
+    }
+
+    if (IMMEDIATE_DELIVERY_STATUSES.has(status)) {
+        return {
+            decision: 'immediate',
+            reason: `session_${status}`,
+            message: `Session is ${status} — delivery allowed immediately.`,
+        };
+    }
+
+    if (BUSY_DELIVERY_STATUSES.has(status)) {
+        if (opts?.allowBusyInjection) {
+            return {
+                decision: 'immediate',
+                reason: `session_${status}_busy_injection_allowed`,
+                message: `Session is ${status} but provider supports busy injection. Delivered immediately.`,
+            };
+        }
+        // approval-kind may be delivered to waiting_approval sessions
+        if (status === 'waiting_approval' && opts?.kind === 'approval') {
+            return {
+                decision: 'immediate',
+                reason: 'session_waiting_approval_approval_message',
+                message: 'Session is waiting for approval — approval message delivered immediately.',
+            };
+        }
+        return {
+            decision: 'queued',
+            reason: `session_${status}_busy`,
+            message: `Session is ${status}. Task queued for delivery when session becomes idle. Do not inject directly into a busy session.`,
+        };
+    }
+
+    if (TERMINAL_DELIVERY_STATUSES.has(status)) {
+        return {
+            decision: 'rejected',
+            reason: `session_${status}_terminal`,
+            message: `Session is ${status} (terminal). Delivery rejected. Launch a new session before dispatching tasks.`,
+        };
+    }
+
+    // Unknown/unrecognized status: fail-closed
+    return {
+        decision: 'rejected',
+        reason: 'unrecognized_session_status',
+        message: `Session status '${sessionStatus}' is not recognized. Delivery rejected (fail-closed). Inspect session state before retrying.`,
+    };
+}
+
+export interface SessionDeliveryRecord {
+    id: string;
+    meshId: string;
+    nodeId?: string;
+    sessionId?: string;
+    providerType?: string;
+    taskId?: string;
+    kind: MeshSessionDeliveryKind;
+    priority: number;
+    message: string;
+    status: MeshSessionDeliveryStatus;
+    deliverAfter?: string;
+    expiresAt?: string;
+    attemptCount: number;
+    sourceCoordinatorSessionId?: string;
+    sourceCoordinatorDaemonId?: string;
+    lastError?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+
+/**
+ * Create a delivery record in the store.
+ */
+export function createSessionDelivery(opts: {
+    meshId: string;
+    nodeId?: string;
+    sessionId?: string;
+    providerType?: string;
+    taskId?: string;
+    kind: MeshSessionDeliveryKind;
+    message: string;
+    status: MeshSessionDeliveryStatus;
+    priority?: number;
+    deliverAfter?: string;
+    expiresAt?: string;
+    sourceCoordinatorSessionId?: string;
+    sourceCoordinatorDaemonId?: string;
+}): SessionDeliveryRecord {
+    const now = new Date().toISOString();
+    const id = randomUUID();
+    const record: SessionDeliveryRecord = {
+        id,
+        meshId: opts.meshId,
+        nodeId: opts.nodeId,
+        sessionId: opts.sessionId,
+        providerType: opts.providerType,
+        taskId: opts.taskId,
+        kind: opts.kind,
+        priority: opts.priority ?? 0,
+        message: opts.message,
+        status: opts.status,
+        deliverAfter: opts.deliverAfter,
+        expiresAt: opts.expiresAt,
+        attemptCount: 0,
+        sourceCoordinatorSessionId: opts.sourceCoordinatorSessionId,
+        sourceCoordinatorDaemonId: opts.sourceCoordinatorDaemonId,
+        createdAt: now,
+        updatedAt: now,
+    };
+    MeshRuntimeStore.getInstance().insertSessionDelivery({
+        id,
+        meshId: opts.meshId,
+        nodeId: opts.nodeId,
+        sessionId: opts.sessionId,
+        providerType: opts.providerType,
+        taskId: opts.taskId,
+        kind: opts.kind,
+        priority: opts.priority ?? 0,
+        message: opts.message,
+        status: opts.status,
+        deliverAfter: opts.deliverAfter,
+        expiresAt: opts.expiresAt,
+        sourceCoordinatorSessionId: opts.sourceCoordinatorSessionId,
+        sourceCoordinatorDaemonId: opts.sourceCoordinatorDaemonId,
+        createdAt: now,
+        updatedAt: now,
+    });
+    return record;
+}
+
+/**
+ * Update the status of a delivery record.
+ */
+export function updateSessionDeliveryStatus(
+    id: string,
+    status: MeshSessionDeliveryStatus,
+    opts?: { lastError?: string; incrementAttempt?: boolean },
+): void {
+    try {
+        MeshRuntimeStore.getInstance().updateSessionDeliveryStatus(id, status, opts);
+    } catch { /* best-effort */ }
+}
+
+/**
+ * Get active (non-terminal) deliveries for a mesh, optionally filtered by session.
+ */
+export function getActiveSessionDeliveries(meshId: string, sessionId?: string) {
+    try {
+        return MeshRuntimeStore.getInstance().getActiveSessionDeliveries(meshId, sessionId);
+    } catch {
+        return [];
+    }
+}
+
+/**
+ * Record a completion conflict diagnostic when a duplicate event points to
+ * different task/session than the already-seen event with the same fingerprint.
+ */
+export function recordCompletionConflict(opts: {
+    meshId: string;
+    fingerprint: string;
+    conflictingTaskId?: string;
+    conflictingSessionId?: string;
+    originalTaskId?: string;
+    originalSessionId?: string;
+    event: string;
+}): void {
+    try {
+        MeshRuntimeStore.getInstance().recordCompletionConflict({
+            id: randomUUID(),
+            meshId: opts.meshId,
+            fingerprint: opts.fingerprint,
+            conflictingTaskId: opts.conflictingTaskId,
+            conflictingSessionId: opts.conflictingSessionId,
+            originalTaskId: opts.originalTaskId,
+            originalSessionId: opts.originalSessionId,
+            event: opts.event,
+            createdAt: new Date().toISOString(),
+        });
+    } catch { /* best-effort diagnostics */ }
+}
+
+/**
+ * Get recent completion conflicts for diagnostic inspection.
+ */
+export function getRecentCompletionConflicts(meshId: string, limitMs?: number) {
+    try {
+        return MeshRuntimeStore.getInstance().getRecentCompletionConflicts(meshId, limitMs);
+    } catch {
+        return [];
+    }
+}
+
+export function __clearSessionDeliveriesForTests(meshId: string): void {
+    MeshRuntimeStore.getInstance().deleteSessionDeliveries(meshId);
+}

package/src/mesh/mesh-events.ts

@@ -8,8 +8,9 @@ import { LOG } from '../logging/logger.js';
 import { appendLedgerEntry, buildTaskCompletionEvidence, getLedgerDir, getSessionRecoveryContext, isIntentionalCleanupStopEntry, readLedgerEntries } from './mesh-ledger.js';
 import type { MeshLedgerKind, SessionRecoveryContext } from './mesh-ledger.js';
 import { buildMeshNodeCapabilityTags, claimNextTask, updateSessionTaskStatus, enqueueTask, updateTaskStatus, getQueue, recordTaskAutoLaunch, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, getActiveDirectDispatches } from './mesh-work-queue.js';
-import { BeadsDB } from './beads-db.js';
+import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { fastForwardMeshNode } from './mesh-fast-forward.js';
+import { createSessionDelivery, updateSessionDeliveryStatus, recordCompletionConflict } from './mesh-delivery-policy.js';
 
 // ---------------------------------------------------------------------------
 // Remote Node Idle Session Tracking
@@ -49,7 +50,7 @@ export function __resetIdleAutoFastForwardForTests(): void {
 
 function sweepExpiredRemoteIdleSessions(): void {
     try {
-        BeadsDB.getInstance().pruneExpiredRemoteIdleSessions();
+        MeshRuntimeStore.getInstance().pruneExpiredRemoteIdleSessions();
     } catch { /* best-effort */ }
 }
 
@@ -438,7 +439,7 @@ const RECENT_COMPLETION_FINGERPRINT_TTL_MS = 10 * 60 * 1000;
 
 function hasFingerprintSeen(fingerprint: string): boolean {
     try {
-        return BeadsDB.getInstance().hasCompletionFingerprint(fingerprint);
+        return MeshRuntimeStore.getInstance().hasCompletionFingerprint(fingerprint);
     } catch {
         return false;
     }
@@ -446,7 +447,7 @@ function hasFingerprintSeen(fingerprint: string): boolean {
 
 function recordFingerprintSeen(fingerprint: string): void {
     try {
-        const db = BeadsDB.getInstance();
+        const db = MeshRuntimeStore.getInstance();
         db.recordCompletionFingerprint(fingerprint, RECENT_COMPLETION_FINGERPRINT_TTL_MS);
         db.sweepExpiredFingerprints();
     } catch { /* best-effort; duplicate events are preferable to a crash */ }
@@ -499,10 +500,27 @@ function isDuplicateMeshCompletionEvent(args: {
     timestamp?: number | null;
     finalSummary?: string;
     coordinatorDaemonId?: string;
+    taskId?: string;
+    nodeId?: string;
 }): boolean {
     const fingerprint = buildMeshCompletionFingerprint(args);
     if (!fingerprint) return false;
-    if (hasFingerprintSeen(fingerprint)) return true;
+    if (hasFingerprintSeen(fingerprint)) {
+        // Suppressed duplicate — but if we have a taskId and it differs from what the
+        // fingerprint was stamped for, record a conflict diagnostic so it doesn't disappear silently.
+        // (We can't recover the original taskId from the fingerprint alone, so we record
+        //  the conflicting taskId/session as a diagnostic for coordinator inspection.)
+        if (args.taskId) {
+            recordCompletionConflict({
+                meshId: args.meshId,
+                fingerprint,
+                conflictingTaskId: args.taskId,
+                conflictingSessionId: args.sessionId,
+                event: args.event,
+            });
+        }
+        return true;
+    }
     recordFingerprintSeen(fingerprint);
     return false;
 }
@@ -550,7 +568,7 @@ function findRecentTerminalLedgerEvidence(args: {
     if (!args.sessionId && !args.nodeId) return null;
     // Tail-limit: 200 entries gives a wide enough window to catch terminal events for active
     // sessions while avoiding a full O(n) scan. If a terminal is older than 200 entries,
-    // the BeadsDB fingerprint dedup will still block duplicate processing downstream.
+    // the MeshRuntimeStore fingerprint dedup will still block duplicate processing downstream.
     const entries = readLedgerEntries(args.meshId, { tail: 200 });
     for (let i = entries.length - 1; i >= 0; i--) {
         const entry = entries[i];
@@ -837,13 +855,27 @@ export function tryAssignQueueTask(
     if (node?.daemonId && components.dispatchMeshCommand) {
         const isLocalNode = components.cliManager.adapters.has(sessionId);
         if (!isLocalNode) {
+            // Create delivery record before attempting P2P send
+            const delivery = createSessionDelivery({
+                meshId,
+                nodeId,
+                sessionId,
+                providerType,
+                taskId: task.id,
+                kind: 'task',
+                message: task.message,
+                status: 'delivering',
+            });
             components.dispatchMeshCommand(node.daemonId, 'agent_command', {
                 targetSessionId: sessionId,
                 cliType: providerType,
                 action: 'send_chat',
                 message: task.message,
+            }).then(() => {
+                updateSessionDeliveryStatus(delivery.id, 'delivered');
             }).catch((e: any) => {
                 LOG.error('MeshQueue', `Failed to dispatch task via P2P to remote node ${nodeId}: ${e?.message}`);
+                updateSessionDeliveryStatus(delivery.id, 'failed', { lastError: e?.message, incrementAttempt: true });
                 // Revert to pending so the task can be retried rather than permanently failing
                 updateTaskStatus(meshId, task.id, 'pending');
                 try {
@@ -851,7 +883,7 @@ export function tryAssignQueueTask(
                         kind: 'dispatch_failed' as any,
                         nodeId,
                         sessionId,
-                        payload: { taskId: task.id, error: e?.message, retryable: true },
+                        payload: { taskId: task.id, deliveryId: delivery.id, error: e?.message, retryable: true },
                     });
                 } catch { /* ledger write is best-effort */ }
             });
@@ -859,14 +891,27 @@ export function tryAssignQueueTask(
         }
     }
 
-    // Local routing
+    // Local routing — create delivery record before send_chat
+    const delivery = createSessionDelivery({
+        meshId,
+        nodeId,
+        sessionId,
+        providerType,
+        taskId: task.id,
+        kind: 'task',
+        message: task.message,
+        status: 'delivering',
+    });
     components.cliManager.handleCliCommand('agent_command', {
         targetSessionId: sessionId,
         cliType: providerType,
         action: 'send_chat',
         message: task.message,
+    }).then(() => {
+        updateSessionDeliveryStatus(delivery.id, 'delivered');
     }).catch((e: any) => {
         LOG.error('MeshQueue', `Failed to dispatch task locally to node ${nodeId}: ${e?.message}`);
+        updateSessionDeliveryStatus(delivery.id, 'failed', { lastError: e?.message, incrementAttempt: true });
         updateTaskStatus(meshId, task.id, 'failed');
     });
 
@@ -1280,7 +1325,7 @@ export async function triggerMeshQueue(components: DaemonComponents, meshId: str
     // Also check known idle remote sessions
     let remoteSessions: Array<{ nodeId: string; sessionId: string; providerType: string }> = [];
     try {
-        remoteSessions = BeadsDB.getInstance().getRemoteIdleSessions();
+        remoteSessions = MeshRuntimeStore.getInstance().getRemoteIdleSessions();
     } catch { /* best-effort */ }
 
     for (const idle of remoteSessions) {
@@ -1291,7 +1336,7 @@ export async function triggerMeshQueue(components: DaemonComponents, meshId: str
             const assigned = tryAssignQueueTask(components, meshId, idle.nodeId, idle.sessionId, idle.providerType);
             if (assigned) {
                 try {
-                    BeadsDB.getInstance().deleteRemoteIdleSession(idle.nodeId, idle.sessionId);
+                    MeshRuntimeStore.getInstance().deleteRemoteIdleSession(idle.nodeId, idle.sessionId);
                 } catch { /* best-effort */ }
             }
         }
@@ -1534,7 +1579,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     if (intentionalCleanupStop) {
         if (eventSessionId && eventNodeId) {
             try {
-                BeadsDB.getInstance().deleteRemoteIdleSession(eventNodeId, eventSessionId);
+                MeshRuntimeStore.getInstance().deleteRemoteIdleSession(eventNodeId, eventSessionId);
             } catch { /* best-effort */ }
         }
         LOG.info('MeshEvents', `Suppressed ${args.event} for intentionally cleanup-stopped session ${eventSessionId || '(unknown session)'}`);
@@ -1625,6 +1670,8 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             // Scope dedup to the coordinator daemon so two coordinators for the same mesh
             // don't suppress each other's completion events via shared fingerprint table.
             coordinatorDaemonId: workerCoordinatorDaemonId || undefined,
+            taskId: readNonEmptyString(args.metadataEvent.taskId) || undefined,
+            nodeId: eventNodeId || undefined,
         });
         if (duplicateCompletion) {
             LOG.info('MeshEvents', `Suppressed duplicate completion for mesh ${args.meshId} session ${eventSessionId}`);
@@ -1641,6 +1688,8 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             timestamp: eventTimestamp,
             finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || undefined,
             coordinatorDaemonId: workerCoordinatorDaemonId || undefined,
+            taskId: readNonEmptyString(args.metadataEvent.taskId) || undefined,
+            nodeId: eventNodeId || undefined,
         });
         if (duplicateStopped) {
             LOG.info('MeshEvents', `Suppressed duplicate stopped event for mesh ${args.meshId} session ${eventSessionId}`);
@@ -1718,14 +1767,14 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         if (sessionId && nodeId && providerType) {
             sweepExpiredRemoteIdleSessions();
             try {
-                BeadsDB.getInstance().setRemoteIdleSession(nodeId, sessionId, providerType, Date.now() + REMOTE_IDLE_SESSION_TTL_MS);
+                MeshRuntimeStore.getInstance().setRemoteIdleSession(nodeId, sessionId, providerType, Date.now() + REMOTE_IDLE_SESSION_TTL_MS);
             } catch { /* best-effort */ }
             setImmediate(() => {
                 maybeAutoFastForwardIdleNode(components, { meshId: args.meshId, nodeId, sessionId, providerType })
                     .finally(() => {
                         try {
                             const assigned = tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
-                            if (assigned) BeadsDB.getInstance().deleteRemoteIdleSession(nodeId, sessionId);
+                            if (assigned) MeshRuntimeStore.getInstance().deleteRemoteIdleSession(nodeId, sessionId);
                         } catch (e: any) {
                             LOG.warn('MeshQueue', `Failed to assign idle queue task after maintenance for ${nodeId}: ${e?.message || e}`);
                         }
@@ -1737,7 +1786,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
         if (sessionId && nodeId) {
             try {
-                BeadsDB.getInstance().deleteRemoteIdleSession(nodeId, sessionId);
+                MeshRuntimeStore.getInstance().deleteRemoteIdleSession(nodeId, sessionId);
             } catch { /* best-effort */ }
         }
         if (sessionId) {
@@ -1748,7 +1797,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
         if (sessionId && nodeId) {
             try {
-                BeadsDB.getInstance().deleteRemoteIdleSession(nodeId, sessionId);
+                MeshRuntimeStore.getInstance().deleteRemoteIdleSession(nodeId, sessionId);
             } catch { /* best-effort */ }
         }
         if (sessionId) {