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

package/dist/boot/daemon-lifecycle.d.ts

@@ -62,6 +62,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;
 }
 export interface DaemonComponents {
     providerLoader: ProviderLoader;
@@ -79,6 +81,7 @@ export interface DaemonComponents {
     };
     refreshProviderAvailability: (providerType?: string) => Promise<void>;
     dispatchMeshCommand?: (daemonId: string, command: string, args: Record<string, unknown>) => Promise<any>;
+    onMeshCoordinatorEventForwarded?: (payload: Record<string, unknown>) => void;
 }
 export interface DaemonDevSupportOptions {
     components: DaemonComponents;

package/dist/index.js

@@ -3182,6 +3182,21 @@ var init_mesh_runtime_store = __esm({
                 expires_at INTEGER NOT NULL
             );
 
+            -- R3: idempotent coordinator inbox. When a terminal/force-inject event is
+            -- direct-injected into a LIVE local CLI coordinator (coord.onEvent('send_message')),
+            -- we record (coordinator_daemon_id, fingerprint) here. That same coordinator also
+            -- polls get_pending_mesh_events, which would re-deliver the queued copy of the very
+            -- event it just received in its PTY \u2192 user sees the completion twice. The drain for
+            -- a coordinator daemon filters out events already direct-delivered to it, giving
+            -- exactly-once-per-coordinator while keeping the queue for other consumers (idle /
+            -- MCP-only / remote) that did NOT receive the direct inject.
+            CREATE TABLE IF NOT EXISTS mesh_direct_delivered_events (
+                coordinator_daemon_id TEXT NOT NULL,
+                fingerprint TEXT NOT NULL,
+                expires_at INTEGER NOT NULL,
+                PRIMARY KEY (coordinator_daemon_id, fingerprint)
+            );
+
             CREATE TABLE IF NOT EXISTS mesh_direct_dispatches (
                 task_id TEXT PRIMARY KEY,
                 mesh_id TEXT NOT NULL,
@@ -3337,6 +3352,25 @@ var init_mesh_runtime_store = __esm({
       sweepExpiredFingerprints() {
         this.db.prepare("DELETE FROM mesh_completion_fingerprints WHERE expires_at <= ?").run(Date.now());
       }
+      // R3: record that an event (by pending-event fingerprint) was direct-injected into a live
+      // coordinator on the given daemon, so that coordinator's own drain skips the queued copy.
+      recordDirectDelivered(coordinatorDaemonId, fingerprint, ttlMs) {
+        if (!coordinatorDaemonId || !fingerprint) return;
+        this.db.prepare(
+          "INSERT OR REPLACE INTO mesh_direct_delivered_events (coordinator_daemon_id, fingerprint, expires_at) VALUES (?, ?, ?)"
+        ).run(coordinatorDaemonId, fingerprint, Date.now() + ttlMs);
+        this.maybeCheckpointWal();
+      }
+      wasDirectDelivered(coordinatorDaemonId, fingerprint) {
+        if (!coordinatorDaemonId || !fingerprint) return false;
+        const row = this.db.prepare(
+          "SELECT 1 FROM mesh_direct_delivered_events WHERE coordinator_daemon_id = ? AND fingerprint = ? AND expires_at > ?"
+        ).get(coordinatorDaemonId, fingerprint, Date.now());
+        return row !== void 0;
+      }
+      sweepExpiredDirectDelivered() {
+        this.db.prepare("DELETE FROM mesh_direct_delivered_events WHERE expires_at <= ?").run(Date.now());
+      }
       maybeCheckpointWal() {
         if (++this.walWriteCounter < _MeshRuntimeStore.WAL_CHECK_INTERVAL) return;
         this.walWriteCounter = 0;
@@ -5615,6 +5649,16 @@ function readNonEmptyString2(value) {
 function readRecord3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
+function canonicalDaemonId(value) {
+  const id = readNonEmptyString2(value);
+  if (!id) return "";
+  return id.replace(/^(?:daemon|standalone)_/, "");
+}
+function sameDaemonId(a, b) {
+  const ca = canonicalDaemonId(a);
+  const cb = canonicalDaemonId(b);
+  return ca !== "" && ca === cb;
+}
 function resolveEventSessionId(event, fallback) {
   return readNonEmptyString2(event.targetSessionId) || readNonEmptyString2(event.sessionId) || readNonEmptyString2(event.instanceId) || readNonEmptyString2(fallback);
 }
@@ -5798,6 +5842,29 @@ function buildPendingEventFingerprint(event) {
     timestamp || ""
   ].join("::");
 }
+function markMeshCoordinatorEventDirectDelivered(coordinatorDaemonId, event) {
+  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 {
+  }
+}
+function wasDirectDeliveredToCoordinator(coordinatorDaemonId, event) {
+  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;
+  }
+}
 function hasPendingCoordinatorEventDuplicate(event) {
   const fingerprint = buildPendingEventFingerprint(event);
   if (!fingerprint.trim()) return false;
@@ -5996,7 +6063,9 @@ function drainPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
     for (const event of filtered) pushUnique(event);
   }
   if (merged.length === 0) return [];
-  return reconcilePendingMeshCoordinatorEvents(meshId, merged);
+  const deliverable = coordinatorDaemonId ? merged.filter((event) => !wasDirectDeliveredToCoordinator(coordinatorDaemonId, event)) : merged;
+  if (deliverable.length === 0) return [];
+  return reconcilePendingMeshCoordinatorEvents(meshId, deliverable);
 }
 function getPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   if (!meshId) return [];
@@ -6023,7 +6092,8 @@ function getPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   for (const event of readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId)) {
     pushUnique(event);
   }
-  return reconcilePendingMeshCoordinatorEvents(meshId, merged);
+  const deliverable = coordinatorDaemonId ? merged.filter((event) => !wasDirectDeliveredToCoordinator(coordinatorDaemonId, event)) : merged;
+  return reconcilePendingMeshCoordinatorEvents(meshId, deliverable);
 }
 function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   if (!meshId) return;
@@ -6039,7 +6109,7 @@ function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
     }
   }
 }
