@adhdev/daemon-core 0.9.82-rc.190 → 0.9.82-rc.192

package/dist/mesh/beads-db.d.ts

@@ -70,4 +70,14 @@ export declare class BeadsDB {
     cleanupTerminalDirectDispatches(olderThanMs: number): void;
     deleteDirectDispatches(meshId: string): void;
     markStaleDirectDispatches(meshId: string, olderThanMs: number): void;
+    setRemoteIdleSession(nodeId: string, sessionId: string, providerType: string, expiresAt: number, metadata?: any): void;
+    getRemoteIdleSessions(): Array<{
+        nodeId: string;
+        sessionId: string;
+        providerType: string;
+        expiresAt: number;
+        metadata?: any;
+    }>;
+    deleteRemoteIdleSession(nodeId: string, sessionId: string): void;
+    pruneExpiredRemoteIdleSessions(): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.190",
+  "version": "0.9.82-rc.192",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/mesh/beads-db.ts

@@ -111,6 +111,15 @@ export class BeadsDB {
 
             CREATE INDEX IF NOT EXISTS idx_direct_dispatches_mesh_session
                 ON mesh_direct_dispatches(mesh_id, session_id, status);
+
+            CREATE TABLE IF NOT EXISTS remote_idle_sessions (
+                node_id TEXT NOT NULL,
+                session_id TEXT NOT NULL,
+                provider_type TEXT NOT NULL,
+                expires_at INTEGER NOT NULL,
+                metadata TEXT,
+                PRIMARY KEY (node_id, session_id)
+            );
         `);
     }
 
@@ -487,4 +496,32 @@ export class BeadsDB {
             WHERE mesh_id = ? AND status = 'dispatched' AND dispatched_at < ?
         `).run(now, meshId, cutoff);
     }
+
+    // ── Remote Idle Sessions ─────────────────────────────────────────────────
+
+    setRemoteIdleSession(nodeId: string, sessionId: string, providerType: string, expiresAt: number, metadata?: any): void {
+        this.db.prepare(`
+            INSERT OR REPLACE INTO remote_idle_sessions (node_id, session_id, provider_type, expires_at, metadata)
+            VALUES (?, ?, ?, ?, ?)
+        `).run(nodeId, sessionId, providerType, expiresAt, metadata ? JSON.stringify(metadata) : null);
+    }
+
+    getRemoteIdleSessions(): Array<{ nodeId: string; sessionId: string; providerType: string; expiresAt: number; metadata?: any }> {
+        const rows = this.db.prepare('SELECT node_id, session_id, provider_type, expires_at, metadata FROM remote_idle_sessions').all() as Array<any>;
+        return rows.map(r => ({
+            nodeId: r.node_id,
+            sessionId: r.session_id,
+            providerType: r.provider_type,
+            expiresAt: r.expires_at,
+            metadata: r.metadata ? JSON.parse(r.metadata) : undefined,
+        }));
+    }
+
+    deleteRemoteIdleSession(nodeId: string, sessionId: string): void {
+        this.db.prepare('DELETE FROM remote_idle_sessions WHERE node_id = ? AND session_id = ?').run(nodeId, sessionId);
+    }
+
+    pruneExpiredRemoteIdleSessions(): void {
+        this.db.prepare('DELETE FROM remote_idle_sessions WHERE expires_at <= ?').run(Date.now());
+    }
 }

package/src/mesh/mesh-events.ts

@@ -18,14 +18,7 @@ import { fastForwardMeshNode } from './mesh-fast-forward.js';
 // can assign tasks to them. Each entry carries an expiresAt timestamp;
 // entries are swept on insertion to prevent unbounded growth.
 // ---------------------------------------------------------------------------
-interface RemoteIdleSession {
-    nodeId: string;
-    sessionId: string;
-    providerType: string;
-    expiresAt: number;
-}
 const REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1000; // 5 minutes
-const remoteIdleSessions = new Map<string, RemoteIdleSession>(); // key: `${nodeId}:${sessionId}`
 
 // ---------------------------------------------------------------------------
 // Workspace-to-mesh lookup cache
@@ -55,10 +48,9 @@ export function __resetIdleAutoFastForwardForTests(): void {
 }
 
 function sweepExpiredRemoteIdleSessions(): void {
-    const now = Date.now();
-    for (const [key, session] of remoteIdleSessions) {
-        if (session.expiresAt <= now) remoteIdleSessions.delete(key);
-    }
+    try {
+        BeadsDB.getInstance().pruneExpiredRemoteIdleSessions();
+    } catch { /* best-effort */ }
 }
 
 // ---------------------------------------------------------------------------
@@ -1286,14 +1278,21 @@ export async function triggerMeshQueue(components: DaemonComponents, meshId: str
     }
 
     // Also check known idle remote sessions
