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

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,10 +20,22 @@ 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 | ReadonlyArray<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[];
+export declare function getPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: string | ReadonlyArray<string>): readonly PendingMeshCoordinatorEvent[];
 /**
  * Test helper: purge all pending-event state for a mesh — SQLite rows
  * (including drained fingerprint history) and JSONL files.

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

@@ -288,13 +288,25 @@ 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 | ReadonlyArray<string>, opts?: {
+        onlyEvents?: ReadonlySet<string>;
+    }): Array<{
         id: string;
         event: string;
         payload: unknown;
     }>;
     /** Non-destructive peek — returns undrained events without marking them drained. */
-    peekPendingEvents(meshId: string, coordinatorDaemonId?: string | null): Array<{
+    peekPendingEvents(meshId: string, coordinatorDaemonId?: string | null | ReadonlyArray<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.276",
   "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.276",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/boot/daemon-lifecycle.ts

@@ -123,6 +123,14 @@ export interface DaemonComponents {
     // single-model (queue + polling) delivery: drains the pending-events queue
     // on a fixed interval and injects into live CLI coordinators when idle.
     meshReconcileLoop?: { stop(): void };
+    // Canonical status/daemon identity (e.g. `standalone_<machineId>` /
+    // `daemon_<machineId>`). This is the SAME id the MCP layer stamps as a
+    // worker's meshCoordinatorDaemonId (ctx.localDaemonId, sourced from
+    // getStatus().status.instanceId), so the reconcile loop MUST drain with it —
+    // draining with bare loadConfig().machineId never matches a unicast event
+    // stamped with the prefixed status id. Absent → reconcile falls back to
+    // machineId only.
+    statusInstanceId?: string;
 }
 
 export interface DaemonDevSupportOptions {
@@ -362,6 +370,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         refreshProviderAvailability,
         dispatchMeshCommand: config.dispatchMeshCommand,
         onMeshCoordinatorEventForwarded: config.onMeshCoordinatorEventForwarded,
+        statusInstanceId: config.statusInstanceId,
     };
 
     // 11. Setup Mesh Event Forwarding (queue persistence) + periodic reconcile loop.

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

@@ -29,6 +29,19 @@ import {
     readWorkerResultMetadata,
 } from './mesh-events-utils.js';
 
+// The set of coordinator-daemon ids this daemon answers to when draining the
+// pending-events queue (canonical status id + bare machineId). Mirrors
+// resolveCoordinatorDaemonIds in mesh-reconcile-loop — a unicast event may be
+// stamped with either id depending on which dispatch path created the worker.
+function resolveCoordinatorDrainDaemonIds(components: DaemonComponents): string[] {
+    const ids = new Set<string>();
+    const statusInstanceId = readNonEmptyString((components as { statusInstanceId?: string }).statusInstanceId);
+    if (statusInstanceId) ids.add(statusInstanceId);
+    const machineId = readNonEmptyString(loadConfig().machineId);
+    if (machineId) ids.add(machineId);
+    return [...ids];
+}
+
 // ---------------------------------------------------------------------------
 // Remote Node Idle Session Tracking
 // ---------------------------------------------------------------------------
@@ -975,7 +988,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',
@@ -1506,8 +1519,13 @@ export function setupMeshEventForwarding(components: DaemonComponents) {
                         const status = readNonEmptyString(flushState.status).toLowerCase();
                         if (status === 'idle') {
                             try {
-                                const localDaemonId = readNonEmptyString(loadConfig().machineId) || undefined;
-                                const pendingEvents = drainPendingMeshCoordinatorEvents(coordinatorMeshId, localDaemonId);
+                                // Drain with the daemon's full coordinator-id set (status id + machineId).
+                                // The MCP layer stamps the prefixed status id (`standalone_<machineId>` /
+                                // `daemon_<machineId>`) as the worker's meshCoordinatorDaemonId; draining
+                                // with bare machineId alone would miss those unicast events. Mirrors
+                                // resolveCoordinatorDaemonIds in mesh-reconcile-loop.
+                                const drainDaemonIds = resolveCoordinatorDrainDaemonIds(components);
+                                const pendingEvents = drainPendingMeshCoordinatorEvents(coordinatorMeshId, drainDaemonIds.length > 0 ? drainDaemonIds : undefined);
                                 if (pendingEvents.length > 0) {
                                     LOG.info('MeshEvents', `Auto-flushing ${pendingEvents.length} pending coordinator event(s) for mesh ${coordinatorMeshId} on coordinator idle`);
                                     for (const pending of pendingEvents) {

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

@@ -37,6 +37,27 @@ export interface PendingMeshCoordinatorEvent {
 
 const REFINE_TERMINAL_EVENTS = new Set(['refine:completed', 'refine:failed']);
 
+/** Normalise a coordinator-daemon-id argument (single id, list, or undefined) into a
+ *  de-duplicated list of non-empty strings. The first entry is treated as primary for
+ *  per-daemon JSONL file naming; all entries are accepted by drain/peek targeting. */
+function normalizeCoordinatorDaemonIds(
+    coordinatorDaemonId?: string | null | ReadonlyArray<string>,
+): string[] {
+    const raw = Array.isArray(coordinatorDaemonId)
+        ? coordinatorDaemonId
+        : coordinatorDaemonId != null ? [coordinatorDaemonId] : [];
+    const seen = new Set<string>();
+    const out: string[] = [];
+    for (const id of raw) {
+        if (typeof id !== 'string') continue;
+        const trimmed = id.trim();
+        if (!trimmed || seen.has(trimmed)) continue;
+        seen.add(trimmed);
+        out.push(trimmed);
+    }
+    return out;
+}
+
 export function readRefineJobId(event: { metadataEvent?: Record<string, unknown> } | Record<string, unknown>): string {
     const metadata = readRecord((event as any).metadataEvent) || event as Record<string, unknown>;
     const result = readRecord(metadata.result);
@@ -108,11 +129,13 @@ function getPendingEventsPath(meshId: string, coordinatorDaemonId?: string): str
     return join(getLedgerDir(), `${safe}.pending-events.jsonl`);
 }
 
-function readPendingMeshCoordinatorEventsFromDisk(meshId?: string, coordinatorDaemonId?: string): PendingMeshCoordinatorEvent[] {
+function readPendingMeshCoordinatorEventsFromDisk(meshId?: string, coordinatorDaemonId?: string | ReadonlyArray<string>): PendingMeshCoordinatorEvent[] {
     if (!meshId) return [];
+    const daemonIds = normalizeCoordinatorDaemonIds(coordinatorDaemonId);
+    const primaryDaemonId = daemonIds[0];
     // Read coordinator-scoped file first; fall back to legacy shared file.
-    const paths = coordinatorDaemonId
-        ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)]
+    const paths = primaryDaemonId
+        ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)]
         : [getPendingEventsPath(meshId)];
     const events: PendingMeshCoordinatorEvent[] = [];
     for (const path of paths) {
@@ -123,8 +146,8 @@ function readPendingMeshCoordinatorEventsFromDisk(meshId?: string, coordinatorDa
                 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)
+            const filtered = (primaryDaemonId && path === getPendingEventsPath(meshId))
+                ? parsed.filter(e => !e.targetCoordinatorDaemonId || daemonIds.includes(e.targetCoordinatorDaemonId))
                 : parsed;
             events.push(...filtered);
         } catch { /* skip unreadable files */ }
@@ -279,10 +302,84 @@ 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 | ReadonlyArray<string>,
+    opts?: { onlyEvents?: ReadonlySet<string> },
+): PendingMeshCoordinatorEvent[] {
     if (!meshId) return [];
 
+    // A daemon may answer to more than one coordinator-id form (its canonical
+    // status id like `standalone_<machineId>` AND the bare machineId). Normalise
+    // to a list so both the SQLite IN-filter and the JSONL targeting predicate
+    // accept any of them.
+    const daemonIds = normalizeCoordinatorDaemonIds(coordinatorDaemonId);
+    const primaryDaemonId = daemonIds[0];
+
+    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 +398,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, daemonIds.length > 0 ? daemonIds : undefined, onlyEvents ? { onlyEvents } : undefined)) {
                 const event = row.payload as PendingMeshCoordinatorEvent;
                 if (event) pushUnique(event);
             }
@@ -310,20 +407,33 @@ export function drainPendingMeshCoordinatorEvents(meshId?: string, coordinatorDa
         // SQLite drain failed — JSONL below still drains
     }
 
-    // JSONL (legacy / migration path) — always drained alongside SQLite
-    const paths = coordinatorDaemonId
-        ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)]
+    // JSONL (legacy / migration path) — always drained alongside SQLite.
+    // The scoped per-daemon file is keyed by a single id; use the primary. The
+    // shared (unscoped) file's targeting predicate accepts ANY of this daemon's ids.
+    const paths = primaryDaemonId
+        ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)]
         : [getPendingEventsPath(meshId)];
     for (const path of paths) {
+        const isSharedFile = !!primaryDaemonId && 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 || daemonIds.includes(e.targetCoordinatorDaemonId);
+
+        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 [];
@@ -335,8 +445,9 @@ export function drainPendingMeshCoordinatorEvents(meshId?: string, coordinatorDa
 }
 
 /** Peek at pending coordinator events without draining (non-destructive). */
-export function getPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: string): readonly PendingMeshCoordinatorEvent[] {
+export function getPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaemonId?: string | ReadonlyArray<string>): readonly PendingMeshCoordinatorEvent[] {
     if (!meshId) return [];
+    const daemonIds = normalizeCoordinatorDaemonIds(coordinatorDaemonId);
 
     // Merge SQLite (primary) + JSONL (legacy) with fingerprint dedup.
     const merged: PendingMeshCoordinatorEvent[] = [];
@@ -354,7 +465,7 @@ export function getPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaem
     try {
         const store = MeshRuntimeStore.getInstance();
         if (store.pendingEventCount(meshId) > 0) {
-            for (const row of store.peekPendingEvents(meshId, coordinatorDaemonId)) {
+            for (const row of store.peekPendingEvents(meshId, daemonIds.length > 0 ? daemonIds : undefined)) {
                 const event = row.payload as PendingMeshCoordinatorEvent;
                 if (event) pushUnique(event);
             }
@@ -362,7 +473,7 @@ export function getPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaem
     } catch { /* SQLite unavailable — JSONL fallback below */ }
 
     // JSONL (legacy)
-    for (const event of readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId)) {
+    for (const event of readPendingMeshCoordinatorEventsFromDisk(meshId, daemonIds)) {
         pushUnique(event);
     }
 

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
@@ -63,6 +69,24 @@ interface LiveCoordinator {
     idle: boolean;
 }
 
+// The set of coordinator-daemon ids THIS daemon answers to when draining the
+// pending-events queue. A unicast completion event is stamped with the worker's
+// meshCoordinatorDaemonId, which can be either:
+//   - the daemon's canonical status id (`standalone_<machineId>` / `daemon_<machineId>`),
+//     stamped by the MCP layer via ctx.localDaemonId (= getStatus().status.instanceId), or
+//   - the bare machineId, stamped by the local queue-assignment path (loadConfig().machineId).
+// Draining with only one of these silently misses events stamped with the other —
+// the exact reason a generating coordinator never self-received local completions.
+// We accept BOTH so the drain matches regardless of which path stamped the event.
+function resolveCoordinatorDaemonIds(components: DaemonComponents): string[] {
+    const ids = new Set<string>();
+    const statusInstanceId = readNonEmptyString((components as { statusInstanceId?: string }).statusInstanceId);
+    if (statusInstanceId) ids.add(statusInstanceId);
+    const machineId = readNonEmptyString(loadConfig().machineId);
+    if (machineId) ids.add(machineId);
+    return [...ids];
+}
+
 // Find live CLI coordinator instances on THIS daemon, keyed by mesh.
 function findLiveCoordinators(components: DaemonComponents): LiveCoordinator[] {
     const out: LiveCoordinator[] = [];
@@ -79,7 +103,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,
@@ -111,6 +137,10 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
     }
 
     const localDaemonId = readNonEmptyString(loadConfig().machineId) || undefined;
+    // The id-set used to scope the local queue drain (status id + machineId). See
+    // resolveCoordinatorDaemonIds — the status id is what the MCP layer stamps and
+    // is mandatory here for a generating CLI coordinator to self-receive completions.
+    const drainDaemonIds = resolveCoordinatorDaemonIds(components);
     const dispatchMeshCommand = components.dispatchMeshCommand;
     const store = (() => {
         try { return MeshRuntimeStore.getInstance(); } catch { return undefined; }
@@ -130,12 +160,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 +183,21 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
 
         let pendingEvents: PendingMeshCoordinatorEvent[] = [];
         try {
-            pendingEvents = drainPendingMeshCoordinatorEvents(meshId, localDaemonId);
+            pendingEvents = drainPendingMeshCoordinatorEvents(
+                meshId,
+                drainDaemonIds.length > 0 ? drainDaemonIds : 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,50 @@ 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 | ReadonlyArray<string>,
+        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] : [];
+            // A coordinator daemon can answer to more than one id form: its canonical
+            // status id (e.g. `standalone_<machineId>` / `daemon_<machineId>`, which the
+            // MCP layer stamps via ctx.localDaemonId) AND the bare machineId (stamped by
+            // the local queue-assignment path). Accept ANY of them so a unicast event
+            // stamped with either id is drained here. Unscoped (NULL) rows always match.
+            const daemonIds = (Array.isArray(coordinatorDaemonId)
+                ? coordinatorDaemonId
+                : coordinatorDaemonId ? [coordinatorDaemonId] : [])
+                .filter((id): id is string => typeof id === 'string' && id.length > 0);
+            // 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 (daemonIds.length > 0) {
+                clauses.push(`(coordinator_daemon_id IS NULL OR coordinator_daemon_id IN (${daemonIds.map(() => '?').join(',')}))`);
+                params.push(...daemonIds);
+            }
+            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);
@@ -1267,11 +1301,15 @@ export class MeshRuntimeStore {
     }
 
     /** Non-destructive peek — returns undrained events without marking them drained. */
-    peekPendingEvents(meshId: string, coordinatorDaemonId?: string | null): Array<{ id: string; event: string; payload: unknown }> {
-        const whereClause = coordinatorDaemonId
-            ? `WHERE mesh_id = ? AND drained = 0 AND (coordinator_daemon_id IS NULL OR coordinator_daemon_id = ?)`
+    peekPendingEvents(meshId: string, coordinatorDaemonId?: string | null | ReadonlyArray<string>): Array<{ id: string; event: string; payload: unknown }> {
+        const daemonIds = (Array.isArray(coordinatorDaemonId)
+            ? coordinatorDaemonId
+            : coordinatorDaemonId ? [coordinatorDaemonId] : [])
+            .filter((id): id is string => typeof id === 'string' && id.length > 0);
+        const whereClause = daemonIds.length > 0
+            ? `WHERE mesh_id = ? AND drained = 0 AND (coordinator_daemon_id IS NULL OR coordinator_daemon_id IN (${daemonIds.map(() => '?').join(',')}))`
             : `WHERE mesh_id = ? AND drained = 0`;
-        const params: unknown[] = coordinatorDaemonId ? [meshId, coordinatorDaemonId] : [meshId];
+        const params: unknown[] = daemonIds.length > 0 ? [meshId, ...daemonIds] : [meshId];
         const rows = this.db.prepare(
             `SELECT id, event, payload FROM mesh_pending_events ${whereClause} ORDER BY queued_at ASC LIMIT 100`
         ).all(...params) as Array<{ id: string; event: string; payload: string }>;