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

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 ? "5b9c8b942cc6dec286f5257470292e03f12c53e7" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "5b9c8b94" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.58-rc.48" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-30T09:40:02.587Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -68137,6 +68137,35 @@ CREATE TABLE IF NOT EXISTS sq_archive (
       ledgerReadCache.set(meshId, { entries, cachedAt: Date.now() });
       return entries;
     }
+    function filteredLedgerCacheKey(opts) {
+      const kinds = opts.kinds ? [...new Set(opts.kinds)].sort() : [];
+      return JSON.stringify([opts.since ?? null, kinds]);
+    }
+    function getCachedFilteredRawEntries(meshId, opts) {
+      const key2 = filteredLedgerCacheKey(opts);
+      let meshCache = filteredLedgerReadCache.get(meshId);
+      if (meshCache) {
+        const now = Date.now();
+        for (const [cachedKey, entry] of meshCache) {
+          if (now - entry.cachedAt >= LEDGER_CACHE_TTL_MS) meshCache.delete(cachedKey);
+        }
+        if (meshCache.size === 0) {
+          filteredLedgerReadCache.delete(meshId);
+          meshCache = void 0;
+        }
+      }
+      const cached5 = meshCache?.get(key2);
+      if (cached5) return cached5.entries;
+      const entries = readLedgerFromStore(meshId, opts);
+      recordLedgerPushdownScan(entries.length);
+      const targetCache = meshCache ?? /* @__PURE__ */ new Map();
+      targetCache.set(key2, { entries, cachedAt: Date.now() });
+      if (!meshCache) filteredLedgerReadCache.set(meshId, targetCache);
+      return entries;
+    }
+    function invalidateFilteredLedgerCache(meshId) {
+      filteredLedgerReadCache.delete(meshId);
+    }
     function entryTimeValue(entry) {
       const t = new Date(entry.timestamp).getTime();
       return Number.isNaN(t) ? NaN : t;
@@ -68156,19 +68185,24 @@ CREATE TABLE IF NOT EXISTS sq_archive (
       return true;
     }
     function recordLedgerAppend(meshId, newEntries) {
+      invalidateFilteredLedgerCache(meshId);
       if (!appendToLedgerCache(meshId, newEntries)) invalidateLedgerCache(meshId);
     }
     function invalidateLedgerCache(meshId) {
       ledgerReadCache.delete(meshId);
+      invalidateFilteredLedgerCache(meshId);
     }
     function clearLedgerImportFlag(meshId) {
       ledgerImportDone.delete(meshId);
+      invalidateFilteredLedgerCache(meshId);
     }
     function invalidateAllLedgerCaches() {
       ledgerReadCache.clear();
+      filteredLedgerReadCache.clear();
     }
     var import_fs12;
     var ledgerReadCache;
+    var filteredLedgerReadCache;
     var LEDGER_CACHE_TTL_MS;
     var ledgerImportStoreRef;
     var ledgerImportDone;
@@ -68183,6 +68217,7 @@ CREATE TABLE IF NOT EXISTS sq_archive (
         init_logger();
         init_mesh_ledger_paths();
         ledgerReadCache = /* @__PURE__ */ new Map();
+        filteredLedgerReadCache = /* @__PURE__ */ new Map();
         LEDGER_CACHE_TTL_MS = 3e4;
         ledgerImportDone = /* @__PURE__ */ new Set();
         ledgerScanStats = {
@@ -68791,12 +68826,10 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       const kinds = opts?.kind?.length ? opts.kind : void 0;
       if (!hasSince && !kinds) return getCachedRawEntries(meshId);
       try {
-        const entries = readLedgerFromStore(meshId, {
+        return getCachedFilteredRawEntries(meshId, {
           ...hasSince ? { since: opts.since } : {},
           ...kinds ? { kinds } : {}
         });
-        recordLedgerPushdownScan(entries.length);
-        return entries;
       } catch {
         return getCachedRawEntries(meshId);
       }
@@ -74031,6 +74064,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 +74225,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 +74241,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 +74342,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 +74354,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 +74384,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 +74428,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 +74445,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 +74491,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 +74644,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 +74663,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 +87170,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 +87179,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 +89905,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 +89925,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 +89936,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 +91795,7 @@ ${cleanBody}`;
           return void 0;
         }
       })();
+      const activeWorkLedgerSnapshots = /* @__PURE__ */ new Map();
       if (dispatchMeshCommand) {
         try {
           await retryUnresolvedDelegateForwards(components);
@@ -91828,11 +91953,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 +92189,8 @@ ${cleanBody}`;
                 targetCoordinators[0].instance,
                 getMesh(meshId)?.policy,
                 void 0,
-                components.instanceManager
+                components.instanceManager,
+                activeWorkLedgerSnapshots.get(meshId)
               );
               continue;
             }
@@ -92126,6 +92257,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 +92296,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 = {};