@adhdev/daemon-core 0.9.82-rc.420 → 0.9.82-rc.421

package/dist/mesh/mesh-event-forwarding.d.ts

@@ -16,4 +16,26 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     success: boolean;
     error: string;
 };
+/**
+ * NOTIF-HELD-DRAIN (Fix 2): event-driven coordinator drain. The reconcile loop delivers a
+ * worker's queued completion to an IDLE local coordinator only on its periodic poll. When a
+ * coordinator is sitting idle awaiting exactly that completion, waiting up to a full poll
+ * interval is the avoidable delivery latency the RCA flags — and combined with the (now-fixed)
+ * modal-park false-positive it stretched into the multi-minute notification stall. So the
+ * MOMENT a worker delegate event is persisted for a mesh, attempt the same idle-coordinator
+ * drain immediately, mirroring the event-driven worker-claim path (agent:ready /
+ * agent:generating_completed → triggerMeshQueue).
+ *
+ * Safety:
+ *  - drainPendingMeshCoordinatorEvents marks rows drained=1 atomically, so this races the
+ *    reconcile poll and the coordinator's own idle auto-flush harmlessly — exactly one consumes
+ *    each row.
+ *  - Only IDLE, non-modal-parked coordinators are delivery targets (never a generating /
+ *    consent-modal PTY).
+ *  - Strict session routing is honoured: an event naming an originating coordinator session is
+ *    delivered only to that live idle session; anything not currently deliverable here
+ *    (wrong/absent session, or a message-less lifecycle event) is RE-QUEUED — never dropped —
+ *    so the reconcile loop's strict hold/expire path remains the single authority for it.
+ */
+export declare function flushPendingForMeshIdleCoordinators(components: DaemonComponents, meshId: string): void;
 export declare function setupMeshEventForwarding(components: DaemonComponents): void;

package/dist/providers/cli-provider-instance.d.ts

