nexus-agents 4.23.0 → 4.26.3

package/dist/{chunk-YVW743K3.js → chunk-RDJWMBUQ.js}

@@ -5,7 +5,7 @@ import {
   getErrorMessage,
   ok,
   parseBoolEnv
-} from "./chunk-OYFKB64X.js";
+} from "./chunk-7GWPLERY.js";
 
 // src/cli/research-helpers-io.ts
 import * as fs2 from "fs/promises";
@@ -156,4 +156,4 @@ export {
   loadPapersRegistry,
   savePapersRegistry
 };
-//# sourceMappingURL=chunk-YVW743K3.js.map
+//# sourceMappingURL=chunk-RDJWMBUQ.js.map

package/dist/{chunk-GVLMTQ46.js → chunk-RNOT2H4K.js}

@@ -7,7 +7,7 @@ import {
   toolStructuredError,
   toolSuccessStructured,
   wrapToolWithTimeout
-} from "./chunk-LSJ2EPOF.js";
+} from "./chunk-OGVHWFYR.js";
 import {
   JsonlStore,
   SECURITY_KEYWORDS,
@@ -19,7 +19,7 @@ import {
   getPipelineEventBus,
   getTimeProvider,
   isDeclaredNeverDeprecate
-} from "./chunk-OYFKB64X.js";
+} from "./chunk-7GWPLERY.js";
 import {
   getNexusDataDir,
   nexusDataPath
@@ -2132,4 +2132,4 @@ export {
   runImprovementReview,
   registerImprovementReviewTool
 };
-//# sourceMappingURL=chunk-GVLMTQ46.js.map
+//# sourceMappingURL=chunk-RNOT2H4K.js.map

package/dist/{chunk-ADC7YEU2.js → chunk-SLDESHM5.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-6T3EPABN.js";
 import {
   SessionMemory
-} from "./chunk-R3H46BNY.js";
+} from "./chunk-BQC3QOHD.js";
 import {
   StatsOnlyAdapter,
   ensureSharedMemoryRegistry
@@ -15,7 +15,7 @@ import {
 } from "./chunk-KSQSWEFH.js";
 import {
   generateId
-} from "./chunk-LMTBX4GZ.js";
+} from "./chunk-IIQZ77BJ.js";
 import {
   ErrorCode,
   NexusError,
@@ -28,7 +28,7 @@ import {
   getTimeProvider,
   ok,
   setSharedMobiMemDbPathResolver
-} from "./chunk-OYFKB64X.js";
+} from "./chunk-7GWPLERY.js";
 import {
   nexusDataPath
 } from "./chunk-OGHEKPLD.js";
@@ -4607,26 +4607,26 @@ function querySessionMemory(learnings, keywords, limit) {
     metadata: { confidence: l.confidence, source: l.source }
   }));
 }