-    for (const [key, idle] of remoteIdleSessions.entries()) {
+    let remoteSessions: Array<{ nodeId: string; sessionId: string; providerType: string }> = [];
+    try {
+        remoteSessions = BeadsDB.getInstance().getRemoteIdleSessions();
+    } catch { /* best-effort */ }
+
+    for (const idle of remoteSessions) {
         // Find if this node is in the same mesh
         const node = mesh.nodes.find((n: any) => n.id === idle.nodeId);
         if (node) {
             remoteIdleSessionsChecked += 1;
             const assigned = tryAssignQueueTask(components, meshId, idle.nodeId, idle.sessionId, idle.providerType);
             if (assigned) {
-                remoteIdleSessions.delete(key);
+                try {
+                    BeadsDB.getInstance().deleteRemoteIdleSession(idle.nodeId, idle.sessionId);
+                } catch { /* best-effort */ }
             }
         }
     }
@@ -1534,7 +1533,9 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     });
     if (intentionalCleanupStop) {
         if (eventSessionId && eventNodeId) {
-            remoteIdleSessions.delete(`${eventNodeId}:${eventSessionId}`);
+            try {
+                BeadsDB.getInstance().deleteRemoteIdleSession(eventNodeId, eventSessionId);
+            } catch { /* best-effort */ }
         }
         LOG.info('MeshEvents', `Suppressed ${args.event} for intentionally cleanup-stopped session ${eventSessionId || '(unknown session)'}`);
         return { success: true, forwarded: 0, suppressed: true, intentionalCleanupStop: true };
@@ -1632,19 +1633,26 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     }
 
     // ── Task Queue & Ledger ──
