@adhdev/daemon-standalone 1.0.58-rc.46 → 1.0.58-rc.47

package/dist/index.js

@@ -36911,10 +36911,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "a03baab8130d59d9dfaca9173cddefd7f052d6a4" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "a03baab8" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.58-rc.46" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-30T06:41:16.415Z" : void 0);
+      const commit = readInjected(true ? "f13d08263df6a24da9d6766eebfbfc7cac237235" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "f13d0826" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.58-rc.47" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-30T09:04:38.562Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -74031,6 +74031,96 @@ ${rendered}`, "utf-8");
           return { status: "failed", attemptId: presentation.attemptId, stage };
       }
     }
+    function pushTerminalBucket(buckets, key2, terminal) {
+      if (!key2) return;
+      let bucket2 = buckets.get(key2);
+      if (!bucket2) {
+        bucket2 = { real: [], approval: [] };
+        buckets.set(key2, bucket2);
+      }
+      (terminal.entry.kind === "task_approval_needed" ? bucket2.approval : bucket2.real).push(terminal);
+    }
+    function pushTerminalQuery(queries, key2, query) {
+      if (!key2) return;
+      const existing = queries.get(key2);
+      if (existing) existing.push(query);
+      else queries.set(key2, [query]);
+    }
+    function earlierTerminal(a, b) {
+      if (!a) return b;
+      if (!b) return a;
+      return a.order <= b.order ? a : b;
+    }
+    function buildMeshActiveWorkLedgerSnapshot(ledgerEntries, options = {}) {
+      const timestampByEntry = /* @__PURE__ */ new Map();
+      for (const entry of ledgerEntries) timestampByEntry.set(entry, new Date(entry.timestamp).getTime());
+      const entries = ledgerEntries.slice().sort((a, b) => timestampByEntry.get(a) - timestampByEntry.get(b));
+      const taskBuckets = /* @__PURE__ */ new Map();
+      const sessionBuckets = /* @__PURE__ */ new Map();
+      const nodeBuckets = /* @__PURE__ */ new Map();
+      let order = 0;
+      for (const entry of entries) {
+        if (!TERMINAL_LEDGER_KINDS.has(entry.kind) && entry.kind !== "task_approval_needed") continue;
+        const timestampMs = timestampByEntry.get(entry);
+        if (!Number.isFinite(timestampMs)) continue;
+        const indexed = { entry, timestampMs, order: order++ };
+        const taskId = readString7(entry.payload?.taskId);
+        if (taskId) {
+          pushTerminalBucket(taskBuckets, taskId, indexed);
+        } else {
+          pushTerminalBucket(sessionBuckets, readString7(entry.sessionId), indexed);
+          pushTerminalBucket(nodeBuckets, machineCoreFromDaemonId(entry.nodeId), indexed);
+        }
+      }
+      return {
+        entries,
+        matchDirectDispatchTerminals(dispatches) {
+          const sortedDispatches = dispatches.slice().sort((a, b) => timestampByEntry.get(a) - timestampByEntry.get(b));
+          const taskQueries = /* @__PURE__ */ new Map();
+          const sessionQueries = /* @__PURE__ */ new Map();
+          const nodeQueries = /* @__PURE__ */ new Map();
+          for (const dispatch of sortedDispatches) {
+            const timestampMs = timestampByEntry.get(dispatch) ?? new Date(dispatch.timestamp).getTime();
+            if (!Number.isFinite(timestampMs)) continue;
+            const query = { dispatch, timestampMs };
+            pushTerminalQuery(taskQueries, directDispatchTaskId(dispatch), query);
+            const sessionId = readString7(dispatch.sessionId);
+            if (dispatch.sessionId) pushTerminalQuery(sessionQueries, sessionId, query);
+            else pushTerminalQuery(nodeQueries, machineCoreFromDaemonId(dispatch.nodeId), query);
+          }
+          const realByDispatch = /* @__PURE__ */ new Map();
+          const approvalByDispatch = /* @__PURE__ */ new Map();
+          const resolve32 = (queries, buckets, bucketKind, output) => {
+            for (const [key2, bucketQueries] of queries) {
+              const terminals = buckets.get(key2)?.[bucketKind];
+              if (!terminals?.length) continue;
+              let cursor = 0;
+              for (const query of bucketQueries) {
+                while (cursor < terminals.length) {
+                  options.onTerminalProbe?.();
+                  if (terminals[cursor].timestampMs >= query.timestampMs) break;
+                  cursor += 1;
+                }
+                const candidate = terminals[cursor];
+                if (candidate) output.set(query.dispatch, earlierTerminal(output.get(query.dispatch), candidate));
+              }
+            }
+          };
+          resolve32(taskQueries, taskBuckets, "real", realByDispatch);
+          resolve32(sessionQueries, sessionBuckets, "real", realByDispatch);
+          resolve32(nodeQueries, nodeBuckets, "real", realByDispatch);
+          resolve32(taskQueries, taskBuckets, "approval", approvalByDispatch);
+          resolve32(sessionQueries, sessionBuckets, "approval", approvalByDispatch);
+          resolve32(nodeQueries, nodeBuckets, "approval", approvalByDispatch);
+          const result = /* @__PURE__ */ new Map();
+          for (const dispatch of sortedDispatches) {
+            const selected = realByDispatch.get(dispatch) || approvalByDispatch.get(dispatch);
+            if (selected) result.set(dispatch, selected.entry);
+          }
+          return result;
+        }
+      };
+    }
     function readString7(value) {
       return typeof value === "string" && value.trim() ? value.trim() : void 0;
     }
