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

package/dist/index.js

@@ -29983,10 +29983,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "e4a64afbd050fa5167c383b1fc6f9df5f8e48ba2" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "e4a64afb" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.273" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-06-15T05:37:35.385Z" : void 0);
+      const commit = readInjected(true ? "080b607ef221e44126942d9d52eaf547b4e92550" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "080b607e" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.275" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-15T08:25:07.224Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -34007,12 +34007,33 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
             this.maybeCheckpointWal();
             return result.changes > 0;
           }
-          drainPendingEvents(meshId, coordinatorDaemonId) {
+          /**
+           * 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, coordinatorDaemonId, opts) {
             return this.transaction(() => {
-              const whereClause = coordinatorDaemonId ? `WHERE mesh_id = ? AND drained = 0 AND (coordinator_daemon_id IS NULL OR coordinator_daemon_id = ?)` : `WHERE mesh_id = ? AND drained = 0`;
-              const params = coordinatorDaemonId ? [meshId, coordinatorDaemonId] : [meshId];
+              const onlyEvents = opts?.onlyEvents;
+              if (onlyEvents && onlyEvents.size === 0) return [];
+              const eventList = onlyEvents ? [...onlyEvents] : [];
+              const clauses = ["mesh_id = ?", "drained = 0"];
+              const params = [meshId];
+              if (coordinatorDaemonId) {
+                clauses.push("(coordinator_daemon_id IS NULL OR coordinator_daemon_id = ?)");
+                params.push(coordinatorDaemonId);
+              }
+              if (eventList.length > 0) {
+                clauses.push(`event IN (${eventList.map(() => "?").join(",")})`);
+                params.push(...eventList);
+              }
               const rows = this.db.prepare(
-                `SELECT id, event, payload FROM mesh_pending_events ${whereClause} ORDER BY queued_at ASC LIMIT 100`
+                `SELECT id, event, payload FROM mesh_pending_events WHERE ${clauses.join(" AND ")} ORDER BY queued_at ASC LIMIT 100`
               ).all(...params);
               if (rows.length === 0) return [];
               const ids = rows.map((r) => r.id);
@@ -35927,16 +35948,6 @@ ${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 buildMeshWorkerRelayStamp(currentSettings, meshContext) {
       if (!meshContext) return void 0;
       const settings = currentSettings && typeof currentSettings === "object" ? currentSettings : {};
@@ -36135,29 +36146,6 @@ 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;
@@ -36319,8 +36307,57 @@ Next step: ${nextStep}`;
         return null;
       }
     }
-    function drainPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
+    function selectiveDrainFile(path39, predicate) {
+      const tmpPath = `${path39}.draining`;
+      try {
+        (0, import_fs8.renameSync)(path39, tmpPath);
+      } catch {
+        return [];
+      }
+      let content;
+      try {
+        content = (0, import_fs8.readFileSync)(tmpPath, "utf-8");
+      } catch {
+        try {
+          (0, import_fs8.unlinkSync)(tmpPath);
+        } catch {
+        }
+        return [];
+      }
+      const consumed = [];
+      const keptLines = [];
+      for (const line of content.split("\n")) {
+        if (!line) continue;
+        let parsed;
+        try {
+          parsed = JSON.parse(line);
+        } catch {
+          parsed = void 0;
+        }
+        if (parsed && predicate(parsed)) {
+          consumed.push(parsed);
+        } else {
+          keptLines.push(line);
+        }
+      }
+      try {
+        if (keptLines.length > 0) {
+          (0, import_fs8.writeFileSync)(path39, keptLines.join("\n") + "\n", "utf-8");
+        }
+        (0, import_fs8.unlinkSync)(tmpPath);
+      } catch {
+        try {
+          if ((0, import_fs8.existsSync)(tmpPath) && !(0, import_fs8.existsSync)(path39)) (0, import_fs8.renameSync)(tmpPath, path39);
+        } catch {
+        }
+        return [];
+      }
+      return consumed;
+    }
+    function drainPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId, opts) {
       if (!meshId) return [];
+      const onlyEvents = opts?.onlyEvents;
+      const matchesFilter = (eventName) => !onlyEvents || onlyEvents.has(eventName);
       const merged = [];
       const seenFingerprints = /* @__PURE__ */ new Set();
       const pushUnique = (event) => {
@@ -36334,7 +36371,7 @@ Next step: ${nextStep}`;
       try {
         const store = MeshRuntimeStore.getInstance();
         if (store.pendingEventCount(meshId) > 0) {
-          for (const row of store.drainPendingEvents(meshId, coordinatorDaemonId)) {
+          for (const row of store.drainPendingEvents(meshId, coordinatorDaemonId, onlyEvents ? { onlyEvents } : void 0)) {
             const event = row.payload;
             if (event) pushUnique(event);
           }
@@ -36343,6 +36380,14 @@ Next step: ${nextStep}`;
       }
       const paths = coordinatorDaemonId ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
       for (const path39 of paths) {
+        const isSharedFile = coordinatorDaemonId && path39 === getPendingEventsPath(meshId);
+        const targets = (e) => !isSharedFile || !e.targetCoordinatorDaemonId || e.targetCoordinatorDaemonId === coordinatorDaemonId;
+        if (onlyEvents) {
+          for (const event of selectiveDrainFile(path39, (e) => targets(e) && matchesFilter(e.event))) {
+            pushUnique(event);
+          }
+          continue;
+        }
         const content = atomicDrainFile(path39);
         if (!content) continue;
         const parsed = content.split("\n").filter(Boolean).flatMap((line) => {
@@ -36352,13 +36397,11 @@ Next step: ${nextStep}`;
             return [];
           }
         });
-        const filtered = coordinatorDaemonId && path39 === getPendingEventsPath(meshId) ? parsed.filter((e) => !e.targetCoordinatorDaemonId || e.targetCoordinatorDaemonId === coordinatorDaemonId) : parsed;
+        const filtered = isSharedFile ? parsed.filter(targets) : parsed;
         for (const event of filtered) pushUnique(event);
       }
       if (merged.length === 0) return [];
-      const deliverable = coordinatorDaemonId ? merged.filter((event) => !wasDirectDeliveredToCoordinator(coordinatorDaemonId, event)) : merged;
-      if (deliverable.length === 0) return [];
-      return reconcilePendingMeshCoordinatorEvents(meshId, deliverable);
+      return reconcilePendingMeshCoordinatorEvents(meshId, merged);
     }
     function getPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
       if (!meshId) return [];
@@ -36385,8 +36428,7 @@ Next step: ${nextStep}`;
       for (const event of readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId)) {
         pushUnique(event);
       }
-      const deliverable = coordinatorDaemonId ? merged.filter((event) => !wasDirectDeliveredToCoordinator(coordinatorDaemonId, event)) : merged;
-      return reconcilePendingMeshCoordinatorEvents(meshId, deliverable);
+      return reconcilePendingMeshCoordinatorEvents(meshId, merged);
     }
     function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
       if (!meshId) return;
@@ -36406,7 +36448,6 @@ 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({
@@ -36420,7 +36461,6 @@ 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;
       }
@@ -37780,7 +37820,6 @@ Next step: ${nextStep}`;
       const workerCoordinatorDaemonId = readNonEmptyString2(
         sourceSession?.getState()?.settings?.meshCoordinatorDaemonId
       );
-      const localDaemonId = readNonEmptyString2(loadConfig2().machineId);
       if (components.onMeshCoordinatorEventForwarded) {
         try {
           components.onMeshCoordinatorEventForwarded({
@@ -38135,60 +38174,6 @@ Next step: ${nextStep}`;
         recoveryContext
       });
       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;
-        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,
-          nodeLabel: args.nodeLabel,
-          nodeId: args.nodeId || void 0,
-          workspace: readNonEmptyString2(args.metadataEvent.workspace),
-          metadataEvent: {
-            ...args.metadataEvent,
-            ...recoveryContext ? { recoveryContext } : {}
-          },
-          coordinatorMessage: messageText,
-          queuedAt: Date.now(),
-          ...workerCoordinatorDaemonId ? { targetCoordinatorDaemonId: workerCoordinatorDaemonId } : {}
-        })) {
-          LOG2.info("MeshEvents", `Queued ${args.event} for MCP coordinator (mesh ${args.meshId}${workerCoordinatorDaemonId ? `, coordinator daemon ${workerCoordinatorDaemonId}` : ""})`);
-        }
-        return { success: true, forwarded: 0 };
-      }
       const pendingEvent = {
         event: args.event,
         meshId: args.meshId,
@@ -38204,21 +38189,9 @@ Next step: ${nextStep}`;
         ...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();
-        LOG2.info("MeshEvents", `Forwarding mesh event to coordinator ${coordState.instanceId}${forceInject ? " (force)" : ""}`);
-        coord.onEvent("send_message", {
-          input: { text: messageText, textFallback: messageText },
-          ...forceInject ? { force: true } : {}
-        });
+        LOG2.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 };
     }
     function handleMeshForwardEvent(components, payload) {
       const eventName = readNonEmptyString2(payload.event);
@@ -38401,6 +38374,174 @@ Next step: ${nextStep}`;
         ]);
       }
     });
