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

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

@@ -82,6 +82,9 @@ 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;
+    meshReconcileLoop?: {
+        stop(): void;
+    };
 }
 export interface DaemonDevSupportOptions {
     components: DaemonComponents;

package/dist/index.js

@@ -275,10 +275,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "e4a64afbd050fa5167c383b1fc6f9df5f8e48ba2" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "e4a64afb" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = 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:07.054Z" : 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 version = 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:24:26.468Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -4264,12 +4264,33 @@ var init_mesh_runtime_store = __esm({
         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);
@@ -6168,16 +6189,6 @@ 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 buildMeshWorkerRelayStamp(currentSettings, meshContext) {
   if (!meshContext) return void 0;
   const settings = currentSettings && typeof currentSettings === "object" ? currentSettings : {};
@@ -6378,29 +6389,6 @@ 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;
@@ -6562,8 +6550,57 @@ function atomicDrainFile(path39) {
     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) => {
@@ -6577,7 +6614,7 @@ function drainPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   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);
       }
@@ -6586,6 +6623,14 @@ function drainPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   }
   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) => {
@@ -6595,13 +6640,11 @@ function drainPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
         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 [];
@@ -6628,8 +6671,7 @@ function getPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   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;
@@ -6645,7 +6687,7 @@ function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
     }
   }
 }
-var import_fs8, import_path8, import_crypto7, REFINE_TERMINAL_EVENTS, DIRECT_DELIVERED_TTL_MS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP;
+var import_fs8, import_path8, import_crypto7, REFINE_TERMINAL_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP;
 var init_mesh_events_pending = __esm({
   "src/mesh/mesh-events-pending.ts"() {
     "use strict";
@@ -6657,7 +6699,6 @@ 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;
   }
@@ -8019,7 +8060,6 @@ function injectMeshSystemMessage(components, args) {
   const workerCoordinatorDaemonId = readNonEmptyString2(
     sourceSession?.getState()?.settings?.meshCoordinatorDaemonId
   );
-  const localDaemonId = readNonEmptyString2(loadConfig().machineId);
   if (components.onMeshCoordinatorEventForwarded) {
     try {
       components.onMeshCoordinatorEventForwarded({
@@ -8374,60 +8414,6 @@ function injectMeshSystemMessage(components, args) {
     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(() => {
-        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,
-      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 } : {}
-    })) {
-      LOG.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,
@@ -8443,21 +8429,9 @@ function injectMeshSystemMessage(components, args) {
     ...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();
-    LOG.info("MeshEvents", `Forwarding mesh event to coordinator ${coordState.instanceId}${forceInject ? " (force)" : ""}`);
-    coord.onEvent("send_message", {
-      input: { text: messageText, textFallback: messageText },
-      ...forceInject ? { force: true } : {}
-    });
+    LOG.info("MeshEvents", `Queued ${args.event} for coordinator (mesh ${args.meshId}${workerCoordinatorDaemonId ? `, coordinator daemon ${workerCoordinatorDaemonId}` : ""})`);
   }
-  return { success: true, forwarded: coordinatorInstances.length };
+  return { success: true, forwarded: 0 };
 }
 function handleMeshForwardEvent(components, payload) {
   const eventName = readNonEmptyString2(payload.event);
@@ -8628,6 +8602,176 @@ var init_mesh_events_coordinator = __esm({
   }
 });
 
+// src/mesh/mesh-reconcile-loop.ts
+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(loadConfig().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) {
+        LOG.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) {
+      LOG.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";
+    LOG.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) => LOG.warn("MeshReconcile", `Reconcile tick error: ${e?.message || e}`)).finally(() => {
+      running = false;
+    });
+  }, intervalMs);
+  if (typeof timer.unref === "function") timer.unref();
+  LOG.info("MeshReconcile", `Mesh reconcile loop started (interval ${intervalMs}ms)`);
+  return {
+    stop() {
+      clearInterval(timer);
+      LOG.info("MeshReconcile", "Mesh reconcile loop stopped");
+    }
+  };
+}
+var DEFAULT_RECONCILE_INTERVAL_MS;
+var init_mesh_reconcile_loop = __esm({
+  "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;
+  }
+});
+
 // src/mesh/mesh-events.ts
 var mesh_events_exports = {};
 __export(mesh_events_exports, {
@@ -8638,10 +8782,11 @@ __export(mesh_events_exports, {
   getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
   handleMeshForwardEvent: () => handleMeshForwardEvent,
   isMeshCoordinatorEvent: () => isMeshCoordinatorEvent,
-  markMeshCoordinatorEventDirectDelivered: () => markMeshCoordinatorEventDirectDelivered,
   queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
   reconcileDirectDispatchCompletionFromTranscript: () => reconcileDirectDispatchCompletionFromTranscript,
+  runMeshReconcileTick: () => runMeshReconcileTick,
   setupMeshEventForwarding: () => setupMeshEventForwarding,
+  setupMeshReconcileLoop: () => setupMeshReconcileLoop,
   triggerMeshQueue: () => triggerMeshQueue,
   tryAssignQueueTask: () => tryAssignQueueTask
 });
@@ -8650,6 +8795,7 @@ var init_mesh_events = __esm({
     "use strict";
     init_mesh_events_pending();
     init_mesh_events_stale();
+    init_mesh_reconcile_loop();
     init_mesh_events_coordinator();
   }
 });
@@ -55437,6 +55583,7 @@ var SessionRegistry = class {
 init_logger();
 init_config();
 init_mesh_events();
+init_mesh_reconcile_loop();
 
 // src/boot/process-hardening.ts
 var _hardened = false;
@@ -55638,6 +55785,7 @@ async function initDaemonComponents(config) {
     onMeshCoordinatorEventForwarded: config.onMeshCoordinatorEventForwarded
   };
   setupMeshEventForwarding(components);
+  components.meshReconcileLoop = setupMeshReconcileLoop(components);
   setImmediate(() => void router.resumePendingRefineJobsOnStartup());
   return components;
 }
@@ -55663,10 +55811,15 @@ async function shutdownDaemonComponents(components) {
     agentStreamManager,
     cliManager,
     instanceManager,
-    cdpManagers
+    cdpManagers,
+    meshReconcileLoop
   } = components;
   poller.stop();
   cdpInitializer.stop();
+  try {
+    meshReconcileLoop?.stop();
+  } catch {
+  }
   try {
     if (agentStreamManager) {
       await agentStreamManager.dispose(cdpManagers);