@@ -74102,13 +74192,6 @@ ${rendered}`, "utf-8");
     function directDispatchTaskId(entry) {
       return readString7(entry.payload?.taskId) || entry.id;
     }
-    function terminalMatchesDispatch(terminal, dispatch, taskId) {
-      const terminalTaskId = readString7(terminal.payload?.taskId);
-      if (terminalTaskId && terminalTaskId === taskId) return true;
-      if (terminalTaskId && terminalTaskId !== taskId) return false;
-      if (dispatch.sessionId && sessionIdsEquivalent(terminal.sessionId, dispatch.sessionId)) return true;
-      return Boolean(dispatch.nodeId && daemonIdsEquivalent(terminal.nodeId, dispatch.nodeId) && !dispatch.sessionId);
-    }
     function statusFromTerminal(entry) {
       if (entry.kind === "task_approval_needed") return "awaiting_approval";
       if (entry.kind === "task_question_pending") return "awaiting_choice";
@@ -74125,8 +74208,7 @@ ${rendered}`, "utf-8");
     }
     function buildLedgerDirectDispatchRecord(dispatch, ctx) {
       const taskId = directDispatchTaskId(dispatch);
-      const matching = ctx.terminals.filter((entry) => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime()).filter((entry) => terminalMatchesDispatch(entry, dispatch, taskId));
-      const terminal = matching.find((entry) => entry.kind !== "task_approval_needed") || matching[0];
+      const terminal = ctx.terminal;
       const terminalStatus = terminal ? statusFromTerminal(terminal) : void 0;
       const live = sessionStatusFromNodes(ctx.nodes, dispatch.nodeId, dispatch.sessionId);
       const status = terminalStatus || live.status || "assigned";
@@ -74227,6 +74309,8 @@ ${rendered}`, "utf-8");
     }
     function buildMeshActiveWork(opts) {
       const now = opts.now ?? Date.now();
+      const ledgerSnapshot = opts.ledgerSnapshot ?? buildMeshActiveWorkLedgerSnapshot(opts.ledgerEntries || []);
+      const ledgerEntries = ledgerSnapshot.entries;
       const records = [];
       const staleDirectWork = [];
       const terminalDirectWork = [];
@@ -74237,7 +74321,7 @@ ${rendered}`, "utf-8");
         const queueNodeId = task.assignedNodeId || task.targetNodeId;
         const queueSessionId = task.assignedSessionId || task.targetSessionId;
         const queueLive = task.status === "assigned" ? sessionStatusFromNodes(opts.nodes, queueNodeId ?? void 0, queueSessionId ?? void 0) : {};