+    function resolveReconcileIntervalMs() {
+      const raw = readNonEmptyString2(process.env.MESH_RECONCILE_INTERVAL_MS);
+      if (raw) {
+        const parsed = Number.parseInt(raw, 10);
+        if (Number.isFinite(parsed) && parsed >= 1e3 && parsed <= 6e4) return parsed;
+      }
+      return DEFAULT_RECONCILE_INTERVAL_MS;
+    }
+    function findLiveCoordinators(components) {
+      const out = [];
+      for (const inst of components.instanceManager.getByCategory("cli")) {
+        const state = inst.getState();
+        const settings = state.settings && typeof state.settings === "object" ? state.settings : {};
+        const meshId = readNonEmptyString2(settings.meshCoordinatorFor);
+        if (!meshId) continue;
+        const status = readNonEmptyString2(state.status).toLowerCase();
+        out.push({ meshId, instance: inst, idle: status === "idle" });
+      }
+      return out;
+    }
+    function injectPendingIntoCoordinator(coordinator, pending) {
+      if (!coordinator || !pending.coordinatorMessage) return;
+      const force = shouldForceInjectMeshEvent(pending.event);
+      coordinator.onEvent("send_message", {
+        input: { text: pending.coordinatorMessage, textFallback: pending.coordinatorMessage },
+        ...force ? { force: true } : {}
+      });
+    }
+    async function runMeshReconcileTick(components) {
+      const coordinators = findLiveCoordinators(components);
+      if (coordinators.length === 0) {
+        return;
+      }
+      const byMesh = /* @__PURE__ */ new Map();
+      for (const c of coordinators) {
+        const list = byMesh.get(c.meshId);
+        if (list) list.push(c);
+        else byMesh.set(c.meshId, [c]);
+      }
+      const localDaemonId = readNonEmptyString2(loadConfig2().machineId) || void 0;
+      const dispatchMeshCommand = components.dispatchMeshCommand;
+      const store = (() => {
+        try {
+          return MeshRuntimeStore.getInstance();
+        } catch {
+          return void 0;
+        }
+      })();
+      for (const [meshId, meshCoordinators] of byMesh) {
+        if (dispatchMeshCommand) {
+          try {
+            await pullRemoteNodeQueues(components, meshId, localDaemonId);
+          } catch (e) {
+            LOG2.warn("MeshReconcile", `Remote node pull failed for mesh ${meshId}: ${e?.message || e}`);
+          }
+        }
+        const idleCoordinators = meshCoordinators.filter((c) => c.idle);
+        const generatingCoordinators = meshCoordinators.filter((c) => !c.idle);
+        const targetCoordinators = idleCoordinators.length > 0 ? idleCoordinators : generatingCoordinators;
+        const forceOnly = idleCoordinators.length === 0;
+        if (store) {
+          try {
+            if (store.pendingEventCount(meshId) === 0) continue;
+          } catch {
+          }
+        }
+        let pendingEvents = [];
+        try {
+          pendingEvents = drainPendingMeshCoordinatorEvents(
+            meshId,
+            localDaemonId,
+            forceOnly ? { onlyEvents: MESH_FORCE_INJECT_EVENTS } : void 0
+          );
+        } catch (e) {
+          LOG2.warn("MeshReconcile", `Drain failed for mesh ${meshId}: ${e?.message || e}`);
+          continue;
+        }
+        if (pendingEvents.length === 0) continue;
+        const mode = forceOnly ? "force-drain \u2192 generating" : "inject \u2192 idle";
+        LOG2.info("MeshReconcile", `Reconcile ${mode}: ${pendingEvents.length} pending event(s) \u2192 ${targetCoordinators.length} coordinator(s) for mesh ${meshId}`);
+        for (const pending of pendingEvents) {
+          for (const c of targetCoordinators) {
+            injectPendingIntoCoordinator(c.instance, pending);
+          }
+        }
+      }
+    }
+    async function pullRemoteNodeQueues(components, meshId, localDaemonId) {
+      const dispatchMeshCommand = components.dispatchMeshCommand;
+      if (!dispatchMeshCommand) return;
+      const mesh = listMeshes().find((m) => m.id === meshId);
+      if (!mesh) return;
+      const pendingEventArgs = {
+        meshId,
+        ...localDaemonId ? { coordinatorDaemonId: localDaemonId } : {}
+      };
+      for (const node of mesh.nodes) {
+        const nodeDaemonId = readNonEmptyString2(node.daemonId);
+        if (!nodeDaemonId) continue;
+        if (localDaemonId && nodeDaemonId === localDaemonId) continue;
+        let events;
+        try {
+          events = await dispatchMeshCommand(nodeDaemonId, "get_pending_mesh_events", pendingEventArgs);
+        } catch {
+          continue;
+        }
+        const list = extractPendingEvents(events).filter((e) => readNonEmptyString2(e?.meshId) === meshId);
+        for (const event of list) {
+          const payload = buildForwardPayloadFromPending(event);
+          if (!payload.event || !payload.meshId) continue;
+          try {
+            handleMeshForwardEvent(components, payload);
+          } catch {
+          }
+        }
+      }
+    }
+    function extractPendingEvents(raw) {
+      if (Array.isArray(raw)) return raw;
+      if (raw && typeof raw === "object") {
+        const events = raw.events;
+        if (Array.isArray(events)) return events;
+      }
+      return [];
+    }
+    function buildForwardPayloadFromPending(event) {
+      const metadata = event?.metadataEvent && typeof event.metadataEvent === "object" ? event.metadataEvent : {};
+      return {
+        event: readNonEmptyString2(event?.event),
+        meshId: readNonEmptyString2(event?.meshId),
+        nodeId: readNonEmptyString2(event?.nodeId) || readNonEmptyString2(metadata.meshNodeId),
+        workspace: readNonEmptyString2(event?.workspace) || readNonEmptyString2(metadata.workspace),
+        ...metadata
+      };
+    }
+    function setupMeshReconcileLoop(components) {
+      const intervalMs = resolveReconcileIntervalMs();
+      let running = false;
+      const timer = setInterval(() => {
+        if (running) return;
+        running = true;
+        void runMeshReconcileTick(components).catch((e) => LOG2.warn("MeshReconcile", `Reconcile tick error: ${e?.message || e}`)).finally(() => {
+          running = false;
+        });
+      }, intervalMs);
+      if (typeof timer.unref === "function") timer.unref();
+      LOG2.info("MeshReconcile", `Mesh reconcile loop started (interval ${intervalMs}ms)`);
+      return {
+        stop() {
+          clearInterval(timer);
+          LOG2.info("MeshReconcile", "Mesh reconcile loop stopped");
+        }
+      };
+    }
+    var DEFAULT_RECONCILE_INTERVAL_MS;
+    var init_mesh_reconcile_loop = __esm2({
+      "src/mesh/mesh-reconcile-loop.ts"() {
+        "use strict";
+        init_config();
+        init_mesh_config();
+        init_logger();
+        init_mesh_events_pending();
+        init_mesh_runtime_store();
+        init_mesh_events_coordinator();
+        init_mesh_events_utils();
+        DEFAULT_RECONCILE_INTERVAL_MS = 4e3;
+      }
+    });
     var mesh_events_exports = {};
     __export2(mesh_events_exports, {
       __resetIdleAutoFastForwardForTests: () => __resetIdleAutoFastForwardForTests,
@@ -38410,10 +38551,11 @@ Next step: ${nextStep}`;
       getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
       handleMeshForwardEvent: () => handleMeshForwardEvent,
       isMeshCoordinatorEvent: () => isMeshCoordinatorEvent,
-      markMeshCoordinatorEventDirectDelivered: () => markMeshCoordinatorEventDirectDelivered,
       queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
       reconcileDirectDispatchCompletionFromTranscript: () => reconcileDirectDispatchCompletionFromTranscript,
+      runMeshReconcileTick: () => runMeshReconcileTick,
       setupMeshEventForwarding: () => setupMeshEventForwarding,
+      setupMeshReconcileLoop: () => setupMeshReconcileLoop,
       triggerMeshQueue: () => triggerMeshQueue,
       tryAssignQueueTask: () => tryAssignQueueTask
     });
@@ -38422,6 +38564,7 @@ Next step: ${nextStep}`;
         "use strict";
         init_mesh_events_pending();
         init_mesh_events_stale();
+        init_mesh_reconcile_loop();
         init_mesh_events_coordinator();
       }
     });
@@ -84922,6 +85065,7 @@ data: ${JSON.stringify(msg.data)}
     init_logger();
     init_config();
     init_mesh_events();
+    init_mesh_reconcile_loop();
     var _hardened = false;
     var HARDENED_PROTOS = [
       { name: "Object", proto: Object.prototype },
@@ -85119,6 +85263,7 @@ data: ${JSON.stringify(msg.data)}
         onMeshCoordinatorEventForwarded: config2.onMeshCoordinatorEventForwarded
       };
       setupMeshEventForwarding(components);
+      components.meshReconcileLoop = setupMeshReconcileLoop(components);
       setImmediate(() => void router.resumePendingRefineJobsOnStartup());
       return components;
     }
@@ -85144,10 +85289,15 @@ data: ${JSON.stringify(msg.data)}
         agentStreamManager,
         cliManager,
         instanceManager,
-        cdpManagers
+        cdpManagers,
+        meshReconcileLoop
       } = components;
       poller.stop();
       cdpInitializer.stop();
+      try {
+        meshReconcileLoop?.stop();
+      } catch {
+      }
       try {
         if (agentStreamManager) {
           await agentStreamManager.dispose(cdpManagers);