@adhdev/daemon-core 0.9.82-rc.395 → 0.9.82-rc.396

package/dist/mesh/mesh-events-stale.d.ts

@@ -34,6 +34,15 @@ export declare function reconcileDirectDispatchCompletionFromTranscript(args: {
     transcriptMessageAt?: string;
     completedAt?: string;
     targetCoordinatorDaemonId?: string;
+    /**
+     * NOTIF-DROP-SYNTH-NO-MESSAGE: the originating coordinator SESSION that dispatched this
+     * task (the `coordinatorSessionId` stamped onto the task_dispatched ledger payload at
+     * dispatch). Stamped onto the synthesized completion's targetCoordinatorSessionId so PHASE 2
+     * STRICT routing matches the exact coordinator session — instead of relying on the
+     * daemon-keyed fallback. When the caller does not pass it, it is recovered from the dispatch
+     * ledger entry below; absent on legacy rows → daemon-level routing (unchanged).
+     */
+    targetCoordinatorSessionId?: string;
     source?: string;
 }): {
     reconciled: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.395",
+  "version": "0.9.82-rc.396",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.395",
+    "@adhdev/mesh-shared": "0.9.82-rc.396",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

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

@@ -3,7 +3,7 @@ import type { MeshLedgerKind } from './mesh-ledger.js';
 import { updateDirectDispatchStatus, cleanupTerminalDirectDispatches } from './mesh-work-queue.js';
 import { markSessionDeliveriesTerminal } from './mesh-delivery-policy.js';
 import { queuePendingMeshCoordinatorEvent } from './mesh-events-pending.js';
-import { readNonEmptyString, readRecord, resolveEventSessionId, readWorkerResultMetadata, isWeakCompletionEvidence } from './mesh-events-utils.js';
+import { readNonEmptyString, readRecord, resolveEventSessionId, readWorkerResultMetadata, isWeakCompletionEvidence, buildMeshSystemMessage } from './mesh-events-utils.js';
 import { meshNodeIdMatches, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 
 // ---------------------------------------------------------------------------
@@ -188,6 +188,15 @@ export function reconcileDirectDispatchCompletionFromTranscript(args: {
     transcriptMessageAt?: string;
     completedAt?: string;
     targetCoordinatorDaemonId?: string;
+    /**
+     * NOTIF-DROP-SYNTH-NO-MESSAGE: the originating coordinator SESSION that dispatched this
+     * task (the `coordinatorSessionId` stamped onto the task_dispatched ledger payload at
+     * dispatch). Stamped onto the synthesized completion's targetCoordinatorSessionId so PHASE 2
+     * STRICT routing matches the exact coordinator session — instead of relying on the
+     * daemon-keyed fallback. When the caller does not pass it, it is recovered from the dispatch
+     * ledger entry below; absent on legacy rows → daemon-level routing (unchanged).
+     */
+    targetCoordinatorSessionId?: string;
     source?: string;
 }): { reconciled: boolean; kind?: MeshLedgerKind; alreadyTerminal?: boolean; workerResult?: unknown; ledgerEntryId?: string; reason?: string } {
     const finalSummary = readNonEmptyString(args.finalSummary);
@@ -282,27 +291,44 @@ export function reconcileDirectDispatchCompletionFromTranscript(args: {
     updateDirectDispatchStatus(args.meshId, args.sessionId, kind === 'task_completed' ? 'completed' : 'failed', args.taskId);
     markSessionDeliveriesTerminal(args.meshId, args.sessionId, kind === 'task_completed' ? 'completed' : 'failed');
     setImmediate(() => cleanupTerminalDirectDispatches());
+    // NOTIF-DROP-SYNTH-NO-MESSAGE: the queued synth completion MUST carry a coordinatorMessage,
+    // or injectPendingIntoCoordinator early-returns (`!pending.coordinatorMessage`) and the row is
+    // drained-without-inject → no [System] surface. The ~8s-later native completion then collides
+    // on the taskId-anchored fingerprint and is blocked at INSERT, so the notification is lost
+    // forever. Build the SAME [System] message the native path builds (buildMeshSystemMessage) so
+    // the synth is itself a complete, deliverable completion. Routing is made STRICT too: stamp the
+    // originating coordinator session so PHASE 2 strict-match delivers to the exact coordinator
+    // session that dispatched the task instead of falling back to a daemon-level broadcast.
+    const eventName = kind === 'task_completed' ? 'agent:generating_completed' : 'agent:stopped';
+    const nodeLabel = nodeId ? `Node '${nodeId}'` : 'Remote agent';
+    const metadataEvent = {
+        targetSessionId: args.sessionId,
+        providerType: providerType || undefined,
+        providerSessionId: readNonEmptyString(args.providerSessionId),
+        finalSummary,
+        taskId: args.taskId,
+        workerResult,
+        completionDiagnostic: {
+            reason: 'direct_task_transcript_reconciliation',
+            terminalLedgerKind: kind,
+            terminalLedgerId: entry.id,
+        },
+    };
+    // Originating coordinator session: prefer the explicit arg; otherwise recover it from the
+    // task_dispatched ledger payload (the MCP dispatch path stamps `coordinatorSessionId` there).
+    // Absent on legacy rows → undefined → daemon-level routing (unchanged, no regression).
+    const targetCoordinatorSessionId = readNonEmptyString(args.targetCoordinatorSessionId)
+        || readNonEmptyString(dispatch?.payload?.coordinatorSessionId);
     queuePendingMeshCoordinatorEvent({
-        event: kind === 'task_completed' ? 'agent:generating_completed' : 'agent:stopped',
+        event: eventName,
         meshId: args.meshId,
-        nodeLabel: nodeId ? `Node '${nodeId}'` : 'Remote agent',
+        nodeLabel,
         nodeId: nodeId || undefined,
-        metadataEvent: {
-            targetSessionId: args.sessionId,
-            providerType: providerType || undefined,
-            providerSessionId: readNonEmptyString(args.providerSessionId),
-            finalSummary,
-            taskId: args.taskId,
-            workerResult,
-            completionDiagnostic: {
-                reason: 'direct_task_transcript_reconciliation',
-                terminalLedgerKind: kind,
-                terminalLedgerId: entry.id,
-            },
-        },
-        coordinatorMessage: undefined,
+        metadataEvent,
+        coordinatorMessage: buildMeshSystemMessage({ event: eventName, nodeLabel, metadataEvent }),
         queuedAt: Date.now(),
         ...(readNonEmptyString(args.targetCoordinatorDaemonId) ? { targetCoordinatorDaemonId: readNonEmptyString(args.targetCoordinatorDaemonId) } : {}),
+        ...(targetCoordinatorSessionId ? { targetCoordinatorSessionId } : {}),
     });
 
     return { reconciled: true, kind, workerResult, ledgerEntryId: entry.id };

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

@@ -55,7 +55,7 @@ import {
     ackUnresolvedDelegateForward,
     expireStaleUnresolvedDelegateForwards,
 } from './mesh-unresolved-forward-outbox.js';
-import { readNonEmptyString, readMeshCompletionSummary } from './mesh-events-utils.js';
+import { readNonEmptyString, readMeshCompletionSummary, buildMeshSystemMessage } from './mesh-events-utils.js';
 import { traceMeshEventStage, traceMeshEventDrop } from './mesh-event-trace.js';
 import { expandDaemonIdForms, daemonIdsEquivalent } from '@adhdev/mesh-shared';
 import { getActiveDirectDispatches, getQueue, reclaimStrandedAssignedTask, updateTaskStatus } from './mesh-work-queue.js';
@@ -368,7 +368,30 @@ function injectPendingIntoCoordinator(
     coordinator: LiveCoordinator['instance'],
     pending: PendingMeshCoordinatorEvent,
 ): void {
-    if (!coordinator || !pending.coordinatorMessage) return;
+    if (!coordinator) return;
+    // NOTIF-DROP-SYNTH-NO-MESSAGE (defence-in-depth): a queued event with no coordinatorMessage
+    // used to be dropped here (drain-without-inject) — the row had already been consumed
+    // (drained=1) by the caller's drain, so silently returning lost it forever. The primary fix
+    // makes the transcript-reconcile synth always carry a coordinatorMessage, but as a backstop,
+    // lazily synthesize the [System] text for any force-inject (terminal: completion / approval /
+    // stop / refine·bootstrap) event that still arrives message-less, so it surfaces instead of
+    // vanishing. A NON-force lifecycle event (agent:ready / generating_started) legitimately
+    // carries no message and must NOT be injected (it is queued only to re-drive the claim state
+    // machine on pull) — for it we still return without injecting.
+    let coordinatorMessage = pending.coordinatorMessage;
+    if (!coordinatorMessage) {
+        if (!shouldForceInjectMeshEvent(pending.event)) return;
+        const metadataEvent = pending.metadataEvent && typeof pending.metadataEvent === 'object'
+            ? pending.metadataEvent
+            : {};
+        coordinatorMessage = buildMeshSystemMessage({
+            event: pending.event,
+            nodeLabel: pending.nodeLabel,
+            metadataEvent,
+        });
+        if (!coordinatorMessage) return; // builder produced nothing — nothing to surface
+        LOG.warn('MeshReconcile', `Lazily synthesized missing coordinatorMessage for ${pending.event} (mesh ${pending.meshId}) at inject time — a queued terminal event arrived message-less`);
+    }
     const force = shouldForceInjectMeshEvent(pending.event);
     // EVTTRACE: event surfaced to the coordinator (injected into its live CLI session).
     // This is the terminal happy-path stage. Observation only.
@@ -380,7 +403,7 @@ function injectPendingIntoCoordinator(
         event: pending.event,
     }, force ? 'force-inject' : 'inject');
     coordinator.onEvent('send_message', {
-        input: { text: pending.coordinatorMessage, textFallback: pending.coordinatorMessage },
+        input: { text: coordinatorMessage, textFallback: coordinatorMessage },
         ...(force ? { force: true } : {}),
     });
 }