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

package/dist/index.js

@@ -275,10 +275,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "89d1ac61612c1dfe7fac53be61ec5dbfa67d00b2" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "89d1ac61" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.274" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-15T07:04:52.710Z" : 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);
@@ -6529,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) => {
@@ -6544,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);
       }
@@ -6553,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) => {
@@ -6562,7 +6640,7 @@ 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 [];
@@ -8582,7 +8660,9 @@ async function runMeshReconcileTick(components) {
       }
     }
     const idleCoordinators = meshCoordinators.filter((c) => c.idle);
-    if (idleCoordinators.length === 0) continue;
+    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;
@@ -8591,15 +8671,20 @@ async function runMeshReconcileTick(components) {
     }
     let pendingEvents = [];
     try {
-      pendingEvents = drainPendingMeshCoordinatorEvents(meshId, localDaemonId);
+      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;
-    LOG.info("MeshReconcile", `Reconcile inject: ${pendingEvents.length} pending event(s) \u2192 ${idleCoordinators.length} idle coordinator(s) for mesh ${meshId}`);
+    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 idleCoordinators) {
+      for (const c of targetCoordinators) {
         injectPendingIntoCoordinator(c.instance, pending);
       }
     }