openclaw-amem 1.2.2 → 1.4.0

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,28 @@ 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";
+  }
+});
+
+// ../amem-core/src/auth.ts
+function canWrite(note, callerAgentId) {
+  return note.owner === callerAgentId || note.writers.includes(callerAgentId) || note.writers.includes("*");
+}
+function canRead(note, callerAgentId) {
+  return note.owner === callerAgentId || note.readers.includes(callerAgentId) || note.readers.includes("*");
+}
+var init_auth = __esm({
+  "../amem-core/src/auth.ts"() {
+    "use strict";
   }
 });
 
@@ -155,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;
@@ -180,8 +218,46 @@ async function ensureCollection(collectionName) {
     field_name: "topics",
     field_schema: "keyword"
   });
+  await qdrant("PUT", `/collections/${col}/index`, {
+    field_name: "subjects",
+    field_schema: "keyword"
+  });
   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,
@@ -212,6 +288,10 @@ function noteToPoint(note) {
       // 30
       evolution_type: note.evolution_type || "",
       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,
       low_quality: note.low_quality ?? false,
@@ -264,6 +344,10 @@ function pointToNote(point) {
     // 30
     evolution_type: typeof p.evolution_type === "string" && ["EVOLVE", "CONFLICT", "EXPAND", "NEW"].includes(p.evolution_type) ? p.evolution_type : void 0,
     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,
     low_quality: p.low_quality === true,
@@ -273,28 +357,41 @@ function pointToNote(point) {
     writers: Array.isArray(p.writers) ? p.writers : [p.agent_id || "main"]
   };
 }
-function agentFilter(agentId) {
+function agentFilter(agentId, subject) {
+  const must = [
+    {
+      should: [
+        { key: "agent_id", match: { value: agentId } },
+        { key: "agent_id", match: { value: "shared" } }
+      ]
+    }
+  ];
+  if (subject !== void 0) {
+    must.push({
+      should: [{ key: "subjects", match: { value: subject } }, { is_empty: { key: "subjects" } }]
+    });
+  }
   return {
-    must: [
-      {
-        should: [
-          { key: "agent_id", match: { value: agentId } },
-          { key: "agent_id", match: { value: "shared" } }
-        ]
-      }
-    ],
+    must,
     must_not: [{ key: "is_active", match: { value: false } }]
   };
 }
 function makeCrud(collectionName, modeBIsolated = false) {
   const col = collectionName;
-  function scopedAgentFilter(agentId) {
+  function scopedAgentFilter(agentId, subject) {
     if (modeBIsolated) {
+      const must = [];
+      if (subject !== void 0) {
+        must.push({
+          should: [{ key: "subjects", match: { value: subject } }, { is_empty: { key: "subjects" } }]
+        });
+      }
       return {
+        ...must.length > 0 && { must },
         must_not: [{ key: "is_active", match: { value: false } }]
       };
     }
-    return agentFilter(agentId);
+    return agentFilter(agentId, subject);
   }
   return {
     async addNote(note) {
@@ -303,7 +400,14 @@ function makeCrud(collectionName, modeBIsolated = false) {
         points: [noteToPoint(note)]
       });
     },
-    async getNote(id) {
+    /**
+     * Story 36: this is the one read that bypasses the agent filter — it fetches
+     * straight by UUID. Pass `readerAgentId` to enforce `readers`; an unreadable
+     * note comes back as `null` (indistinguishable from missing, so nothing leaks,
+     * and callers already handle null). Omitting it skips the check, preserving
+     * behaviour for internal callers that only ever hold their own ids.
+     */
+    async getNote(id, readerAgentId) {
       await ensureCollection(col);
       try {
         const result = await qdrant("POST", `/collections/${col}/points`, {
@@ -312,7 +416,9 @@ function makeCrud(collectionName, modeBIsolated = false) {
           with_vector: true
         });
         if (!result.length) return null;
-        return pointToNote(result[0]);
+        const note = pointToNote(result[0]);
+        if (readerAgentId !== void 0 && !canRead(note, readerAgentId)) return null;
+        return note;
       } catch {
         return null;
       }
@@ -348,17 +454,48 @@ function makeCrud(collectionName, modeBIsolated = false) {
       if (!result.points.length) return null;
       return pointToNote(result.points[0]);
     },
-    async updateNoteContent(id, content, embedding, hash) {
+    /**
+     * Story 33: pass `callerAgentId` to enforce the writers policy. Callers that
+     * hold the note already should prefer checking `canWrite` themselves; this
+     * fetch-then-check path exists for callers that only have an id (the plugin's
+     * CRUD hook). Returns false — without writing — when the caller may not write.
+     * Omitting `callerAgentId` skips the check, preserving existing behaviour for
+     * internal callers that are already scoped to their own notes.
+     */
+    async updateNoteContent(id, content, embedding, hash, callerAgentId) {
       await ensureCollection(col);
+      let existing = null;
+      if (callerAgentId !== void 0) {
+        existing = await this.getNote(id);
+        if (existing && !canWrite(existing, callerAgentId)) return false;
+      }
       await qdrant("PUT", `/collections/${col}/points/vectors?wait=true`, {
         points: [{ id, vector: embedding }]
       });
+      const payload = { content, hash };
+      if (existing) {
+        const history = [
+          ...existing.evolution_history ?? [],
+          {
+            triggeredBy: "",
+            triggeredAt: (/* @__PURE__ */ new Date()).toISOString(),
+            oldContext: existing.context,
+            newContext: existing.context,
+            oldTags: existing.tags,
+            newTags: existing.tags,
+            action: "crud_update",
+            oldContent: existing.content
+          }
+        ];
+        payload.evolution_history = JSON.stringify(history);
+      }
       await qdrant("POST", `/collections/${col}/points/payload?wait=true`, {
-        payload: { content, hash },
+        payload,
         points: [id]
       });
+      return true;
     },
-    async queryByEmbedding(embedding, topK, agentId, scoreThreshold = 0) {
+    async queryByEmbedding(embedding, topK, agentId, scoreThreshold = 0, subject) {
       await ensureCollection(col);
       const result = await qdrant("POST", `/collections/${col}/points/search`, {
         vector: embedding,
@@ -366,7 +503,7 @@ function makeCrud(collectionName, modeBIsolated = false) {
         with_payload: true,
         with_vector: true,
         score_threshold: scoreThreshold,
-        filter: scopedAgentFilter(agentId)
+        filter: scopedAgentFilter(agentId, subject)
       });
       const queryResults = result.map((r) => ({
         note: pointToNote(r),
@@ -400,14 +537,14 @@ function makeCrud(collectionName, modeBIsolated = false) {
       }
       return queryResults;
     },
-    async listNotes(agentId) {
+    async listNotes(agentId, subject) {
       await ensureCollection(col);
       const body = {
         with_payload: true,
         with_vector: true,
         limit: 1e4
       };
-      if (agentId) body.filter = scopedAgentFilter(agentId);
+      if (agentId) body.filter = scopedAgentFilter(agentId, subject);
       const result = await qdrant("POST", `/collections/${col}/points/scroll`, body);
       return result.points.map(pointToNote);
     },
@@ -417,12 +554,18 @@ function makeCrud(collectionName, modeBIsolated = false) {
         points: [id]
       });
     },
-    async invalidateNote(id) {
+    /** Story 33: see `updateNoteContent` — returns false, unwritten, when denied. */
+    async invalidateNote(id, callerAgentId) {
       await ensureCollection(col);
+      if (callerAgentId !== void 0) {
+        const existing = await this.getNote(id);
+        if (existing && !canWrite(existing, callerAgentId)) return false;
+      }
       await qdrant("POST", `/collections/${col}/points/payload?wait=true`, {
         payload: { is_active: false },
         points: [id]
       });
+      return true;
     },
     async getNotesByDatePrefix(datePrefix, agentId) {
       await ensureCollection(col);
@@ -468,6 +611,7 @@ function makeCrud(collectionName, modeBIsolated = false) {
     async replaceLinkReferences(oldId, newId, agentId) {
       const notes = await this.listNotes(agentId);
       for (const note of notes) {
+        if (!canWrite(note, agentId)) continue;
         if (note.links.includes(oldId)) {
           const newLinks = note.links.map((linkId) => linkId === oldId ? newId : linkId);
           const filteredLinks = newLinks.filter((linkId) => linkId !== note.id);
@@ -481,31 +625,49 @@ function makeCrud(collectionName, modeBIsolated = false) {
 function createStorageContext(collectionName, modeBIsolated = false) {
   return makeCrud(collectionName || getCollection(), modeBIsolated);
 }
-async function getNote(id) {
-  return makeCrud(getCollection()).getNote(id);
+async function getNote(id, readerAgentId) {
+  return makeCrud(getCollection()).getNote(id, readerAgentId);
 }
 async function updateNote(note) {
   return makeCrud(getCollection()).updateNote(note);
 }
-async function listNotes(agentId) {
-  return makeCrud(getCollection()).listNotes(agentId);
+async function listNotes(agentId, subject) {
+  return makeCrud(getCollection()).listNotes(agentId, subject);
 }
 async function deleteNote(id) {
   return makeCrud(getCollection()).deleteNote(id);
 }
-async function invalidateNote(id) {
-  return makeCrud(getCollection()).invalidateNote(id);
+async function invalidateNote(id, callerAgentId) {
+  return makeCrud(getCollection()).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();
   }
@@ -600,7 +762,39 @@ Classification rules:
 - NEW: Completely unrelated information, no substantive connection to the old memory
   Return: {"type": "NEW"}
 
-Return only JSON, no other text.`
+Return only JSON, no other text.`,
+      conflictScan: (numberedNotes) => `You are auditing a person's memory store for CONTRADICTIONS.
+
+Below are numbered memories. Find pairs that CANNOT both be true of the same person at the same time.
+
+${numberedNotes}
+
+What counts as a contradiction:
+- The same attribute holding two incompatible values ("lives in Paris" vs "moved to Berlin")
+- A stated preference or constraint that a later memory violates ("is vegetarian" vs "loved the steak")
+- A fact that a later memory supersedes ("uses MySQL" vs "migrated to PostgreSQL")
+
+What does NOT count \u2014 be strict, these are the common false positives:
+- Additive facts. Two things can both be true ("has a dog named Buddy" + "adopted a second dog, Scout" is NOT a contradiction)
+- Change over time that both memories already acknowledge
+- Merely similar or related topics
+- Different contexts (likes coffee at work, tea at home)
+
+For each contradicting pair, also say which one is SUPERSEDED \u2014 the one that is
+no longer true. Judge this from the WORDING, not from any assumed order: phrases
+like "used to", "back in 2019", "moved last month", "switched to" tell you which
+statement describes the past. The memories are NOT listed in chronological order,
+and the number does not imply age.
+
+If you cannot tell which one is superseded, set it to null. That is a normal and
+useful answer \u2014 say null rather than guessing, because a wrong guess retires a
+memory that is still true.
+
+Return ONLY a JSON array. Empty array if nothing genuinely contradicts:
+[{"a": 0, "b": 3, "superseded": 0, "reason": "one short sentence naming the incompatible attribute"}]
+
+"superseded" must be either the value of "a", the value of "b", or null.
+Use the numbers shown. Report a pair once. Prefer returning nothing over guessing.`
     };
     zh = {
       crudDecision: (userText, assistantText, memoryList) => `\u4F60\u662F\u4E00\u4E2A\u8BB0\u5FC6\u7BA1\u7406 agent\uFF0C\u8D1F\u8D23\u5206\u6790\u5BF9\u8BDD\u5185\u5BB9\u5E76\u51B3\u5B9A\u5982\u4F55\u64CD\u4F5C\u8BB0\u5FC6\u5E93\u3002
@@ -685,7 +879,36 @@ B: "\u7528\u6237\u7684 VS Code \u4F7F\u7528 One Dark Pro \u4E3B\u9898"
 - NEW\uFF1A\u5168\u65B0\u4FE1\u606F\uFF0C\u4E0E\u65E7\u8BB0\u5FC6\u65E0\u5B9E\u8D28\u5173\u8054\uFF08\u5982\u300C\u559C\u6B22 dark mode\u300Dvs\u300C\u4E0B\u5468\u8981\u53BB\u51FA\u5DEE\u300D\uFF09
   \u8FD4\u56DE\uFF1A{"type": "NEW"}
 
-\u53EA\u8FD4\u56DE JSON\uFF0C\u4E0D\u8981\u4EFB\u4F55\u5176\u4ED6\u6587\u5B57\u3002`
+\u53EA\u8FD4\u56DE JSON\uFF0C\u4E0D\u8981\u4EFB\u4F55\u5176\u4ED6\u6587\u5B57\u3002`,
+      conflictScan: (numberedNotes) => `\u4F60\u5728\u5BA1\u8BA1\u4E00\u4E2A\u4EBA\u7684\u8BB0\u5FC6\u5E93\uFF0C\u627E\u51FA\u5176\u4E2D**\u4E92\u76F8\u77DB\u76FE**\u7684\u6761\u76EE\u3002
+
+\u4E0B\u9762\u662F\u7F16\u53F7\u7684\u8BB0\u5FC6\u3002\u627E\u51FA\u90A3\u4E9B**\u4E0D\u53EF\u80FD\u540C\u65F6\u4E3A\u771F**\u7684\u914D\u5BF9\u3002
+
+${numberedNotes}
+
+\u7B97\u77DB\u76FE\u7684\u60C5\u51B5\uFF1A
+- \u540C\u4E00\u5C5E\u6027\u4E0A\u51FA\u73B0\u4E92\u65A5\u7684\u503C\uFF08\u300C\u4F4F\u5728\u5DF4\u9ECE\u300Dvs\u300C\u642C\u5230\u4E86\u67CF\u6797\u300D\uFF09
+- \u540E\u6765\u7684\u8BB0\u5FC6\u8FDD\u53CD\u4E86\u5148\u524D\u9648\u8FF0\u7684\u504F\u597D\u6216\u7EA6\u675F\uFF08\u300C\u5403\u7D20\u300Dvs\u300C\u90A3\u5757\u725B\u6392\u5F88\u597D\u5403\u300D\uFF09
+- \u540E\u6765\u7684\u4E8B\u5B9E\u53D6\u4EE3\u4E86\u5148\u524D\u7684\uFF08\u300C\u7528 MySQL\u300Dvs\u300C\u5DF2\u8FC1\u79FB\u5230 PostgreSQL\u300D\uFF09
+
+**\u4E0D\u7B97**\u77DB\u76FE \u2014\u2014 \u8BF7\u4E25\u683C\uFF0C\u4EE5\u4E0B\u662F\u6700\u5E38\u89C1\u7684\u8BEF\u5224\uFF1A
+- \u7D2F\u52A0\u7684\u4E8B\u5B9E\u3002\u4E24\u8005\u53EF\u4EE5\u540C\u65F6\u6210\u7ACB\uFF08\u300C\u517B\u4E86\u4E00\u53EA\u72D7\u53EB Buddy\u300D+\u300C\u53C8\u9886\u517B\u4E86\u7B2C\u4E8C\u53EA\u53EB Scout\u300D**\u4E0D\u662F**\u77DB\u76FE\uFF09
+- \u4E24\u6761\u8BB0\u5FC6\u672C\u8EAB\u5DF2\u7ECF\u4F53\u73B0\u4E86\u968F\u65F6\u95F4\u7684\u53D8\u5316
+- \u53EA\u662F\u4E3B\u9898\u76F8\u4F3C\u6216\u76F8\u5173
+- \u573A\u666F\u4E0D\u540C\uFF08\u5728\u516C\u53F8\u559D\u5496\u5561\uFF0C\u5728\u5BB6\u559D\u8336\uFF09
+
+\u5BF9\u6BCF\u4E00\u5BF9\u77DB\u76FE\uFF0C\u8FD8\u8981\u6307\u51FA\u54EA\u4E00\u6761\u662F**\u5DF2\u5931\u6548\u7684**\uFF08\u4E0D\u518D\u4E3A\u771F\u7684\u90A3\u6761\uFF09\u3002\u8BF7\u4ECE**\u63AA\u8F9E**\u5224\u65AD\uFF0C\u4E0D\u8981\u5047\u8BBE\u987A\u5E8F\uFF1A
+\u300C\u4EE5\u524D\u300D\u300C2019 \u5E74\u90A3\u4F1A\u513F\u300D\u300C\u4E0A\u4E2A\u6708\u642C\u4E86\u300D\u300C\u6539\u7528\u4E86\u300D\u8FD9\u7C7B\u8BF4\u6CD5\u80FD\u544A\u8BC9\u4F60\u54EA\u6761\u63CF\u8FF0\u7684\u662F\u8FC7\u53BB\u3002
+\u8FD9\u4E9B\u8BB0\u5FC6**\u4E0D\u662F\u6309\u65F6\u95F4\u987A\u5E8F\u6392\u5217\u7684**\uFF0C\u7F16\u53F7\u4E5F\u4E0D\u4EE3\u8868\u65B0\u65E7\u3002
+
+\u5982\u679C\u65E0\u6CD5\u5224\u65AD\u54EA\u6761\u5DF2\u5931\u6548\uFF0C\u5C31\u586B null\u3002\u8FD9\u662F\u4E00\u4E2A**\u6B63\u5E38\u4E14\u6709\u7528**\u7684\u56DE\u7B54 \u2014\u2014 \u5B81\u53EF\u586B null \u4E5F\u4E0D\u8981\u731C\uFF0C
+\u56E0\u4E3A\u731C\u9519\u4F1A\u8BA9\u4E00\u6761**\u4ECD\u7136\u4E3A\u771F**\u7684\u8BB0\u5FC6\u88AB\u505C\u7528\u3002
+
+\u53EA\u8FD4\u56DE JSON \u6570\u7EC4\u3002\u6CA1\u6709\u771F\u6B63\u77DB\u76FE\u5C31\u8FD4\u56DE\u7A7A\u6570\u7EC4\uFF1A
+[{"a": 0, "b": 3, "superseded": 0, "reason": "\u4E00\u53E5\u8BDD\u8BF4\u660E\u662F\u54EA\u4E2A\u5C5E\u6027\u4E92\u65A5"}]
+
+"superseded" \u53EA\u80FD\u662F "a" \u7684\u503C\u3001"b" \u7684\u503C\uFF0C\u6216 null\u3002
+\u4F7F\u7528\u4E0A\u9762\u663E\u793A\u7684\u7F16\u53F7\u3002\u540C\u4E00\u5BF9\u53EA\u62A5\u4E00\u6B21\u3002**\u5B81\u53EF\u4E0D\u62A5\uFF0C\u4E5F\u4E0D\u8981\u731C\u3002**`
     };
     templates = { en, zh };
     t = templates[LOCALE];
@@ -693,35 +916,92 @@ B: "\u7528\u6237\u7684 VS Code \u4F7F\u7528 One Dark Pro \u4E3B\u9898"
 });
 
 // ../amem-core/src/llm.ts
-function anthropic() {
-  return _anthropic ??= new import_sdk.default({
-    ...process.env.AMEM_LLM_API_KEY && { apiKey: process.env.AMEM_LLM_API_KEY },
-    ...process.env.AMEM_LLM_BASE_URL && { baseURL: process.env.AMEM_LLM_BASE_URL }
-  });
+function configureLlm(cfg) {
+  _override = { ...cfg };
+  _anthropicClients.clear();
+  _openaiClients.clear();
+}
+function warnOnce(key, message) {
+  if (_warned.has(key)) return;
+  _warned.add(key);
+  console.error(message);
+}
+function resolveProvider(role = "fast") {
+  const raw = role === "strong" ? process.env.AMEM_LLM_STRONG_PROVIDER || _override.strong?.provider || void 0 : void 0;
+  const p = (raw || process.env.AMEM_LLM_PROVIDER || _override.provider || "anthropic").trim().toLowerCase();
+  if (p !== "anthropic" && p !== "openai") {
+    warnOnce(`provider:${p}`, `[amem] unknown LLM provider "${p}"; falling back to anthropic`);
+  }
+  return p;
 }
-function openai() {
-  return _openai ??= new import_openai.default({
-    // AMEM_LLM_API_KEY first (engine convention), then the SDK's own
-    // OPENAI_API_KEY (the standard) — passing an explicit key blocks the SDK's
-    // env fallback, so read it here. Placeholder last, so keyless local servers
-    // (Ollama, vLLM) still work.
-    apiKey: process.env.AMEM_LLM_API_KEY || process.env.OPENAI_API_KEY || "sk-no-key-required",
-    ...process.env.AMEM_LLM_BASE_URL && { baseURL: process.env.AMEM_LLM_BASE_URL }
-  });
+function resolveModel(role = "fast") {
+  const strong = role === "strong" ? process.env.AMEM_LLM_STRONG_MODEL || _override.strong?.model || void 0 : void 0;
+  return strong || process.env.AMEM_LLM_MODEL || _override.model || (resolveProvider(role) === "openai" ? "gpt-4o-mini" : "claude-sonnet-4-6");
+}
+function resolveBaseURL(role = "fast") {
+  const strong = role === "strong" ? process.env.AMEM_LLM_STRONG_BASE_URL || _override.strong?.baseURL || void 0 : void 0;
+  return strong || process.env.AMEM_LLM_BASE_URL || _override.baseURL || void 0;
+}
+function resolveCrudRole() {
+  const raw = (process.env.AMEM_LLM_CRUD_ROLE || _override.crudRole || "fast").trim().toLowerCase();
+  if (raw === "strong") return "strong";
+  if (raw !== "fast") {
+    warnOnce(`crudRole:${raw}`, `[amem] unknown AMEM_LLM_CRUD_ROLE "${raw}"; using fast`);
+  }
+  return "fast";
+}
+function resolveTimeoutMs() {
+  const envVal = Number(process.env.AMEM_LLM_TIMEOUT);
+  if (Number.isFinite(envVal) && envVal > 0) return envVal;
+  if (_override.timeoutMs && _override.timeoutMs > 0) return _override.timeoutMs;
+  return DEFAULT_TIMEOUT_MS;
+}
+function anthropic(baseURL) {
+  const key = baseURL ?? "";
+  let client = _anthropicClients.get(key);
+  if (!client) {
+    client = new import_sdk.default({
+      ...process.env.AMEM_LLM_API_KEY && { apiKey: process.env.AMEM_LLM_API_KEY },
+      ...baseURL && { baseURL },
+      timeout: resolveTimeoutMs()
+    });
+    _anthropicClients.set(key, client);
+  }
+  return client;
+}
+function openai(baseURL) {
+  const key = baseURL ?? "";
+  let client = _openaiClients.get(key);
+  if (!client) {
+    client = new import_openai.default({
+      // AMEM_LLM_API_KEY first (engine convention), then the SDK's own
+      // OPENAI_API_KEY (the standard) — passing an explicit key blocks the SDK's
+      // env fallback, so read it here. Placeholder last, so keyless local servers
+      // (Ollama, vLLM) still work.
+      apiKey: process.env.AMEM_LLM_API_KEY || process.env.OPENAI_API_KEY || "sk-no-key-required",
+      ...baseURL && { baseURL },
+      timeout: resolveTimeoutMs()
+    });
+    _openaiClients.set(key, client);
+  }
+  return client;
 }
-async function llmCall(prompt, maxTokens = 500) {
-  const isThinking = MODEL.includes("gemini") || MODEL.includes("pro-agent");
+async function llmCall(prompt, maxTokens = 500, role = "fast") {
+  const provider = resolveProvider(role);
+  const model = resolveModel(role);
+  const baseURL = resolveBaseURL(role);
+  const isThinking = model.includes("gemini") || model.includes("pro-agent");
   const effectiveMaxTokens = isThinking ? Math.max(maxTokens * 8, 4e3) : maxTokens;
   try {
-    return PROVIDER === "openai" ? await openaiCall(prompt, effectiveMaxTokens) : await anthropicCall(prompt, effectiveMaxTokens);
+    return provider === "openai" ? await openaiCall(prompt, model, effectiveMaxTokens, baseURL) : await anthropicCall(prompt, model, effectiveMaxTokens, baseURL);
   } catch (e) {
     console.error(`[amem] LLM call failed: ${e.message}`);
     return null;
   }
 }
-async function anthropicCall(prompt, maxTokens) {
-  const resp = await anthropic().messages.create({
-    model: MODEL,
+async function anthropicCall(prompt, model, maxTokens, baseURL) {
+  const resp = await anthropic(baseURL).messages.create({
+    model,
     max_tokens: maxTokens,
     messages: [{ role: "user", content: prompt }]
   });
@@ -730,17 +1010,20 @@ async function anthropicCall(prompt, maxTokens) {
   }
   return null;
 }
-async function openaiCall(prompt, maxTokens) {
-  const isReasoning = /^o\d/.test(MODEL) || MODEL.startsWith("gpt-5");
-  const resp = await openai().chat.completions.create({
-    model: MODEL,
+async function openaiCall(prompt, model, maxTokens, baseURL) {
+  const isReasoning = /^o\d/.test(model) || model.startsWith("gpt-5");
+  const resp = await openai(baseURL).chat.completions.create({
+    model,
     ...isReasoning ? { max_completion_tokens: maxTokens } : { max_tokens: maxTokens },
     messages: [{ role: "user", content: prompt }]
   });
   return resp.choices[0]?.message?.content?.trim() ?? null;
 }
+function stripReasoning(raw) {
+  return raw.replace(/<think>[\s\S]*?<\/think>/gi, "").replace(/<\|(?:eot_id|im_start|im_end|begin_of_text|end_of_text|endoftext)\|>/g, "").trim();
+}
 function stripFences(raw) {
-  raw = raw.trim();
+  raw = stripReasoning(raw);
   if (raw.startsWith("```")) {
     const lines = raw.split("\n");
     lines.shift();
@@ -755,6 +1038,16 @@ function stripFences(raw) {
   }
   return raw;
 }
+function parseJsonLoose(raw) {
+  const cleaned = stripFences(raw);
+  try {
+    return JSON.parse(cleaned);
+  } catch (e) {
+    const m = cleaned.match(/\{[\s\S]*\}/);
+    if (m) return JSON.parse(m[0]);
+    throw e;
+  }
+}
 async function llmConstructNote(content) {
   const prompt = `Analyze the following text and respond with valid JSON only (no markdown fences, no explanation, no comments). All string values must use standard double quotes and be properly escaped:
 {
@@ -802,7 +1095,7 @@ Text: ${content}`;
       confidence: "medium"
     };
   try {
-    const data = JSON.parse(stripFences(raw));
+    const data = parseJsonLoose(raw);
     const rawCategory = typeof data.category === "string" ? data.category : "General";
     const category = VALID_CATEGORIES.has(rawCategory) ? rawCategory : "General";
     const note_type = data.note_type === "knowledge" ? "knowledge" : "memory";
@@ -845,9 +1138,9 @@ async function llmCrudDecision(userText, assistantText, existingMemories) {
   const memoryList = existingMemories.length > 0 ? existingMemories.map((m) => `[${m.idx}] ${m.content}`).join("\n") : "(none)";
   const prompt = t.crudDecision(userText.slice(0, 500), assistantText.slice(0, 500), memoryList);
   try {
-    const raw = await llmCall(prompt, 400);
+    const raw = await llmCall(prompt, 400, resolveCrudRole());
     if (!raw) return [];
-    const match = raw.match(/\[.*\]/s);
+    const match = stripReasoning(raw).match(/\[.*\]/s);
     if (!match) return [];
     const parsed = JSON.parse(match[0]);
     if (!Array.isArray(parsed)) return [];
@@ -875,10 +1168,10 @@ async function llmCrudDecision(userText, assistantText, existingMemories) {
 }
 async function llmShouldMerge(contentA, contentB) {
   const prompt = t.shouldMerge(contentA, contentB);
-  const raw = await llmCall(prompt, 300);
+  const raw = await llmCall(prompt, 300, "strong");
   if (!raw) return { shouldMerge: false };
   try {
-    const data = JSON.parse(stripFences(raw));
+    const data = parseJsonLoose(raw);
     if (typeof data.shouldMerge !== "boolean") return { shouldMerge: false };
     if (data.shouldMerge && typeof data.merged === "string") {
       return { shouldMerge: true, merged: data.merged };
@@ -891,10 +1184,10 @@ async function llmShouldMerge(contentA, contentB) {
 }
 async function llmEvolutionJudge(oldContent, newContent) {
   const prompt = t.evolutionJudge(oldContent, newContent);
-  const raw = await llmCall(prompt, 300);
+  const raw = await llmCall(prompt, 300, "strong");
   if (!raw) return { type: "NEW" };
   try {
-    const data = JSON.parse(stripFences(raw));
+    const data = parseJsonLoose(raw);
     const type = VALID_EVOLUTION_TYPES.has(data.type) ? data.type : "NEW";
     return {
       type,
@@ -931,7 +1224,7 @@ ${linkedStr}`;
   const raw = await llmCall(prompt, 500);
   if (!raw) return { tags: null, context: null, shouldStrengthen: false, suggestedConnections: [], tagsToUpdate: [] };
   try {
-    const data = JSON.parse(stripFences(raw));
+    const data = parseJsonLoose(raw);
     return {
       tags: Array.isArray(data.tags) ? data.tags : null,
       context: typeof data.context === "string" ? data.context : null,
@@ -944,20 +1237,56 @@ ${linkedStr}`;
     return { tags: null, context: null, shouldStrengthen: false, suggestedConnections: [], tagsToUpdate: [] };
   }
 }
-var import_sdk, import_openai, PROVIDER, MODEL, _anthropic, _openai, VALID_CONFIDENCE, VALID_CATEGORIES, VALID_EVOLUTION_TYPES;
+async function llmConflictScan(contents) {
+  if (contents.length < 2) return [];
+  const numbered = contents.map((c, i) => `[${i}] ${c}`).join("\n");
+  try {
+    const raw = await llmCall(t.conflictScan(numbered), 600, "strong");
+    if (!raw) return [];
+    const cleaned = stripReasoning(raw);
+    const match = cleaned.match(/\[[\s\S]*\]/);
+    if (!match) return [];
+    const parsed = JSON.parse(match[0]);
+    if (!Array.isArray(parsed)) return [];
+    const pairs = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const item of parsed) {
+      if (!item || typeof item !== "object") continue;
+      const { a, b } = item;
+      if (typeof a !== "number" || typeof b !== "number") continue;
+      if (!Number.isInteger(a) || !Number.isInteger(b)) continue;
+      if (a < 0 || b < 0 || a >= contents.length || b >= contents.length) continue;
+      if (a === b) continue;
+      const key = a < b ? `${a}:${b}` : `${b}:${a}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const rawSup = item.superseded;
+      const supersededIndex = rawSup === a || rawSup === b ? rawSup : null;
+      pairs.push({
+        a,
+        b,
+        reason: typeof item.reason === "string" ? item.reason : "",
+        supersededIndex
+      });
+    }
+    return pairs;
+  } catch (e) {
+    console.error(`[amem] llmConflictScan failed: ${e.message}`);
+    return [];
+  }
+}
+var import_sdk, import_openai, _override, _warned, DEFAULT_TIMEOUT_MS, _anthropicClients, _openaiClients, VALID_CONFIDENCE, VALID_CATEGORIES, VALID_EVOLUTION_TYPES;
 var init_llm = __esm({
   "../amem-core/src/llm.ts"() {
     "use strict";
     import_sdk = __toESM(require("@anthropic-ai/sdk"), 1);
     import_openai = __toESM(require("openai"), 1);
     init_prompts();
-    PROVIDER = (process.env.AMEM_LLM_PROVIDER ?? "anthropic").trim().toLowerCase();
-    if (PROVIDER !== "anthropic" && PROVIDER !== "openai") {
-      console.error(`[amem] unknown AMEM_LLM_PROVIDER "${PROVIDER}"; falling back to anthropic`);
-    }
-    MODEL = process.env.AMEM_LLM_MODEL ?? (PROVIDER === "openai" ? "gpt-4o-mini" : "claude-sonnet-4-6");
-    _anthropic = null;
-    _openai = null;
+    _override = {};
+    _warned = /* @__PURE__ */ new Set();
+    DEFAULT_TIMEOUT_MS = 3e4;
+    _anthropicClients = /* @__PURE__ */ new Map();
+    _openaiClients = /* @__PURE__ */ new Map();
     VALID_CONFIDENCE = /* @__PURE__ */ new Set(["high", "medium", "low"]);
     VALID_CATEGORIES = /* @__PURE__ */ new Set([
       "Technical",
@@ -1077,6 +1406,7 @@ function defaultCtx() {
 }
 async function addMemory(content, agentId = "main", opts) {
   const scope = opts?.scope ?? "private";
+  const subjects = opts?.subjects ?? [];
   const ctx = opts?.storageCtx ?? defaultCtx();
   const quality = checkQuality(content);
   if (!quality.ok) {
@@ -1101,9 +1431,14 @@ async function addMemory(content, agentId = "main", opts) {
   const embedding = await encode(fieldsText);
   const topMatch = await ctx.queryByEmbedding(embedding, 1, agentId, 0);
   if (topMatch.length > 0 && topMatch[0].score >= 0.85) {
-    console.log(`[add] dedup: high-sim match (sim=${topMatch[0].score.toFixed(3)}), updating existing`);
-    await ctx.updateNoteContent(topMatch[0].note.id, content, embedding, hash);
-    return topMatch[0].note.id;
+    if (canWrite(topMatch[0].note, agentId)) {
+      console.log(`[add] dedup: high-sim match (sim=${topMatch[0].score.toFixed(3)}), updating existing`);
+      await ctx.updateNoteContent(topMatch[0].note.id, content, embedding, hash);
+      return topMatch[0].note.id;
+    }
+    console.log(
+      `[add] dedup: high-sim match ${topMatch[0].note.id.slice(0, 8)} is not writable by ${logSafe(agentId)} \u2014 inserting a new note instead`
+    );
   }
   const pendingMerge = topMatch.length > 0 && topMatch[0].score >= 0.72 && topMatch[0].score < 0.85;
   if (pendingMerge) {
@@ -1113,6 +1448,7 @@ async function addMemory(content, agentId = "main", opts) {
   const writers = [agentId];
   const note = {
     id: (0, import_uuid.v4)(),
+    subjects,
     content,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     keywords,
@@ -1171,6 +1507,10 @@ async function addMemory(content, agentId = "main", opts) {
         for (const lid of linkedIds) {
           const linked = await ctx.getNote(lid);
           if (linked && !linked.links.includes(note.id)) {
+            if (!canWrite(linked, agentId)) {
+              console.log(`[link] back-link into ${lid.slice(0, 8)} skipped \u2014 not writable by ${logSafe(agentId)}`);
+              continue;
+            }
             linked.links.push(note.id);
             await ctx.updateNote(linked);
           }
@@ -1180,10 +1520,14 @@ async function addMemory(content, agentId = "main", opts) {
           for (const lid of linkedIds.slice(0, 3)) {
             const linked = await ctx.getNote(lid);
             if (!linked) continue;
+            if (!canWrite(linked, agentId)) {
+              console.log(`  [evo] skipping ${lid.slice(0, 8)} \u2014 not writable by ${logSafe(agentId)}`);
+              continue;
+            }
             const linkedNotes = [];
             for (const llid of linked.links.slice(0, 5)) {
               if (llid === note.id) continue;
-              const ln = await ctx.getNote(llid);
+              const ln = await ctx.getNote(llid, agentId);
               if (ln) linkedNotes.push({ id: ln.id, content: ln.content });
             }
             linkedNotes.push({ id: note.id, content });
@@ -1220,10 +1564,14 @@ async function addMemory(content, agentId = "main", opts) {
                   note.links.push(targetId);
                   noteChanged = true;
                 }
-                const target = await ctx.getNote(targetId);
+                const target = await ctx.getNote(targetId, agentId);
                 if (target && !target.links.includes(note.id)) {
-                  target.links.push(note.id);
-                  await ctx.updateNote(target);
+                  if (canWrite(target, agentId)) {
+                    target.links.push(note.id);
+                    await ctx.updateNote(target);
+                  } else {
+                    console.log(`  [evo] strengthen back-link into ${targetId.slice(0, 8)} skipped \u2014 not writable`);
+                  }
                 }
               }
               if (tagsToUpdate.length > 0) {
@@ -1272,6 +1620,7 @@ async function addMemory(content, agentId = "main", opts) {
 }
 async function addEpisodic(content, agentId = "main", opts) {
   const scope = opts?.scope ?? "private";
+  const subjects = opts?.subjects ?? [];
   const ctx = opts?.storageCtx ?? defaultCtx();
   const quality = checkQuality(content);
   if (!quality.ok) {
@@ -1281,6 +1630,7 @@ async function addEpisodic(content, agentId = "main", opts) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const note = {
     id: (0, import_uuid.v4)(),
+    subjects,
     content,
     timestamp: now,
     keywords: [],
@@ -1310,14 +1660,15 @@ async function addEpisodic(content, agentId = "main", opts) {
 }
 async function searchMemory(query, topK = 5, agentId = "main", opts) {
   const useBfs = opts?.useBfs !== false;
+  const subject = opts?.subject;
   const bfsSimThreshold = opts?.bfsSimThreshold ?? 0.25;
   const ctx = opts?.storageCtx ?? defaultCtx();
   const total = await ctx.countNotes(agentId);
   if (total === 0) return [];
   const queryEmbedding = await encode(query);
   const n = Math.min(Math.max(topK * 4, 20), total);
-  const embResults = await ctx.queryByEmbedding(queryEmbedding, n, agentId, 0);
-  const allNotes = await ctx.listNotes(agentId);
+  const embResults = await ctx.queryByEmbedding(queryEmbedding, n, agentId, 0, subject);
+  const allNotes = await ctx.listNotes(agentId, subject);
   const bm25State = buildBM25(allNotes);
   const queryTokens = simpleTokenize(query);
   const bm25Ranked = bm25Score(bm25State, queryTokens).slice(0, n);
@@ -1628,7 +1979,81 @@ async function consolidateMemories(agentId, logger, storageCtx) {
   log.info(`[Consolidation] Completed consolidation run. Merged ${mergedCount} pairs.`);
   return mergedCount;
 }
-var import_uuid, import_crypto, fs2, path3, import_jieba, _jieba, EPHEMERAL_SIGNALS;
+function resolveConflictMode(override) {
+  const raw = (process.env.AMEM_CONFLICT_MODE || override || "review").trim().toLowerCase();
+  return raw === "auto" ? "auto" : "review";
+}
+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);
+  const notes = raw.filter((n) => n.agent_id !== "shared" && n.note_type !== "knowledge" && n.is_active !== false);
+  const groups = /* @__PURE__ */ new Map();
+  for (const n of notes) {
+    const c = n.category || "General";
+    if (!groups.has(c)) groups.set(c, []);
+    groups.get(c).push(n);
+  }
+  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];
+        const noteB = batch[b];
+        if (!noteA || !noteB) continue;
+        pairsFound++;
+        await ctx.patchNotePayload(noteA.id, {
+          conflict: true,
+          evolution_type: "CONFLICT",
+          conflicts_with: Array.from(/* @__PURE__ */ new Set([...noteA.conflicts_with ?? [], noteB.id])),
+          conflict_reason: reason
+        });
+        await ctx.patchNotePayload(noteB.id, {
+          conflict: true,
+          evolution_type: "CONFLICT",
+          conflicts_with: Array.from(/* @__PURE__ */ new Set([...noteB.conflicts_with ?? [], noteA.id])),
+          conflict_reason: reason
+        });
+        log(`[conflict] ${category}: ${noteA.id.slice(0, 8)} \u2194 ${noteB.id.slice(0, 8)} \u2014 ${reason}`);
+        if (mode === "auto") {
+          const superseded = supersededIndex === a ? noteA : supersededIndex === b ? noteB : null;
+          if (!superseded) {
+            log(`[conflict] auto: no superseded side identified \u2014 marked only, nothing retired`);
+          } else {
+            const ok = await ctx.invalidateNote(superseded.id, agentId);
+            if (ok) {
+              retired++;
+              log(`[conflict] auto-retired the superseded note ${superseded.id.slice(0, 8)}`);
+            }
+          }
+        }
+      }
+      const scannedAt = (/* @__PURE__ */ new Date()).toISOString();
+      for (const n of batch) {
+        await ctx.patchNotePayload(n.id, { conflict_scanned_at: scannedAt });
+      }
+    }
+  }
+  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({
   "../amem-core/src/memory.ts"() {
     "use strict";
@@ -1638,12 +2063,15 @@ var init_memory = __esm({
     path3 = __toESM(require("path"), 1);
     init_embedding();
     init_storage();
+    init_auth();
     init_llm();
     init_evo_counter();
     init_config();
     import_jieba = require("@node-rs/jieba");
+    logSafe = (id) => id.replace(/[\r\n]/g, "");
     _jieba = null;
     EPHEMERAL_SIGNALS = ["\u5F85\u8DD1", "\u7B49\u786E\u8BA4", "\u6628\u65E5", "\u660E\u5929\u5B8C\u6210"];
+    CONFLICT_BATCH_SIZE = 25;
   }
 });
 
@@ -1654,6 +2082,7 @@ async function scanLowQuality(agentId) {
   const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1e3;
   const results = [];
   for (const note of notes) {
+    if (!canWrite(note, agentId)) continue;
     const reasons = [];
     if (note.content.trim().length < 10) {
       reasons.push("too_short");
@@ -1737,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}`);
@@ -1746,6 +2175,48 @@ async function generateReviewBatch(agentId, outputPath) {
   if (items.length === 0) {
     lines.push(LOCALE2 === "zh" ? "\u2705 \u6CA1\u6709\u53D1\u73B0\u4F4E\u8D28\u91CF\u6761\u76EE\u3002" : "\u2705 No low-quality items found.");
   }
+  const byId = new Map(items.map((it) => [it.note.id, it.note]));
+  const renderedPairs = /* @__PURE__ */ new Set();
+  const pairLines = [];
+  for (const { note } of items) {
+    for (const otherId of note.conflicts_with ?? []) {
+      const other = byId.get(otherId);
+      if (!other) continue;
+      const key = note.id < otherId ? `${note.id}:${otherId}` : `${otherId}:${note.id}`;
+      if (renderedPairs.has(key)) continue;
+      renderedPairs.add(key);
+      const [newer, older] = Date.parse(note.timestamp) >= Date.parse(other.timestamp) ? [note, other] : [other, note];
+      const zh2 = LOCALE2 === "zh";
+      pairLines.push(`### \u{1F7E0} ${zh2 ? "\u51B2\u7A81" : "CONFLICT"} | ${newer.category || "General"}`);
+      if (newer.conflict_reason) {
+        pairLines.push(`**${zh2 ? "\u5224\u5B9A\u7406\u7531" : "Why"}\uFF1A** ${newer.conflict_reason}`);
+        pairLines.push("");
+      }
+      pairLines.push(`| | ${zh2 ? "\u65F6\u95F4" : "When"} | ${zh2 ? "\u5185\u5BB9" : "Content"} |`);
+      pairLines.push("| :-- | :-- | :-- |");
+      pairLines.push(`| **A** | ${newer.timestamp.slice(0, 10)} | ${newer.content.replace(/\n/g, " ")} |`);
+      pairLines.push(`| **B** | ${older.timestamp.slice(0, 10)} | ${older.content.replace(/\n/g, " ")} |`);
+      pairLines.push("");
+      pairLines.push(`\`A: ${newer.id}\``);
+      pairLines.push(`\`B: ${older.id}\``);
+      pairLines.push("");
+      pairLines.push(
+        zh2 ? `- [ ] \u2705 **A \u662F\u5F53\u524D\u72B6\u6001\uFF0C\u505C\u7528 B**\uFF08\u63A8\u8350\uFF1AA \u66F4\u65B0\uFF09` : `- [ ] \u2705 **A is current \u2014 retire B** (recommended: A is newer)`
+      );
+      pairLines.push(zh2 ? `- [ ] \u21A9\uFE0F B \u662F\u5F53\u524D\u72B6\u6001\uFF0C\u505C\u7528 A` : `- [ ] \u21A9\uFE0F B is current \u2014 retire A`);
+      pairLines.push(zh2 ? `- [ ] \u{1F91D} \u4E24\u8005\u90FD\u6210\u7ACB\uFF08\u8BEF\u5224\uFF09` : `- [ ] \u{1F91D} Both hold \u2014 not a contradiction`);
+      pairLines.push("");
+      pairLines.push("---");
+      pairLines.push("");
+    }
+  }
+  if (pairLines.length > 0) {
+    lines.push(LOCALE2 === "zh" ? "## \u51B2\u7A81\uFF08\u6210\u5BF9\uFF0C\u4E00\u4E2A\u51B2\u7A81\u4E00\u4E2A\u51B3\u5B9A\uFF09" : "## Conflicts (paired \u2014 one decision each)");
+    lines.push("");
+    lines.push(...pairLines);
+    lines.push(LOCALE2 === "zh" ? "## \u5176\u4F59\u6761\u76EE" : "## Other items");
+    lines.push("");
+  }
   for (let i = 0; i < items.length; i++) {
     const { note, reasons } = items[i];
     const badge = severityBadge(reasons);
@@ -1788,34 +2259,155 @@ var init_quality = __esm({
     fs3 = __toESM(require("fs"), 1);
     path4 = __toESM(require("path"), 1);
     init_storage();
+    init_auth();
     LOCALE2 = process.env.AMEM_PROMPT_LOCALE === "zh" ? "zh" : "en";
     DEFAULT_OUTPUT_DIR = process.env.AMEM_REVIEW_DIR || process.cwd();
   }
 });
 
+// ../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);
+  if (Number.isFinite(envVal) && envVal >= 0) return envVal;
+  if (override !== void 0 && Number.isFinite(override) && override >= 0) return override;
+  return DEFAULT_CRUD_UPDATE_MIN_SIM;
+}
+function isPlausibleUpdateTarget(newEmbedding, targetEmbedding, minSimilarity) {
+  if (!newEmbedding?.length || !targetEmbedding?.length) return false;
+  if (newEmbedding.length !== targetEmbedding.length) return false;
+  return cosineSimilarity(newEmbedding, targetEmbedding) >= resolveCrudUpdateMinSim(minSimilarity);
+}
+var DEFAULT_CRUD_UPDATE_MIN_SIM;
+var init_crud_guard = __esm({
+  "../amem-core/src/crud-guard.ts"() {
+    "use strict";
+    init_embedding();
+    DEFAULT_CRUD_UPDATE_MIN_SIM = 0.35;
+  }
+});
+
 // ../amem-core/src/index.ts
 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,
+  canWrite: () => canWrite,
   checkQuality: () => checkQuality,
   configure: () => configure,
+  configureLlm: () => configureLlm,
+  conflictSweep: () => conflictSweep,
   consolidateMemories: () => consolidateMemories,
   createStorageContext: () => createStorageContext,
   deleteNote: () => deleteNote,
   encode: () => encode,
   ensureCollection: () => ensureCollection,
   generateReviewBatch: () => generateReviewBatch,
+  getEmbeddingDim: () => getEmbeddingDim,
+  getEmbeddingModel: () => getEmbeddingModel,
   getNote: () => getNote,
   invalidateNote: () => invalidateNote,
   isModelLoaded: () => isModelLoaded,
+  isPlausibleUpdateTarget: () => isPlausibleUpdateTarget,
   listMemories: () => listMemories,
   listNotes: () => listNotes,
   llmCrudDecision: () => llmCrudDecision,
   loadModel: () => loadModel,
   mergeSimilarNotes: () => mergeSimilarNotes,
+  migrateCollection: () => migrateCollection,
   patchNotePayload: () => patchNotePayload,
   pingQdrant: () => pingQdrant,
+  resolveCrudUpdateMinSim: () => resolveCrudUpdateMinSim,
   scanLowQuality: () => scanLowQuality,
   searchMemory: () => searchMemory,
   updateNote: () => updateNote
@@ -1828,6 +2420,12 @@ var init_src = __esm({
     init_memory();
     init_quality();
     init_storage();
+    init_auth();
+    init_embedding();
+    init_storage();
+    init_migrate();
+    init_memory();
+    init_crud_guard();
     init_llm();
   }
 });
@@ -1901,6 +2499,26 @@ function register(api) {
   const convBlocked = isConvAccessBlocked(api.config, pluginId);
   if (convBlocked) logger.warn(BLOCKED_WARNING_LOG);
   configure({ dataDir: path5.join(os2.homedir(), ".openclaw") });
+  const hasStrong = !!(pluginConfig.llmStrongProvider || pluginConfig.llmStrongModel || pluginConfig.llmStrongBaseURL);
+  if (pluginConfig.llmProvider || pluginConfig.llmModel || pluginConfig.llmBaseURL || pluginConfig.llmCrudRole || hasStrong) {
+    configureLlm({
+      provider: pluginConfig.llmProvider,
+      model: pluginConfig.llmModel,
+      baseURL: pluginConfig.llmBaseURL,
+      crudRole: pluginConfig.llmCrudRole,
+      // Omit the whole block when unset so `strong` transparently falls back to
+      // `fast` — the zero-config path stays byte-for-byte today's behaviour.
+      ...hasStrong && {
+        strong: {
+          provider: pluginConfig.llmStrongProvider,
+          model: pluginConfig.llmStrongModel,
+          baseURL: pluginConfig.llmStrongBaseURL
+        }
+      }
+    });
+  }
+  const conflictSweepEnabled = pluginConfig.conflictSweep !== false;
+  const crudUpdateMinSim = pluginConfig.crudUpdateMinSim;
   const resolveAgentId2 = (ctx) => resolveAgentId(ctx, pluginConfig);
   const buildScope2 = (rawAgentId) => buildScope(rawAgentId, pluginConfig, createStorageContext);
   const defaultScope = buildScope2(resolveAgentId2());
@@ -1908,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: {
@@ -2001,17 +2623,22 @@ function register(api) {
                 type: "array",
                 items: { type: "string" },
                 description: "Story 26B: filter knowledge notes by topics (all must match)"
+              },
+              subject: {
+                type: "string",
+                description: "Who you are talking to or about (e.g. a player name). Returns memories about them plus memories about nobody in particular. Omit to search everything."
               }
             },
             required: ["query"]
           },
           async execute(_toolCallId, params) {
-            const { query, limit = 5, topicsFilter } = params;
+            const { query, limit = 5, topicsFilter, subject } = params;
             const start = Date.now();
             const hookWarning = convBlocked ? BLOCKED_WARNING_SUFFIX : "";
             try {
               const results = await searchMemory(query, limit, scope.agentId, {
                 topicsFilter,
+                subject,
                 storageCtx: scope.storageCtx
               });
               logger.info(
@@ -2052,15 +2679,20 @@ ${text}${hookWarning}` }],
           parameters: {
             type: "object",
             properties: {
-              text: { type: "string", description: "Fact or information to remember" }
+              text: { type: "string", description: "Fact or information to remember" },
+              subjects: {
+                type: "array",
+                items: { type: "string" },
+                description: "Who this memory is about (e.g. player names). Use several for a shared experience \u2014 it will surface for each of them. Leave empty for a fact about the world or about yourself."
+              }
             },
             required: ["text"]
           },
           async execute(_toolCallId, params) {
-            const { text } = params;
+            const { text, subjects } = params;
             const start = Date.now();
             try {
-              const id = await addMemory(text, scope.agentId, { storageCtx: scope.storageCtx });
+              const id = await addMemory(text, scope.agentId, { subjects, storageCtx: scope.storageCtx });
               logger.info(`openclaw-amem: memory_add OK id=${id} (${Date.now() - start}ms)`);
               return {
                 content: [{ type: "text", text: "Memory saved successfully." }],
@@ -2238,7 +2870,21 @@ ${text}${hookWarning}` }],
               if (target) {
                 const newEmbedding = await encode(op.fact);
                 const hash = (0, import_crypto2.createHash)("md5").update(op.fact).digest("hex");
-                await storageCtx.updateNoteContent(target.id, op.fact, newEmbedding, hash);
+                const targetNote = await storageCtx.getNote(target.id, agentId);
+                if (!targetNote || !isPlausibleUpdateTarget(newEmbedding, targetNote.embedding, crudUpdateMinSim)) {
+                  await addMemory(op.fact, agentId, { storageCtx });
+                  logger.warn(
+                    `openclaw-amem: CRUD UPDATE on ${target.id.slice(0, 8)} looks mis-targeted \u2014 stored as a new memory instead`
+                  );
+                  continue;
+                }
+                const ok = await storageCtx.updateNoteContent(target.id, op.fact, newEmbedding, hash, agentId);
+                if (!ok) {
+                  logger.warn(
+                    `openclaw-amem: CRUD UPDATE denied id=${target.id.slice(0, 8)} \u2014 ${agentId} not in writers`
+                  );
+                  continue;
+                }
                 logger.info(
                   `openclaw-amem: CRUD UPDATE id=${target.id.slice(0, 8)}: "${op.fact.slice(0, 60)}${op.fact.length > 60 ? "..." : ""}"`
                 );
@@ -2246,7 +2892,13 @@ ${text}${hookWarning}` }],
             } else if (op.action === "DELETE" && op.existingIdx !== void 0) {
               const target = existingMemories[op.existingIdx];
               if (target) {
-                await storageCtx.invalidateNote(target.id);
+                const ok = await storageCtx.invalidateNote(target.id, agentId);
+                if (!ok) {
+                  logger.warn(
+                    `openclaw-amem: CRUD DELETE denied id=${target.id.slice(0, 8)} \u2014 ${agentId} not in writers`
+                  );
+                  continue;
+                }
                 logger.info(
                   `openclaw-amem: CRUD INVALIDATE id=${target.id.slice(0, 8)}: "${op.fact.slice(0, 60)}${op.fact.length > 60 ? "..." : ""}"`
                 );
@@ -2294,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);
   }
@@ -2314,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;