@adhdev/daemon-core 0.9.82-rc.256 → 0.9.82-rc.258

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

@@ -1,5 +1,6 @@
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
 export declare function __resetIdleAutoFastForwardForTests(): void;
+export declare function __resetMeshWorkspaceCacheForTests(): void;
 export declare function tryAssignQueueTask(components: DaemonComponents, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
 export interface MeshQueueTriggerResult {
     success: true;
@@ -39,6 +40,7 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateCompletion?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
+    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -51,6 +53,7 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateCompletion?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
+    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -63,6 +66,7 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateCompletion?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
+    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -75,6 +79,7 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateCompletion?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
+    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -87,6 +92,7 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateApproval?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
+    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -99,6 +105,7 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     duplicateApproval?: undefined;
     duplicateStopped?: undefined;
     error?: undefined;
+    remoteForwarded?: undefined;
 } | {
     success: boolean;
     forwarded: number;
@@ -111,9 +118,11 @@ 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;
@@ -123,6 +132,19 @@ 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,6 +18,13 @@ 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. */

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

@@ -1,6 +1,8 @@
 import type { SessionRecoveryContext } from './mesh-ledger.js';
 export declare function readNonEmptyString(value: unknown): string;
 export declare function readRecord(value: unknown): Record<string, unknown> | undefined;
+export declare function canonicalDaemonId(value: unknown): string;
+export declare function sameDaemonId(a: unknown, b: unknown): boolean;
 export declare function resolveEventSessionId(event: Record<string, unknown>, fallback?: unknown): string;
 export declare function readRefineJobId(event: {
     metadataEvent?: Record<string, unknown>;

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

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

package/dist/mesh/mesh-ledger.d.ts

@@ -14,7 +14,7 @@
  */
 import { EventEmitter } from 'events';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
-export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward';
+export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable';
 export interface MeshLedgerEntry {
     id: string;
     meshId: string;

package/dist/mesh/mesh-routing.d.ts

@@ -0,0 +1,70 @@
+import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
+export type WorkerDelegateRejectionReason = 'not_cli' | 'no_workspace' | 'no_worker_envelope' | 'coordinator_not_dispatch_target' | 'mesh_unresolved';
+export interface WorkerDelegateRouting {
+    /** True when the source session is a mesh worker whose events must route to a coordinator. */
+    isDelegate: boolean;
+    /** Resolved mesh id (runtime stamp, direct-dispatch recovery, or workspace lookup). */
+    meshId: string;
+    /** Resolved node id within the mesh, or '' when it cannot be determined. */
+    nodeId: string;
+    /** Human-readable node label for the coordinator system message. */
+    nodeLabel: string;
+    /** Coordinator daemon anchor (prefixed id) when the worker carries one; '' otherwise. */
+    coordinatorDaemonId: string;
+    /** Source session workspace (best-effort; '' when the session/workspace is missing). */
+    workspace: string;
+    /** Source session id echoed back, so diagnostics can name the dropped event's origin. */
+    sessionId: string;
+    /** Why routing was rejected (isDelegate=false), for fail-loud diagnostics (R4). */
+    rejectionReason?: WorkerDelegateRejectionReason;
+}
+interface ResolveDeps {
+    /** Resolve a mesh by id (local config + inline cache). */
+    getMeshById: (meshId: string) => any | undefined;
+    /** Resolve a mesh by workspace path (cached repo lookup). */
+    getMeshByWorkspace: (workspace: string) => any | undefined;
+}
+/**
+ * Resolve how a source CLI session's mesh events should route to a coordinator.
+ *
+ * This is the single authoritative interpretation of the worker envelope. It folds
+ * together every signal that previously lived in inline branches:
+ *  - runtime stamps (meshNodeFor / meshNodeId)
+ *  - the coordinator anchor (meshCoordinatorDaemonId) and launch marker (launchedByCoordinator,
+ *    meshCoordinatorNodeId) — any one proves delegation even if the node/mesh stamp was dropped
+ *  - direct-dispatch recovery: a coordinator session that is itself a dispatch target
+ *  - workspace→mesh fallback when no runtime mesh id survived
+ *
+ * Returns isDelegate=false (with a rejectionReason) instead of throwing, so the caller
+ * can either ignore non-delegate events or surface a diagnostic.
+ */
+export declare function resolveWorkerDelegateRouting(components: DaemonComponents, instanceId: string, deps: ResolveDeps): WorkerDelegateRouting;
+/** Ledger stream that collects delivery_unroutable diagnostics (no real mesh id exists for them). */
+export declare const UNROUTABLE_DIAGNOSTIC_STREAM = "__unroutable__";
+export declare function __resetUnroutableDiagnosticsForTests(): void;
+/** True only for rejections that represent a silently-dropped delegate event worth a diagnostic. */
+export declare function isUnroutableDelegateRejection(routing: WorkerDelegateRouting): boolean;
+/**
+ * R4: record that a worker event with a valid envelope could not be routed to a coordinator.
+ * Writes a `delivery_unroutable` ledger entry (deduped within a short window) so operators see
+ * WHY a completion never arrived instead of it vanishing. No-op for non-diagnostic rejections.
+ */
+export declare function recordUnroutableDelegateEvent(routing: WorkerDelegateRouting, eventName: string): boolean;
+export interface UnroutableDeliveryDiagnostic {
+    timestamp: string;
+    event: string;
+    sessionId?: string;
+    workspace?: string;
+    coordinatorDaemonId?: string;
+}
+/**
+ * R4 visibility: recent delivery_unroutable diagnostics, newest first. Surfaced in mesh_status
+ * so an operator/coordinator can see that completions were dropped (envelope present, mesh
+ * unresolved) rather than the drops being invisible in a ledger nobody reads. The diagnostics
+ * live in a single shared stream because an unroutable event has no resolvable mesh.
+ */
+export declare function getRecentUnroutableDeliveries(opts?: {
+    sinceMs?: number;
+    limit?: number;
+}): UnroutableDeliveryDiagnostic[];
+export {};

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

@@ -17,6 +17,9 @@ export declare class MeshRuntimeStore {
     hasCompletionFingerprint(fingerprint: string): boolean;
     recordCompletionFingerprint(fingerprint: string, ttlMs: number): void;
     sweepExpiredFingerprints(): void;
+    recordDirectDelivered(coordinatorDaemonId: string, fingerprint: string, ttlMs: number): void;
+    wasDirectDelivered(coordinatorDaemonId: string, fingerprint: string): boolean;
+    sweepExpiredDirectDelivered(): void;
     private maybeCheckpointWal;
     private ensureLegacyQueueMigrated;
     getQueueEntries(meshId: string, statuses?: MeshTaskStatus[]): MeshWorkQueueEntry[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.256",
+  "version": "0.9.82-rc.258",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/boot/daemon-lifecycle.ts

@@ -92,6 +92,8 @@ export interface DaemonInitConfig {
     dispatchMeshCommand?: (daemonId: string, command: string, args: Record<string, unknown>) => Promise<any>;
     /** Returns selected-coordinator mesh peer telemetry for a target daemon when available. */
     getMeshPeerConnectionStatus?: (daemonId: string) => Record<string, unknown> | null;
+    /** Cloud-only: P2P dashboard metadata sync after the core forwarder handles a mesh event. */
+    onMeshCoordinatorEventForwarded?: (payload: Record<string, unknown>) => void;
 }
 
 // ─── Result ───
@@ -110,6 +112,11 @@ export interface DaemonComponents {
     detectedIdes: { value: IDEInfo[] };
     refreshProviderAvailability: (providerType?: string) => Promise<void>;
     dispatchMeshCommand?: (daemonId: string, command: string, args: Record<string, unknown>) => Promise<any>;
+    // Cloud-only hook: after the single core forwarder handles a mesh coordinator event, cloud
+    // uses this to keep its P2P dashboard view in sync (mesh-owned session metadata + flush
+    // 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;
 }
 
 export interface DaemonDevSupportOptions {
@@ -348,6 +355,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         detectedIdes: detectedIdesRef,
         refreshProviderAvailability,
         dispatchMeshCommand: config.dispatchMeshCommand,
+        onMeshCoordinatorEventForwarded: config.onMeshCoordinatorEventForwarded,
     };
 
     // 11. Setup Mesh Event Forwarding

package/src/commands/router.ts

@@ -40,6 +40,7 @@ import { createHermesManualMeshCoordinatorSetup, resolveMeshCoordinatorSetup } f
 import { buildSessionEntries } from '../status/builders.js';
 import { registerMeshCoordinator, getCoordinatorForSession } from '../mesh/coordinator-registry.js';
 import { handleMeshForwardEvent, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, queuePendingMeshCoordinatorEvent, type PendingMeshCoordinatorEvent } from '../mesh/mesh-events.js';
+import { getRecentUnroutableDeliveries } from '../mesh/mesh-routing.js';
 import { buildMeshHostRequiredFailure, normalizeMeshDaemonRole, resolveMeshHostStatus } from '../mesh/mesh-host-ownership.js';
 import { fastForwardMeshNode } from '../mesh/mesh-fast-forward.js';
 import { buildPreviewFreshness } from '../mesh/preview-freshness.js';
@@ -7364,6 +7365,10 @@ export class DaemonCommandRouter {
                         ? args.coordinatorDaemonId.trim()
                         : (this.deps.statusInstanceId || undefined);
                     const pendingCoordinatorEvents = getPendingMeshCoordinatorEvents(meshId, callerCoordinatorDaemonId);
+                    // R4: surface recent fail-loud routing drops so a coordinator/operator can see
+                    // that a worker completion was lost (envelope present, mesh unresolved) instead
+                    // of it vanishing silently. Diagnostic-only — never cached (see omit below).
+                    const unroutableDeliveries = getRecentUnroutableDeliveries();
                     const previewFreshness = (() => {
                         const localRepoRoot = nodeStatuses
                             .map((node: any) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace))
@@ -7425,6 +7430,7 @@ export class DaemonCommandRouter {
                         ...(asyncRefineJobs.length > 0 ? { asyncRefineJobs } : {}),
                         ...(historicalSessions ? { historicalSessions } : {}),
                         ...(pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {}),
+                        ...(unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {}),
                         activeRefineJobs: Array.from(this.runningRefineJobs.values())
                             .filter(job => job.meshId === meshId)
                             .map(job => ({
@@ -7436,11 +7442,13 @@ export class DaemonCommandRouter {
                                 targetCoordinatorDaemonId: job.targetCoordinatorDaemonId,
                             })),
                     };
-                    const { pendingCoordinatorEvents: _pendingCoordinatorEvents, ...cacheableStatusResult } = statusResult as any;
+                    const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, ...cacheableStatusResult } = statusResult as any;
                     const rememberedStatus = this.rememberAggregateMeshStatus(meshId, cacheableStatusResult, refreshReason);
-                    const returnedStatus = pendingCoordinatorEvents.length > 0
-                        ? { ...rememberedStatus, pendingCoordinatorEvents }
-                        : rememberedStatus;
+                    const returnedStatus = {
+                        ...rememberedStatus,
+                        ...(pendingCoordinatorEvents.length > 0 ? { pendingCoordinatorEvents } : {}),
+                        ...(unroutableDeliveries.length > 0 ? { unroutableDeliveries } : {}),
+                    };
                     logRepoMeshStatusDebug('return_live', {
                         meshId,
                         command: 'mesh_status',

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

@@ -10,8 +10,9 @@ 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 } from './mesh-events-pending.js';
+import { queuePendingMeshCoordinatorEvent, drainPendingMeshCoordinatorEvents, markMeshCoordinatorEventDirectDelivered } from './mesh-events-pending.js';
 import type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
+import { resolveWorkerDelegateRouting, recordUnroutableDelegateEvent } from './mesh-routing.js';
 import {
     findRecentTerminalLedgerEvidence,
     hasDispatchAfterTerminal,
@@ -25,6 +26,7 @@ import {
     resolveEventSessionId,
     readRefineJobId,
     readWorkerResultMetadata,
+    sameDaemonId,
 } from './mesh-events-utils.js';
 
 // ---------------------------------------------------------------------------
@@ -53,6 +55,10 @@ export function __resetIdleAutoFastForwardForTests(): void {
     idleAutoFastForwardLastAttempt.clear();
 }
 
+export function __resetMeshWorkspaceCacheForTests(): void {
+    meshByWorkspaceCache.clear();
+}
+
 function sweepExpiredRemoteIdleSessions(): void {
     try {
         MeshRuntimeStore.getInstance().pruneExpiredRemoteIdleSessions();
@@ -980,6 +986,22 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         (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
+    // standalone) so the event path stays single-listener and the local code path is identical
+    // across standalone and cloud.
+    if (components.onMeshCoordinatorEventForwarded) {
+        try {
+            components.onMeshCoordinatorEventForwarded({
+                event: args.event,
+                meshId: args.meshId,
+                nodeId: eventNodeId || undefined,
+                ...args.metadataEvent,
+            });
+        } catch { /* dashboard metadata sync is best-effort */ }
+    }
+
     const intentionalCleanupStop = shouldSuppressIntentionalCleanupStop({
         event: args.event,
         meshId: args.meshId,
@@ -1349,11 +1371,52 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         const instState = inst.getState();
         if (instState.settings?.meshCoordinatorFor !== args.meshId) return false;
         if (args.sourceInstanceId && instState.instanceId === args.sourceInstanceId) return false;
-        if (workerCoordinatorDaemonId && localDaemonId && workerCoordinatorDaemonId !== localDaemonId) 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,
@@ -1380,23 +1443,35 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     // 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.
-    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 } : {}),
-        })) {
+    const pendingEvent = {
+        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 } : {}),
+    };
+    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();
@@ -1520,48 +1595,29 @@ export function setupMeshEventForwarding(components: DaemonComponents) {
         const instanceId = readNonEmptyString(event.instanceId);
         if (!instanceId) return;
 
-        const sourceInstance = components.instanceManager.getInstance(instanceId);
-        if (!sourceInstance || sourceInstance.category !== 'cli') return;
-        const state = sourceInstance.getState();
-        const workspace = readNonEmptyString(state.workspace);
-        if (!workspace) return;
-        const settings = state.settings && typeof state.settings === 'object' ? state.settings as Record<string, unknown> : {};
-
-        const coordinatorMeshId = readNonEmptyString(settings.meshCoordinatorFor);
-        let meshIdFromDirectDispatch = '';
-        if (coordinatorMeshId) {
-            try {
-                const hasActiveDispatch =
-                    getActiveDirectDispatches(coordinatorMeshId).some(d => d.sessionId === instanceId)
-                    || hasUnterminalDirectDispatchLedgerEntry(coordinatorMeshId, instanceId);
-                if (hasActiveDispatch) meshIdFromDirectDispatch = coordinatorMeshId;
-            } catch { /* best-effort */ }
-            if (!meshIdFromDirectDispatch) return;
+        // R1: all session→node→mesh→coordinator interpretation is folded into the single
+        // resolveWorkerDelegateRouting() resolver. No stamp (meshNodeFor / meshNodeId /
+        // meshCoordinatorDaemonId / meshCoordinatorNodeId / launchedByCoordinator) is read
+        // here to make a routing decision — the resolver is the one authority, and the
+        // forwarder consumes its typed result only.
+        const routing = resolveWorkerDelegateRouting(components, instanceId, {
+            getMeshById: (meshId) => getMeshWithCache(components, meshId),
+            getMeshByWorkspace: (workspace) => getCachedMeshByWorkspace(workspace),
+        });
+        if (!routing.isDelegate) {
+            // R4: a worker that presented a valid envelope but resolved to no mesh used to be
+            // dropped silently. Leave a fail-loud diagnostic so the missing completion is
+            // traceable. Benign non-delegate rejections (not_cli / no_workspace / etc.) are
+            // no-ops inside recordUnroutableDelegateEvent.
+            recordUnroutableDelegateEvent(routing, event.event);
+            return;
         }
 
-        const meshIdFromRuntime = readNonEmptyString(settings.meshNodeFor) || meshIdFromDirectDispatch;
-
-        const isMeshDelegate = Boolean(meshIdFromRuntime || settings.launchedByCoordinator);
-        if (!isMeshDelegate) return;
-
-        const mesh = meshIdFromRuntime ? getMeshWithCache(components, meshIdFromRuntime) : getCachedMeshByWorkspace(workspace);
-        const meshId = meshIdFromRuntime || readNonEmptyString(mesh?.id);
-        if (!meshId) return;
-
-        const targetNode = mesh?.nodes?.find((n: any) => n.workspace === workspace);
-        const runtimeNodeId = readNonEmptyString(settings.meshNodeId);
-        const resolvedNodeId = targetNode?.id || runtimeNodeId;
-        const nodeLabel = targetNode
-            ? `Node '${targetNode.id}'`
-            : runtimeNodeId
-                ? `Node '${runtimeNodeId}'`
-                : `Agent at ${workspace}`;
-
         injectMeshSystemMessage(components, {
-            meshId,
+            meshId: routing.meshId,
             sourceInstanceId: instanceId,
-            nodeId: resolvedNodeId,
-            nodeLabel,
+            nodeId: routing.nodeId,
+            nodeLabel: routing.nodeLabel,
             event: event.event,
             metadataEvent: event,
         });

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

@@ -4,7 +4,7 @@ import { randomUUID } from 'crypto';
 import { LOG } from '../logging/logger.js';
 import { getLedgerDir, readLedgerEntries } from './mesh-ledger.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
-import { buildMeshSystemMessage, readNonEmptyString, readRecord, resolveEventSessionId } from './mesh-events-utils.js';
+import { buildMeshSystemMessage, canonicalDaemonId, readNonEmptyString, readRecord, resolveEventSessionId } from './mesh-events-utils.js';
 
 // ---------------------------------------------------------------------------
 // MCP coordinator pending-event queue — FILE-BASED PERSISTENCE
@@ -83,6 +83,47 @@ export function buildPendingEventFingerprint(event: PendingMeshCoordinatorEvent)
     ].join('::');
 }
 
+// R3: TTL for the direct-delivered marker. A coordinator polls get_pending_mesh_events
+// well within this window after a terminal event; after it expires the marker is swept and
+// a late/duplicate drain would (harmlessly) re-surface — but by then the event is long gone
+// from the queue too. 10 minutes mirrors the completion-fingerprint TTL.
+const DIRECT_DELIVERED_TTL_MS = 10 * 60 * 1000;
+
+/**
+ * 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 function markMeshCoordinatorEventDirectDelivered(
+    coordinatorDaemonId: string,
+    event: PendingMeshCoordinatorEvent,
+): void {
+    // Canonicalize so the raw machineId used at inject time and the prefixed instanceId the
+    // coordinator drains with resolve to the same key.
+    const canonical = canonicalDaemonId(coordinatorDaemonId);
+    if (!canonical) return;
+    const fingerprint = buildPendingEventFingerprint(event);
+    if (!fingerprint.trim()) return;
+    try {
+        const store = MeshRuntimeStore.getInstance();
+        store.recordDirectDelivered(canonical, fingerprint, DIRECT_DELIVERED_TTL_MS);
+        store.sweepExpiredDirectDelivered();
+    } catch { /* best-effort — a duplicate is preferable to a crash */ }
+}
+
+function wasDirectDeliveredToCoordinator(coordinatorDaemonId: string, event: PendingMeshCoordinatorEvent): boolean {
+    const canonical = canonicalDaemonId(coordinatorDaemonId);
+    if (!canonical) return false;
+    const fingerprint = buildPendingEventFingerprint(event);
+    if (!fingerprint.trim()) return false;
+    try {
+        return MeshRuntimeStore.getInstance().wasDirectDelivered(canonical, fingerprint);
+    } catch {
+        return false;
+    }
+}
+
 export function hasPendingCoordinatorEventDuplicate(event: PendingMeshCoordinatorEvent): boolean {
     const fingerprint = buildPendingEventFingerprint(event);
     if (!fingerprint.trim()) return false;
@@ -321,7 +362,14 @@ export function drainPendingMeshCoordinatorEvents(meshId?: string, coordinatorDa
         for (const event of filtered) pushUnique(event);
     }
     if (merged.length === 0) return [];
-    return reconcilePendingMeshCoordinatorEvents(meshId, merged);
+    // R3: when this drain is scoped to a coordinator daemon, exclude events that were already
+    // direct-injected into that coordinator's live CLI session. Unscoped drains (no daemon id)
+    // keep everything — they belong to consumers that never received the direct inject.
+    const deliverable = coordinatorDaemonId
+        ? merged.filter(event => !wasDirectDeliveredToCoordinator(coordinatorDaemonId, event))
+        : merged;
+    if (deliverable.length === 0) return [];
+    return reconcilePendingMeshCoordinatorEvents(meshId, deliverable);
 }
 
 /** Peek at pending coordinator events without draining (non-destructive). */
@@ -356,7 +404,13 @@ export function getPendingMeshCoordinatorEvents(meshId?: string, coordinatorDaem
         pushUnique(event);
     }
 
-    return reconcilePendingMeshCoordinatorEvents(meshId, merged);
+    // R3: hide events already direct-delivered to this coordinator from its status peek, so
+    // mesh_status doesn't report a "pending" event the coordinator has in fact already received.
+    const deliverable = coordinatorDaemonId
+        ? merged.filter(event => !wasDirectDeliveredToCoordinator(coordinatorDaemonId, event))
+        : merged;
+
+    return reconcilePendingMeshCoordinatorEvents(meshId, deliverable);
 }
 
 /**

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

@@ -10,6 +10,26 @@ export function readRecord(value: unknown): Record<string, unknown> | undefined
         : undefined;
 }
 
+// A single daemon is identified three ways across the system: the raw machineId
+// (`mach_X`, what loadConfig().machineId returns and what the core forwarder uses as
+// localDaemonId), the cloud daemon id (`daemon_mach_X`), and the standalone daemon id
+// (`standalone_mach_X`, the runtime instanceId the MCP coordinator reports as
+// ctx.localDaemonId). Worker envelope stamps (meshCoordinatorDaemonId) and coordinator
+// drains use the prefixed forms, while the forwarder compares against the raw id — so a
+// naive `===` treats the same daemon as remote and breaks both coordinator matching and
+// the R3 direct-delivered dedup. Canonicalize to the raw id before comparing.
+export function canonicalDaemonId(value: unknown): string {
+    const id = readNonEmptyString(value);
+    if (!id) return '';
+    return id.replace(/^(?:daemon|standalone)_/, '');
+}
+
+export function sameDaemonId(a: unknown, b: unknown): boolean {
+    const ca = canonicalDaemonId(a);
+    const cb = canonicalDaemonId(b);
+    return ca !== '' && ca === cb;
+}
+
 export function resolveEventSessionId(event: Record<string, unknown>, fallback?: unknown): string {
     return readNonEmptyString(event.targetSessionId)
         || readNonEmptyString(event.sessionId)