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

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

@@ -31,11 +31,11 @@ export declare function queuePendingMeshCoordinatorEvent(event: PendingMeshCoord
  * 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?: {
+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

@@ -298,7 +298,7 @@ export declare class MeshRuntimeStore {
      * drained=1 marking, so force-drain + a concurrent full drain can never both
      * consume the same row.
      */
-    drainPendingEvents(meshId: string, coordinatorDaemonId?: string | null, opts?: {
+    drainPendingEvents(meshId: string, coordinatorDaemonId?: string | null | ReadonlyArray<string>, opts?: {
         onlyEvents?: ReadonlySet<string>;
     }): Array<{
         id: string;
@@ -306,7 +306,7 @@ export declare class MeshRuntimeStore {
         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.275",
+  "version": "0.9.82-rc.277",
   "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.275",
+    "@adhdev/mesh-shared": "0.9.82-rc.277",
     "@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
 // ---------------------------------------------------------------------------
@@ -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 */ }
@@ -342,11 +365,18 @@ function selectiveDrainFile(
  */
 export function drainPendingMeshCoordinatorEvents(
     meshId?: string,
-    coordinatorDaemonId?: 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);
 
@@ -368,7 +398,7 @@ export function drainPendingMeshCoordinatorEvents(
     try {
         const store = MeshRuntimeStore.getInstance();
         if (store.pendingEventCount(meshId) > 0) {
-            for (const row of store.drainPendingEvents(meshId, coordinatorDaemonId, onlyEvents ? { onlyEvents } : undefined)) {
+            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);
             }
@@ -377,16 +407,18 @@ export function drainPendingMeshCoordinatorEvents(
         // 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 = coordinatorDaemonId && path === getPendingEventsPath(meshId);
+        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 || e.targetCoordinatorDaemonId === coordinatorDaemonId;
+            !isSharedFile || !e.targetCoordinatorDaemonId || daemonIds.includes(e.targetCoordinatorDaemonId);
 
         if (onlyEvents) {
             // Selective JSONL drain: consume only matching events, rewrite the rest back.
@@ -413,8 +445,9 @@ export function drainPendingMeshCoordinatorEvents(
 }
 
 /** 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[] = [];
@@ -432,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);
             }
@@ -440,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

@@ -69,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[] = [];
@@ -119,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; }
@@ -163,7 +185,7 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
         try {
             pendingEvents = drainPendingMeshCoordinatorEvents(
                 meshId,
-                localDaemonId,
+                drainDaemonIds.length > 0 ? drainDaemonIds : localDaemonId,
                 forceOnly ? { onlyEvents: MESH_FORCE_INJECT_EVENTS } : undefined,
             );
         } catch (e: any) {

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

@@ -1253,7 +1253,7 @@ export class MeshRuntimeStore {
      */
     drainPendingEvents(
         meshId: string,
-        coordinatorDaemonId?: string | null,
+        coordinatorDaemonId?: string | null | ReadonlyArray<string>,
         opts?: { onlyEvents?: ReadonlySet<string> },
     ): Array<{ id: string; event: string; payload: unknown }> {
         return this.transaction(() => {
@@ -1261,14 +1261,23 @@ export class MeshRuntimeStore {
             // 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 (coordinatorDaemonId) {
-                clauses.push('(coordinator_daemon_id IS NULL OR coordinator_daemon_id = ?)');
-                params.push(coordinatorDaemonId);
+            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(',')})`);
@@ -1292,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 }>;