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

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

@@ -28,6 +28,8 @@ 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;
     forwarded: number;
@@ -40,7 +42,6 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateCompletion?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
-    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -53,7 +54,6 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateCompletion?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
-    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -66,7 +66,6 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateCompletion?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
-    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -79,7 +78,6 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateCompletion?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
-    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -92,7 +90,6 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateApproval?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
-    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -105,7 +102,6 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateApproval?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
-    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -118,11 +114,9 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateApproval?: undefined;
     duplicateCompletion?: undefined;
     error?: undefined;
-    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
-    remoteForwarded: boolean;
     suppressed?: undefined;
     intentionalCleanupStop?: undefined;
     terminalLedgerEvidence?: undefined;
@@ -132,19 +126,6 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateCompletion?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
-} | {
-    success: boolean;
-    forwarded: number;
-    suppressed?: undefined;
-    intentionalCleanupStop?: undefined;
-    terminalLedgerEvidence?: undefined;
-    terminalLedgerKind?: undefined;
-    duplicateRefineTerminalEvent?: undefined;
-    duplicateApproval?: undefined;
-    duplicateCompletion?: undefined;
-    duplicateStopped?: undefined;
-    error?: undefined;
-    remoteForwarded?: undefined;
 } | {
     success: boolean;
     error: string;

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

@@ -18,17 +18,22 @@ export declare function readRefineJobId(event: {
     metadataEvent?: Record<string, unknown>;
 } | Record<string, unknown>): string;
 export declare function buildPendingEventFingerprint(event: PendingMeshCoordinatorEvent): string;
-/**
- * R3: record that an event was direct-injected into a live coordinator on `coordinatorDaemonId`.
- * That coordinator's own drain (get_pending_mesh_events with the same coordinatorDaemonId) will
- * skip the queued copy, so it receives the event exactly once instead of twice (PTY + poll).
- * Other consumers (unscoped drainers, other daemons) are unaffected — they did not get the inject.
- */
-export declare function markMeshCoordinatorEventDirectDelivered(coordinatorDaemonId: string, event: PendingMeshCoordinatorEvent): void;
 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-events.d.ts

@@ -1,5 +1,6 @@
 export type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
-export { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, markMeshCoordinatorEventDirectDelivered, } from './mesh-events-pending.js';
+export { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, } from './mesh-events-pending.js';
 export { reconcileDirectDispatchCompletionFromTranscript, } from './mesh-events-stale.js';
+export { setupMeshReconcileLoop, runMeshReconcileTick, } from './mesh-reconcile-loop.js';
 export type { MeshQueueTriggerResult } from './mesh-events-coordinator.js';
 export { tryAssignQueueTask, triggerMeshQueue, handleMeshForwardEvent, setupMeshEventForwarding, isMeshCoordinatorEvent, __resetIdleAutoFastForwardForTests, __resetMeshWorkspaceCacheForTests, } from './mesh-events-coordinator.js';

package/dist/mesh/mesh-reconcile-loop.d.ts

@@ -0,0 +1,7 @@
+import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
+export declare function runMeshReconcileTick(components: DaemonComponents): Promise<void>;
+interface ReconcileLoopHandle {
+    stop(): void;
+}
+export declare function setupMeshReconcileLoop(components: DaemonComponents): ReconcileLoopHandle;
+export {};

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.273",
+  "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.273",
+    "@adhdev/mesh-shared": "0.9.82-rc.275",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/boot/daemon-lifecycle.ts

@@ -37,6 +37,7 @@ import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import type { IdeProviderInstance } from '../providers/ide-provider-instance.js';
 import { createDefaultGitCommandServices } from '../git/git-commands.js';
 import { setupMeshEventForwarding } from '../mesh/mesh-events.js';
+import { setupMeshReconcileLoop } from '../mesh/mesh-reconcile-loop.js';
 import { loadMeshCoordinatorRegistry } from '../mesh/coordinator-registry.js';
 import { applyProcessHardening } from './process-hardening.js';
 import { installProviderProcessShim } from '../providers/sdk/v1/sandbox/require-whitelist.js';
@@ -117,6 +118,11 @@ export interface DaemonComponents {
     // subscriptions). Injected by daemon-cloud; absent/no-op on standalone. Replaces cloud's
     // former separate instanceManager.onEvent listener so the event path stays single-listener.
     onMeshCoordinatorEventForwarded?: (payload: Record<string, unknown>) => void;
+    // Periodic queue → live-coordinator reconcile loop handle. Set during
+    // initDaemonComponents, stopped during shutdownDaemonComponents. Drives the
+    // 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 };
 }
 
 export interface DaemonDevSupportOptions {
@@ -341,7 +347,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
     // 10. Start instance ticking
     instanceManager.startTicking(config.tickIntervalMs ?? 5_000);
 
-    const components = {
+    const components: DaemonComponents = {
         providerLoader,
         instanceManager,
         cliManager,
@@ -358,8 +364,14 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         onMeshCoordinatorEventForwarded: config.onMeshCoordinatorEventForwarded,
     };
 
-    // 11. Setup Mesh Event Forwarding
+    // 11. Setup Mesh Event Forwarding (queue persistence) + periodic reconcile loop.
+    // injectMeshSystemMessage now ONLY persists events to the pending-events queue;
+    // the reconcile loop drains that queue on a fixed interval and injects into live
+    // CLI coordinators when idle (and, in cloud mode, pulls remote worker daemons'
+    // queues over P2P). This is the single-model (queue + polling) replacement for the
+    // old spontaneous-forward push paths.
     setupMeshEventForwarding(components);
+    components.meshReconcileLoop = setupMeshReconcileLoop(components);
 
     // 12. Resume any refine jobs that were interrupted by a previous daemon restart.
     setImmediate(() => void router.resumePendingRefineJobsOnStartup());
@@ -404,11 +416,13 @@ export async function shutdownDaemonComponents(components: DaemonComponents): Pr
     const {
         poller, cdpInitializer, agentStreamManager,
         cliManager, instanceManager, cdpManagers,
+        meshReconcileLoop,
     } = components;
 
     // 1. Stop timers
     poller.stop();
     cdpInitializer.stop();
+    try { meshReconcileLoop?.stop(); } catch { /* noop */ }
 
     // 2. Dispose agent stream
     try {

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

@@ -10,7 +10,7 @@ import { buildMeshNodeCapabilityTags, nodeSatisfiesRequiredTags, claimNextTask,
 import { fastForwardMeshNode } from './mesh-fast-forward.js';
 import { createSessionDelivery, markSessionDeliveriesTerminal, updateSessionDeliveryStatus, recordCompletionConflict } from './mesh-delivery-policy.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
-import { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, markMeshCoordinatorEventDirectDelivered } from './mesh-events-pending.js';
+import { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents } from './mesh-events-pending.js';
 import type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import { resolveWorkerDelegateRouting, recordUnroutableDelegateEvent } from './mesh-routing.js';
 import { resolveDelegatedWorkerAutoApprove } from '../repo-mesh-types.js';
@@ -27,7 +27,6 @@ import {
     resolveEventSessionId,
     readRefineJobId,
     readWorkerResultMetadata,
-    sameDaemonId,
 } from './mesh-events-utils.js';
 
 // ---------------------------------------------------------------------------
@@ -976,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',
@@ -986,7 +985,7 @@ const MESH_FORCE_INJECT_EVENTS = new Set([
     'worktree_bootstrap_failed',
 ]);
 
-function shouldForceInjectMeshEvent(eventName: unknown): boolean {
+export function shouldForceInjectMeshEvent(eventName: unknown): boolean {
     return typeof eventName === 'string' && MESH_FORCE_INJECT_EVENTS.has(eventName);
 }
 
@@ -1007,7 +1006,6 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     const workerCoordinatorDaemonId = readNonEmptyString(
         (sourceSession?.getState()?.settings as Record<string, unknown>)?.meshCoordinatorDaemonId,
     );
-    const localDaemonId = readNonEmptyString(loadConfig().machineId);
 
     // R2: cloud P2P dashboard metadata sync. The cloud daemon used to do this from its own
     // relay listener; now the single core forwarder invokes the injected hook (no-op on
@@ -1392,82 +1390,24 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     });
     if (!messageText) return { success: false, error: 'unsupported mesh event' };
 
-    const coordinatorInstances = components.instanceManager.getByCategory('cli').filter((inst) => {
-        const instState = inst.getState();
-        if (instState.settings?.meshCoordinatorFor !== args.meshId) return false;
-        if (args.sourceInstanceId && instState.instanceId === args.sourceInstanceId) return false;
-        // canonicalize: the worker stamps the prefixed daemon id (standalone_/daemon_) while
-        // localDaemonId is the raw machineId — a literal !== wrongly excludes the local coordinator.
-        if (workerCoordinatorDaemonId && localDaemonId && !sameDaemonId(workerCoordinatorDaemonId, localDaemonId)) return false;
-        return true;
-    });
-
-    if (coordinatorInstances.length === 0) {
-        // R2: the coordinator is not a live instance on THIS daemon. If it lives on a remote
-        // daemon, forward over the injected transport (dispatchMeshCommand, supplied by cloud as
-        // P2P; absent/no-op on standalone). This replaces cloud's separate
-        // relayRemoteMeshCoordinatorEvent listener — remote delivery is now part of the single
-        // core forwarder path, so local-vs-remote is one code path and standalone == cloud for
-        // the local case. The pending queue remains the fallback when there is no remote target
-        // or the transport send fails (e.g. P2P down), so MCP coordinators can still backfill.
-        const remoteCoordinatorDaemonId = workerCoordinatorDaemonId && localDaemonId && !sameDaemonId(workerCoordinatorDaemonId, localDaemonId)
-            ? workerCoordinatorDaemonId
-            : '';
-        if (remoteCoordinatorDaemonId && components.dispatchMeshCommand) {
-            const forwardPayload: Record<string, unknown> = {
-                event: args.event,
-                meshId: args.meshId,
-                nodeId: args.nodeId || undefined,
-                workspace: readNonEmptyString(args.metadataEvent.workspace),
-                ...args.metadataEvent,
-                ...(recoveryContext ? { recoveryContext } : {}),
-            };
-            components.dispatchMeshCommand(remoteCoordinatorDaemonId, 'mesh_forward_event', forwardPayload)
-                .then(() => {
-                    LOG.info('MeshEvents', `Forwarded ${args.event} for mesh ${args.meshId} to remote coordinator daemon ${remoteCoordinatorDaemonId.slice(0, 12)}…`);
-                })
-                .catch((error: any) => {
-                    LOG.warn('MeshEvents', `Remote forward of ${args.event} failed (${error?.message || error}); queuing for backfill`);
-                    queuePendingMeshCoordinatorEvent({
-                        event: args.event,
-                        meshId: args.meshId,
-                        nodeLabel: args.nodeLabel,
-                        nodeId: args.nodeId || undefined,
-                        workspace: readNonEmptyString(args.metadataEvent.workspace),
-                        metadataEvent: { ...args.metadataEvent, ...(recoveryContext ? { recoveryContext } : {}) },
-                        coordinatorMessage: messageText,
-                        queuedAt: Date.now(),
-                        targetCoordinatorDaemonId: remoteCoordinatorDaemonId,
-                    });
-                });
-            return { success: true, forwarded: 0, remoteForwarded: true };
-        }
-        if (queuePendingMeshCoordinatorEvent({
-                event: args.event,
-                meshId: args.meshId,
-                nodeLabel: args.nodeLabel,
-                nodeId: args.nodeId || undefined,
-                workspace: readNonEmptyString(args.metadataEvent.workspace),
-                metadataEvent: {
-                    ...args.metadataEvent,
-                    ...(recoveryContext ? { recoveryContext } : {}),
-                },
-                coordinatorMessage: messageText,
-                queuedAt: Date.now(),
-                ...(workerCoordinatorDaemonId ? { targetCoordinatorDaemonId: workerCoordinatorDaemonId } : {}),
-            })) {
-            LOG.info('MeshEvents', `Queued ${args.event} for MCP coordinator (mesh ${args.meshId}${workerCoordinatorDaemonId ? `, coordinator daemon ${workerCoordinatorDaemonId}` : ''})`);
-        }
-        return { success: true, forwarded: 0 };
-    }
-
-    // All events — terminal and non-terminal — are queued for MCP coordinator
-    // delivery via the pending-events file/SQLite path. This ensures that MCP
-    // coordinators (which poll via get_pending_mesh_events / mesh_status) always
-    // receive terminal events even when a live CLI coordinator session is present.
-    // Previously, terminal events skipped the queue and were only direct-injected
-    // into live CLI coordinators via send_message, which silently dropped them
-    // when the coordinator was in a generating state.
+    // ── Queue-only delivery (single-model: queue + periodic poll) ──────────────
+    // Every mesh coordinator event — terminal or not, local-coordinator or
+    // remote — is persisted to the pending-events queue (SQLite + JSONL) and
+    // NOTHING is pushed here. The old spontaneous-forward paths were removed:
+    //   - F1 remote P2P `mesh_forward_event` dispatch (network/stamp-dependent,
+    //     silently dropped on P2P failure or missing meshCoordinatorDaemonId)
+    //   - F3 live-CLI PTY `send_message` fire-and-forget inject (silently
+    //     dropped when the coordinator was generating)
+    // Delivery to a live CLI coordinator now happens via setupMeshReconcileLoop,
+    // which drains this queue on a fixed interval and injects into the coordinator
+    // only when it is idle. A pure stdio MCP (LLM) coordinator — which has no live
+    // CLI session to inject into — drains the queue itself when it calls a mesh
+    // tool (mesh_status / mesh_read_chat). Either way the queue is the single
+    // source of truth and the only thing this function writes to.
+    //
+    // targetCoordinatorDaemonId scopes the event to a specific coordinator daemon
+    // (unicast) when the worker carries one, so the reconcile loop on the right
+    // daemon drains it and other daemons skip it. Absent → broadcast/backfill.
     const pendingEvent = {
         event: args.event,
         meshId: args.meshId,
@@ -1483,30 +1423,9 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         ...(workerCoordinatorDaemonId ? { targetCoordinatorDaemonId: workerCoordinatorDaemonId } : {}),
     };
     if (queuePendingMeshCoordinatorEvent(pendingEvent)) {
-        LOG.info('MeshEvents', `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
-    }
-
-    // R3: the live coordinators below receive this event directly in their PTY. They (or their
-    // MCP client) also poll get_pending_mesh_events with coordinatorDaemonId = this daemon, which
-    // would re-deliver the queued copy → the user saw the same completion twice. Mark the event
-    // direct-delivered to THIS daemon so that coordinator's own drain skips it. The queue entry
-    // stays for every OTHER consumer (idle / MCP-only / remote) that did not get the direct inject.
-    // markMeshCoordinatorEventDirectDelivered canonicalizes the id internally so the raw
-    // machineId here matches the prefixed instanceId (standalone_mach_X) the coordinator drains with.
-    if (localDaemonId) {
-        markMeshCoordinatorEventDirectDelivered(localDaemonId, pendingEvent);
-    }
-
-    const forceInject = shouldForceInjectMeshEvent(args.event);
-    for (const coord of coordinatorInstances) {
-        const coordState = coord.getState();
-        LOG.info('MeshEvents', `Forwarding mesh event to coordinator ${coordState.instanceId}${forceInject ? ' (force)' : ''}`);
-        coord.onEvent('send_message', {
-            input: { text: messageText, textFallback: messageText },
-            ...(forceInject ? { force: true } : {}),
-        });
+        LOG.info('MeshEvents', `Queued ${args.event} for coordinator (mesh ${args.meshId}${workerCoordinatorDaemonId ? `, coordinator daemon ${workerCoordinatorDaemonId}` : ''})`);
     }
-    return { success: true, forwarded: coordinatorInstances.length };
+    return { success: true, forwarded: 0 };
 }
 
 export function handleMeshForwardEvent(components: DaemonComponents, payload: Record<string, unknown>) {
@@ -1563,10 +1482,15 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
 
 export function setupMeshEventForwarding(components: DaemonComponents) {
     components.instanceManager.onEvent((event) => {
-        // --- Coordinator idle auto-flush ---
-        // When a coordinator session becomes idle, flush any pending coordinator events
-        // that accumulated while it was generating. This runs before the delegate routing
-        // below so that coordinator-own idle transitions are handled first.
+        // --- Coordinator idle auto-flush (fast path) ---
+        // When a coordinator session becomes idle, immediately flush any pending
+        // coordinator events that accumulated while it was generating, rather than
+        // waiting up to one reconcile interval for setupMeshReconcileLoop to do it.
+        // Both paths drain the SAME queue via drainPendingMeshCoordinatorEvents,
+        // whose SQLite drained=1 marking is atomic — whichever fires first consumes
+        // the events and the other gets nothing, so there is no double-delivery.
+        // This runs before the delegate routing below so that coordinator-own idle
+        // transitions are handled first.
         // Exception: a coordinator that is itself a direct-dispatch target still needs
         // to go through delegate routing so that the dispatching coordinator receives a
         // pendingCoordinatorEvents entry for the completion.