-async function queryBeliefMemory(beliefs, query, keywords, limit, log) {
+async function keywordScanBeliefs(beliefs, keywords, onFailure) {
+  if (keywords.length === 0) return [];
+  const KEYWORD_SCAN_LIMIT = 1e3;
+  const allResult = await beliefs.query({ includeSuperseded: false, limit: KEYWORD_SCAN_LIMIT });
+  if (!allResult.ok) {
+    onFailure?.();
+    return [];
+  }
+  return allResult.value.filter((b) => {
+    const text = (b.subject + " " + b.predicate + " " + b.object).toLowerCase();
+    return keywords.some((k) => text.includes(k));
+  });
+}
+async function queryBeliefMemory(beliefs, query, keywords, limit, ctx) {
+  const { log, onFailure } = ctx;
   const results = [];
   try {
     const beliefResult = await beliefs.recallBySubject(query, limit);
-    let matched = [];
-    if (beliefResult.ok && beliefResult.value.length > 0) {
-      matched = beliefResult.value;
-    } else if (keywords.length > 0) {
-      const KEYWORD_SCAN_LIMIT = 1e3;
-      const allResult = await beliefs.query({
-        includeSuperseded: false,
-        limit: KEYWORD_SCAN_LIMIT
-      });
-      if (allResult.ok) {
-        matched = allResult.value.filter((b) => {
-          const text = (b.subject + " " + b.predicate + " " + b.object).toLowerCase();
-          return keywords.some((k) => text.includes(k));
-        });
-      }
-    }
+    if (!beliefResult.ok) onFailure?.();
+    const matched = beliefResult.ok && beliefResult.value.length > 0 ? beliefResult.value : await keywordScanBeliefs(beliefs, keywords, onFailure);
     for (const b of matched.filter((x) => !x.superseded)) {
       results.push({
         source: "belief",
@@ -4639,13 +4639,16 @@ async function queryBeliefMemory(beliefs, query, keywords, limit, log) {
     }
   } catch (e) {
     log.debug("Belief memory query failed", { error: String(e) });
+    onFailure?.();
   }
   return results;
 }
-async function queryAgenticMemory(agentic, query, keywords, limit, log) {
+async function queryAgenticMemory(agentic, query, keywords, limit, ctx) {
+  const { log, onFailure } = ctx;
   const results = [];
   try {
     const agResult = await agentic.searchAgentic(query, limit);
+    if (!agResult.ok) onFailure?.();
     if (agResult.ok) {
       for (const e of agResult.value) {
         results.push({
@@ -4660,10 +4663,12 @@ async function queryAgenticMemory(agentic, query, keywords, limit, log) {
     }
   } catch (e) {
     log.debug("Agentic memory query failed", { error: String(e) });
+    onFailure?.();
   }
   return results;
 }
-async function queryTypedMemory(typed, query, keywords, limitPerType, log) {
+async function queryTypedMemory(typed, query, keywords, limitPerType, ctx) {
+  const { log, onFailure } = ctx;
   const results = [];
   try {
     const [semanticResult, episodicResult] = await Promise.all([
@@ -4671,6 +4676,7 @@ async function queryTypedMemory(typed, query, keywords, limitPerType, log) {
       typed.queryByType("episodic", query, limitPerType)
     ]);
     for (const r of [semanticResult, episodicResult]) {
+      if (!r.ok) onFailure?.();
       if (r.ok) {
         for (const e of r.value) {
           results.push({
@@ -4685,13 +4691,16 @@ async function queryTypedMemory(typed, query, keywords, limitPerType, log) {
     }
   } catch (e) {
     log.debug("Typed memory query failed", { error: String(e) });
+    onFailure?.();
   }
   return results;
 }
-async function queryAdaptiveMemory(adaptive, query, keywords, limit, log) {
+async function queryAdaptiveMemory(adaptive, query, keywords, limit, ctx) {
+  const { log, onFailure } = ctx;
   const results = [];
   try {
     const searchResult = await adaptive.search(query, limit);
+    if (!searchResult.ok) onFailure?.();
     if (searchResult.ok) {
       for (const e of searchResult.value) {
         results.push({
@@ -4706,6 +4715,7 @@ async function queryAdaptiveMemory(adaptive, query, keywords, limit, log) {
     }
   } catch (e) {
     log.debug("Adaptive memory query failed", { error: String(e) });
+    onFailure?.();
   }
   return results;
 }
@@ -5335,7 +5345,7 @@ var ToolMemoryManager = class {
    * Returns results from SessionMemory, BeliefMemory, AgenticMemory, and TypedMemory
    * with source attribution and relevance scoring.
    */
-  async queryAll(query, limit = 10) {
+  async queryAll(query, limit = 10, errored) {
     if (this.initPromise !== null) {
       await this.initPromise;
       this.initPromise = null;
@@ -5345,21 +5355,41 @@ var ToolMemoryManager = class {
     const perSource = Math.ceil(limit / sourceCount);
     const results = [
       ...this.querySessionMemory(query, keywords, perSource),
-      ...await this.queryBeliefMemory(query, keywords, perSource),
-      ...await this.queryAgenticMemory(query, keywords, perSource),
-      ...await this.queryTypedMemory(query, keywords, Math.ceil(perSource / 2)),
-      ...await this.queryAdaptiveMemory(query, keywords, perSource)
+      ...await this.queryBeliefMemory(query, keywords, perSource, () => errored?.("belief")),
+      ...await this.queryAgenticMemory(query, keywords, perSource, () => errored?.("agentic")),
+      ...await this.queryTypedMemory(
+        query,
+        keywords,
+        Math.ceil(perSource / 2),
+        () => errored?.("typed")
+      ),
+      ...await this.queryAdaptiveMemory(query, keywords, perSource, () => errored?.("adaptive"))
     ];
     return results.sort((a, b) => b.relevance - a.relevance).slice(0, limit);
   }
+  /**
+   * `queryBySource`, plus the names of the backends that threw while answering (#4999).
+   *
+   * Each per-backend helper swallows its error and contributes `[]`, so a store
+   * that failed is invisible in the merged result set — indistinguishable from
+   * one that simply matched nothing. Callers that report coverage need the
+   * difference, and only this variant can tell them. Single-source queries get
+   * the same treatment as `'all'` — a corrupt store must not read as an empty
+   * one whichever way it was asked.
+   */
+  async queryWithStatus(source, query, limit = 10) {
+    const failures = /* @__PURE__ */ new Set();
+    const results = await this.queryBySource(source, query, limit, (name) => failures.add(name));
+    return { results, errored: [...failures] };
+  }
   /**
    * Query a specific memory backend directly, bypassing cross-backend limit dilution.
    * When source is 'all', delegates to queryAll(). Otherwise dispatches to the
    * single-backend method so the full limit is applied to that backend only.
    */
-  async queryBySource(source, query, limit = 10) {
+  async queryBySource(source, query, limit = 10, errored) {
     if (source === "all") {
-      return this.queryAll(query, limit);
+      return this.queryAll(query, limit, errored);
     }
     if (this.initPromise !== null) {
       await this.initPromise;
@@ -5372,16 +5402,21 @@ var ToolMemoryManager = class {
         results = this.querySessionMemory(query, keywords, limit);
         break;
       case "belief":
-        results = await this.queryBeliefMemory(query, keywords, limit);
+        results = await this.queryBeliefMemory(query, keywords, limit, () => errored?.("belief"));
         break;
       case "agentic":
-        results = await this.queryAgenticMemory(query, keywords, limit);
+        results = await this.queryAgenticMemory(query, keywords, limit, () => errored?.("agentic"));
         break;
       case "typed":
-        results = await this.queryTypedMemory(query, keywords, limit);
+        results = await this.queryTypedMemory(query, keywords, limit, () => errored?.("typed"));
         break;
       case "adaptive":
-        results = await this.queryAdaptiveMemory(query, keywords, limit);
+        results = await this.queryAdaptiveMemory(
+          query,
+          keywords,
+          limit,
+          () => errored?.("adaptive")
+        );
         break;
     }
     return results.sort((a, b) => b.relevance - a.relevance).slice(0, limit);
@@ -5391,20 +5426,32 @@ var ToolMemoryManager = class {
   querySessionMemory(query, keywords, limit) {
     return querySessionMemory(this.searchLearnings(query), keywords, limit);
   }
-  async queryBeliefMemory(query, keywords, limit) {
-    return queryBeliefMemory(this.beliefs, query, keywords, limit, this.log);
+  async queryBeliefMemory(query, keywords, limit, onFailure) {
+    return queryBeliefMemory(this.beliefs, query, keywords, limit, {
+      log: this.log,
+      onFailure
+    });
   }
-  async queryAgenticMemory(query, keywords, limit) {
+  async queryAgenticMemory(query, keywords, limit, onFailure) {
     if (this.agentic === null) return [];
-    return queryAgenticMemory(this.agentic, query, keywords, limit, this.log);
+    return queryAgenticMemory(this.agentic, query, keywords, limit, {
+      log: this.log,
+      onFailure
+    });
   }
-  async queryTypedMemory(query, keywords, limitPerType) {
+  async queryTypedMemory(query, keywords, limitPerType, onFailure) {
     if (this.typed === null) return [];
-    return queryTypedMemory(this.typed, query, keywords, limitPerType, this.log);
+    return queryTypedMemory(this.typed, query, keywords, limitPerType, {
+      log: this.log,
+      onFailure
+    });
   }
-  async queryAdaptiveMemory(query, keywords, limit) {
+  async queryAdaptiveMemory(query, keywords, limit, onFailure) {
     if (this.adaptive === null) return [];
-    return queryAdaptiveMemory(this.adaptive, query, keywords, limit, this.log);
+    return queryAdaptiveMemory(this.adaptive, query, keywords, limit, {
+      log: this.log,
+      onFailure
+    });
   }
   // ==========================================================================
   // Memory Promotion Pipeline (Phase 4 #746)
@@ -5561,4 +5608,4 @@ export {
   reinitializeMemoryBackends,
   ToolMemoryManager
 };
-//# sourceMappingURL=chunk-ADC7YEU2.js.map
+//# sourceMappingURL=chunk-SLDESHM5.js.map