@icex-labs/openclaw-memory-engine 5.2.1 → 5.3.0

package/index.js

@@ -147,16 +147,8 @@ export default definePluginEntry({
       } catch { /* don't break message flow */ }
     }, { name: "memory-engine-capture-received", description: "Auto-capture facts from incoming messages" });
 
-    api.registerHook("message:sent", (event) => {
-      try {
-        const ctx = event.context;
-        if (!ctx?.content || !ctx?.success) return;
-        if (ctx.content.length < 50) return;
-        const agentId = extractAgentId(event.sessionKey);
-        const wsDir = resolveWorkspace({ agentId });
-        captureMessage(wsDir, ctx.content, "agent-reply");
-      } catch { /* don't break message flow */ }
-    }, { name: "memory-engine-capture-sent", description: "Auto-capture facts from agent replies" });
+    // message:sent hook removed — agent replies are restatements, not new facts.
+    // Only user messages (message:received) are auto-captured.
 
     // ─── core_memory_read ───
     api.registerTool(withAgent((agentId) => ({

package/lib/dedup.js

@@ -1,22 +1,45 @@
 /**
  * Deduplication via embedding cosine similarity.
+ * v5.2: smarter dedup — ignores records with different numbers/dates/IDs.
  */
 
 import { loadArchival, rewriteArchival } from "./archival.js";
 import {
   loadEmbeddingCache, saveEmbeddingCache, getEmbedding, cosineSimilarity,
 } from "./embedding.js";
-import { DEDUP_SIMILARITY_THRESHOLD } from "./paths.js";
+
+// Raised from 0.92 to 0.96 — fewer false positives
+const DEDUP_THRESHOLD = 0.96;
+
+/**
+ * Extract numbers, dates, and IDs from text for comparison.
+ * Two records with different numbers are NOT duplicates even if semantically similar.
+ */
+function extractIdentifiers(text) {
+  const numbers = (text.match(/\$?[\d,.]+%?/g) || []).map((n) => n.replace(/[,$]/g, ""));
+  const dates = text.match(/\d{4}-\d{2}-\d{2}/g) || [];
+  const ids = text.match(/#\d+|PR\s*#?\d+|U\d{5,}|IMM-\d+/gi) || [];
+  return [...numbers, ...dates, ...ids].map((s) => s.toLowerCase());
+}
+
+function hasDifferentIdentifiers(a, b) {
+  const idsA = extractIdentifiers(a);
+  const idsB = extractIdentifiers(b);
+  if (idsA.length === 0 || idsB.length === 0) return false;
+  // If both have identifiers but they differ → not duplicates
+  const setA = new Set(idsA);
+  const setB = new Set(idsB);
+  const overlap = [...setA].filter((x) => setB.has(x)).length;
+  return overlap === 0 && idsA.length > 0 && idsB.length > 0;
+}
 
 /**
  * Find near-duplicate pairs in archival memory.
- * @returns {Array<{ keep: object, drop: object, similarity: number }>}
  */
 export async function findDuplicates(ws) {
   const records = loadArchival(ws);
   const embCache = loadEmbeddingCache(ws);
 
-  // Build missing embeddings
   for (const r of records) {
     if (!embCache[r.id]) {
       const emb = await getEmbedding(
@@ -27,7 +50,6 @@ export async function findDuplicates(ws) {
   }
   saveEmbeddingCache(ws);
 
-  // O(n²) pairwise comparison
   const dupes = [];
   for (let i = 0; i < records.length; i++) {
     for (let j = i + 1; j < records.length; j++) {
@@ -35,16 +57,19 @@ export async function findDuplicates(ws) {
       const embB = embCache[records[j].id];
       if (!embA || !embB) continue;
       const sim = cosineSimilarity(embA, embB);
-      if (sim >= DEDUP_SIMILARITY_THRESHOLD) {
-        const keepIdx =
-          (records[j].access_count || 0) >= (records[i].access_count || 0) ? j : i;
-        const dropIdx = keepIdx === i ? j : i;
-        dupes.push({
-          keep: records[keepIdx],
-          drop: records[dropIdx],
-          similarity: Math.round(sim * 1000) / 1000,
-        });
-      }
+      if (sim < DEDUP_THRESHOLD) continue;
+
+      // Smart check: if records contain different numbers/dates/IDs, skip
+      if (hasDifferentIdentifiers(records[i].content, records[j].content)) continue;
+
+      const keepIdx =
+        (records[j].access_count || 0) >= (records[i].access_count || 0) ? j : i;
+      const dropIdx = keepIdx === i ? j : i;
+      dupes.push({
+        keep: records[keepIdx],
+        drop: records[dropIdx],
+        similarity: Math.round(sim * 1000) / 1000,
+      });
     }
   }
   return dupes;
@@ -52,7 +77,6 @@ export async function findDuplicates(ws) {
 
 /**
  * Remove duplicate records from archival.
- * @returns {{ removed: number, remaining: number }}
  */
 export function applyDedup(ws, dupes) {
   const records = loadArchival(ws);

package/lib/graph.js

@@ -28,11 +28,17 @@ export function loadGraph(ws) {
 export function addTriple(ws, subject, relation, object, sourceId = null) {
   const triples = loadGraph(ws);
 
+  // Case-insensitive dedup to prevent "Edmonton" vs "edmonton" duplicates
   const exists = triples.some(
-    (t) => t.s === subject && t.r === relation && t.o === object,
+    (t) => t.s.toLowerCase() === subject.toLowerCase() &&
+           t.r.toLowerCase() === relation.toLowerCase() &&
+           t.o.toLowerCase() === object.toLowerCase(),
   );
   if (exists) return null;
 
+  // Reject if subject or object is too long (garbage prevention)
+  if (subject.length > 30 || object.length > 40) return null;
+
   const triple = {
     id: `tri-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
     s: subject,

package/lib/paths.js

@@ -9,7 +9,7 @@ export const DEFAULT_TOP_K = 5;
 export const MAX_TOP_K = 20;
 export const EMBEDDING_MODEL = "text-embedding-3-small";
 export const EMBEDDING_DIM = 512;
-export const DEDUP_SIMILARITY_THRESHOLD = 0.92;
+export const DEDUP_SIMILARITY_THRESHOLD = 0.96; // raised from 0.92 to reduce false positives
 
 import { readFileSync as _readFileSync, existsSync as _existsSync } from "node:fs";
 

package/package.json

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