@adhdev/daemon-core 0.9.82-rc.274 → 0.9.82-rc.275

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

@@ -28,6 +28,7 @@ export interface MeshQueueTriggerResult {
 }
 export declare function triggerMeshQueue(components: DaemonComponents, meshId: string): Promise<MeshQueueTriggerResult>;
 export declare function isMeshCoordinatorEvent(eventName: unknown): eventName is string;
+export declare const MESH_FORCE_INJECT_EVENTS: ReadonlySet<string>;
 export declare function shouldForceInjectMeshEvent(eventName: unknown): boolean;
 export declare function handleMeshForwardEvent(components: DaemonComponents, payload: Record<string, unknown>): {
     success: boolean;

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

@@ -20,8 +20,20 @@ export declare function readRefineJobId(event: {
 export declare function buildPendingEventFingerprint(event: PendingMeshCoordinatorEvent): string;
 export declare function hasPendingCoordinatorEventDuplicate(event: PendingMeshCoordinatorEvent): boolean;
 export declare function queuePendingMeshCoordinatorEvent(event: PendingMeshCoordinatorEvent): boolean;
-/** Drain and return all pending coordinator events for meshId, removing them from disk. */
-export declare function drainPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: string): PendingMeshCoordinatorEvent[];
+/**
+ * Drain and return pending coordinator events for meshId, removing the drained
+ * ones from both the SQLite inbox and the JSONL legacy file.
+ *
+ * When `opts.onlyEvents` is supplied, ONLY events whose name is in that set are
+ * drained; every other event stays queued (undrained in SQLite, rewritten back to
+ * the JSONL file). The reconcile loop uses this to force-drain terminal/force-inject
+ * events into a *generating* coordinator while leaving non-force progress events for
+ * the coordinator's next idle transition. The atomic SQLite drained=1 marking and the
+ * atomic JSONL rename keep force-drain and a concurrent full drain from double-consuming.
+ */
+export declare function drainPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: string, opts?: {
+    onlyEvents?: ReadonlySet<string>;
+}): PendingMeshCoordinatorEvent[];
 /** Peek at pending coordinator events without draining (non-destructive). */
 export declare function getPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: string): readonly PendingMeshCoordinatorEvent[];
 /**

package/dist/mesh/mesh-runtime-store.d.ts

@@ -288,7 +288,19 @@ export declare class MeshRuntimeStore {
         fingerprint?: string | null;
         queuedAt: number;
     }): boolean;
-    drainPendingEvents(meshId: string, coordinatorDaemonId?: string | null): Array<{
+    /**
+     * Drain undrained pending events for a mesh, atomically marking them drained.
+     * When `opts.onlyEvents` is supplied, ONLY rows whose `event` is in that set are
+     * drained — the rest stay queued (drained=0) for a later drain. This is how the
+     * reconcile loop force-drains terminal/force-inject events into a *generating*
+     * coordinator while leaving non-force progress events for the coordinator's next
+     * idle transition. Filtering happens inside the same transaction as the
+     * drained=1 marking, so force-drain + a concurrent full drain can never both
+     * consume the same row.
+     */
+    drainPendingEvents(meshId: string, coordinatorDaemonId?: string | null, opts?: {
+        onlyEvents?: ReadonlySet<string>;
+    }): Array<{
         id: string;
         event: string;
         payload: unknown;

package/package.json

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

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

@@ -975,7 +975,7 @@ export function isMeshCoordinatorEvent(eventName: unknown): eventName is string
 // only flushed on the coordinator's OWN idle transition. That transition can't
 // happen until it receives this very event → deadlock. We force-inject these so
 // they bypass the busy send-guard and land in the PTY while generating.
-const MESH_FORCE_INJECT_EVENTS = new Set([
+export const MESH_FORCE_INJECT_EVENTS: ReadonlySet<string> = new Set([
     'agent:generating_completed',
     'agent:stopped',
     'agent:waiting_approval',

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

@@ -279,10 +279,77 @@ function atomicDrainFile(path: string): string | null {
     }
 }
 
-/** Drain and return all pending coordinator events for meshId, removing them from disk. */
-export function drainPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: string): PendingMeshCoordinatorEvent[] {
+// Selectively drain a JSONL pending-events file: atomically claim it (rename), then
+// consume only the lines whose parsed event matches `predicate` and rewrite the
+// remaining (kept) lines back to the original path. Unparseable lines are kept
+// untouched. Returns the consumed events. The rename makes claiming exclusive —
+// only one concurrent caller wins, so there is no double-consume of the same lines.
+function selectiveDrainFile(
+    path: string,
+    predicate: (event: PendingMeshCoordinatorEvent) => boolean,
+): PendingMeshCoordinatorEvent[] {
+    const tmpPath = `${path}.draining`;
+    try {
+        renameSync(path, tmpPath);
+    } catch {
+        return []; // another drain claimed it, or the file doesn't exist
+    }
+    let content: string;
+    try {
+        content = readFileSync(tmpPath, 'utf-8');
+    } catch {
+        try { unlinkSync(tmpPath); } catch { /* best-effort */ }
+        return [];
+    }
+
+    const consumed: PendingMeshCoordinatorEvent[] = [];
+    const keptLines: string[] = [];
+    for (const line of content.split('\n')) {
+        if (!line) continue;
+        let parsed: PendingMeshCoordinatorEvent | undefined;
+        try { parsed = JSON.parse(line) as PendingMeshCoordinatorEvent; } catch { parsed = undefined; }
+        if (parsed && predicate(parsed)) {
+            consumed.push(parsed);
+        } else {
+            keptLines.push(line); // non-matching or unparseable → leave queued
+        }
+    }
+
+    try {
+        if (keptLines.length > 0) {
+            writeFileSync(path, keptLines.join('\n') + '\n', 'utf-8');
+        }
+        unlinkSync(tmpPath);
+    } catch {
+        // If the rewrite/cleanup fails, restore the claimed file so no events are
+        // lost — the next drain retries the whole file.
+        try { if (existsSync(tmpPath) && !existsSync(path)) renameSync(tmpPath, path); } catch { /* best-effort */ }
+        return [];
+    }
+    return consumed;
+}
+
+/**
+ * Drain and return pending coordinator events for meshId, removing the drained
+ * ones from both the SQLite inbox and the JSONL legacy file.
+ *
+ * When `opts.onlyEvents` is supplied, ONLY events whose name is in that set are
+ * drained; every other event stays queued (undrained in SQLite, rewritten back to
+ * the JSONL file). The reconcile loop uses this to force-drain terminal/force-inject
+ * events into a *generating* coordinator while leaving non-force progress events for
+ * the coordinator's next idle transition. The atomic SQLite drained=1 marking and the
+ * atomic JSONL rename keep force-drain and a concurrent full drain from double-consuming.
+ */
+export function drainPendingMeshCoordinatorEvents(
+    meshId?: string,
+    coordinatorDaemonId?: string,
+    opts?: { onlyEvents?: ReadonlySet<string> },
+): PendingMeshCoordinatorEvent[] {
     if (!meshId) return [];
 
+    const onlyEvents = opts?.onlyEvents;
+    const matchesFilter = (eventName: string): boolean => !onlyEvents || onlyEvents.has(eventName);
+
     // Dual-write means SQLite and JSONL hold the same events. Both stores must be
     // emptied in one drain call — draining only one leaves the other to re-deliver
     // the same events on the next call. Merge with fingerprint dedup.
@@ -301,7 +368,7 @@ export function drainPendingMeshCoordinatorEvents(meshId?: string, coordinatorDa
     try {
         const store = MeshRuntimeStore.getInstance();
         if (store.pendingEventCount(meshId) > 0) {
-            for (const row of store.drainPendingEvents(meshId, coordinatorDaemonId)) {
+            for (const row of store.drainPendingEvents(meshId, coordinatorDaemonId, onlyEvents ? { onlyEvents } : undefined)) {
                 const event = row.payload as PendingMeshCoordinatorEvent;
                 if (event) pushUnique(event);
             }
@@ -315,15 +382,26 @@ export function drainPendingMeshCoordinatorEvents(meshId?: string, coordinatorDa
         ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)]
         : [getPendingEventsPath(meshId)];
     for (const path of paths) {
+        const isSharedFile = coordinatorDaemonId && path === getPendingEventsPath(meshId);
+        // Targeting predicate for the shared (unscoped) file: only this coordinator's
+        // events (or legacy untargeted ones) are eligible.
+        const targets = (e: PendingMeshCoordinatorEvent): boolean =>
+            !isSharedFile || !e.targetCoordinatorDaemonId || e.targetCoordinatorDaemonId === coordinatorDaemonId;
+
+        if (onlyEvents) {
+            // Selective JSONL drain: consume only matching events, rewrite the rest back.
+            for (const event of selectiveDrainFile(path, e => targets(e) && matchesFilter(e.event))) {
+                pushUnique(event);
+            }
+            continue;
+        }
         const content = atomicDrainFile(path);
         if (!content) continue;
         const parsed = content.split('\n').filter(Boolean).flatMap(line => {
             try { return [JSON.parse(line) as PendingMeshCoordinatorEvent]; } catch { return []; }
         });
         // If reading the shared file, filter to events that target this coordinator or are unscoped.
-        const filtered = (coordinatorDaemonId && path === getPendingEventsPath(meshId))
-            ? parsed.filter(e => !e.targetCoordinatorDaemonId || e.targetCoordinatorDaemonId === coordinatorDaemonId)
-            : parsed;
+        const filtered = isSharedFile ? parsed.filter(targets) : parsed;
         for (const event of filtered) pushUnique(event);
     }
     if (merged.length === 0) return [];

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

@@ -14,10 +14,16 @@
 //
 // This loop is that drainer. On a fixed interval it:
 //   1. Finds live CLI coordinator sessions on THIS daemon (meshCoordinatorFor
-//      stamp). For each, drains the local queue scoped to this daemon and
-//      injects pending events into the coordinator when it is idle. (idle-only:
-//      a generating coordinator's PTY ignores send_message, so we leave events
-//      queued and retry next tick.)
+//      stamp). For each mesh, drains the local queue scoped to this daemon and
+//      injects pending events into the coordinator. When a coordinator is idle it
+//      receives every queued event. When ONLY generating coordinators exist (the
+//      common case while the coordinator is blocked awaiting a worker result), the
+//      loop force-drains ONLY the force-inject events (completion / approval / stop /
+//      refine·bootstrap terminal) and force-writes them into the generating PTY —
+//      the same busy-bypass send-guard escape the live-CLI inject used to use.
+//      Non-force progress events stay queued for the next idle tick (injecting them
+//      mid-generation would be noise). This is what makes a coordinator parked in
+//      `generating` while awaiting a worker's completion actually receive it.
 //   2. In cloud mode (dispatchMeshCommand present), pulls each remote worker
 //      node daemon's queue over P2P (get_pending_mesh_events) and re-injects via
 //      handleMeshForwardEvent — the same pull the MCP drainCoordinatorPendingEvents
@@ -41,7 +47,7 @@ import { LOG } from '../logging/logger.js';
 import { drainPendingMeshCoordinatorEvents } from './mesh-events-pending.js';
 import type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
-import { handleMeshForwardEvent, shouldForceInjectMeshEvent } from './mesh-events-coordinator.js';
+import { handleMeshForwardEvent, shouldForceInjectMeshEvent, MESH_FORCE_INJECT_EVENTS } from './mesh-events-coordinator.js';
 import { readNonEmptyString } from './mesh-events-utils.js';
 
 // Default reconcile cadence. approval/completion notifications to a live CLI
@@ -79,7 +85,9 @@ function findLiveCoordinators(components: DaemonComponents): LiveCoordinator[] {
     return out;
 }
 
-// Inject a drained pending event into a live, idle coordinator session.
+// Inject a drained pending event into a live coordinator session. Force-inject
+// events carry force:true so they bypass the busy send-guard and land in the PTY
+// even while the coordinator is generating (see shouldForceInjectMeshEvent).
 function injectPendingIntoCoordinator(
     coordinator: LiveCoordinator['instance'],
     pending: PendingMeshCoordinatorEvent,
@@ -130,12 +138,19 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
             }
         }
 
-        // (b) Drain the local queue scoped to this coordinator daemon and inject
-        //     into idle coordinators. A generating coordinator is skipped — its
-        //     events stay queued (drained=1 only happens inside the drain call,
-        //     so we must NOT drain when there is no idle coordinator to receive).
+        // (b) Drain the local queue scoped to this coordinator daemon and inject.
+        //     - If an idle coordinator exists, FULL-drain and deliver every event to it
+        //       (it can receive non-force progress events without deadlocking).
+        //     - If only GENERATING coordinators exist, force-drain ONLY the force-inject
+        //       events (completion/approval/stop/refine·bootstrap terminal) and force-inject
+        //       them so a coordinator parked in `generating` while awaiting that very event
+        //       is not deadlocked. Non-force progress events stay queued for the next idle
+        //       tick — injecting them would be noise mid-generation. Both drains mark the
+        //       consumed rows drained=1 atomically, so the pull path can't re-deliver.
         const idleCoordinators = meshCoordinators.filter(c => c.idle);
-        if (idleCoordinators.length === 0) continue;
+        const generatingCoordinators = meshCoordinators.filter(c => !c.idle);
+        const targetCoordinators = idleCoordinators.length > 0 ? idleCoordinators : generatingCoordinators;
+        const forceOnly = idleCoordinators.length === 0;
 
         // O(1) guard: skip the drain entirely when the queue is empty.
         if (store) {
@@ -146,16 +161,21 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
 
         let pendingEvents: PendingMeshCoordinatorEvent[] = [];
         try {
-            pendingEvents = drainPendingMeshCoordinatorEvents(meshId, localDaemonId);
+            pendingEvents = drainPendingMeshCoordinatorEvents(
+                meshId,
+                localDaemonId,
+                forceOnly ? { onlyEvents: MESH_FORCE_INJECT_EVENTS } : undefined,
+            );
         } catch (e: any) {
             LOG.warn('MeshReconcile', `Drain failed for mesh ${meshId}: ${e?.message || e}`);
             continue;
         }
         if (pendingEvents.length === 0) continue;
 
-        LOG.info('MeshReconcile', `Reconcile inject: ${pendingEvents.length} pending event(s) → ${idleCoordinators.length} idle coordinator(s) for mesh ${meshId}`);
+        const mode = forceOnly ? 'force-drain → generating' : 'inject → idle';
+        LOG.info('MeshReconcile', `Reconcile ${mode}: ${pendingEvents.length} pending event(s) → ${targetCoordinators.length} coordinator(s) for mesh ${meshId}`);
         for (const pending of pendingEvents) {
-            for (const c of idleCoordinators) {
+            for (const c of targetCoordinators) {
                 injectPendingIntoCoordinator(c.instance, pending);
             }
         }

package/src/mesh/mesh-runtime-store.ts

@@ -1241,16 +1241,41 @@ export class MeshRuntimeStore {
         return result.changes > 0;
     }
 
-    drainPendingEvents(meshId: string, coordinatorDaemonId?: string | null): Array<{ id: string; event: string; payload: unknown }> {
+    /**
+     * Drain undrained pending events for a mesh, atomically marking them drained.
+     * When `opts.onlyEvents` is supplied, ONLY rows whose `event` is in that set are
+     * drained — the rest stay queued (drained=0) for a later drain. This is how the
+     * reconcile loop force-drains terminal/force-inject events into a *generating*
+     * coordinator while leaving non-force progress events for the coordinator's next
+     * idle transition. Filtering happens inside the same transaction as the
+     * drained=1 marking, so force-drain + a concurrent full drain can never both
+     * consume the same row.
+     */
+    drainPendingEvents(
+        meshId: string,
+        coordinatorDaemonId?: string | null,
+        opts?: { onlyEvents?: ReadonlySet<string> },
+    ): Array<{ id: string; event: string; payload: unknown }> {
         return this.transaction(() => {
-            const whereClause = coordinatorDaemonId
-                ? `WHERE mesh_id = ? AND drained = 0 AND (coordinator_daemon_id IS NULL OR coordinator_daemon_id = ?)`
-                : `WHERE mesh_id = ? AND drained = 0`;
-            const params: unknown[] = coordinatorDaemonId
-                ? [meshId, coordinatorDaemonId]
-                : [meshId];
+            const onlyEvents = opts?.onlyEvents;
+            // An explicit-but-empty filter means "drain nothing" (no event name can match).
+            if (onlyEvents && onlyEvents.size === 0) return [];
+            const eventList = onlyEvents ? [...onlyEvents] : [];
+            // Filter by event name IN-SQL when onlyEvents is set so the LIMIT applies to
+            // matching rows — a long run of non-force events ahead in the queue must not
+            // crowd a force event out of the 100-row window.
+            const clauses = ['mesh_id = ?', 'drained = 0'];
+            const params: unknown[] = [meshId];
+            if (coordinatorDaemonId) {
+                clauses.push('(coordinator_daemon_id IS NULL OR coordinator_daemon_id = ?)');
+                params.push(coordinatorDaemonId);
+            }
+            if (eventList.length > 0) {
+                clauses.push(`event IN (${eventList.map(() => '?').join(',')})`);
+                params.push(...eventList);
+            }
             const rows = this.db.prepare(
-                `SELECT id, event, payload FROM mesh_pending_events ${whereClause} ORDER BY queued_at ASC LIMIT 100`
+                `SELECT id, event, payload FROM mesh_pending_events WHERE ${clauses.join(' AND ')} ORDER BY queued_at ASC LIMIT 100`
             ).all(...params) as Array<{ id: string; event: string; payload: string }>;
             if (rows.length === 0) return [];
             const ids = rows.map(r => r.id);