-var import_fs8, import_path8, import_crypto7, REFINE_TERMINAL_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP;
+var import_fs8, import_path8, import_crypto7, REFINE_TERMINAL_EVENTS, DIRECT_DELIVERED_TTL_MS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP;
 var init_mesh_events_pending = __esm({
   "src/mesh/mesh-events-pending.ts"() {
     "use strict";
@@ -6051,6 +6121,7 @@ var init_mesh_events_pending = __esm({
     init_mesh_runtime_store();
     init_mesh_events_utils();
     REFINE_TERMINAL_EVENTS = /* @__PURE__ */ new Set(["refine:completed", "refine:failed"]);
+    DIRECT_DELIVERED_TTL_MS = 10 * 60 * 1e3;
     MAX_PENDING_EVENTS_BYTES = 100 * 1024;
     MAX_PENDING_EVENTS_KEEP = 50;
   }
@@ -6587,6 +6658,140 @@ var init_cli_detector = __esm({
   }
 });
 
+// src/mesh/mesh-routing.ts
+function readSettings(state) {
+  return state?.settings && typeof state.settings === "object" ? state.settings : {};
+}
+function resolveWorkerDelegateRouting(components, instanceId, deps) {
+  const sessionId = readNonEmptyString2(instanceId);
+  let workspace = "";
+  let coordinatorDaemonId = "";
+  const reject = (rejectionReason) => ({
+    isDelegate: false,
+    meshId: "",
+    nodeId: "",
+    nodeLabel: "",
+    coordinatorDaemonId,
+    workspace,
+    sessionId,
+    rejectionReason
+  });
+  const sourceInstance = components.instanceManager.getInstance(instanceId);
+  if (!sourceInstance || sourceInstance.category !== "cli") return reject("not_cli");
+  const state = sourceInstance.getState();
+  workspace = readNonEmptyString2(state.workspace);
+  if (!workspace) return reject("no_workspace");
+  const settings = readSettings(state);
+  coordinatorDaemonId = readNonEmptyString2(settings.meshCoordinatorDaemonId);
+  const coordinatorMeshId = readNonEmptyString2(settings.meshCoordinatorFor);
+  let meshIdFromDirectDispatch = "";
+  if (coordinatorMeshId) {
+    let hasActiveDispatch = false;
+    try {
+      hasActiveDispatch = getActiveDirectDispatches(coordinatorMeshId).some((d) => d.sessionId === instanceId) || hasUnterminalDirectDispatchLedgerEntry(coordinatorMeshId, instanceId);
+    } catch {
+    }
+    if (!hasActiveDispatch) return reject("coordinator_not_dispatch_target");
+    meshIdFromDirectDispatch = coordinatorMeshId;
+  }
+  const meshIdFromRuntime = readNonEmptyString2(settings.meshNodeFor) || meshIdFromDirectDispatch;
+  const hasWorkerEnvelope = Boolean(
+    meshIdFromRuntime || settings.launchedByCoordinator || coordinatorDaemonId || readNonEmptyString2(settings.meshCoordinatorNodeId)
+  );
+  if (!hasWorkerEnvelope) return reject("no_worker_envelope");
+  const mesh = meshIdFromRuntime ? deps.getMeshById(meshIdFromRuntime) : deps.getMeshByWorkspace(workspace);
+  const meshId = meshIdFromRuntime || readNonEmptyString2(mesh?.id);
+  if (!meshId) return reject("mesh_unresolved");
+  const targetNode = mesh?.nodes?.find((n) => n.workspace === workspace);
+  const runtimeNodeId = readNonEmptyString2(settings.meshNodeId);
+  const nodeId = readNonEmptyString2(targetNode?.id) || runtimeNodeId;
+  const nodeLabel = targetNode ? `Node '${targetNode.id}'` : runtimeNodeId ? `Node '${runtimeNodeId}'` : `Agent at ${workspace}`;
+  return {
+    isDelegate: true,
+    meshId,
+    nodeId,
+    nodeLabel,
+    coordinatorDaemonId,
+    workspace,
+    sessionId
+  };
+}
+function isUnroutableDelegateRejection(routing) {
+  return !routing.isDelegate && routing.rejectionReason === "mesh_unresolved";
+}
+function recordUnroutableDelegateEvent(routing, eventName) {
+  if (!isUnroutableDelegateRejection(routing)) return false;
+  const dedupKey = `${routing.sessionId}::${eventName}::${routing.workspace}`;
+  const now = Date.now();
+  const last = recentUnroutableDiagnostics.get(dedupKey);
+  if (last !== void 0 && now - last < UNROUTABLE_DIAGNOSTIC_DEDUP_MS) return false;
+  recentUnroutableDiagnostics.set(dedupKey, now);
+  if (recentUnroutableDiagnostics.size > 256) {
+    for (const [key, ts2] of recentUnroutableDiagnostics) {
+      if (now - ts2 >= UNROUTABLE_DIAGNOSTIC_DEDUP_MS) recentUnroutableDiagnostics.delete(key);
+    }
+  }
+  try {
+    appendLedgerEntry(UNROUTABLE_DIAGNOSTIC_STREAM, {
+      kind: "delivery_unroutable",
+      sessionId: routing.sessionId || void 0,
+      payload: {
+        event: eventName,
+        reason: routing.rejectionReason,
+        workspace: routing.workspace || void 0,
+        coordinatorDaemonId: routing.coordinatorDaemonId || void 0,
+        detail: "Worker envelope was present but no mesh could be resolved; the event could not be routed to a coordinator."
+      }
+    });
+    LOG.warn("MeshEvents", `delivery_unroutable: ${eventName} from session ${routing.sessionId || "(unknown)"} at ${routing.workspace || "(no workspace)"} \u2014 envelope present but mesh unresolved`);
+    return true;
+  } catch (e) {
+    LOG.warn("MeshEvents", `Failed to record delivery_unroutable diagnostic: ${e?.message || e}`);
+    return false;
+  }
+}
+function getRecentUnroutableDeliveries(opts) {
+  const sinceMs = opts?.sinceMs ?? 60 * 60 * 1e3;
+  const limit = opts?.limit ?? 20;
+  let entries;
+  try {
+    entries = readLedgerEntries(UNROUTABLE_DIAGNOSTIC_STREAM, { kind: ["delivery_unroutable"], tail: 200 });
+  } catch {
+    return [];
+  }
+  const cutoff = Date.now() - sinceMs;
+  const out = [];
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    const ts2 = new Date(entry.timestamp).getTime();
+    if (!Number.isNaN(ts2) && ts2 < cutoff) continue;
+    const payload = entry.payload && typeof entry.payload === "object" ? entry.payload : {};
+    out.push({
+      timestamp: entry.timestamp,
+      event: readNonEmptyString2(payload.event),
+      sessionId: readNonEmptyString2(entry.sessionId) || readNonEmptyString2(payload.sessionId) || void 0,
+      workspace: readNonEmptyString2(payload.workspace) || void 0,
+      coordinatorDaemonId: readNonEmptyString2(payload.coordinatorDaemonId) || void 0
+    });
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+var UNROUTABLE_DIAGNOSTIC_STREAM, UNROUTABLE_DIAGNOSTIC_DEDUP_MS, recentUnroutableDiagnostics;
+var init_mesh_routing = __esm({
+  "src/mesh/mesh-routing.ts"() {
+    "use strict";
+    init_mesh_work_queue();
+    init_mesh_events_stale();
+    init_mesh_ledger();
+    init_logger();
+    init_mesh_events_utils();
+    UNROUTABLE_DIAGNOSTIC_STREAM = "__unroutable__";
+    UNROUTABLE_DIAGNOSTIC_DEDUP_MS = 60 * 1e3;
+    recentUnroutableDiagnostics = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/mesh/mesh-events-coordinator.ts
 function getCachedMeshByWorkspace(workspace) {
   const now = Date.now();
@@ -6599,6 +6804,9 @@ function getCachedMeshByWorkspace(workspace) {
 function __resetIdleAutoFastForwardForTests() {
   idleAutoFastForwardLastAttempt.clear();
 }
+function __resetMeshWorkspaceCacheForTests() {
+  meshByWorkspaceCache.clear();
+}
 function sweepExpiredRemoteIdleSessions() {
   try {
     MeshRuntimeStore.getInstance().pruneExpiredRemoteIdleSessions();
@@ -7265,6 +7473,17 @@ function injectMeshSystemMessage(components, args) {
     sourceSession?.getState()?.settings?.meshCoordinatorDaemonId
   );
   const localDaemonId = readNonEmptyString2(loadConfig().machineId);
+  if (components.onMeshCoordinatorEventForwarded) {
+    try {
+      components.onMeshCoordinatorEventForwarded({
+        event: args.event,
+        meshId: args.meshId,
+        nodeId: eventNodeId || void 0,
+        ...args.metadataEvent
+      });
+    } catch {
+    }
+  }
   const intentionalCleanupStop = shouldSuppressIntentionalCleanupStop({
     event: args.event,
     meshId: args.meshId,
@@ -7609,10 +7828,38 @@ function injectMeshSystemMessage(components, 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;
+    if (workerCoordinatorDaemonId && localDaemonId && !sameDaemonId(workerCoordinatorDaemonId, localDaemonId)) return false;
     return true;
   });
   if (coordinatorInstances.length === 0) {
+    const remoteCoordinatorDaemonId = workerCoordinatorDaemonId && localDaemonId && !sameDaemonId(workerCoordinatorDaemonId, localDaemonId) ? workerCoordinatorDaemonId : "";
+    if (remoteCoordinatorDaemonId && components.dispatchMeshCommand) {
+      const forwardPayload = {
+        event: args.event,
+        meshId: args.meshId,
+        nodeId: args.nodeId || void 0,
+        workspace: readNonEmptyString2(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)}\u2026`);
+      }).catch((error) => {
+        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 || void 0,
+          workspace: readNonEmptyString2(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,
@@ -7631,7 +7878,7 @@ function injectMeshSystemMessage(components, args) {
     }
     return { success: true, forwarded: 0 };
   }
-  if (queuePendingMeshCoordinatorEvent({
+  const pendingEvent = {
     event: args.event,
     meshId: args.meshId,
     nodeLabel: args.nodeLabel,
@@ -7644,9 +7891,13 @@ function injectMeshSystemMessage(components, args) {
     coordinatorMessage: messageText,
     queuedAt: Date.now(),
     ...workerCoordinatorDaemonId ? { targetCoordinatorDaemonId: workerCoordinatorDaemonId } : {}
-  })) {
+  };
+  if (queuePendingMeshCoordinatorEvent(pendingEvent)) {
     LOG.info("MeshEvents", `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
   }
+  if (localDaemonId) {
+    markMeshCoordinatorEventDirectDelivered(localDaemonId, pendingEvent);
+  }
   const forceInject = shouldForceInjectMeshEvent(args.event);
   for (const coord of coordinatorInstances) {
     const coordState = coord.getState();
@@ -7714,15 +7965,15 @@ function setupMeshEventForwarding(components) {
         if (flushSource && flushSource.category === "cli") {
           const flushState = flushSource.getState();
           const flushSettings = flushState.settings && typeof flushState.settings === "object" ? flushState.settings : {};
-          const coordinatorMeshId2 = readNonEmptyString2(flushSettings.meshCoordinatorFor);
-          if (coordinatorMeshId2) {
+          const coordinatorMeshId = readNonEmptyString2(flushSettings.meshCoordinatorFor);
+          if (coordinatorMeshId) {
             const status = readNonEmptyString2(flushState.status).toLowerCase();
             if (status === "idle") {
               try {
                 const localDaemonId = readNonEmptyString2(loadConfig().machineId) || void 0;
-                const pendingEvents = drainPendingMeshCoordinatorEvents(coordinatorMeshId2, localDaemonId);
+                const pendingEvents = drainPendingMeshCoordinatorEvents(coordinatorMeshId, localDaemonId);
                 if (pendingEvents.length > 0) {
-                  LOG.info("MeshEvents", `Auto-flushing ${pendingEvents.length} pending coordinator event(s) for mesh ${coordinatorMeshId2} on coordinator idle`);
+                  LOG.info("MeshEvents", `Auto-flushing ${pendingEvents.length} pending coordinator event(s) for mesh ${coordinatorMeshId} on coordinator idle`);
                   for (const pending of pendingEvents) {
                     if (!pending.coordinatorMessage) continue;
                     const forcePending = shouldForceInjectMeshEvent(pending.event);
@@ -7738,7 +7989,7 @@ function setupMeshEventForwarding(components) {
             }
             let hasDirectDispatch = false;
             try {
-              hasDirectDispatch = getActiveDirectDispatches(coordinatorMeshId2).some((d) => d.sessionId === flushInstanceId) || hasUnterminalDirectDispatchLedgerEntry(coordinatorMeshId2, flushInstanceId);
+              hasDirectDispatch = getActiveDirectDispatches(coordinatorMeshId).some((d) => d.sessionId === flushInstanceId) || hasUnterminalDirectDispatchLedgerEntry(coordinatorMeshId, flushInstanceId);
             } catch {
             }
             if (!hasDirectDispatch) return;
@@ -7749,37 +8000,19 @@ function setupMeshEventForwarding(components) {
     if (!isMeshCoordinatorEvent(event.event)) return;
     const instanceId = readNonEmptyString2(event.instanceId);
     if (!instanceId) return;
-    const sourceInstance = components.instanceManager.getInstance(instanceId);
-    if (!sourceInstance || sourceInstance.category !== "cli") return;
-    const state = sourceInstance.getState();
-    const workspace = readNonEmptyString2(state.workspace);
-    if (!workspace) return;
-    const settings = state.settings && typeof state.settings === "object" ? state.settings : {};
-    const coordinatorMeshId = readNonEmptyString2(settings.meshCoordinatorFor);
-    let meshIdFromDirectDispatch = "";
-    if (coordinatorMeshId) {
-      try {
-        const hasActiveDispatch = getActiveDirectDispatches(coordinatorMeshId).some((d) => d.sessionId === instanceId) || hasUnterminalDirectDispatchLedgerEntry(coordinatorMeshId, instanceId);
-        if (hasActiveDispatch) meshIdFromDirectDispatch = coordinatorMeshId;
-      } catch {
-      }
-      if (!meshIdFromDirectDispatch) return;
-    }
-    const meshIdFromRuntime = readNonEmptyString2(settings.meshNodeFor) || meshIdFromDirectDispatch;
-    const isMeshDelegate = Boolean(meshIdFromRuntime || settings.launchedByCoordinator);
-    if (!isMeshDelegate) return;
-    const mesh = meshIdFromRuntime ? getMeshWithCache(components, meshIdFromRuntime) : getCachedMeshByWorkspace(workspace);
-    const meshId = meshIdFromRuntime || readNonEmptyString2(mesh?.id);
-    if (!meshId) return;
-    const targetNode = mesh?.nodes?.find((n) => n.workspace === workspace);
-    const runtimeNodeId = readNonEmptyString2(settings.meshNodeId);
-    const resolvedNodeId = targetNode?.id || runtimeNodeId;
-    const nodeLabel = targetNode ? `Node '${targetNode.id}'` : runtimeNodeId ? `Node '${runtimeNodeId}'` : `Agent at ${workspace}`;
+    const routing = resolveWorkerDelegateRouting(components, instanceId, {
+      getMeshById: (meshId) => getMeshWithCache(components, meshId),
+      getMeshByWorkspace: (workspace) => getCachedMeshByWorkspace(workspace)
+    });
+    if (!routing.isDelegate) {
+      recordUnroutableDelegateEvent(routing, event.event);
+      return;
+    }
     injectMeshSystemMessage(components, {
-      meshId,
+      meshId: routing.meshId,
       sourceInstanceId: instanceId,
-      nodeId: resolvedNodeId,
-      nodeLabel,
+      nodeId: routing.nodeId,
+      nodeLabel: routing.nodeLabel,
       event: event.event,
       metadataEvent: event
     });
@@ -7800,6 +8033,7 @@ var init_mesh_events_coordinator = __esm({
     init_mesh_delivery_policy();
     init_mesh_runtime_store();
     init_mesh_events_pending();
+    init_mesh_routing();
     init_mesh_events_stale();
     init_mesh_events_utils();
     REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1e3;
@@ -7847,11 +8081,13 @@ var init_mesh_events_coordinator = __esm({
 var mesh_events_exports = {};
 __export(mesh_events_exports, {
   __resetIdleAutoFastForwardForTests: () => __resetIdleAutoFastForwardForTests,
+  __resetMeshWorkspaceCacheForTests: () => __resetMeshWorkspaceCacheForTests,
   clearPendingMeshCoordinatorEvents: () => clearPendingMeshCoordinatorEvents,
   drainPendingMeshCoordinatorEvents: () => drainPendingMeshCoordinatorEvents,
   getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
   handleMeshForwardEvent: () => handleMeshForwardEvent,
   isMeshCoordinatorEvent: () => isMeshCoordinatorEvent,
+  markMeshCoordinatorEventDirectDelivered: () => markMeshCoordinatorEventDirectDelivered,
   queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
   reconcileDirectDispatchCompletionFromTranscript: () => reconcileDirectDispatchCompletionFromTranscript,
   setupMeshEventForwarding: () => setupMeshEventForwarding,
@@ -38359,6 +38595,7 @@ var yaml3 = __toESM(require("js-yaml"));
 init_logger();
 init_mesh_coordinator();
 init_mesh_events();
+init_mesh_routing();
 init_mesh_host_ownership();
 init_mesh_fast_forward();
 
@@ -45125,6 +45362,7 @@ ${ptyResult.output.slice(-2e3)}`);
           }
           const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : this.deps.statusInstanceId || void 0;
           const pendingCoordinatorEvents = getPendingMeshCoordinatorEvents(meshId, callerCoordinatorDaemonId);
+          const unroutableDeliveries = getRecentUnroutableDeliveries();
           const previewFreshness = (() => {
             const localRepoRoot = nodeStatuses.map((node) => readStringValue(node?.git?.repoRoot, node?.repoRoot, node?.workspace)).find((candidate) => !!candidate && fs23.existsSync(candidate));
             return localRepoRoot ? buildPreviewFreshness(localRepoRoot) : void 0;
@@ -45180,6 +45418,7 @@ ${ptyResult.output.slice(-2e3)}`);
             ...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) => ({
               jobId: job.jobId,
               nodeId: job.targetNodeId,
@@ -45189,9 +45428,13 @@ ${ptyResult.output.slice(-2e3)}`);
               targetCoordinatorDaemonId: job.targetCoordinatorDaemonId
             }))
           };
-          const { pendingCoordinatorEvents: _pendingCoordinatorEvents, ...cacheableStatusResult } = statusResult;
+          const { pendingCoordinatorEvents: _pendingCoordinatorEvents, unroutableDeliveries: _unroutableDeliveries, ...cacheableStatusResult } = statusResult;
           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",
@@ -53513,7 +53756,8 @@ async function initDaemonComponents(config) {
     sessionRegistry,
     detectedIdes: detectedIdesRef,
     refreshProviderAvailability,
-    dispatchMeshCommand: config.dispatchMeshCommand
+    dispatchMeshCommand: config.dispatchMeshCommand,
+    onMeshCoordinatorEventForwarded: config.onMeshCoordinatorEventForwarded
   };
   setupMeshEventForwarding(components);
   setImmediate(() => void router.resumePendingRefineJobsOnStartup());