+    // Helpers that keep queue and direct-dispatch status transitions symmetric.
+    // Both paths must move together so buildMeshActiveWork and the coordinator
+    // view stay consistent regardless of which dispatch path was used.
+    function markSessionTerminal(sessionId: string, outcome: 'completed' | 'failed', occurredAtMs?: number | null): { id?: string } | null {
+        const task = updateSessionTaskStatus(args.meshId, sessionId, outcome, {
+            occurredAt: occurredAtMs != null ? new Date(occurredAtMs).toISOString() : undefined,
+        });
+        updateDirectDispatchStatus(args.meshId, sessionId, outcome);
+        setImmediate(() => cleanupTerminalDirectDispatches());
+        return task ? { id: task.id } : null;
+    }
+
     let completedTaskForLedger: { id?: string } | null = null;
     if (args.event === 'agent:generating_completed') {
         const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
         const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
         const providerType = readNonEmptyString(args.metadataEvent.providerType);
-        
+
         if (sessionId) {
-            const completedTask = updateSessionTaskStatus(args.meshId, sessionId, 'completed', {
-                occurredAt: eventTimestamp !== null ? new Date(eventTimestamp).toISOString() : undefined,
-            });
-            completedTaskForLedger = completedTask ? { id: completedTask.id } : null;
-            updateDirectDispatchStatus(args.meshId, sessionId, 'completed');
-            setImmediate(() => cleanupTerminalDirectDispatches());
+            completedTaskForLedger = markSessionTerminal(sessionId, 'completed', eventTimestamp);
             if (nodeId && providerType) {
                 runIdleMaintenanceThenAssignQueue(components, { meshId: args.meshId, nodeId, sessionId, providerType });
             }
@@ -1657,55 +1665,51 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         const finalSummary = readNonEmptyString(args.metadataEvent.finalSummary) || undefined;
         const workerResult = readWorkerResultMetadata(args.metadataEvent);
         const hasCompletionEvidence = !!finalSummary || !!workerResult;
-        const completedTask = sessionId && hasCompletionEvidence
-            ? updateSessionTaskStatus(args.meshId, sessionId, 'completed')
-            : null;
-        if (completedTask && sessionId) {
-            completedTaskForLedger = { id: completedTask.id };
-            updateDirectDispatchStatus(args.meshId, sessionId, 'completed');
-            setImmediate(() => cleanupTerminalDirectDispatches());
-            try {
-                appendLedgerEntry(args.meshId, {
-                    kind: 'task_completed',
-                    nodeId: nodeId || undefined,
-                    sessionId,
-                    providerType: providerType || undefined,
-                    payload: {
-                        event: args.event,
-                        nodeLabel: args.nodeLabel,
-                        taskId: completedTask.id,
-                        completedViaReady: true,
-                        providerSessionId,
-                        finalSummary,
-                        workerResult,
-                        evidence: buildTaskCompletionEvidence({
-                            event: 'agent:ready',
-                            nodeId,
-                            sessionId,
-                            providerType: providerType || undefined,
+        if (sessionId && hasCompletionEvidence) {
+            completedTaskForLedger = markSessionTerminal(sessionId, 'completed');
+            if (completedTaskForLedger) {
+                try {
+                    appendLedgerEntry(args.meshId, {
+                        kind: 'task_completed',
+                        nodeId: nodeId || undefined,
+                        sessionId,
+                        providerType: providerType || undefined,
+                        payload: {
+                            event: args.event,
+                            nodeLabel: args.nodeLabel,
+                            taskId: completedTaskForLedger.id,
+                            completedViaReady: true,
                             providerSessionId,
                             finalSummary,
                             workerResult,
-                        }),
-                    },
-                });
-            } catch (e: any) {
-                LOG.warn('MeshLedger', `Failed to record task_completed from ready: ${e?.message || e}`);
+                            evidence: buildTaskCompletionEvidence({
+                                event: 'agent:ready',
+                                nodeId,
+                                sessionId,
+                                providerType: providerType || undefined,
+                                providerSessionId,
+                                finalSummary,
+                                workerResult,
+                            }),
+                        },
+                    });
+                } catch (e: any) {
+                    LOG.warn('MeshLedger', `Failed to record task_completed from ready: ${e?.message || e}`);
+                }
             }
         }
-        
+
         if (sessionId && nodeId && providerType) {
             sweepExpiredRemoteIdleSessions();
-            remoteIdleSessions.set(`${nodeId}:${sessionId}`, {
-                nodeId, sessionId, providerType,
-                expiresAt: Date.now() + REMOTE_IDLE_SESSION_TTL_MS,
-            });
+            try {
+                BeadsDB.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) remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+                            if (assigned) BeadsDB.getInstance().deleteRemoteIdleSession(nodeId, sessionId);
                         } catch (e: any) {
                             LOG.warn('MeshQueue', `Failed to assign idle queue task after maintenance for ${nodeId}: ${e?.message || e}`);
                         }
@@ -1716,22 +1720,23 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
         const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
         if (sessionId && nodeId) {
-            remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+            try {
+                BeadsDB.getInstance().deleteRemoteIdleSession(nodeId, sessionId);
+            } catch { /* best-effort */ }
         }
         if (sessionId) {
-            // Mark direct dispatch as acknowledged — the session started generating.
             updateDirectDispatchStatus(args.meshId, sessionId, 'acked');
         }
     } else if (args.event === 'agent:stopped') {
         const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
         const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
         if (sessionId && nodeId) {
-            remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+            try {
+                BeadsDB.getInstance().deleteRemoteIdleSession(nodeId, sessionId);
+            } catch { /* best-effort */ }
         }
         if (sessionId) {
-            const failedTask = updateSessionTaskStatus(args.meshId, sessionId, 'failed');
-            completedTaskForLedger = failedTask ? { id: failedTask.id } : null;
-            updateDirectDispatchStatus(args.meshId, sessionId, 'failed');
+            completedTaskForLedger = markSessionTerminal(sessionId, 'failed');
         }
     }
 
@@ -2019,21 +2024,20 @@ export function setupMeshEventForwarding(components: DaemonComponents) {
         if (!workspace) return;
         const settings = state.settings && typeof state.settings === 'object' ? state.settings as Record<string, unknown> : {};
 
-        // Coordinator sessions normally must not inject events into themselves, but a
-        // coordinator session can also be the direct-dispatch target of mesh_send_task
-        // issued by another coordinator (e.g. a remote orchestrator delegated a task to
-        // this local coordinator). In that case the completion event must still flow into
-        // injectMeshSystemMessage so the ledger records task_completed and the *other*
-        // coordinator's pendingCoordinatorEvents queue is populated. Skip only when this
-        // session is purely a coordinator with no in-flight direct dispatch waiting on it.
+        // A coordinator session normally must not inject events into itself. However,
+        // a coordinator can also be the direct-dispatch target of mesh_send_task from
+        // another coordinator. In that case the completion event must flow through
+        // injectMeshSystemMessage so the ledger records task_completed and the other
+        // coordinator's pendingCoordinatorEvents queue is populated. Skip only when
+        // this session has no in-flight direct dispatch.
         const coordinatorMeshId = readNonEmptyString(settings.meshCoordinatorFor);
         let meshIdFromDirectDispatch = '';
         if (coordinatorMeshId) {
             try {
-                const activeDispatches = getActiveDirectDispatches(coordinatorMeshId);
-                if (activeDispatches.some(d => d.sessionId === instanceId) || hasUnterminalDirectDispatchLedgerEntry(coordinatorMeshId, instanceId)) {
-                    meshIdFromDirectDispatch = coordinatorMeshId;
-                }
+                const hasActiveDispatch =
+                    getActiveDirectDispatches(coordinatorMeshId).some(d => d.sessionId === instanceId)
+                    || hasUnterminalDirectDispatchLedgerEntry(coordinatorMeshId, instanceId);
+                if (hasActiveDispatch) meshIdFromDirectDispatch = coordinatorMeshId;
             } catch { /* best-effort */ }
             if (!meshIdFromDirectDispatch) return;
         }