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

package/dist/index.js

@@ -32926,6 +32926,21 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
                 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,
@@ -33081,6 +33096,25 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
           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;
@@ -35373,6 +35407,16 @@ ${rendered}`, "utf-8");
     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);
     }
@@ -35554,6 +35598,29 @@ Next step: ${nextStep}`;
         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;
@@ -35752,7 +35819,9 @@ Next step: ${nextStep}`;
         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 [];
@@ -35779,7 +35848,8 @@ Next step: ${nextStep}`;
       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;
@@ -35799,6 +35869,7 @@ Next step: ${nextStep}`;
     var import_path8;
     var import_crypto7;
     var REFINE_TERMINAL_EVENTS;
+    var DIRECT_DELIVERED_TTL_MS;
     var MAX_PENDING_EVENTS_BYTES;
     var MAX_PENDING_EVENTS_KEEP;
     var init_mesh_events_pending = __esm2({
@@ -35812,6 +35883,7 @@ Next step: ${nextStep}`;
         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;
       }
@@ -36347,6 +36419,140 @@ Next step: ${nextStep}`;
         import_fs9 = require("fs");
       }
     });
+    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."
+          }
+        });
+        LOG2.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) {
+        LOG2.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;
+    var UNROUTABLE_DIAGNOSTIC_DEDUP_MS;
+    var recentUnroutableDiagnostics;
+    var init_mesh_routing = __esm2({
+      "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();
+      }
+    });
     function getCachedMeshByWorkspace(workspace) {
       const now = Date.now();
       const cached2 = meshByWorkspaceCache.get(workspace);
@@ -36358,6 +36564,9 @@ Next step: ${nextStep}`;
     function __resetIdleAutoFastForwardForTests() {
       idleAutoFastForwardLastAttempt.clear();
     }
+    function __resetMeshWorkspaceCacheForTests() {
+      meshByWorkspaceCache.clear();
+    }
     function sweepExpiredRemoteIdleSessions() {
       try {
         MeshRuntimeStore.getInstance().pruneExpiredRemoteIdleSessions();
@@ -37024,6 +37233,17 @@ Next step: ${nextStep}`;
         sourceSession?.getState()?.settings?.meshCoordinatorDaemonId
       );
       const localDaemonId = readNonEmptyString2(loadConfig2().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,
@@ -37368,10 +37588,38 @@ Next step: ${nextStep}`;
         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(() => {
+            LOG2.info("MeshEvents", `Forwarded ${args.event} for mesh ${args.meshId} to remote coordinator daemon ${remoteCoordinatorDaemonId.slice(0, 12)}\u2026`);
+          }).catch((error48) => {
+            LOG2.warn("MeshEvents", `Remote forward of ${args.event} failed (${error48?.message || error48}); 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,
@@ -37390,7 +37638,7 @@ Next step: ${nextStep}`;
         }
         return { success: true, forwarded: 0 };
       }
-      if (queuePendingMeshCoordinatorEvent({
+      const pendingEvent = {
         event: args.event,
         meshId: args.meshId,
         nodeLabel: args.nodeLabel,
@@ -37403,9 +37651,13 @@ Next step: ${nextStep}`;
         coordinatorMessage: messageText,
         queuedAt: Date.now(),
         ...workerCoordinatorDaemonId ? { targetCoordinatorDaemonId: workerCoordinatorDaemonId } : {}
-      })) {
+      };
+      if (queuePendingMeshCoordinatorEvent(pendingEvent)) {
         LOG2.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();
@@ -37473,15 +37725,15 @@ Next step: ${nextStep}`;
             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(loadConfig2().machineId) || void 0;
-                    const pendingEvents = drainPendingMeshCoordinatorEvents(coordinatorMeshId2, localDaemonId);
+                    const pendingEvents = drainPendingMeshCoordinatorEvents(coordinatorMeshId, localDaemonId);
                     if (pendingEvents.length > 0) {
-                      LOG2.info("MeshEvents", `Auto-flushing ${pendingEvents.length} pending coordinator event(s) for mesh ${coordinatorMeshId2} on coordinator idle`);
+                      LOG2.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);
@@ -37497,7 +37749,7 @@ Next step: ${nextStep}`;
                 }
                 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;
@@ -37508,37 +37760,19 @@ Next step: ${nextStep}`;
         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
         });
@@ -37572,6 +37806,7 @@ Next step: ${nextStep}`;
         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;
@@ -37617,11 +37852,13 @@ Next step: ${nextStep}`;
     var mesh_events_exports = {};
     __export2(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,
@@ -67916,6 +68153,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     init_logger();
     init_mesh_coordinator();
     init_mesh_events();
+    init_mesh_routing();
     init_mesh_host_ownership();
     init_mesh_fast_forward();
     var import_node_child_process4 = require("child_process");
@@ -74672,6 +74910,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;
@@ -74727,6 +74966,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,
@@ -74736,9 +74976,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",
@@ -83000,7 +83244,8 @@ data: ${JSON.stringify(msg.data)}
         sessionRegistry,
         detectedIdes: detectedIdesRef,
         refreshProviderAvailability,
-        dispatchMeshCommand: config2.dispatchMeshCommand
+        dispatchMeshCommand: config2.dispatchMeshCommand,
+        onMeshCoordinatorEventForwarded: config2.onMeshCoordinatorEventForwarded
       };
       setupMeshEventForwarding(components);
       setImmediate(() => void router.resumePendingRefineJobsOnStartup());