openclaw-amem 1.2.2 → 1.3.0

package/dist/index.js

@@ -127,6 +127,19 @@ var init_embedding = __esm({
   }
 });
 
+// ../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";
+  }
+});
+
 // ../amem-core/src/storage.ts
 async function qdrant(method, path6, body) {
   const res = await fetch(`${QDRANT_URL}${path6}`, {
@@ -180,6 +193,10 @@ async function ensureCollection(collectionName) {
     field_name: "topics",
     field_schema: "keyword"
   });
+  await qdrant("PUT", `/collections/${col}/index`, {
+    field_name: "subjects",
+    field_schema: "keyword"
+  });
   markReady();
 }
 function noteToPoint(note) {
@@ -212,6 +229,9 @@ function noteToPoint(note) {
       // 30
       evolution_type: note.evolution_type || "",
       conflict: note.conflict ?? false,
+      conflicts_with: note.conflicts_with ?? [],
+      conflict_reason: note.conflict_reason ?? "",
+      subjects: note.subjects ?? [],
       // 31
       ephemeral: note.ephemeral ?? false,
       low_quality: note.low_quality ?? false,
@@ -264,6 +284,9 @@ 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 : "",
+    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 +296,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 +339,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 +355,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 +393,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 +442,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 +476,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 +493,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 +550,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,20 +564,20 @@ 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);
@@ -503,6 +586,7 @@ var QDRANT_URL, getCollection, VECTOR_DIM, _collectionReady, _collectionReadyMap
 var init_storage = __esm({
   "../amem-core/src/storage.ts"() {
     "use strict";
+    init_auth();
     QDRANT_URL = "http://localhost:6333";
     getCollection = () => process.env.AMEM_COLLECTION || "amem_notes";
     VECTOR_DIM = 384;
@@ -600,7 +684,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 +801,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 +838,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");
 }
-async function llmCall(prompt, maxTokens = 500) {
-  const isThinking = MODEL.includes("gemini") || MODEL.includes("pro-agent");
+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, 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 +932,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 +960,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 +1017,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 +1060,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 +1090,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 +1106,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 +1146,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 +1159,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 +1328,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 +1353,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 +1370,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 +1429,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 +1442,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 +1486,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 +1542,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 +1552,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 +1582,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 +1901,66 @@ 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 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;
+  for (const [category, groupNotes] of groups.entries()) {
+    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;
+      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)}`);
+            }
+          }
+        }
+      }
+    }
+  }
+  log(`[conflict] scanned ${notes.length} notes, found ${pairsFound} pair(s), retired ${retired}`);
+  return { scanned: notes.length, pairsFound, retired };
+}
+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 +1970,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 +1989,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");
@@ -1746,6 +2082,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,18 +2166,45 @@ 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/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,
   addEpisodic: () => addEpisodic,
   addMemory: () => addMemory,
+  canRead: () => canRead,
+  canWrite: () => canWrite,
   checkQuality: () => checkQuality,
   configure: () => configure,
+  configureLlm: () => configureLlm,
+  conflictSweep: () => conflictSweep,
   consolidateMemories: () => consolidateMemories,
   createStorageContext: () => createStorageContext,
   deleteNote: () => deleteNote,
@@ -1809,6 +2214,7 @@ __export(src_exports, {
   getNote: () => getNote,
   invalidateNote: () => invalidateNote,
   isModelLoaded: () => isModelLoaded,
+  isPlausibleUpdateTarget: () => isPlausibleUpdateTarget,
   listMemories: () => listMemories,
   listNotes: () => listNotes,
   llmCrudDecision: () => llmCrudDecision,
@@ -1816,6 +2222,7 @@ __export(src_exports, {
   mergeSimilarNotes: () => mergeSimilarNotes,
   patchNotePayload: () => patchNotePayload,
   pingQdrant: () => pingQdrant,
+  resolveCrudUpdateMinSim: () => resolveCrudUpdateMinSim,
   scanLowQuality: () => scanLowQuality,
   searchMemory: () => searchMemory,
   updateNote: () => updateNote
@@ -1828,6 +2235,9 @@ var init_src = __esm({
     init_memory();
     init_quality();
     init_storage();
+    init_auth();
+    init_memory();
+    init_crud_guard();
     init_llm();
   }
 });
@@ -1901,6 +2311,25 @@ 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 crudUpdateMinSim = pluginConfig.crudUpdateMinSim;
   const resolveAgentId2 = (ctx) => resolveAgentId(ctx, pluginConfig);
   const buildScope2 = (rawAgentId) => buildScope(rawAgentId, pluginConfig, createStorageContext);
   const defaultScope = buildScope2(resolveAgentId2());
@@ -2001,17 +2430,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 +2486,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 +2677,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 +2699,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 ? "..." : ""}"`
                 );

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "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.2.2",
+  "version": "1.3.0",
   "kind": "memory",
   "openclaw": {
     "compat": {
@@ -31,6 +31,13 @@
           "OPENAI_API_KEY",
           "AMEM_LLM_BASE_URL",
           "AMEM_LLM_MODEL",
+          "AMEM_LLM_STRONG_PROVIDER",
+          "AMEM_LLM_STRONG_MODEL",
+          "AMEM_LLM_STRONG_BASE_URL",
+          "AMEM_LLM_CRUD_ROLE",
+          "AMEM_CONFLICT_MODE",
+          "AMEM_LLM_TIMEOUT",
+          "AMEM_CRUD_UPDATE_MIN_SIM",
           "AMEM_COLLECTION",
           "AMEM_DATA_DIR",
           "AMEM_EVO_COUNTER_PATH",
@@ -90,6 +97,53 @@
         "type": "string",
         "description": "Qdrant collection name (mode A shared default)."
       },
+      "llmProvider": {
+        "type": "string",
+        "enum": [
+          "anthropic",
+          "openai"
+        ],
+        "default": "anthropic",
+        "description": "LLM API dialect for the engine's own calls. Overridden by AMEM_LLM_PROVIDER."
+      },
+      "llmModel": {
+        "type": "string",
+        "description": "Model the engine uses for note construction, linking and evolution. Overridden by AMEM_LLM_MODEL. Defaults to claude-sonnet-4-6 (anthropic) or gpt-4o-mini (openai)."
+      },
+      "llmBaseURL": {
+        "type": "string",
+        "description": "Base URL for the LLM endpoint, e.g. an OpenAI-compatible gateway. Overridden by AMEM_LLM_BASE_URL. API keys are read from the environment only and cannot be set here."
+      },
+      "llmStrongProvider": {
+        "type": "string",
+        "enum": [
+          "anthropic",
+          "openai"
+        ],
+        "description": "Optional stronger tier: request format. Falls back to llmProvider. Overridden by AMEM_LLM_STRONG_PROVIDER."
+      },
+      "llmStrongModel": {
+        "type": "string",
+        "description": "Optional stronger tier: model for the few genuinely hard judgements (merge adjudication, contradiction classification). Falls back to llmModel, so leaving it unset keeps single-model behaviour. Overridden by AMEM_LLM_STRONG_MODEL."
+      },
+      "llmStrongBaseURL": {
+        "type": "string",
+        "description": "Optional stronger tier: endpoint. Falls back to llmBaseURL. Set all three strong fields to run the tiers on entirely different backends, e.g. a local Ollama for fast and a hosted API for strong. Overridden by AMEM_LLM_STRONG_BASE_URL."
+      },
+      "llmCrudRole": {
+        "type": "string",
+        "enum": [
+          "fast",
+          "strong"
+        ],
+        "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."
+      },
+      "crudUpdateMinSim": {
+        "type": "number",
+        "default": 0.35,
+        "description": "Similarity floor (0-1) for accepting an LLM-chosen CRUD UPDATE target. Below it the fact is stored as a new memory instead of overwriting, so a mis-picked memory is never destroyed. Raise it for cheaper/weaker models. Overridden by AMEM_CRUD_UPDATE_MIN_SIM."
+      },
       "agents": {
         "type": "object",
         "description": "Per-agent overrides keyed by agentId.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-amem",
-  "version": "1.2.2",
+  "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.",
   "license": "MIT",
   "main": "dist/index.js",
@@ -16,7 +16,7 @@
     }
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.110.0",
+    "@anthropic-ai/sdk": "^0.112.1",
     "@huggingface/transformers": "^4.2.0",
     "@node-rs/jieba": "^2.0.1",
     "@qdrant/js-client-rest": "^1.18.0",
@@ -32,7 +32,7 @@
     "tsup": "^8.4.0",
     "tsx": "^4.23.1",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.60.1",
+    "typescript-eslint": "^8.64.0",
     "vitest": "^4.1.10"
   },
   "optionalDependencies": {