@icex-labs/openclaw-memory-engine 5.1.0 → 5.2.0

package/extras/auto-consolidation-crons.json

@@ -32,6 +32,14 @@
       "message": "Run memory_dashboard to regenerate the HTML dashboard. Do NOT output anything to the main chat.",
       "model": "anthropic/claude-sonnet-4-6",
       "description": "Daily dashboard refresh at 9:30am"
+    },
+    {
+      "id": "memory-graph-weekly",
+      "schedule": "0 5 * * 0",
+      "agent": "main",
+      "message": "Review the last 50 archival records via archival_search. For any that describe clear relationships between entities (person owns thing, person works at place, person has condition, etc.), add them via graph_add. Only add relationships you are confident about. Do NOT output anything to the main chat. Send summary to notify bot.",
+      "model": "anthropic/claude-sonnet-4-6",
+      "description": "Weekly: LLM-based graph triple extraction from recent archival"
     }
   ]
 }

package/index.js

@@ -323,13 +323,32 @@ export default definePluginEntry({
         const old = records[idx].content;
         records[idx].content = params.content;
         records[idx].updated_at = new Date().toISOString();
-        if (params.entity !== undefined) records[idx].entity = params.entity;
+
+        // Re-classify if entity not explicitly provided
+        if (params.entity !== undefined) {
+          records[idx].entity = params.entity;
+        } else {
+          const { classify } = await import("./lib/classifier.js");
+          const cls = await classify(params.content, wsp);
+          if (cls.entity !== "general") records[idx].entity = cls.entity;
+          records[idx].importance = cls.importance;
+          // Reuse embedding for indexing
+          if (cls.embedding) {
+            const embCache = loadEmbeddingCache(wsp);
+            embCache[params.id] = cls.embedding;
+            saveEmbeddingCache(wsp);
+          }
+        }
         if (params.tags !== undefined) records[idx].tags = params.tags;
         rewriteArchival(wsp, records);
-        const embCache = loadEmbeddingCache(wsp);
-        delete embCache[params.id];
-        saveEmbeddingCache(wsp);
-        indexEmbedding(wsp, records[idx]).catch(() => {});
+
+        // Re-embed if classify didn't already do it
+        if (params.entity !== undefined) {
+          const embCache = loadEmbeddingCache(wsp);
+          delete embCache[params.id];
+          saveEmbeddingCache(wsp);
+          indexEmbedding(wsp, records[idx]).catch(() => {});
+        }
         return text(`OK: Updated ${params.id}. Old: "${old.slice(0, 60)}..." → New: "${params.content.slice(0, 60)}..."`);
       },
     })));

package/lib/consolidate.js

@@ -4,7 +4,7 @@
  */
 
 import { loadArchival, appendRecord } from "./archival.js";
-import { loadEmbeddingCache, saveEmbeddingCache } from "./embedding.js";
+import { loadEmbeddingCache, saveEmbeddingCache, cosineSimilarity } from "./embedding.js";
 import { classify } from "./classifier.js";
 
 /** Split text into sentence-level fact candidates. */
