@joshuaswarren/openclaw-engram 8.3.61 → 8.3.63

package/dist/index.js

@@ -418,6 +418,9 @@ function parseConfig(raw) {
     causalGraphEnabled: cfg.causalGraphEnabled !== false,
     maxGraphTraversalSteps: typeof cfg.maxGraphTraversalSteps === "number" ? Math.max(0, cfg.maxGraphTraversalSteps) : 3,
     graphActivationDecay: typeof cfg.graphActivationDecay === "number" ? Math.min(1, Math.max(0, cfg.graphActivationDecay)) : 0.7,
+    graphExpansionActivationWeight: typeof cfg.graphExpansionActivationWeight === "number" ? Math.min(1, Math.max(0, cfg.graphExpansionActivationWeight)) : 0.65,
+    graphExpansionBlendMin: typeof cfg.graphExpansionBlendMin === "number" ? Math.min(1, Math.max(0, cfg.graphExpansionBlendMin)) : 0.05,
+    graphExpansionBlendMax: typeof cfg.graphExpansionBlendMax === "number" ? Math.min(1, Math.max(0, cfg.graphExpansionBlendMax)) : 0.95,
     maxEntityGraphEdgesPerMemory: typeof cfg.maxEntityGraphEdgesPerMemory === "number" ? Math.max(0, cfg.maxEntityGraphEdgesPerMemory) : 10,
     // v8.2: Temporal Memory Tree
     temporalMemoryTreeEnabled: cfg.temporalMemoryTreeEnabled === true,
@@ -8600,6 +8603,22 @@ var NegativeExampleStore = class {
 import { appendFile as appendFile3, mkdir as mkdir8, readFile as readFile8, writeFile as writeFile8 } from "fs/promises";
 import path10 from "path";
 import { createHash as createHash2 } from "crypto";
+function clampGraphRecallExpandedEntries(entries, maxEntries = 64) {
+  const limit = Math.max(1, Math.floor(maxEntries));
+  if (!Array.isArray(entries)) return [];
+  return entries.filter((item) => !!item && typeof item === "object").map((item) => {
+    const graphType = item.graphType === "entity" || item.graphType === "time" || item.graphType === "causal" ? item.graphType : "entity";
+    return {
+      path: typeof item.path === "string" ? item.path : "",
+      score: typeof item.score === "number" && Number.isFinite(item.score) ? item.score : 0,
+      namespace: typeof item.namespace === "string" ? item.namespace : "",
+      seed: typeof item.seed === "string" ? item.seed : "",
+      hopDepth: typeof item.hopDepth === "number" && Number.isFinite(item.hopDepth) ? Math.max(0, Math.floor(item.hopDepth)) : 0,
+      decayedWeight: typeof item.decayedWeight === "number" && Number.isFinite(item.decayedWeight) ? Math.max(0, item.decayedWeight) : 0,
+      graphType
+    };
+  }).filter((item) => item.path.length > 0 && item.namespace.length > 0).slice(0, limit);
+}
 var LastRecallStore = class {
   statePath;
   impressionsPath;
@@ -11004,10 +11023,11 @@ var GraphIndex = class {
       }
       const seedSet = new Set(seeds);
       const scores = /* @__PURE__ */ new Map();
+      const provenance = /* @__PURE__ */ new Map();
       const visited = new Set(seeds);
-      const queue = seeds.map((s) => [s, 0]);
+      const queue = seeds.map((s) => [s, 0, s]);
       while (queue.length > 0) {
-        const [node, hop] = queue.shift();
+        const [node, hop, sourceSeed] = queue.shift();
         if (hop >= steps) continue;
         const edges = adj.get(node) ?? [];
         for (const edge of edges) {
@@ -11016,14 +11036,30 @@ var GraphIndex = class {
           if (!seedSet.has(neighbor)) {
             const existing = scores.get(neighbor) ?? 0;
             scores.set(neighbor, existing + score);
+            const prev = provenance.get(neighbor);
+            if (!prev || hop + 1 < prev.hopDepth || hop + 1 === prev.hopDepth && score > prev.decayedWeight) {
+              provenance.set(neighbor, {
+                seed: sourceSeed,
+                hopDepth: hop + 1,
+                decayedWeight: score,
+                graphType: edge.type
+              });
+            }
           }
           if (!visited.has(neighbor)) {
             visited.add(neighbor);
-            queue.push([neighbor, hop + 1]);
+            queue.push([neighbor, hop + 1, sourceSeed]);
           }
         }
       }
-      return Array.from(scores.entries()).map(([p, score]) => ({ path: p, score })).sort((a, b) => b.score - a.score);
+      return Array.from(scores.entries()).map(([p, score]) => ({
+        path: p,
+        score,
+        seed: provenance.get(p)?.seed ?? "",
+        hopDepth: provenance.get(p)?.hopDepth ?? 0,
+        decayedWeight: provenance.get(p)?.decayedWeight ?? 0,
+        graphType: provenance.get(p)?.graphType ?? "entity"
+      })).sort((a, b) => b.score - a.score);
     } catch (err) {
       const { log: log2 } = await import("./logger-KPTKTANX.js");
       log2.warn(`[graph] spreadingActivation error: ${err}`);
@@ -12534,10 +12570,20 @@ function graphPathRelativeToStorage(storageDir, candidatePath) {
   if (rel.startsWith("..")) return null;
   return rel.split(path25.sep).join("/");
 }
-function graphActivationScoreToRecallScore(score) {
+function normalizeGraphActivationScore(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));
+  return bounded / (1 + bounded);
+}
+function blendGraphExpandedRecallScore(options) {
+  const graphNorm = normalizeGraphActivationScore(options.graphActivationScore);
+  const seedScore = Number.isFinite(options.seedRecallScore) ? Math.min(1, Math.max(0, options.seedRecallScore)) : 0;
+  const weight = Math.min(1, Math.max(0, options.activationWeight));
+  const rawMin = Math.min(1, Math.max(0, options.blendMin));
+  const rawMax = Math.min(1, Math.max(0, options.blendMax));
+  const minBound = Math.min(rawMin, rawMax);
+  const maxBound = Math.max(rawMin, rawMax);
+  const blended = graphNorm * weight + seedScore * (1 - weight);
+  return Math.max(minBound, Math.min(maxBound, blended));
 }
 function mergeArtifactRecallCandidates(candidatesByNamespace, limit) {
   const cappedLimit = Math.max(0, limit);
@@ -13061,9 +13107,7 @@ var Orchestrator = class _Orchestrator {
         seedCount: typeof parsed.seedCount === "number" ? parsed.seedCount : 0,
         expandedCount: typeof parsed.expandedCount === "number" ? parsed.expandedCount : 0,
         seeds: Array.isArray(parsed.seeds) ? parsed.seeds.filter((v) => typeof v === "string") : [],
-        expanded: Array.isArray(parsed.expanded) ? parsed.expanded.filter(
-          (v) => !!v && typeof v === "object" && typeof v.path === "string" && typeof v.score === "number" && typeof v.namespace === "string"
-        ) : []
+        expanded: clampGraphRecallExpandedEntries(parsed.expanded, 64)
       };
     } catch {
       return null;
@@ -13084,7 +13128,9 @@ var Orchestrator = class _Orchestrator {
       `Seed paths (${snapshot.seedCount}):`,
       ...snapshot.seeds.map((p) => `- ${p}`),
       `Expanded paths (${snapshot.expandedCount}, showing ${expanded.length}):`,
-      ...expanded.map((e) => `- ${e.path} (score=${e.score.toFixed(3)}, ns=${e.namespace})`)
+      ...expanded.map(
+        (e) => `- ${e.path} (score=${e.score.toFixed(3)}, ns=${e.namespace}, seed=${e.seed || "unknown"}, hop=${e.hopDepth}, w=${e.decayedWeight.toFixed(3)}, type=${e.graphType})`
+      )
     ].join("\n");
   }
   async searchConversationRecallResults(retrievalQuery, topK) {
@@ -13430,8 +13476,10 @@ ${r.snippet.trim()}
     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);
+      const seedCandidates = nsResults.slice(0, perNamespaceSeedCap);
+      const seedRelativePaths = seedCandidates.map((result) => graphPathRelativeToStorage(storage.dir, result.path)).filter((value) => typeof value === "string" && value.length > 0);
       if (seedRelativePaths.length === 0) continue;
+      const seedRecallScore = seedCandidates.reduce((max, item) => Math.max(max, item.score), 0);
       seedPaths.push(...seedRelativePaths.map((rel) => path25.join(storage.dir, rel)));
       const seedSet = new Set(seedRelativePaths);
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
@@ -13447,7 +13495,13 @@ ${r.snippet.trim()}
         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);
+        const score = blendGraphExpandedRecallScore({
+          graphActivationScore: candidate.score,
+          seedRecallScore,
+          activationWeight: this.config.graphExpansionActivationWeight,
+          blendMin: this.config.graphExpansionBlendMin,
+          blendMax: this.config.graphExpansionBlendMax
+        });
         expandedResults.push({
           docid: memory.frontmatter.id,
           path: memory.path,
@@ -13457,7 +13511,11 @@ ${r.snippet.trim()}
         expandedPaths.push({
           path: memory.path,
           score,
-          namespace
+          namespace,
+          seed: path25.resolve(storage.dir, candidate.seed),
+          hopDepth: candidate.hopDepth,
+          decayedWeight: candidate.decayedWeight,
+          graphType: candidate.graphType
         });
       }
     }
@@ -13472,16 +13530,20 @@ ${r.snippet.trim()}
       const snapshotPath = path25.join(options.storage.dir, "state", "last_graph_recall.json");
       await mkdir18(path25.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
+      const totalSeedCount = options.seedPaths.length;
+      const totalExpandedCount = options.expandedPaths.length;
+      const seeds = options.seedPaths.slice(0, 64);
+      const expanded = clampGraphRecallExpandedEntries(options.expandedPaths, 64);
       const payload = {
         recordedAt: now,
         mode: options.recallMode,
         queryHash: createHash5("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
+        seedCount: totalSeedCount,
+        expandedCount: totalExpandedCount,
+        seeds,
+        expanded
       };
       await writeFile17(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
     } catch (err) {