-        const queueTerminalAuthority = task.status === "assigned" && hasTerminalLedgerAuthorityForTask(opts.ledgerEntries, task.id);
+        const queueTerminalAuthority = task.status === "assigned" && hasTerminalLedgerAuthorityForTask(ledgerEntries, task.id);
         let queueStatus = !queueTerminalAuthority && (queueLive.status === "awaiting_approval" || queueLive.status === "awaiting_choice" || queueLive.status === "generating") ? queueLive.status : task.status;
         const turnOverlay = task.status === "assigned" ? turnProjectionActiveWorkStatus(opts.meshId, task.id) : null;
         if (turnOverlay) queueStatus = turnOverlay.status;
@@ -74267,7 +74351,7 @@ ${rendered}`, "utf-8");
           const dbStatus = dispatch.status;
           const isTerminal = dbStatus === "completed" || dbStatus === "failed" || dbStatus === "stale";
           const turnOverlay = isTerminal ? null : turnProjectionActiveWorkStatus(opts.meshId, dispatch.taskId);
-          const directTerminalAuthority = !isTerminal && hasTerminalLedgerAuthorityForTask(opts.ledgerEntries, dispatch.taskId);
+          const directTerminalAuthority = !isTerminal && hasTerminalLedgerAuthorityForTask(ledgerEntries, dispatch.taskId);
           const liveStatus = directTerminalAuthority ? void 0 : live.status;
           const status = isTerminal ? dbStatus === "completed" ? "idle" : "failed" : turnOverlay?.status || liveStatus || (dbStatus === "acked" ? "generating" : "assigned");
           const { ledgerOnlyStaleReason, isFreshUnacknowledged } = classifyDirectDispatch({
@@ -74311,12 +74395,12 @@ ${rendered}`, "utf-8");
           }
           records.push(record2);
         }
