openclaw-amem 1.3.0 → 1.4.1

package/README.md

@@ -1,21 +1,26 @@
 # openclaw-amem
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/heichaowo/amem/main/docs/public/logo.webp" width="120" alt="A-MEM Logo" />
+  <img src="https://raw.githubusercontent.com/amemhq/amem/main/docs/public/logo.webp" width="120" alt="amem logo" />
 </p>
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow?style=for-the-badge)](../../LICENSE)
 [![npm](https://img.shields.io/npm/v/openclaw-amem?style=for-the-badge&logo=npm&logoColor=white)](https://www.npmjs.com/package/openclaw-amem)
 [![arXiv](https://img.shields.io/badge/arXiv-2502.12110-b31b1b?style=for-the-badge)](https://arxiv.org/abs/2502.12110)
 
-**A-MEM agentic memory backend for [OpenClaw](https://github.com/openclaw/openclaw)** — memories **evolve**, not just accumulate.
+**Memory for [OpenClaw](https://github.com/openclaw/openclaw) agents that catches its own contradictions.**
 
-The first open-source A-MEM memory plugin for OpenClaw: dynamic graph linking, hybrid (BM25 + dense) retrieval with 2-hop graph expansion, and LLM-driven memory evolution. Backed by Qdrant + local Transformers.js. **No Python required.**
+A nightly pass re-reads what changed and flags memories that no longer agree with each other — the failure mode every long-lived memory store eventually has. The rest: facts extracted instead of transcripts stored, notes rewritten as new ones arrive, linked into a Zettelkasten-style graph, retrieved with hybrid BM25 + dense search over 2-hop expansion. Memories are scoped per agent (`owner`/`readers`/`writers`) and per subject, both enforced inside the Qdrant query rather than filtered after it.
+
+Runs on a small model — `gpt-4o-mini`, `haiku`, a local Ollama. No Python.
+
+中文走 [jieba](https://github.com/messense/node-jieba) 分词，提示词有完整中文版（`AMEM_PROMPT_LOCALE=zh`），embedding 模型本身多语言。
+
+Requires a local [Qdrant](https://qdrant.tech). Implements [A-MEM](https://arxiv.org/abs/2502.12110) (arXiv 2502.12110); the engine itself is [`@amemhq/core`](../amem-core).
 
-> 🧠 The memory **engine** lives in **[`amem-core`](../amem-core)**; this package is the thin OpenClaw plugin around it.
 > 📖 Full guides, architecture & references: **[amem.owo.lc](https://amem.owo.lc)**.
 
-⭐ Useful? [Star it on GitHub](https://github.com/heichaowo/amem).
+⭐ Useful? [Star it on GitHub](https://github.com/amemhq/amem).
 
 ## Highlights
 
@@ -26,7 +31,7 @@ The first open-source A-MEM memory plugin for OpenClaw: dynamic graph linking, h
 - 🔐 **Per-agent isolation** — private by default; explicit `owner`/`readers`/`writers`; Mode A (shared collection) or Mode B (dedicated collection).
 - 🀄 **Chinese-optimized** & local embeddings (Transformers.js, 384-dim) — no Python, no external embedding API.
 
-→ Full feature list & internals: **[amem-core README](../amem-core)** · **[docs](https://amem.owo.lc)**.
+→ Full feature list & internals: **[@amemhq/core README](../amem-core)** · **[docs](https://amem.owo.lc)**.
 
 ## Requirements
 
@@ -41,7 +46,7 @@ The first open-source A-MEM memory plugin for OpenClaw: dynamic graph linking, h
 
 ```bash
 # From ClawHub (recommended)
-openclaw plugins install clawhub:@heichaowo/openclaw-amem
+openclaw plugins install clawhub:openclaw-amem
 
 # From npm
 openclaw plugins install openclaw-amem
@@ -136,7 +141,7 @@ pnpm --filter openclaw-amem test    # vitest (needs Qdrant on :6333)
 
 ## Docs & References
 
-Full guides, architecture, and academic references: **[amem.owo.lc](https://amem.owo.lc)** · engine: **[amem-core](../amem-core)** · paper: [A-MEM (arXiv:2502.12110)](https://arxiv.org/abs/2502.12110).
+Full guides, architecture, and academic references: **[amem.owo.lc](https://amem.owo.lc)** · engine: **[@amemhq/core](../amem-core)** · paper: [A-MEM (arXiv:2502.12110)](https://arxiv.org/abs/2502.12110).
 
 ## License
 

package/dist/index.js

@@ -53,17 +53,29 @@ var init_config = __esm({
 });
 
 // ../amem-core/src/embedding.ts
+function getEmbeddingModel() {
+  return process.env.AMEM_EMBED_MODEL?.trim() || DEFAULT_EMBEDDING_MODEL;
+}
 async function getExtractor() {
-  if (extractor) return extractor;
+  const wanted = getEmbeddingModel();
+  if (extractor && loadedModelName === wanted) return extractor;
   if (!pipeline) {
     const mod = await import("@huggingface/transformers");
     pipeline = mod.pipeline;
   }
-  extractor = await pipeline("feature-extraction", MODEL_NAME, {
+  extractor = await pipeline("feature-extraction", wanted, {
     revision: "main"
   });
+  loadedModelName = wanted;
+  cachedDim = null;
   return extractor;
 }
+async function getEmbeddingDim() {
+  if (cachedDim !== null && loadedModelName === getEmbeddingModel()) return cachedDim;
+  const probe = await encode("dimension probe");
+  cachedDim = probe.length;
+  return cachedDim;
+}
 function meanPoolingNormalize(output, attentionMask) {
   const seqLen = output.length;
   const dim = output[0].length;
@@ -117,13 +129,15 @@ function cosineSimilarity(a, b) {
   for (let i = 0; i < a.length; i++) dot += a[i] * b[i];
   return dot;
 }
-var pipeline, extractor, MODEL_NAME;
+var pipeline, extractor, loadedModelName, cachedDim, DEFAULT_EMBEDDING_MODEL;
 var init_embedding = __esm({
   "../amem-core/src/embedding.ts"() {
     "use strict";
     pipeline = null;
     extractor = null;
-    MODEL_NAME = "Xenova/paraphrase-multilingual-MiniLM-L12-v2";
+    loadedModelName = null;
+    cachedDim = null;
+    DEFAULT_EMBEDDING_MODEL = "Xenova/paraphrase-multilingual-MiniLM-L12-v2";
   }
 });
 
@@ -168,15 +182,26 @@ async function ensureCollection(collectionName) {
     if (collectionName) _collectionReadyMap.set(col, true);
     else _collectionReady = true;
   };
+  let existing = null;
   try {
-    await qdrant("GET", `/collections/${col}`);
+    existing = await qdrant("GET", `/collections/${col}`);
+  } catch {
+  }
+  if (existing) {
+    const collectionDim = existing.config?.params?.vectors?.size;
+    if (typeof collectionDim === "number") {
+      const modelDim = await getEmbeddingDim();
+      if (collectionDim !== modelDim) {
+        throw new EmbeddingDimensionMismatchError(col, collectionDim, modelDim, getEmbeddingModel());
+      }
+    }
     markReady();
     return;
-  } catch {
   }
   try {
+    const size = await getEmbeddingDim();
     await qdrant("PUT", `/collections/${col}`, {
-      vectors: { size: VECTOR_DIM, distance: "Cosine" }
+      vectors: { size, distance: "Cosine" }
     });
   } catch (err) {
     if (!(err instanceof Error) || !err.message.includes("already exists")) throw err;
@@ -199,6 +224,40 @@ async function ensureCollection(collectionName) {
   });
   markReady();
 }
+async function scrollAllRaw(collection, limit = 1e4) {
+  const out = [];
+  let offset = void 0;
+  for (; ; ) {
+    const body = { with_payload: true, with_vector: true, limit };
+    if (offset !== void 0 && offset !== null) body.offset = offset;
+    const res = await qdrant("POST", `/collections/${collection}/points/scroll`, body);
+    out.push(...res.points);
+    offset = res.next_page_offset;
+    if (offset === void 0 || offset === null || res.points.length === 0) break;
+  }
+  return out;
+}
+async function countPointsRaw(collection) {
+  const res = await qdrant("POST", `/collections/${collection}/points/count`, { exact: true });
+  return res.count;
+}
+async function collectionDimRaw(collection) {
+  try {
+    const info = await qdrant("GET", `/collections/${collection}`);
+    return info.config?.params?.vectors?.size ?? null;
+  } catch {
+    return null;
+  }
+}
+async function createCollectionRaw(collection, size) {
+  await qdrant("PUT", `/collections/${collection}`, { vectors: { size, distance: "Cosine" } });
+  for (const field_name of ["agent_id", "hash", "topics", "subjects"]) {
+    await qdrant("PUT", `/collections/${collection}/index`, { field_name, field_schema: "keyword" });
+  }
+}
+async function upsertPointsRaw(collection, points) {
+  await qdrant("PUT", `/collections/${collection}/points?wait=true`, { points });
+}
 function noteToPoint(note) {
   return {
     id: note.id,
@@ -231,6 +290,7 @@ function noteToPoint(note) {
       conflict: note.conflict ?? false,
       conflicts_with: note.conflicts_with ?? [],
       conflict_reason: note.conflict_reason ?? "",
+      conflict_scanned_at: note.conflict_scanned_at ?? "",
       subjects: note.subjects ?? [],
       // 31
       ephemeral: note.ephemeral ?? false,
@@ -286,6 +346,7 @@ function pointToNote(point) {
     conflict: p.conflict === true,
     conflicts_with: Array.isArray(p.conflicts_with) ? p.conflicts_with.filter((v) => typeof v === "string") : [],
     conflict_reason: typeof p.conflict_reason === "string" ? p.conflict_reason : "",
+    conflict_scanned_at: typeof p.conflict_scanned_at === "string" ? p.conflict_scanned_at : "",
     subjects: Array.isArray(p.subjects) ? p.subjects.filter((v) => typeof v === "string") : [],
     // 31
     ephemeral: p.ephemeral === true,
@@ -582,14 +643,31 @@ async function invalidateNote(id, callerAgentId) {
 async function patchNotePayload(id, fields) {
   return makeCrud(getCollection()).patchNotePayload(id, fields);
 }
-var QDRANT_URL, getCollection, VECTOR_DIM, _collectionReady, _collectionReadyMap;
+var QDRANT_URL, getCollection, EmbeddingDimensionMismatchError, _collectionReady, _collectionReadyMap;
 var init_storage = __esm({
   "../amem-core/src/storage.ts"() {
     "use strict";
     init_auth();
+    init_embedding();
     QDRANT_URL = "http://localhost:6333";
     getCollection = () => process.env.AMEM_COLLECTION || "amem_notes";
-    VECTOR_DIM = 384;
+    EmbeddingDimensionMismatchError = class extends Error {
+      constructor(collection, collectionDim, modelDim, model) {
+        super(
+          `Collection "${collection}" stores ${collectionDim}-dimension vectors, but the embedding model "${model}" produces ${modelDim}. Qdrant fixes a collection's vector size at creation and cannot change it, so writes and searches would both fail.
+Either set AMEM_EMBED_MODEL back to the model this collection was built with, or migrate: build a new collection with the new model, backfill it, then point AMEM_COLLECTION at it. See docs/reference/embedding-models.md.`
+        );
+        this.collection = collection;
+        this.collectionDim = collectionDim;
+        this.modelDim = modelDim;
+        this.model = model;
+        this.name = "EmbeddingDimensionMismatchError";
+      }
+      collection;
+      collectionDim;
+      modelDim;
+      model;
+    };
     _collectionReady = false;
     _collectionReadyMap = /* @__PURE__ */ new Map();
   }
@@ -1907,6 +1985,7 @@ function resolveConflictMode(override) {
 }
 async function conflictSweep(agentId, opts) {
   const ctx = opts?.storageCtx ?? defaultCtx();
+  const force = opts?.force === true;
   const mode = resolveConflictMode(opts?.mode);
   const log = opts?.logger?.info ?? ((m) => console.log(m));
   const raw = await ctx.listNotes(agentId);
@@ -1919,10 +1998,18 @@ async function conflictSweep(agentId, opts) {
   }
   let pairsFound = 0;
   let retired = 0;
+  let batchesScanned = 0;
+  let batchesSkipped = 0;
   for (const [category, groupNotes] of groups.entries()) {
+    groupNotes.sort((a, b) => Date.parse(b.timestamp) - Date.parse(a.timestamp));
     for (let start = 0; start < groupNotes.length; start += CONFLICT_BATCH_SIZE) {
       const batch = groupNotes.slice(start, start + CONFLICT_BATCH_SIZE);
       if (batch.length < 2) continue;
+      if (!force && batch.every((n) => n.conflict_scanned_at)) {
+        batchesSkipped++;
+        continue;
+      }
+      batchesScanned++;
       const pairs = await llmConflictScan(batch.map((n) => n.content));
       for (const { a, b, reason, supersededIndex } of pairs) {
         const noteA = batch[a];
@@ -1955,10 +2042,16 @@ async function conflictSweep(agentId, opts) {
           }
         }
       }
+      const scannedAt = (/* @__PURE__ */ new Date()).toISOString();
+      for (const n of batch) {
+        await ctx.patchNotePayload(n.id, { conflict_scanned_at: scannedAt });
+      }
     }
   }
-  log(`[conflict] scanned ${notes.length} notes, found ${pairsFound} pair(s), retired ${retired}`);
-  return { scanned: notes.length, pairsFound, retired };
+  log(
+    `[conflict] ${batchesScanned} batch(es) scanned, ${batchesSkipped} already up to date; ${pairsFound} pair(s) found, ${retired} retired`
+  );
+  return { scanned: notes.length, pairsFound, retired, batchesScanned, batchesSkipped };
 }
 var import_uuid, import_crypto, fs2, path3, import_jieba, logSafe, _jieba, EPHEMERAL_SIGNALS, CONFLICT_BATCH_SIZE;
 var init_memory = __esm({
@@ -2073,7 +2166,7 @@ async function generateReviewBatch(agentId, outputPath) {
   const title = LOCALE2 === "zh" ? "A-MEM \u8D28\u91CF\u5BA1\u6838" : "A-MEM Quality Review";
   const genLabel = LOCALE2 === "zh" ? "\u751F\u6210\u65F6\u95F4" : "Generated";
   const countLabel = LOCALE2 === "zh" ? `\u5171 ${items.length} \u6761\u4F4E\u8D28\u91CF\u6761\u76EE` : `${items.length} low-quality item(s)`;
-  const applyHint = LOCALE2 === "zh" ? "\u9009\u597D\u540E\u53EF\u4F7F\u7528 memory_quality_apply \u6279\u91CF\u5904\u7406" : "Use memory_quality_apply to batch-process selected items";
+  const applyHint = LOCALE2 === "zh" ? "\u52FE\u9009\u540E\u4EA4\u7ED9\u52A9\u624B\u5904\u7406\u8FD9\u4E9B\u6761\u76EE" : "Tick your choices, then ask the assistant to act on them";
   lines.push(`# ${title} \u2014 Batch ${batchN || "custom"}`);
   lines.push("");
   lines.push(`> ${genLabel}\uFF1A${now} | ${countLabel}`);
@@ -2172,6 +2265,93 @@ var init_quality = __esm({
   }
 });
 
+// ../amem-core/src/migrate.ts
+function missingDerivedFields(n) {
+  return n.keywords.length === 0 || n.tags.length === 0;
+}
+async function migrateCollection(opts) {
+  const { from, to } = opts;
+  const refreshFields = opts.refreshFields !== false;
+  const dryRun = opts.dryRun !== false;
+  const log = opts.logger?.info ?? ((m) => console.log(m));
+  const warn = opts.logger?.warn ?? ((m) => console.warn(m));
+  if (from === to) throw new Error(`migrate: source and target are the same collection ("${from}")`);
+  const model = getEmbeddingModel();
+  const targetDim = await getEmbeddingDim();
+  const sourceDim = await collectionDimRaw(from);
+  if (sourceDim === null) throw new Error(`migrate: source collection "${from}" does not exist`);
+  const points = await scrollAllRaw(from);
+  const notes = points.map(pointToNote);
+  const missingDerived = notes.filter(missingDerivedFields).length;
+  log(
+    `[migrate] ${from} (${sourceDim}d, ${notes.length} notes) \u2192 ${to} (${targetDim}d, ${model}); ${missingDerived} note(s) missing keywords/tags`
+  );
+  if (dryRun) {
+    log("[migrate] dry run \u2014 nothing written. Pass dryRun: false to apply.");
+    return { total: notes.length, missingDerived, refreshed: 0, migrated: 0, sourceDim, targetDim, model, dryRun: true };
+  }
+  const existingTargetDim = await collectionDimRaw(to);
+  if (existingTargetDim === null) {
+    await createCollectionRaw(to, targetDim);
+    log(`[migrate] created ${to} at ${targetDim}d`);
+  } else {
+    if (existingTargetDim !== targetDim) {
+      throw new Error(`migrate: target "${to}" exists at ${existingTargetDim}d but the model produces ${targetDim}d`);
+    }
+    const existingCount = await countPointsRaw(to);
+    if (existingCount > 0) {
+      throw new Error(`migrate: target "${to}" already holds ${existingCount} point(s); use an empty collection`);
+    }
+  }
+  let refreshed = 0;
+  let migrated = 0;
+  const BATCH = 64;
+  let buffer = [];
+  const flush = async () => {
+    if (!buffer.length) return;
+    await upsertPointsRaw(to, buffer);
+    migrated += buffer.length;
+    buffer = [];
+  };
+  for (const note of notes) {
+    if (refreshFields && missingDerivedFields(note)) {
+      try {
+        const built = await llmConstructNote(note.content);
+        if (note.keywords.length === 0) note.keywords = built.keywords;
+        if (note.tags.length === 0) note.tags = built.tags;
+        if (!note.context) note.context = built.context;
+        refreshed++;
+      } catch (e) {
+        warn(`[migrate] re-extract failed for ${note.id.slice(0, 8)} \u2014 keeping as-is: ${e.message}`);
+      }
+    }
+    const point = noteToPoint({ ...note, embedding: await encode(buildEmbedText(note)) });
+    buffer.push(point);
+    if (buffer.length >= BATCH) {
+      await flush();
+      log(`[migrate] ${migrated}/${notes.length}`);
+    }
+  }
+  await flush();
+  const finalCount = await countPointsRaw(to);
+  if (finalCount !== notes.length) {
+    warn(`[migrate] target holds ${finalCount} point(s) but the source had ${notes.length} \u2014 check before switching`);
+  }
+  log(
+    `[migrate] done: ${migrated} migrated, ${refreshed} re-extracted. "${from}" is untouched \u2014 switch with AMEM_COLLECTION=${to}, and keep the old one until you are satisfied.`
+  );
+  return { total: notes.length, missingDerived, refreshed, migrated, sourceDim, targetDim, model, dryRun: false };
+}
+var init_migrate = __esm({
+  "../amem-core/src/migrate.ts"() {
+    "use strict";
+    init_storage();
+    init_embedding();
+    init_llm();
+    init_memory();
+  }
+});
+
 // ../amem-core/src/crud-guard.ts
 function resolveCrudUpdateMinSim(override) {
   const envVal = Number(process.env.AMEM_CRUD_UPDATE_MIN_SIM);
@@ -2197,6 +2377,8 @@ var init_crud_guard = __esm({
 var src_exports = {};
 __export(src_exports, {
   DEFAULT_CRUD_UPDATE_MIN_SIM: () => DEFAULT_CRUD_UPDATE_MIN_SIM,
+  DEFAULT_EMBEDDING_MODEL: () => DEFAULT_EMBEDDING_MODEL,
+  EmbeddingDimensionMismatchError: () => EmbeddingDimensionMismatchError,
   addEpisodic: () => addEpisodic,
   addMemory: () => addMemory,
   canRead: () => canRead,
@@ -2211,6 +2393,8 @@ __export(src_exports, {
   encode: () => encode,
   ensureCollection: () => ensureCollection,
   generateReviewBatch: () => generateReviewBatch,
+  getEmbeddingDim: () => getEmbeddingDim,
+  getEmbeddingModel: () => getEmbeddingModel,
   getNote: () => getNote,
   invalidateNote: () => invalidateNote,
   isModelLoaded: () => isModelLoaded,
@@ -2220,6 +2404,7 @@ __export(src_exports, {
   llmCrudDecision: () => llmCrudDecision,
   loadModel: () => loadModel,
   mergeSimilarNotes: () => mergeSimilarNotes,
+  migrateCollection: () => migrateCollection,
   patchNotePayload: () => patchNotePayload,
   pingQdrant: () => pingQdrant,
   resolveCrudUpdateMinSim: () => resolveCrudUpdateMinSim,
@@ -2236,6 +2421,9 @@ var init_src = __esm({
     init_quality();
     init_storage();
     init_auth();
+    init_embedding();
+    init_storage();
+    init_migrate();
     init_memory();
     init_crud_guard();
     init_llm();
@@ -2329,6 +2517,7 @@ function register(api) {
       }
     });
   }
+  const conflictSweepEnabled = pluginConfig.conflictSweep !== false;
   const crudUpdateMinSim = pluginConfig.crudUpdateMinSim;
   const resolveAgentId2 = (ctx) => resolveAgentId(ctx, pluginConfig);
   const buildScope2 = (rawAgentId) => buildScope(rawAgentId, pluginConfig, createStorageContext);
@@ -2337,9 +2526,13 @@ function register(api) {
   logger.info(
     `openclaw-amem: registered (native TS, Qdrant, default agent_id=${defaultScope.agentId}, default collection=${pluginConfig.collection ?? "amem_notes (default)"}, per-agent scope resolved per call)`
   );
-  ensureCollection(pluginConfig.collection).catch(
-    (e) => logger.warn(`openclaw-amem: ensureCollection failed \u2014 ${e.message}`)
-  );
+  ensureCollection(pluginConfig.collection).catch((e) => {
+    if (e instanceof EmbeddingDimensionMismatchError) {
+      logger.error(`openclaw-amem: memory is UNUSABLE \u2014 ${e.message}`);
+    } else {
+      logger.warn(`openclaw-amem: ensureCollection failed \u2014 ${e.message}`);
+    }
+  });
   if (typeof api.registerMemoryCapability === "function") {
     api.registerMemoryCapability({
       publicArtifacts: {
@@ -2753,6 +2946,21 @@ ${mergeErr.stack}`
       } catch (err) {
         logger.warn(`openclaw-amem: Scheduled daily consolidation failed \u2014 ${err.message}`);
       }
+      if (conflictSweepEnabled) {
+        try {
+          const res = await conflictSweep(defaultScope.agentId, {
+            storageCtx: defaultScope.storageCtx,
+            logger
+          });
+          if (res.pairsFound > 0) {
+            logger.info(
+              `openclaw-amem: Contradiction sweep flagged ${res.pairsFound} pair(s)` + (res.retired > 0 ? `, retired ${res.retired}` : "") + ` (${res.batchesScanned} batch(es) read, ${res.batchesSkipped} unchanged).`
+            );
+          }
+        } catch (err) {
+          logger.warn(`openclaw-amem: Scheduled contradiction sweep failed \u2014 ${err.message}`);
+        }
+      }
       scheduleNextRun();
     }, delay);
   }
@@ -2773,8 +2981,8 @@ ${mergeErr.stack}`
 }
 var plugin = (0, import_plugin_entry.definePluginEntry)({
   id: "openclaw-amem",
-  name: "Memory (A-MEM v2)",
-  description: "A-MEM agentic memory backend for OpenClaw \u2014 Qdrant + Transformers.js, no Python required.",
+  name: "amem",
+  description: "Agentic memory for OpenClaw \u2014 memories evolve, link into a graph, and stay separated per agent and per person.",
   register
 });
 var index_default = plugin;

package/openclaw.plugin.json

@@ -1,8 +1,8 @@
 {
   "id": "openclaw-amem",
-  "name": "Memory (A-MEM v2)",
-  "description": "OpenClaw memory plugin implementing A-MEM — memories evolve, not just accumulate. Graph linking, hybrid retrieval, LLM-driven evolution. No Python.",
-  "version": "1.3.0",
+  "name": "amem",
+  "description": "Catches memories that contradict each other. Notes rewrite themselves as new ones arrive, link into a graph, and stay separated per agent and per person. Runs on a small model. Requires a local Qdrant. 中文走 jieba 分词，提示词有中文版。",
+  "version": "1.4.1",
   "kind": "memory",
   "openclaw": {
     "compat": {
@@ -38,6 +38,7 @@
           "AMEM_CONFLICT_MODE",
           "AMEM_LLM_TIMEOUT",
           "AMEM_CRUD_UPDATE_MIN_SIM",
+          "AMEM_EMBED_MODEL",
           "AMEM_COLLECTION",
           "AMEM_DATA_DIR",
           "AMEM_EVO_COUNTER_PATH",
@@ -139,6 +140,11 @@
         "default": "fast",
         "description": "Which tier the agent_end CRUD decision runs on. Defaults to fast: it runs every turn, and its destructive failure mode is handled by the update guard rather than by model tier. Overridden by AMEM_LLM_CRUD_ROLE."
       },
+      "conflictSweep": {
+        "type": "boolean",
+        "default": true,
+        "description": "Run the nightly contradiction sweep after daily consolidation. Only batches that gained a memory are re-read, so a typical night costs one or two LLM calls. Set false to disable."
+      },
       "crudUpdateMinSim": {
         "type": "number",
         "default": 0.35,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "openclaw-amem",
-  "version": "1.3.0",
-  "description": "OpenClaw memory plugin implementing A-MEM — memories evolve, not just accumulate. Graph linking, hybrid retrieval, LLM-driven evolution. No Python.",
+  "version": "1.4.1",
+  "description": "Catches memories that contradict each other. Notes rewrite themselves as new ones arrive, link into a graph, and stay separated per agent and per person. Runs on a small model. Requires a local Qdrant. 中文走 jieba 分词，提示词有中文版。",
   "license": "MIT",
   "main": "dist/index.js",
   "openclaw": {
@@ -20,13 +20,13 @@
     "@huggingface/transformers": "^4.2.0",
     "@node-rs/jieba": "^2.0.1",
     "@qdrant/js-client-rest": "^1.18.0",
-    "@types/uuid": "^11.0.0",
     "openai": "^6.48.0",
     "uuid": "^14.0.0"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/node": "^26.1.1",
+    "@types/uuid": "^11.0.0",
     "eslint": "^10.7.0",
     "prettier": "^3.9.5",
     "tsup": "^8.4.0",
@@ -41,16 +41,17 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/heichaowo/amem.git",
+    "url": "git+https://github.com/amemhq/amem.git",
     "directory": "packages/openclaw-amem"
   },
   "homepage": "https://amem.owo.lc",
   "bugs": {
-    "url": "https://github.com/heichaowo/amem/issues"
+    "url": "https://github.com/amemhq/amem/issues"
   },
   "keywords": [
     "openclaw",
     "openclaw-plugin",
+    "amem",
     "a-mem",
     "agent-memory",
     "agentic-memory",