@adhdev/daemon-core 0.9.82-rc.394 → 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.394",
+  "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.394",
+    "@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-queue-assignment.ts

@@ -269,6 +269,37 @@ export function tryAssignQueueTask(
     const mesh = getMeshWithCache(components, meshId);
     const node = mesh?.nodes.find((n: any) => readMeshNodeId(n) === nodeId);
 
+    // WORKTREE-CLAIM-GATE-BYPASS: the SINGLE claim-time gate for the worktree-bootstrap defer.
+    // tryAssignQueueTask is the one funnel every claim path flows through — the event-driven
+    // agent:ready drain, the triggerMeshQueue idle-session drain (local + remote), the
+    // auto-launch claim, and the PHASE 3 reconcile re-drain all call it. The agent:ready handler
+    // (mesh-event-forwarding) deferred its OWN claim while a worktree node's bootstrap was still
+    // 'running', but it ALSO called setRemoteIdleSession first — registering the session as a
+    // claim candidate. A concurrent triggerMeshQueue drain then pulled that candidate and claimed
+    // through tryAssignQueueTask within ~0.16s, BYPASSING the event-handler-local defer: the task
+    // dispatched into a half-built worktree (native addons not yet installed → child daemon dies
+    // → empty session, totalMessages=0). The transport ack returns ok:true, so neither the
+    // assigned-stranded watchdog nor the pending-only PHASE 3 reconcile ever re-fires it → the
+    // session is stranded empty forever.
+    //
+    // Lowering the gate HERE makes the defer a property of the claim itself, not of one caller:
+    // a worktree node whose bootstrap is still 'running' can never be claimed from any path. The
+    // task stays pending (we return false WITHOUT touching its status — no fail/cancel), so the
+    // bootstrap_complete refire (triggerMeshQueue re-fired on worktree_bootstrap_complete) re-runs
+    // this claim and passes once status is no longer 'running'. The registered remote-idle session
+    // persists for REMOTE_IDLE_SESSION_TTL_MS (5min > observed ~2m8s bootstrap), so the refire
+    // still finds a live candidate to re-claim. Identity uses meshNodeIdMatches (the same shared
+    // 3-form normalizer the defer guard uses), never a raw === — canon-identity regression guard.
+    // Conservative: any non-'running' status (idle/complete/failed/absent/unknown) does NOT gate,
+    // so a base node and a fully-bootstrapped worktree keep prior behavior exactly.
+    const gateNode = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, nodeId)) as
+        | { worktreeBootstrap?: { status?: string } }
+        | undefined;
+    if (gateNode?.worktreeBootstrap?.status === 'running') {
+        LOG.info('MeshQueue', `Gating queue claim for worktree node ${nodeId} (${sessionId}): worktree bootstrap still running — task left pending; claim re-fires once bootstrap reaches a terminal state (guards against dispatching into a half-built worktree → empty session)`);
+        return false;
+    }
+
     // WTCLAIM (fix-B extended to the enqueue→claim path): a base-targeted task must never be
     // claimed by — and dispatched into — a co-located worktree-clone session, nor vice versa.
     // The drain candidate's nodeId is derived from settings.meshNodeId || settings.nodeId

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 } : {}),
     });
 }