@adhdev/daemon-core 0.9.82-rc.379 → 0.9.82-rc.380

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.379",
+  "version": "0.9.82-rc.380",
   "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.379",
+    "@adhdev/mesh-shared": "0.9.82-rc.380",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/mesh/mesh-event-forwarding.ts

@@ -310,6 +310,44 @@ function isDuplicateRefineTerminalEvent(meshId: string, eventName: string, metad
     return false;
 }
 
+// NOTIF-MISS (FIX 2): the set of `source` tags the transcript-reconcile synthesis path stamps
+// onto the terminal ledger entry it writes (mesh-events-stale.reconcileDirectDispatchCompletion
+// FromTranscript). A terminal carrying one of these was NOT produced by an actual provider
+// agent_status_event — it is a coordinator-side reconstruction from the worker's transcript. The
+// authoritative real completion must never be permanently masked by such a synthesized record.
+const RECONCILED_COMPLETION_SOURCES = new Set([
+    'direct_task_transcript_reconciliation',
+    'daemon_reconcile_transcript_completion',
+    'mcp_mesh_status_transcript_reconciliation',
+    'no_progress_reconciliation',
+]);
+
+// True when the recorded terminal ledger entry was SYNTHESIZED by transcript reconciliation
+// rather than emitted by the real provider event. The reconcile path tags its ledger payload
+// with a reconcile `source`; a genuine provider completion carries no such tag (or a normal
+// completionDiagnostic.reason). Both the explicit source AND the diagnostic reason are checked so
+// either carrier identifies the synthesized record.
+function isSynthesizedReconciledTerminal(terminalPayload: Record<string, unknown>): boolean {
+    const source = readNonEmptyString(terminalPayload.source);
+    if (source && RECONCILED_COMPLETION_SOURCES.has(source)) return true;
+    const diagnostic = terminalPayload.completionDiagnostic;
+    if (diagnostic && typeof diagnostic === 'object' && !Array.isArray(diagnostic)) {
+        const reason = readNonEmptyString((diagnostic as Record<string, unknown>).reason);
+        if (reason && RECONCILED_COMPLETION_SOURCES.has(reason)) return true;
+    }
+    return false;
+}
+
+// True when the INCOMING completion event is a REAL provider agent_status_event (an actual
+// agent:generating_completed from the live session) rather than itself a synthesized/reconciled
+// re-injection. We must only let a real event override a synthesized terminal — a second
+// synthesized re-arrival should still dedup normally. A real provider event carries no reconcile
+// `source` tag; a re-injected reconciliation does.
+function isRealProviderCompletionEvent(metadataEvent: Record<string, unknown>): boolean {
+    const source = readNonEmptyString(metadataEvent.source);
+    return !source || !RECONCILED_COMPLETION_SOURCES.has(source);
+}
+
 // The genuine-completion counterpart: a real final summary / worker result is present and
 // the completion is not flagged as a missing-final-assistant false idle. Used to decide
 // whether a new completion may supersede a prior WEAK (false-idle) terminal. NOTE this gates
@@ -516,7 +554,20 @@ function evaluateMeshEventSuppression(
                 terminalTaskId,
                 eventTaskId,
             });
