@joshuaswarren/openclaw-engram 8.3.0 → 8.3.2

package/dist/index.js

@@ -339,6 +339,7 @@ function parseConfig(raw) {
     queryAwareIndexingMaxCandidates: typeof cfg.queryAwareIndexingMaxCandidates === "number" ? Math.max(0, cfg.queryAwareIndexingMaxCandidates) : 200,
     // v8.2: Multi-graph memory (PR 18)
     multiGraphMemoryEnabled: cfg.multiGraphMemoryEnabled === true,
+    graphRecallEnabled: cfg.graphRecallEnabled === true,
     entityGraphEnabled: cfg.entityGraphEnabled !== false,
     timeGraphEnabled: cfg.timeGraphEnabled !== false,
     causalGraphEnabled: cfg.causalGraphEnabled !== false,
@@ -9729,6 +9730,13 @@ function computeArtifactRecallLimit(recallMode, recallResultLimit, verbatimArtif
   }
   return base;
 }
+function resolveEffectiveRecallMode(options) {
+  const plannedMode = options.plannerEnabled ? planRecallMode(options.prompt) : "full";
+  if (plannedMode === "graph_mode" && (!options.graphRecallEnabled || !options.multiGraphMemoryEnabled)) {
+    return "full";
+  }
+  return plannedMode;
+}
 function computeArtifactCandidateFetchLimit(targetCount) {
   const cappedTarget = Math.max(0, targetCount);
   if (cappedTarget === 0) return 0;
@@ -9742,6 +9750,32 @@ function computeQmdHybridFetchLimit(recallFetchLimit, artifactsEnabled, maxArtif
   const artifactHeadroom = Math.max(20, Math.max(0, maxArtifactRecall) * 8);
   return Math.min(400, cappedRecallLimit + artifactHeadroom);
 }
+function mergeGraphExpandedResults(primary, expanded) {
+  const mergedByPath = /* @__PURE__ */ new Map();
+  for (const item of [...primary, ...expanded]) {
+    const prev = mergedByPath.get(item.path);
+    if (!prev) {
+      mergedByPath.set(item.path, item);
+      continue;
+    }
+    const better = item.score > prev.score ? item : prev;
+    const snippet = prev.snippet || item.snippet;
+    mergedByPath.set(item.path, { ...better, snippet });
+  }
+  return Array.from(mergedByPath.values());
+}
+function graphPathRelativeToStorage(storageDir, candidatePath) {
+  const absolutePath = path22.isAbsolute(candidatePath) ? candidatePath : path22.resolve(storageDir, candidatePath);
+  const rel = path22.relative(storageDir, absolutePath);
+  if (!rel || rel === ".") return null;
+  if (rel.startsWith("..")) return null;
+  return rel.split(path22.sep).join("/");
+}
+function graphActivationScoreToRecallScore(score) {
+  const bounded = Number.isFinite(score) && score > 0 ? score : 0;
+  const normalized = bounded / (1 + bounded);
+  return Math.max(0.05, Math.min(0.95, normalized));
+}
 function mergeArtifactRecallCandidates(candidatesByNamespace, limit) {
   const cappedLimit = Math.max(0, limit);
   if (cappedLimit === 0) return [];
@@ -10378,11 +10412,93 @@ var Orchestrator = class _Orchestrator {
     }
     return bestFiltered;
   }
+  async expandResultsViaGraph(options) {
+    const byNamespace = /* @__PURE__ */ new Map();
+    for (const result of options.memoryResults) {
+      const ns = this.namespaceFromPath(result.path);
+      if (!options.recallNamespaces.includes(ns)) continue;
+      const existing = byNamespace.get(ns);
+      if (existing) {
+        existing.push(result);
+      } else {
+        byNamespace.set(ns, [result]);
+      }
+    }
+    const perNamespaceSeedCap = Math.max(3, options.recallResultLimit);
+    const perNamespaceExpandedCap = Math.max(8, options.recallResultLimit * 2);
+    const seedPaths = [];
+    const expandedPaths = [];
+    const expandedResults = [];
+    for (const [namespace, nsResults] of byNamespace.entries()) {
+      const storage = await this.storageRouter.storageFor(namespace);
+      const seedRelativePaths = nsResults.slice(0, perNamespaceSeedCap).map((result) => graphPathRelativeToStorage(storage.dir, result.path)).filter((value) => typeof value === "string" && value.length > 0);
+      if (seedRelativePaths.length === 0) continue;
+      seedPaths.push(...seedRelativePaths.map((rel) => path22.join(storage.dir, rel)));
+      const seedSet = new Set(seedRelativePaths);
+      const expanded = await this.graphIndexFor(storage).spreadingActivation(
+        seedRelativePaths,
+        this.config.maxGraphTraversalSteps
+      );
+      if (expanded.length === 0) continue;
+      for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
+        if (seedSet.has(candidate.path)) continue;
+        const memoryPath = path22.resolve(storage.dir, candidate.path);
+        const memory = await storage.readMemoryByPath(memoryPath);
+        if (!memory) continue;
+        if (isArtifactMemoryPath(memory.path)) continue;
+        if (memory.frontmatter.status && memory.frontmatter.status !== "active") continue;
+        const snippet = memory.content.slice(0, 400);
+        const score = graphActivationScoreToRecallScore(candidate.score);
+        expandedResults.push({
+          docid: memory.frontmatter.id,
+          path: memory.path,
+          snippet,
+          score
+        });
+        expandedPaths.push({
+          path: memory.path,
+          score,
+          namespace
+        });
+      }
+    }
+    return {
+      merged: mergeGraphExpandedResults(options.memoryResults, expandedResults),
+      seedPaths,
+      expandedPaths
+    };
+  }
+  async recordLastGraphRecallSnapshot(options) {
+    try {
+      const snapshotPath = path22.join(options.storage.dir, "state", "last_graph_recall.json");
+      await mkdir16(path22.dirname(snapshotPath), { recursive: true });
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const payload = {
+        recordedAt: now,
+        mode: options.recallMode,
+        queryHash: createHash4("sha256").update(options.prompt).digest("hex"),
+        queryLength: options.prompt.length,
+        namespaces: options.recallNamespaces,
+        seedCount: options.seedPaths.length,
+        expandedCount: options.expandedPaths.length,
+        seeds: options.seedPaths,
+        expanded: options.expandedPaths
+      };
+      await writeFile15(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
+    } catch (err) {
+      log.debug(`last graph recall write failed: ${err}`);
+    }
+  }
   async recallInternal(prompt, sessionKey) {
     const recallStart = Date.now();
     const timings = {};
     const sections = [];
-    const recallMode = this.config.recallPlannerEnabled ? planRecallMode(prompt) : "full";
+    const recallMode = resolveEffectiveRecallMode({
+      plannerEnabled: this.config.recallPlannerEnabled,
+      graphRecallEnabled: this.config.graphRecallEnabled,
+      multiGraphMemoryEnabled: this.config.multiGraphMemoryEnabled,
+      prompt
+    });
     timings.recallPlan = recallMode;
     const recallResultLimit = recallMode === "no_recall" ? 0 : recallMode === "minimal" ? Math.max(0, Math.min(this.config.qmdMaxResults, this.config.recallPlannerMaxQmdResultsMinimal)) : this.config.qmdMaxResults;
     const recallHeadroom = this.config.verbatimArtifactsEnabled ? Math.max(12, this.config.verbatimArtifactsMaxRecall * 4) : 12;
@@ -10530,20 +10646,7 @@ ${tmtNode.summary}`);
     if (qmdResult) {
       const t0 = Date.now();
       const { memoryResultsLists, globalResults } = qmdResult;
-      const mergedByPath = /* @__PURE__ */ new Map();
-      for (const list of memoryResultsLists) {
-        for (const r of list) {
-          const prev = mergedByPath.get(r.path);
-          if (!prev) {
-            mergedByPath.set(r.path, r);
-            continue;
-          }
-          const better = r.score > prev.score ? r : prev;
-          const snippet = prev.snippet || r.snippet;
-          mergedByPath.set(r.path, { ...better, snippet });
-        }
-      }
-      const memoryResultsRaw = Array.from(mergedByPath.values());
+      const memoryResultsRaw = mergeGraphExpandedResults(memoryResultsLists.flat(), []);
       let memoryResults = memoryResultsRaw;
       if (this.config.namespacesEnabled) {
         memoryResults = memoryResults.filter(
@@ -10551,6 +10654,26 @@ ${tmtNode.summary}`);
         );
       }
       memoryResults = memoryResults.filter((r) => !isArtifactMemoryPath(r.path));
+      if (recallMode === "graph_mode") {
+        const {
+          merged,
+          seedPaths,
+          expandedPaths
+        } = await this.expandResultsViaGraph({
+          memoryResults,
+          recallNamespaces,
+          recallResultLimit
+        });
+        memoryResults = merged;
+        await this.recordLastGraphRecallSnapshot({
+          storage: profileStorage,
+          prompt,
+          recallMode,
+          recallNamespaces,
+          seedPaths,
+          expandedPaths
+        });
+      }
       memoryResults = await this.boostSearchResults(memoryResults, recallNamespaces, prompt);
       if (this.config.rerankEnabled && this.config.rerankProvider === "local") {
         const ranked = await rerankLocalOrNoop({