@@ -205,6 +205,17 @@ export declare class CliProviderInstance implements ProviderInstance {
      * absent from some of them.
      */
     resolveModalParkStatus(): 'waiting_choice' | 'waiting_approval' | null;
+    /**
+     * NOTIF-HELD-DRAIN: true when this `waiting_approval` is a routine, transient tool-consent
+     * of an autonomously-progressing mesh session rather than a genuine human-await modal —
+     * i.e. it is a mesh coordinator/worker session, a turn is actively in flight
+     * (hasAdapterPendingResponse), and no human is attending it by hand. Such a consent is
+     * driven to resolution by the harness/operator as part of the in-flight turn, so holding
+     * the mesh's completion events behind it (modal_parked) is the false-positive that stalls
+     * delivery. Narrow by design: manual attendance or a non-progressing session falls through
+     * to the genuine-modal classification.
+     */
+    private isTransientToolConsent;
     /** True when this session is parked on a modal awaiting a human answer. */
     isModalParked(): boolean;
     onEvent(event: string, data?: any): void;

package/package.json

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

package/src/index.ts

@@ -293,7 +293,7 @@ export type { PendingMeshCoordinatorEvent } from './mesh/mesh-events.js';
 // (finalSummary / workerResult.summary / lastMessagePreview). Same data the mobile
 // inbox is fed; reused by mesh_read_chat's cache fallback when the live P2P read path
 // is unavailable (saturated/unreachable peer).
-export { resolveMeshSurfacedSessionPreview, readMeshCompletionSummary } from './mesh/mesh-events-utils.js';
+export { resolveMeshSurfacedSessionPreview, readMeshCompletionSummary, isWeakCompletionEvidence } from './mesh/mesh-events-utils.js';
 
 // ── Mesh Delivery Policy ──
 export { resolveDeliveryDecision, createSessionDelivery, updateSessionDeliveryStatus, getActiveSessionDeliveries, markSessionDeliveriesTerminal, recordCompletionConflict, getRecentCompletionConflicts } from './mesh/mesh-delivery-policy.js';

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

@@ -7,7 +7,8 @@ import type { SessionRecoveryContext } from './mesh-ledger.js';
 import { updateSessionTaskStatus, enqueueTask, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, getActiveDirectDispatches, hasPendingDependents, getQueue } from './mesh-work-queue.js';
 import { markSessionDeliveriesTerminal, updateSessionDeliveryStatus, recordCompletionConflict } from './mesh-delivery-policy.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
-import { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents } from './mesh-events-pending.js';
+import { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, type PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
+import type { ProviderInstance } from '../providers/provider-instance.js';
 import { resolveWorkerDelegateRouting, recordUnroutableDelegateEvent, isUnroutableDelegateRejection } from './mesh-routing.js';
 import { resolveMeshHostStatus } from './mesh-host-ownership.js';
 import { enqueueUnresolvedDelegateForward, peekUnresolvedDelegateForwards, ackUnresolvedDelegateForward } from './mesh-unresolved-forward-outbox.js';
@@ -1670,6 +1671,93 @@ function ackUnresolvedDelegateForwardByFingerprint(
     if (match) ackUnresolvedDelegateForward(match.id);
 }
 
+/**
+ * NOTIF-HELD-DRAIN (Fix 2): event-driven coordinator drain. The reconcile loop delivers a
+ * worker's queued completion to an IDLE local coordinator only on its periodic poll. When a
+ * coordinator is sitting idle awaiting exactly that completion, waiting up to a full poll
+ * interval is the avoidable delivery latency the RCA flags — and combined with the (now-fixed)
+ * modal-park false-positive it stretched into the multi-minute notification stall. So the
+ * MOMENT a worker delegate event is persisted for a mesh, attempt the same idle-coordinator
+ * drain immediately, mirroring the event-driven worker-claim path (agent:ready /
+ * agent:generating_completed → triggerMeshQueue).
+ *
+ * Safety:
+ *  - drainPendingMeshCoordinatorEvents marks rows drained=1 atomically, so this races the
+ *    reconcile poll and the coordinator's own idle auto-flush harmlessly — exactly one consumes
+ *    each row.
+ *  - Only IDLE, non-modal-parked coordinators are delivery targets (never a generating /
+ *    consent-modal PTY).
+ *  - Strict session routing is honoured: an event naming an originating coordinator session is
+ *    delivered only to that live idle session; anything not currently deliverable here
+ *    (wrong/absent session, or a message-less lifecycle event) is RE-QUEUED — never dropped —
+ *    so the reconcile loop's strict hold/expire path remains the single authority for it.
+ */
+export function flushPendingForMeshIdleCoordinators(components: DaemonComponents, meshId: string): void {
+    // O(1) gate: skip the (relatively expensive) per-instance getState scan when the queue is
+    // empty for this mesh.
+    try {
+        const store = MeshRuntimeStore.getInstance();
+        if (store.pendingEventCount(meshId) === 0) return;
+    } catch { /* store unavailable — fall through and let the drain decide */ }
+
+    const idleCoordinators: { instance: ProviderInstance; sessionId: string }[] = [];
+    try {
+        for (const inst of components.instanceManager.getByCategory('cli')) {
+            const state = inst.getState();
+            const settings = state.settings && typeof state.settings === 'object'
+                ? state.settings as Record<string, unknown>
+                : {};
+            if (readNonEmptyString(settings.meshCoordinatorFor) !== meshId) continue;
+            const status = readNonEmptyString(state.status).toLowerCase();
+            const modalParked = typeof (inst as any).isModalParked === 'function'
+                ? (inst as any).isModalParked() === true
+                : (status === 'waiting_choice' || status === 'waiting_approval');
+            if (status === 'idle' && !modalParked) {
+                idleCoordinators.push({ instance: inst, sessionId: readNonEmptyString(state.instanceId) });
+            }
+        }
+    } catch { return; }
+    if (idleCoordinators.length === 0) return; // no idle target now → leave for the reconcile poll
+
+    const drainDaemonIds = resolveCoordinatorDrainDaemonIds(components);
+    let pendingEvents: PendingMeshCoordinatorEvent[];
+    try {
+        pendingEvents = drainPendingMeshCoordinatorEvents(meshId, drainDaemonIds.length > 0 ? drainDaemonIds : undefined);
+    } catch (e: any) {
+        LOG.warn('MeshEvents', `Event-driven coordinator drain failed for mesh ${meshId}: ${e?.message || e}`);
+        return;
+    }
+    if (pendingEvents.length === 0) return;
+
+    let delivered = 0;
+    for (const pending of pendingEvents) {
+        const wantSession = readNonEmptyString(pending.targetCoordinatorSessionId);
+        const targets = wantSession
+            ? idleCoordinators.filter(c => c.sessionId === wantSession)
+            : idleCoordinators;
+        // Not deliverable into an idle target here (wrong/absent session), or a message-less
+        // lifecycle event (agent:ready / generating_started carry no coordinatorMessage and
+        // must not be injected): re-queue so the reconcile loop owns it (lazy-synth / strict
+        // hold/expire). Re-queue preserves queuedAt so the strict TTL measures true age.
+        if (targets.length === 0 || !pending.coordinatorMessage) {
+            try { queuePendingMeshCoordinatorEvent(pending); } catch { /* best-effort re-queue */ }
+            continue;
+        }
+        const message = pending.coordinatorMessage;
+        const force = shouldForceInjectMeshEvent(pending.event);
+        for (const c of targets) {
+            c.instance.onEvent('send_message', {
+                input: { text: message, textFallback: message },
+                ...(force ? { force: true } : {}),
+            });
+            delivered++;
+        }
+    }
+    if (delivered > 0) {
+        LOG.info('MeshEvents', `Event-driven drain delivered ${delivered} pending event(s) to ${idleCoordinators.length} idle coordinator(s) for mesh ${meshId}`);
+    }
+}
+
 export function setupMeshEventForwarding(components: DaemonComponents) {
     components.instanceManager.onEvent((event) => {
         // --- Coordinator idle auto-flush (fast path) ---
@@ -1785,5 +1873,11 @@ export function setupMeshEventForwarding(components: DaemonComponents) {
             event: event.event,
             metadataEvent: event,
         });
+
+        // NOTIF-HELD-DRAIN (Fix 2): the worker's event is now persisted in the pending queue.
+        // If a local coordinator for this mesh is sitting idle awaiting it, deliver immediately
+        // instead of waiting up to a full reconcile interval (event-driven, mirrors the
+        // worker-claim path). No-op when no idle coordinator is present (held for reconcile).
+        flushPendingForMeshIdleCoordinators(components, routing.meshId);
     });
 }

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

@@ -307,9 +307,17 @@ function findLiveCoordinators(components: DaemonComponents): LiveCoordinator[] {
         const status = readNonEmptyString(state.status).toLowerCase();
         // getState() overlays the modal-park statuses: an active AskUserQuestion
         // prompt surfaces as waiting_choice, a tool-consent prompt as waiting_approval.
-        // Lowercase literal compare — the SessionStatus enum is forked across modules
-        // and waiting_choice is absent from some of them (see cli-provider-instance).
-        const modalParked = status === 'waiting_choice' || status === 'waiting_approval';
+        // NOTIF-HELD-DRAIN (Fix 1): consult the instance's own isModalParked() rather than the
+        // raw status literal so the corrected classification flows here — a busy mesh
+        // coordinator's routine, in-flight tool-consent (auto-approve off) is NOT a human-await
+        // modal and must NOT wedge the mesh's pending completion events under `modal_parked`.
+        // resolveModalParkStatus() (which isModalParked wraps) already encodes that distinction
+        // and the waiting_choice/stalled-auto-approve genuine-modal cases. Fall back to the
+        // status literal for any instance that does not expose the method. Lowercase compare —
+        // the SessionStatus enum is forked across modules and waiting_choice is absent from some.
+        const modalParked = typeof (inst as any).isModalParked === 'function'
+            ? (inst as any).isModalParked() === true
+            : (status === 'waiting_choice' || status === 'waiting_approval');
         const sessionId = readNonEmptyString(state.instanceId);
         // Modal-park transition observability: a coordinator entering modal-park is what
         // begins holding completion events under `modal_parked`; one leaving it is what

package/src/providers/cli-provider-instance.ts

@@ -1134,11 +1134,44 @@ export class CliProviderInstance implements ProviderInstance {
         // as modal-parked so its events are held/surfaced rather than masked behind generating.
         if (adapterStatus.status === 'waiting_approval'
             && (!this.autoApproveEffectivelyActive(adapterStatus.status) || this.autoApproveMaskStalled())) {
+            // NOTIF-HELD-DRAIN (Fix 1): an autonomous mesh session (coordinator or worker)
+            // that is actively progressing a turn — a tool call is in flight
+            // (hasAdapterPendingResponse) and NO human is attending it by hand — surfaces a
+            // routine tool-consent `waiting_approval` on EVERY tool call when auto-approve is
+            // off. That transient consent is part of the turn the harness/operator drives to
+            // completion, NOT a session genuinely wedged awaiting a human's modal answer.
+            // Classifying it modal-parked makes findLiveCoordinators hold the mesh's pending
+            // completion events under `modal_parked` across a busy coordinator's whole work
+            // batch, which is the multi-minute notification stall. Treat such a transient
+            // consent as NOT modal-parked so it is held as ordinary "generating" (released on
+            // the next idle) instead. A manually-attended session, a stalled auto-approve, or a
+            // non-progressing session (no turn in flight) still parks — those are the genuine
+            // human-await cases the guard must keep holding.
+            if (this.isTransientToolConsent()) {
+                return null;
+            }
             return 'waiting_approval';
         }
         return null;
     }
 
+    /**
+     * NOTIF-HELD-DRAIN: true when this `waiting_approval` is a routine, transient tool-consent
+     * of an autonomously-progressing mesh session rather than a genuine human-await modal —
+     * i.e. it is a mesh coordinator/worker session, a turn is actively in flight
+     * (hasAdapterPendingResponse), and no human is attending it by hand. Such a consent is
+     * driven to resolution by the harness/operator as part of the in-flight turn, so holding
+     * the mesh's completion events behind it (modal_parked) is the false-positive that stalls
+     * delivery. Narrow by design: manual attendance or a non-progressing session falls through
+     * to the genuine-modal classification.
+     */
+    private isTransientToolConsent(now = Date.now()): boolean {
+        const isAutonomousMeshSession = this.isMeshWorkerSession() || !!this.settings.meshCoordinatorFor;
+        return isAutonomousMeshSession
+            && this.hasAdapterPendingResponse()
+            && !this.manualAttendance.isAttended(now);
+    }
+
     /** True when this session is parked on a modal awaiting a human answer. */
     isModalParked(): boolean {
         return this.resolveModalParkStatus() !== null;