@@ -54,6 +54,12 @@ export async function consolidateText(ws, text, defaultEntity = "", defaultTags
   const inserted = [];
   const skipped = [];
 
+  // Load embedding cache for semantic dedup
+  const embCache = loadEmbeddingCache(ws);
+  const recentEmbeddings = existing.slice(-100)
+    .map((r) => embCache[r.id])
+    .filter(Boolean);
+
   for (const fact of candidates) {
     const factLower = fact.toLowerCase();
     if (isDuplicate(factLower, existingTexts)) {
@@ -62,6 +68,17 @@ export async function consolidateText(ws, text, defaultEntity = "", defaultTags
     }
 
     const { entity, importance, embedding } = await classify(fact, ws);
+
+    // Semantic dedup: skip if cosine similarity > 0.92 with any recent record
+    if (embedding && recentEmbeddings.length > 0) {
+      const isSemDupe = recentEmbeddings.some(
+        (emb) => cosineSimilarity(embedding, emb) > 0.92,
+      );
+      if (isSemDupe) {
+        skipped.push(fact.slice(0, 60));
+        continue;
+      }
+    }
     const finalEntity = (entity !== "general") ? entity : defaultEntity || "general";
 
     const record = appendRecord(ws, {

package/lib/graph.js

@@ -1,9 +1,6 @@
 /**
  * Knowledge Graph: triple store (subject, relation, object).
- * Enables relational queries like "who is George's doctor" or "what treats 荨麻疹".
- *
- * Storage: memory/graph.jsonl — one triple per line.
- * Auto-extraction: pattern-based extraction from archival insert content.
+ * v5.1: strict extraction — only extract triples from clear, short, structured statements.
  */
 
 import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync } from "node:fs";
@@ -12,7 +9,7 @@ import { graphPath } from "./paths.js";
 
 // ─── In-memory cache ───
 
-const cache = new Map(); // ws → { triples: [], loaded: false }
+const cache = new Map();
 
 export function loadGraph(ws) {
   if (cache.has(ws) && cache.get(ws).loaded) return cache.get(ws).triples;
@@ -31,7 +28,6 @@ export function loadGraph(ws) {
 export function addTriple(ws, subject, relation, object, sourceId = null) {
   const triples = loadGraph(ws);
 
-  // Deduplicate: same subject+relation+object
   const exists = triples.some(
     (t) => t.s === subject && t.r === relation && t.o === object,
   );
@@ -61,13 +57,6 @@ export function removeTriple(ws, tripleId) {
   return true;
 }
 
-/**
- * Query the graph from a starting entity, optionally filtering by relation.
- * @param {string} entity - starting node
- * @param {string} [relation] - optional relation filter
- * @param {number} [depth=2] - traversal depth
- * @returns {Array<{ path: string[], triple: object }>}
- */
 export function queryGraph(ws, entity, relation = null, depth = 2) {
   const triples = loadGraph(ws);
   const entityLower = entity.toLowerCase();
@@ -82,16 +71,14 @@ export function queryGraph(ws, entity, relation = null, depth = 2) {
 
     const currentLower = current.toLowerCase();
     for (const t of triples) {
-      // Forward: subject matches
       if (t.s.toLowerCase() === currentLower) {
         if (relation && t.r.toLowerCase() !== relation.toLowerCase()) continue;
-        results.push({ path: [...path, `--${t.r}-->`], node: t.o, triple: t });
+        results.push({ path: [...path, `--${t.r}-->`], node: t.o, triple: { id: t.id, s: t.s, r: t.r, o: t.o } });
         traverse(t.o, currentDepth + 1, [...path, `--${t.r}-->`, t.o]);
       }
-      // Reverse: object matches
       if (t.o.toLowerCase() === currentLower) {
         if (relation && t.r.toLowerCase() !== relation.toLowerCase()) continue;
-        results.push({ path: [...path, `<--${t.r}--`], node: t.s, triple: t });
+        results.push({ path: [...path, `<--${t.r}--`], node: t.s, triple: { id: t.id, s: t.s, r: t.r, o: t.o } });
         traverse(t.s, currentDepth + 1, [...path, `<--${t.r}--`, t.s]);
       }
     }
@@ -101,45 +88,65 @@ export function queryGraph(ws, entity, relation = null, depth = 2) {
   return results;
 }
 
-// ─── Auto-extraction patterns ───
+// ─── Auto-extraction: strict patterns only ───
+
+/**
+ * Validate that a string looks like a proper entity name (not a sentence fragment).
+ * - Must be short (≤25 chars)
+ * - Must not contain markdown, code, or sentence-like patterns
+ * - Must start with a capital letter or CJK character
+ */
+function isValidEntity(s) {
+  if (!s || s.length > 25 || s.length < 2) return false;
+  // Reject markdown, code, URLs, punctuation-heavy strings
+  if (/[`*\[\]{}()|→←⚠#>]/.test(s)) return false;
+  // Reject if it looks like a sentence (has verb-like patterns or too many words)
+  if (s.split(/\s+/).length > 5) return false;
+  // Must start with uppercase, CJK, or known pattern
+  if (!/^[A-Z\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/.test(s)) return false;
+  return true;
+}
 
 const EXTRACTION_PATTERNS = [
-  // "X's doctor is Y" / "X的医生是Y"
-  { re: /(.+?)(?:'s|的)\s*(?:doctor|医生|主治医生)\s*(?:is|是|为)\s*(.+)/i, r: "has_doctor" },
-  // "X lives in Y" / "X住在Y"
-  { re: /(.+?)\s*(?:lives? in|住在|位于)\s*(.+)/i, r: "lives_in" },
-  // "X works at Y" / "X在Y工作"
-  { re: /(.+?)\s*(?:works? at|在(.+?)工作)/i, r: "works_at" },
-  // "X has condition Y" / disease / 疾病
-  { re: /(.+?)\s*(?:has|有|患有)\s*(?:chronic |慢性)?\s*(.+?(?:症|病|urticaria|condition|disease))/i, r: "has_condition" },
-  // "X treated by/takes Y" / 用药
-  { re: /(.+?)\s*(?:takes?|服用|用药|treated (?:by|with))\s*(.+)/i, r: "treated_by" },
+  // "X's doctor is Y"
+  { re: /^([A-Z]\w+)(?:'s)\s+doctor\s+is\s+(.+)$/i, r: "has_doctor" },
+  // "X's lawyer is Y"
+  { re: /^([A-Z]\w+)(?:'s)\s+(?:lawyer|attorney)\s+is\s+(.+)$/i, r: "has_lawyer" },
+  // "X lives in Y"
+  { re: /^([A-Z]\w+)\s+lives?\s+in\s+([A-Z][\w\s,]+)$/i, r: "lives_in" },
+  // "X works at Y"
+  { re: /^([A-Z]\w+)\s+works?\s+at\s+([A-Z][\w\s&.]+)$/i, r: "works_at" },
+  // "X owns Y" — only match short clear statements
+  { re: /^([A-Z]\w+)\s+owns?\s+(?:a\s+)?([A-Z][\w\s]+)$/i, r: "owns" },
+  // "X drives a Y"
+  { re: /^([A-Z]\w+)\s+drives?\s+(?:a\s+)?([A-Z][\w\s]+)$/i, r: "owns" },
+  // "X has chronic Y" / "X has Y disease/condition"
+  { re: /^([A-Z]\w+)\s+has\s+(?:chronic\s+)?(\w[\w\s]*(?:disease|condition|syndrome|urticaria|diabetes|asthma))$/i, r: "has_condition" },
+  // "X takes Y" (medication)
+  { re: /^([A-Z]\w+)\s+takes?\s+([A-Z][\w\s]+\d+\s*mg)$/i, r: "treated_by" },
+  // "X attends Y"
+  { re: /^([A-Z]\w+)\s+attends?\s+([A-Z][\w\s]+)$/i, r: "attends" },
   // "X's wife/husband is Y"
-  { re: /(.+?)(?:'s|的)\s*(wife|husband|妻子|丈夫|老婆|老公)\s*(?:is|是|为)\s*(.+)/i, r: "spouse", triple: true },
+  { re: /^([A-Z]\w+)(?:'s)\s+(?:wife|husband)\s+is\s+(.+)$/i, r: "spouse" },
   // "X's son/daughter is Y"
-  { re: /(.+?)(?:'s|的)\s*(son|daughter|儿子|女儿)\s*(?:is|是|为)\s*(.+)/i, r: "has_child", triple: true },
-  // "X costs/price Y" / 定价
-  { re: /(.+?)\s*(?:costs?|定价|售价|price[ds]?\s*(?:at)?)\s*\$?([\d,.]+)/i, r: "price" },
-  // "X's lawyer is Y"
-  { re: /(.+?)(?:'s|的)\s*(?:lawyer|律师|attorney)\s*(?:is|是|为)\s*(.+)/i, r: "has_lawyer" },
-  // "X owns Y" / 拥有
-  { re: /(.+?)\s*(?:owns?|拥有|有一辆|drives?)\s*(.+)/i, r: "owns" },
-  // "X studies/attends Y" / 就读
-  { re: /(.+?)\s*(?:attends?|studies? at|就读于?|在(.+?)(?:上学|读书))/i, r: "attends" },
+  { re: /^([A-Z]\w+)(?:'s)\s+(?:son|daughter)\s+is\s+(.+)$/i, r: "has_child" },
 ];
 
 /**
  * Extract triples from a text string.
- * @returns {Array<{ s: string, r: string, o: string }>}
+ * Strict: only matches clean, short statements with proper entity names.
  */
 export function extractTriples(text) {
   const results = [];
+  // Only try extraction on short, clear text (not paragraphs)
+  if (text.length > 150) return results;
+
   for (const pat of EXTRACTION_PATTERNS) {
     const m = text.match(pat.re);
     if (m) {
       const s = (m[1] || "").trim();
-      const o = (pat.triple ? m[3] : m[2] || "").trim();
-      if (s && o && s.length < 50 && o.length < 80) {
+      const o = (m[2] || "").trim();
+      if (isValidEntity(s) && o.length >= 2 && o.length <= 40) {
         results.push({ s, r: pat.r, o });
       }
     }

package/lib/reflection.js

@@ -9,6 +9,7 @@
 import { loadArchival } from "./archival.js";
 import { loadEpisodes } from "./episodes.js";
 import { loadGraph } from "./graph.js";
+import { readCore } from "./core.js";
 
 /**
  * Analyze recent memory for patterns and trends.
@@ -132,9 +133,27 @@ export function analyzePatterns(ws, windowDays = 7) {
       neglected_entities: neglected.slice(0, 10),
       forgetting_candidates: forgettingCandidates.length,
     },
+    // Core memory focus age check
+    stale_focus: checkStaleFocus(ws),
   };
 }
 
+/**
+ * Check if current_focus items in core memory are stale (>14 days since last update).
+ */
+function checkStaleFocus(ws) {
+  try {
+    const core = readCore(ws);
+    const updatedAt = core._meta?.updated_at;
+    if (!updatedAt) return [];
+    const daysSinceUpdate = (Date.now() - new Date(updatedAt).getTime()) / 86400000;
+    if (daysSinceUpdate > 14 && Array.isArray(core.current_focus) && core.current_focus.length > 0) {
+      return core.current_focus;
+    }
+  } catch { /* ignore */ }
+  return [];
+}
+
 /**
  * Format analysis into a human-readable report for the agent.
  */
@@ -182,6 +201,14 @@ export function formatReflection(analysis) {
     lines.push(``, `⚠️ ${analysis.health.forgetting_candidates} facts below forgetting threshold — consider archival_deduplicate or cleanup`);
   }
 
+  if (analysis.stale_focus && analysis.stale_focus.length > 0) {
+    lines.push(``, `⚠️ Core memory current_focus not updated in >14 days. Review these items:`);
+    for (const item of analysis.stale_focus) {
+      lines.push(`  - ${item}`);
+    }
+    lines.push(`  Use core_memory_replace to update or remove completed items.`);
+  }
+
   lines.push(``, `Totals: ${analysis.health.total_archival} facts, ${analysis.health.total_episodes} episodes, ${analysis.health.total_graph} graph triples`);
 
   return lines.join("\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icex-labs/openclaw-memory-engine",
-  "version": "5.1.0",
+  "version": "5.2.0",
   "description": "MemGPT-style hierarchical memory plugin for OpenClaw — core memory block + archival storage with semantic search",
   "type": "module",
   "main": "index.js",