-        const ledgerEntries = (opts.ledgerEntries || []).slice().sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-        const terminals = ledgerEntries.filter((entry) => TERMINAL_LEDGER_KINDS.has(entry.kind) || entry.kind === "task_approval_needed");
-        for (const dispatch of ledgerEntries.filter(isDirectDispatch)) {
+        const ledgerDispatches = ledgerEntries.filter(isDirectDispatch);
+        const terminalByDispatch = ledgerSnapshot.matchDirectDispatchTerminals(ledgerDispatches);
+        for (const dispatch of ledgerDispatches) {
           if (dbTaskIds.has(directDispatchTaskId(dispatch))) continue;
           if (queueTaskIds.has(directDispatchTaskId(dispatch))) continue;
-          const { record: record2, terminalRow } = buildLedgerDirectDispatchRecord(dispatch, { terminals, nodes: opts.nodes, now });
+          const { record: record2, terminalRow } = buildLedgerDirectDispatchRecord(dispatch, { terminal: terminalByDispatch.get(dispatch), nodes: opts.nodes, now });
           if (terminalRow) {
             terminalDirectWork.push(record2);
             if (opts.includeTerminalDirect !== true) continue;
@@ -74328,11 +74412,11 @@ ${rendered}`, "utf-8");
           records.push(record2);
         }
       } else {
-        const ledgerEntries = (opts.ledgerEntries || []).slice().sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-        const terminals = ledgerEntries.filter((entry) => TERMINAL_LEDGER_KINDS.has(entry.kind) || entry.kind === "task_approval_needed");
-        for (const dispatch of ledgerEntries.filter(isDirectDispatch)) {
+        const ledgerDispatches = ledgerEntries.filter(isDirectDispatch);
+        const terminalByDispatch = ledgerSnapshot.matchDirectDispatchTerminals(ledgerDispatches);
+        for (const dispatch of ledgerDispatches) {
           if (queueTaskIds.has(directDispatchTaskId(dispatch))) continue;
-          const { record: record2, terminalRow } = buildLedgerDirectDispatchRecord(dispatch, { terminals, nodes: opts.nodes, now });
+          const { record: record2, terminalRow } = buildLedgerDirectDispatchRecord(dispatch, { terminal: terminalByDispatch.get(dispatch), nodes: opts.nodes, now });
           if (terminalRow) {
             terminalDirectWork.push(record2);
             if (opts.includeTerminalDirect !== true) continue;
@@ -74374,6 +74458,7 @@ ${rendered}`, "utf-8");
         meshId: opts.meshId,
         queue: opts.queue,
         ledgerEntries: opts.ledgerEntries,
+        ledgerSnapshot: opts.ledgerSnapshot,
         directDispatches: opts.directDispatches,
         nodes: opts.nodes,
         now,
@@ -74526,13 +74611,13 @@ ${rendered}`, "utf-8");
 ${lines.join("\n")}
 The mesh has no work in flight. For each mission, decide its outcome: continue it (enqueue/dispatch the remaining work) or close it with mesh_mission_upsert(mission_id, status: "completed" | "abandoned"). Do not leave a finished mission in 'active'. This is a one-time reminder.`;
     }
-    function maybeInjectIdleActiveMissionReminder(meshId, coordinator, policy, now = Date.now(), instanceManager) {
+    function maybeInjectIdleActiveMissionReminder(meshId, coordinator, policy, now = Date.now(), instanceManager, sharedLedgerSnapshot) {
       try {
         if (!coordinator) return false;
         if (policy?.idleActiveMissionReminder === false) return false;
         const activeMissions = getMeshMissions(meshId, ["active"]);
         if (activeMissions.length === 0) return false;
-        const ledgerEntries = readLedgerEntriesByKind(meshId, [
+        const ledgerEntries = sharedLedgerSnapshot?.entries ?? readLedgerEntriesByKind(meshId, [
           "task_dispatched",
           "task_completed",
           "task_failed",
@@ -74545,6 +74630,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           queue: getQueue(meshId),
           directDispatches: getActiveDirectDispatches(meshId),
           ledgerEntries,
+          ledgerSnapshot: sharedLedgerSnapshot,
           now
         }).summary;
         if (summary.totalActiveCount !== 0 || summary.generatingCount !== 0) return false;
@@ -87051,6 +87137,7 @@ ${cleanBody}`;
     }
     var DEFAULT_RECONCILE_INTERVAL_MS;
     var DEFAULT_AUTO_PRUNE_MIN_AGE_MS;
+    var DEFAULT_AUTO_PRUNE_INTERVAL_MS;
     var DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS;
     var init_mesh_reconcile_config = __esm2({
       "src/mesh/mesh-reconcile-config.ts"() {
@@ -87059,6 +87146,7 @@ ${cleanBody}`;
         init_mesh_reconcile_acked_hold();
         DEFAULT_RECONCILE_INTERVAL_MS = 4e3;
         DEFAULT_AUTO_PRUNE_MIN_AGE_MS = 24 * 60 * 6e4;
+        DEFAULT_AUTO_PRUNE_INTERVAL_MS = 6e4;
         DEFAULT_PENDING_HELD_DRAIN_ESCALATE_MS = 12e3;
       }
     });
@@ -89784,10 +89872,18 @@ ${cleanBody}`;
         }
       }
     }
-    async function autoPruneStaleDirectDispatches(components, mesh, selfIds, localDaemonId, minAgeMs) {
+    async function autoPruneStaleDirectDispatches(components, mesh, selfIds, localDaemonId, minAgeMs, sharedLedgerSnapshot) {
       const directDispatches = getActiveDirectDispatches(mesh.id);
-      if (directDispatches.length === 0) return;
+      if (directDispatches.length === 0) return void 0;
       const liveNodes = await collectLiveNodesWithSessions(components, mesh, selfIds, localDaemonId);
+      const ledgerSnapshot = sharedLedgerSnapshot ?? buildMeshActiveWorkLedgerSnapshot(readLedgerEntriesByKind(mesh.id, [
+        "task_dispatched",
+        "task_completed",
+        "task_failed",
+        "task_stalled",
+        "task_approval_needed",
+        "task_question_pending"
+      ]));
       const result = pruneStaleDirectDispatches({
         meshId: mesh.id,
         queue: getQueue(mesh.id),
@@ -89796,14 +89892,8 @@ ${cleanBody}`;
         // tail:500 window can be crowded out by unrelated mesh traffic while a still-active
         // dispatch's ledger evidence falls out of the window, risking a live dispatch being
         // misclassified as an orphan and pruned.
-        ledgerEntries: readLedgerEntriesByKind(mesh.id, [
-          "task_dispatched",
-          "task_completed",
-          "task_failed",
-          "task_stalled",
-          "task_approval_needed",
-          "task_question_pending"
-        ]),
+        ledgerEntries: ledgerSnapshot.entries,
+        ledgerSnapshot,
         directDispatches,
         nodes: liveNodes,
         execute: true,
@@ -89813,6 +89903,7 @@ ${cleanBody}`;
       if (result.prunedCount > 0) {
         LOG2.info("MeshReconcile", `Auto-pruned ${result.prunedCount} orphaned direct dispatch record(s) for mesh ${mesh.id}`);
       }
+      return ledgerSnapshot;
     }
     async function fetchAssignedTaskChatTail(components, mesh, row, tailLimit = 10) {
       const sessionId = readNonEmptyString(row.assignedSessionId);
@@ -91671,6 +91762,7 @@ ${cleanBody}`;
           return void 0;
         }
       })();
