@adhdev/daemon-core 0.9.82-rc.250 → 0.9.82-rc.252

package/package.json

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

package/src/commands/router.ts

@@ -7301,19 +7301,15 @@ export class DaemonCommandRouter {
                         nodeStatuses.push(status);
                     }
 
-                    // (B3) Resolve the coordinator daemon scope for the drain.
-                    // Emit-time always tags events with the worker's
-                    // targetCoordinatorDaemonId and writes them to the
-                    // scoped pending-events file. If the caller (MCP tool,
-                    // dashboard, etc.) doesn't tell us which coordinator
-                    // they're running under, fall back to *this daemon's*
-                    // ID — the caller reached us over our IPC/WS, so they
-                    // are by definition under this daemon. Falling back to
-                    // undefined would silently miss every scoped event.
+                    // (B3) Resolve the coordinator daemon scope for the peek.
+                    // mesh_status is a read-only status query — it must not consume
+                    // (drain) pending events as a side effect. Coordinators that see
+                    // pendingCoordinatorEvents in the response are expected to call
+                    // get_pending_mesh_events to explicitly drain them after processing.
                     const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === 'string' && args.coordinatorDaemonId.trim()
                         ? args.coordinatorDaemonId.trim()
                         : (this.deps.statusInstanceId || undefined);
-                    const pendingCoordinatorEvents = drainPendingMeshCoordinatorEvents(meshId, callerCoordinatorDaemonId);
+                    const pendingCoordinatorEvents = getPendingMeshCoordinatorEvents(meshId, callerCoordinatorDaemonId);
                     const previewFreshness = (() => {
                         const localRepoRoot = nodeStatuses
                             .map((node: any) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace))
@@ -7323,7 +7319,7 @@ export class DaemonCommandRouter {
                     const asyncRefineJobs = buildMeshAsyncRefineJobs({
                         meshId,
                         ledgerEntries: asyncRefineLedgerEntries,
-                        pendingEvents: pendingCoordinatorEvents,
+                        pendingEvents: [...pendingCoordinatorEvents],
                     });
                     const historicalSessions = buildHistoricalMeshSessions({
                         meshId,

package/src/mesh/mesh-events-coordinator.ts

@@ -1338,28 +1338,28 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         return { success: true, forwarded: 0 };
     }
 
-    // Non-terminal events are also queued for MCP coordinator dual delivery.
-    // Terminal events are forwarded directly without buffering — previously
-    // they were buffered when coordinators were generating and auto-flushed on
-    // idle, but auto-flush was unreliable and events were silently lost.
-    const isTerminalEvent = new Set(['refine:completed', 'refine:failed', 'agent:generating_completed', 'agent:stopped']).has(args.event);
-    if (!isTerminalEvent) {
-        if (queuePendingMeshCoordinatorEvent({
-                event: args.event,
-                meshId: args.meshId,
-                nodeLabel: args.nodeLabel,
-                nodeId: args.nodeId || undefined,
-                workspace: readNonEmptyString(args.metadataEvent.workspace),
-                metadataEvent: {
-                    ...args.metadataEvent,
-                    ...(recoveryContext ? { recoveryContext } : {}),
-                },
-                coordinatorMessage: messageText,
-                queuedAt: Date.now(),
-                ...(workerCoordinatorDaemonId ? { targetCoordinatorDaemonId: workerCoordinatorDaemonId } : {}),
-            })) {
-            LOG.info('MeshEvents', `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
-        }
+    // All events — terminal and non-terminal — are queued for MCP coordinator
+    // delivery via the pending-events file/SQLite path. This ensures that MCP
+    // coordinators (which poll via get_pending_mesh_events / mesh_status) always
+    // receive terminal events even when a live CLI coordinator session is present.
+    // Previously, terminal events skipped the queue and were only direct-injected
+    // into live CLI coordinators via send_message, which silently dropped them
+    // when the coordinator was in a generating state.
+    if (queuePendingMeshCoordinatorEvent({
+            event: args.event,
+            meshId: args.meshId,
+            nodeLabel: args.nodeLabel,
+            nodeId: args.nodeId || undefined,
+            workspace: readNonEmptyString(args.metadataEvent.workspace),
+            metadataEvent: {
+                ...args.metadataEvent,
+                ...(recoveryContext ? { recoveryContext } : {}),
+            },
+            coordinatorMessage: messageText,
+            queuedAt: Date.now(),
+            ...(workerCoordinatorDaemonId ? { targetCoordinatorDaemonId: workerCoordinatorDaemonId } : {}),
+        })) {
+        LOG.info('MeshEvents', `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
     }
 
     for (const coord of coordinatorInstances) {

package/src/mesh/mesh-events-pending.ts

@@ -60,6 +60,12 @@ function hasPendingRefineTerminalEventDuplicate(event: PendingMeshCoordinatorEve
 
 export function buildPendingEventFingerprint(event: PendingMeshCoordinatorEvent): string {
     const metadata = readRecord(event.metadataEvent) || {};
+    // Bootstrap events are node-scoped: dedup by meshId+event+nodeId only.
+    // They carry no sessionId/taskId/timestamp — using those fields would produce
+    // an empty fingerprint that defeats dedup entirely.
+    if (event.event === 'worktree_bootstrap_complete' || event.event === 'worktree_bootstrap_failed') {
+        return [event.meshId, event.event, event.nodeId || ''].join('::');
+    }
     const sessionId = resolveEventSessionId(metadata);
     const providerSessionId = readNonEmptyString(metadata.providerSessionId);
     const taskId = readNonEmptyString(metadata.taskId) || readNonEmptyString(readRecord(metadata.payload)?.taskId);