@joshuaswarren/openclaw-engram 9.0.9 → 9.0.11

package/dist/index.js

@@ -474,6 +474,8 @@ function parseConfig(raw) {
     recallConfidenceGateEnabled: cfg.recallConfidenceGateEnabled === true,
     recallConfidenceGateThreshold: typeof cfg.recallConfidenceGateThreshold === "number" ? Math.max(0, Math.min(1, cfg.recallConfidenceGateThreshold)) : 0.12,
     causalRuleExtractionEnabled: cfg.causalRuleExtractionEnabled === true,
+    memoryReconstructionEnabled: cfg.memoryReconstructionEnabled === true,
+    memoryReconstructionMaxExpansions: typeof cfg.memoryReconstructionMaxExpansions === "number" ? Math.max(0, Math.round(cfg.memoryReconstructionMaxExpansions)) : 3,
     graphLateralInhibitionEnabled: cfg.graphLateralInhibitionEnabled !== false,
     graphLateralInhibitionBeta: typeof cfg.graphLateralInhibitionBeta === "number" ? Math.max(0, Math.min(1, cfg.graphLateralInhibitionBeta)) : 0.15,
     graphLateralInhibitionTopM: typeof cfg.graphLateralInhibitionTopM === "number" ? Math.max(0, Math.round(cfg.graphLateralInhibitionTopM)) : 7,
@@ -4179,6 +4181,26 @@ function rescoreMemoryImportance(memory) {
   return scoreImportance(memory.content, memory.frontmatter.category, memory.frontmatter.tags ?? []);
 }
 
+// src/reconstruct.ts
+function findUnresolvedEntityRefs(recalledSnippets, recalledEntityRefs, knownEntities) {
+  const refSet = new Set(recalledEntityRefs.map((r) => r.toLowerCase()));
+  const combinedText = recalledSnippets.join(" ").toLowerCase();
+  const sorted = [...knownEntities].sort((a, b) => b.length - a.length);
+  const matched = /* @__PURE__ */ new Set();
+  const unresolved = [];
+  for (const entity of sorted) {
+    const lower = entity.toLowerCase();
+    if (refSet.has(lower)) continue;
+    const escaped = lower.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`(?:^|[\\s,;:'"(\\[])${escaped}(?:$|[\\s,;:'".)\\]])`, "i");
+    if (pattern.test(combinedText) && !matched.has(lower)) {
+      unresolved.push(entity);
+      matched.add(lower);
+    }
+  }
+  return unresolved;
+}
+
 // src/search/noop-backend.ts
 var NoopSearchBackend = class {
   async probe() {
@@ -12536,6 +12558,9 @@ function serializeBoxFrontmatter(fm) {
   ];
   if (fm.sessionKey) lines.push(`sessionKey: ${fm.sessionKey}`);
   if (fm.traceId) lines.push(`traceId: ${fm.traceId}`);
+  if (fm.goal) lines.push(`goal: ${fm.goal.replace(/[\r\n]+/g, " ")}`);
+  if (fm.toolsUsed?.length) lines.push(`toolsUsed: [${fm.toolsUsed.map((t) => `"${t}"`).join(", ")}]`);
+  if (fm.outcome) lines.push(`outcome: ${fm.outcome}`);
   lines.push("---");
   return lines.join("\n");
 }
@@ -12555,6 +12580,7 @@ function parseBoxFrontmatter(raw) {
     if (!m) return [];
     return m[1].split(",").map((s) => s.trim().replace(/^"|"$/g, "")).filter(Boolean);
   };
+  const outcome = fm.outcome;
   return {
     id: fm.id ?? "",
     memoryKind: "box",
@@ -12564,7 +12590,10 @@ function parseBoxFrontmatter(raw) {
     sessionKey: fm.sessionKey,
     topics: parseArray(fm.topics),
     memoryIds: parseArray(fm.memoryIds),
-    traceId: fm.traceId
+    traceId: fm.traceId,
+    goal: fm.goal || void 0,
+    toolsUsed: fm.toolsUsed ? parseArray(fm.toolsUsed) : void 0,
+    outcome: outcome && ["success", "failure", "partial", "unknown"].includes(outcome) ? outcome : void 0
   };
 }
 var BoxBuilder = class {
@@ -12650,6 +12679,10 @@ var BoxBuilder = class {
         const topicSet = /* @__PURE__ */ new Set([...this.openBox.topics, ...newTopics]);
         this.openBox.topics = [...topicSet];
         this.openBox.memoryIds.push(...event.memoryIds);
+        if (event.toolsUsed?.length) {
+          const toolSet = /* @__PURE__ */ new Set([...this.openBox.toolsUsed ?? [], ...event.toolsUsed]);
+          this.openBox.toolsUsed = [...toolSet];
+        }
         await this.sealCurrent("max_memories");
       } else if (topicShifted) {
         await this.sealCurrent("topic_shift");
@@ -12664,6 +12697,10 @@ var BoxBuilder = class {
         const topicSet = /* @__PURE__ */ new Set([...this.openBox.topics, ...newTopics]);
         this.openBox.topics = [...topicSet];
         this.openBox.lastActivityAt = now.toISOString();
+        if (event.toolsUsed?.length) {
+          const toolSet = /* @__PURE__ */ new Set([...this.openBox.toolsUsed ?? [], ...event.toolsUsed]);
+          this.openBox.toolsUsed = [...toolSet];
+        }
         await this.saveOpenBox();
       }
     } else {
@@ -12681,7 +12718,9 @@ var BoxBuilder = class {
       createdAt: ts,
       lastActivityAt: ts,
       topics: event.topics.filter(Boolean),
-      memoryIds: [...event.memoryIds]
+      memoryIds: [...event.memoryIds],
+      goal: event.goal,
+      toolsUsed: event.toolsUsed?.length ? [...event.toolsUsed] : void 0
     };
   }
   /**
@@ -12713,7 +12752,10 @@ var BoxBuilder = class {
       sealReason: reason,
       topics: box.topics,
       memoryIds: box.memoryIds,
-      traceId
+      traceId,
+      goal: box.goal,
+      toolsUsed: box.toolsUsed?.length ? box.toolsUsed : void 0,
+      outcome: "unknown"
     };
     const content = `${serializeBoxFrontmatter(fm)}
 
@@ -17842,6 +17884,37 @@ ${tmtNode.summary}`);
         confidenceGateRejected = true;
       }
       memoryResults = memoryResults.slice(0, recallResultLimit);
+      if (this.config.memoryReconstructionEnabled && memoryResults.length > 0) {
+        try {
+          const snippets = memoryResults.map((r) => r.snippet);
+          const coveredRefs = memoryResults.map((r) => r.path).filter((p) => p.startsWith("entities/")).map((p) => p.replace(/^entities\//, "").replace(/\.md$/, ""));
+          const knownEntities = await profileStorage.listEntityNames();
+          const missing = findUnresolvedEntityRefs(snippets, coveredRefs, knownEntities);
+          if (missing.length > 0) {
+            const budget = this.config.memoryReconstructionMaxExpansions;
+            let expanded = 0;
+            for (const entityName of missing) {
+              if (expanded >= budget) break;
+              const raw = await profileStorage.readEntity(entityName);
+              if (raw && raw.length > 0) {
+                const snippet = raw.length > 300 ? raw.slice(0, 300) + "\u2026" : raw;
+                memoryResults.push({
+                  docid: `entity:${entityName}`,
+                  path: `entities/${entityName}.md`,
+                  snippet: `[Entity: ${entityName}] ${snippet}`,
+                  score: 0.1
+                });
+                expanded++;
+              }
+            }
+            if (expanded > 0) {
+              log.debug(`recall: reconstructed ${expanded} entity contexts`);
+            }
+          }
+        } catch (err) {
+          log.warn("recall: memory reconstruction failed (non-fatal)", err);
+        }
+      }
       if (memoryResults.length > 0) {
         recallSource = "hot_qmd";
         recalledMemoryCount = memoryResults.length;
@@ -18387,10 +18460,13 @@ _Context: ${topQuestion.context}_`
     await clearBuffer();
     if (this.config.memoryBoxesEnabled && persistedIds.length > 0) {
       const extractionTopics = deriveTopicsFromExtraction(result);
+      const firstUserTurn = turns.find((t) => t.role === "user");
+      const boxGoal = firstUserTurn?.content?.slice(0, 100)?.trim() || void 0;
       await this.boxBuilderFor(storage).onExtraction({
         topics: extractionTopics,
         memoryIds: persistedIds,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        goal: boxGoal
       }).catch((err) => log.warn("[boxes] onExtraction failed (non-fatal)", err));
     }
     if (this.config.threadingEnabled && threadIdForExtraction && persistedIds.length > 0) {