+      const activeWorkLedgerSnapshots = /* @__PURE__ */ new Map();
       if (dispatchMeshCommand) {
         try {
           await retryUnresolvedDelegateForwards(components);
@@ -91828,11 +91920,16 @@ ${cleanBody}`;
       }
       {
         const minAgeMs = resolveAutoPruneMinAgeMs();
+        const nowMs = Date.now();
         for (const mesh of listMeshes()) {
           const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
           if (!daemonHostsMesh(mesh, selfIds)) continue;
+          const lastRunAt = lastAutoPruneRunAtByMesh.get(mesh.id);
+          if (lastRunAt !== void 0 && nowMs - lastRunAt < DEFAULT_AUTO_PRUNE_INTERVAL_MS) continue;
+          lastAutoPruneRunAtByMesh.set(mesh.id, nowMs);
           try {
-            await autoPruneStaleDirectDispatches(components, mesh, selfIds, localDaemonId, minAgeMs);
+            const snapshot = await autoPruneStaleDirectDispatches(components, mesh, selfIds, localDaemonId, minAgeMs);
+            if (snapshot) activeWorkLedgerSnapshots.set(mesh.id, snapshot);
           } catch (e) {
             LOG2.warn("MeshReconcile", `Auto-prune stale direct failed for mesh ${mesh.id}: ${e?.message || e}`);
           }
@@ -92059,7 +92156,8 @@ ${cleanBody}`;
                 targetCoordinators[0].instance,
                 getMesh(meshId)?.policy,
                 void 0,
-                components.instanceManager
+                components.instanceManager,
+                activeWorkLedgerSnapshots.get(meshId)
               );
               continue;
             }
@@ -92126,6 +92224,7 @@ ${cleanBody}`;
     var lastDiskRetentionRunAt;
     var IDLE_SESSION_REAP_INTERVAL_MS;
     var lastIdleSessionReapRunAt;
+    var lastAutoPruneRunAtByMesh;
     var init_mesh_reconcile_loop = __esm2({
       "src/mesh/mesh-reconcile-loop.ts"() {
         "use strict";
@@ -92164,6 +92263,7 @@ ${cleanBody}`;
         init_mesh_reconcile_unresolved_forward();
         DISK_RETENTION_INTERVAL_MS2 = 60 * 60 * 1e3;
         IDLE_SESSION_REAP_INTERVAL_MS = 5 * 60 * 1e3;
+        lastAutoPruneRunAtByMesh = /* @__PURE__ */ new Map();
       }
     });
     var mesh_events_exports = {};