-            if (!newDispatchAfterTerminal && !supersedesWeakTerminal && !distinctTaskCompletion && !supersedesTruncatedTerminal) {
+            // NOTIF-MISS (FIX 2): the recorded terminal was SYNTHESIZED by transcript reconciliation
+            // (no real provider event), and THIS incoming event is the authoritative REAL provider
+            // completion. The reconcile path may fire ~1s after a direct dispatch from a reused
+            // session's stale transcript tail, writing a synthesized terminal whose providerSessionId
+            // (stable across a session's turns) and/or finalSummary then match the real completion —
+            // so the providerSessionId/finalSummary dedup below would drop the genuine event and the
+            // coordinator would never learn the task finished. A synthesized record must NEVER
+            // permanently mask the real completion: let the real event through (it is re-recorded by
+            // the normal task_completed path, superseding the synthesized one). A second SYNTHESIZED
+            // re-arrival is NOT a real event and still dedups normally.
+            const supersedesSynthesizedTerminal = isSynthesizedReconciledTerminal(terminal.payload)
+                && isRealProviderCompletionEvent(args.metadataEvent)
+                && isGenuineCompletionEvidence(args.metadataEvent);
+            if (!newDispatchAfterTerminal && !supersedesWeakTerminal && !distinctTaskCompletion && !supersedesTruncatedTerminal && !supersedesSynthesizedTerminal) {
                 const terminalProviderSessionId = readNonEmptyString(terminal.payload.providerSessionId);
                 const terminalFinalSummary = readNonEmptyString(terminal.payload.finalSummary);
                 const eventProviderSessionId = readNonEmptyString(args.metadataEvent.providerSessionId);
@@ -1180,8 +1231,14 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
         return { success: false, error: 'meshId required' };
     }
     // EVTTRACE: forwarded event accepted at receive (meshId resolved).
+    // NOTIF-MISS (FIX 3): mirror buildRelayMetadataEvent's taskId fallback. A worker provider
+    // completion stamps its task id as `meshActiveTaskId` (settings → event), not always the
+    // top-level `taskId`, so reading payload.taskId alone rendered `task=-` at the received stage
+    // (the [stage:queued] task=<id> → [stage:received] task=- loss). Falling back to
+    // meshActiveTaskId keeps the trace task-scoped end-to-end so same-task redelivery is
+    // distinguishable from a different task's real completion.
     traceMeshEventStage('received', {
-        taskId: payload.taskId,
+        taskId: readNonEmptyString(payload.taskId) || readNonEmptyString(payload.meshActiveTaskId),
         sessionId: readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId),
         nodeId,
         meshId,

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

@@ -10,6 +10,25 @@ import { meshNodeIdMatches, type MeshNodeIdentified } from '@adhdev/mesh-shared'
 // Stale direct-dispatch detection & transcript reconciliation
 // ---------------------------------------------------------------------------
 
+// NOTIF-MISS grace gate. A direct dispatch (mesh_send_task) to an ALREADY-IDLE,
+// previously-used session reuses a transcript that still holds the PRIOR turn's final
+// assistant message. The session momentarily reads `idle` in the first second after
+// dispatch (the worker hasn't started generating yet), so the transcript reconcile here
+// would otherwise synthesize a "completion" ~1s after dispatch from that stale tail —
+// writing a synthesized task_completed + queuing a completion event. When the REAL
+// completion fires minutes later, checkSuppressMeshEvent drops it as a duplicate of the
+// synthesized one (same providerSessionId/finalSummary), so the coordinator never learns
+// the task actually finished. The grace period refuses to synthesize until enough time has
+// passed since dispatch that a genuine same-task completion is plausible, closing the race
+// window. The stale-summary timestamp guard (transcript predates dispatch) and FIX 2 in
+// mesh-event-forwarding (a synthesized completion never suppresses the authoritative real
+// one) are the correctness backstops; this grace just stops the synthesis from firing in
+// the first place for the common case. An idle-session dispatch (dispatchedToIdleSession)
+// is the exact race above, so it gets a LONGER grace than a dispatch to a session that was
+// already generating (where a transcript reconcile is far less likely to be premature).
+const DIRECT_DISPATCH_RECONCILE_GRACE_MS = 60_000;
+const DIRECT_DISPATCH_IDLE_SESSION_RECONCILE_GRACE_MS = 120_000;
+
 export function findRecentTerminalLedgerEvidence(args: {
     meshId: string;
     sessionId?: string;
@@ -210,6 +229,29 @@ export function reconcileDirectDispatchCompletionFromTranscript(args: {
     if (workerResult.source !== 'final_summary_json' && !transcriptAfterDispatch) {
         return { reconciled: false, reason: 'transcript_not_proven_after_dispatch' };
     }
+    // NOTIF-MISS grace gate (FIX 1): refuse to synthesize a completion for a direct dispatch
+    // until a grace period has elapsed since its dispatch. A direct dispatch to an ALREADY-IDLE,
+    // previously-used session reuses a transcript that still holds the PRIOR turn's final
+    // assistant message; the session momentarily reads `idle` in the first second after dispatch
+    // (the worker hasn't started generating yet), so without this gate the reconcile would
+    // synthesize a "completion" ~1s after dispatch from that stale tail. When the REAL completion
+    // fires minutes later, checkSuppressMeshEvent drops it as a duplicate of the synthesized one
+    // (same providerSessionId/finalSummary) — the coordinator never learns the task finished.
+    // The grace refuses synthesis until a genuine same-task completion is plausible. An idle-
+    // session dispatch (dispatchedToIdleSession) is the exact race, so it gets a LONGER grace.
+    // A structured final_summary_json is self-attributing (the provider emitted it for THIS turn),
+    // so it is exempt; the grace only guards the ambiguous plain-text-tail case. When the dispatch
+    // entry is missing we cannot date it and do NOT block (the stale-summary timestamp guard +
+    // FIX 2 supersession remain the correctness backstops).
+    if (Number.isFinite(dispatchTime) && workerResult.source !== 'final_summary_json') {
+        const dispatchedToIdleSession = dispatch?.payload?.dispatchedToIdleSession === true;
+        const graceMs = dispatchedToIdleSession
+            ? DIRECT_DISPATCH_IDLE_SESSION_RECONCILE_GRACE_MS
+            : DIRECT_DISPATCH_RECONCILE_GRACE_MS;
+        if (Date.now() - dispatchTime < graceMs) {
+            return { reconciled: false, reason: 'direct_dispatch_grace_period' };
+        }
+    }
     const workerFailed = workerResult.status === 'failed' || (workerResult.status !== 'completed' && workerResult.errors.length > 0);
     const kind: MeshLedgerKind = workerFailed ? 'task_failed' : 'task_completed';
 

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

@@ -1291,6 +1291,17 @@ function buildForwardPayloadFromPending(event: any): Record<string, unknown> {
             ? { targetCoordinatorSessionId: readNonEmptyString(event.targetCoordinatorSessionId) }
             : {}),
         ...metadata,
+        // NOTIF-MISS (FIX 3): surface the dispatch task id at the TOP LEVEL so the relay's
+        // received-stage trace (and buildRelayMetadataEvent) recovers it regardless of which
+        // carrier the producing daemon used. The metadata spread above may carry the id only as
+        // `meshActiveTaskId` (a worker provider event), leaving top-level `taskId` unset and the
+        // received stage rendering `task=-`. Resolve both carriers into an explicit `taskId` so
+        // dedup stays task-scoped end-to-end. Only set when a non-empty id exists (no clobber to
+        // undefined when neither is present).
+        ...((): Record<string, unknown> => {
+            const tid = readNonEmptyString(metadata.taskId) || readNonEmptyString(metadata.meshActiveTaskId);
+            return tid ? { taskId: tid } : {};
+        })(),
     };
 }