openclaw-memory-alibaba-local 1.0.13 → 1.0.15

package/db.ts

@@ -1201,6 +1201,61 @@ export class MemoryDB {
     return rows.length > 0;
   }
 
+  /**
+   * Whether this agent+session already has user-memory rows whose embeddings are ≥ minScore similar to the query.
+   * Used to suppress near-duplicate inserts when the userImage LLM issues insert instead of skip/update.
+   */
+  async hasHighlySimilarUserMemoryInSession(
+    agentId: string,
+    sessionId: string,
+    vectors: number[][],
+    minScore: number,
+  ): Promise<boolean> {
+    if (vectors.length === 0) {
+      return false;
+    }
+    await this.ensureInitialized();
+    await this.refreshToLatest();
+    const hits = await this.searchMerged(agentId, vectors, 28, minScore, [...USER_MEMORY_CATEGORIES]);
+    const sid = normSessionId(sessionId);
+    for (const h of hits) {
+      if (normSessionId(h.entry.sessionId) !== sid) {
+        continue;
+      }
+      if (h.score >= minScore) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Same as {@link hasHighlySimilarUserMemoryInSession} but scoped to `world_fact` rows (session-local dedup on re-send).
+   */
+  async hasHighlySimilarWorldFactInSession(
+    agentId: string,
+    sessionId: string,
+    vectors: number[][],
+    minScore: number,
+  ): Promise<boolean> {
+    if (vectors.length === 0) {
+      return false;
+    }
+    await this.ensureInitialized();
+    await this.refreshToLatest();
+    const hits = await this.searchMerged(agentId, vectors, 28, minScore, [WORLD_FACT]);
+    const sid = normSessionId(sessionId);
+    for (const h of hits) {
+      if (normSessionId(h.entry.sessionId) !== sid) {
+        continue;
+      }
+      if (h.score >= minScore) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   /**
    * Vector search with multiple query embeddings; merge by category + text (chunk 行共享同一逻辑正文), keep max score.
    */

package/index.ts

@@ -181,13 +181,6 @@ function formatRelevantMemoriesContext(
   ].join("\n");
 }
 
-function getThresholdForCategory(cfg: MemoryConfig, category: MemoryCategory): number {
-  if (isUserMemoryCategory(category) || isFullContextSourceCategory(category) || category === FULL_CONTEXT_MEMORY) {
-    return cfg.similarityThresholdUserMemory;
-  }
-  return cfg.similarityThresholdSelfImproving;
-}
-
 /** 精简日志：仅记录 tag + prompt 字符数，不贴原文。 */
 function logLlmCall(tag: string, promptChars: number): void {
   console.debug(`[openclaw-memory-alibaba-local] llm ${tag} prompt (${promptChars} chars)`);
@@ -532,8 +525,8 @@ async function extractUserMemoriesWithLLM(
       for (const item of list) {
         const text = typeof item.text === "string" ? item.text.trim() : "";
         if (text.length >= 10 && text.length <= 2000) {
-          // importance: 0.7 if text mentions User, 0.5 otherwise
-          const importance = /\bUser\b/.test(text) ? 0.7 : 0.5;
+          // importance: 0.7 if text mentions User / 用户, 0.5 otherwise
+          const importance = /\bUser\b|用户/.test(text) ? 0.7 : 0.5;
           out.push({ category: USER_MEMORY_FACT, text, importance });
         }
       }
@@ -1214,6 +1207,198 @@ async function runAgentEndCapture(
   saveAgentEndCursorMap(lancedbDir, map);
 }
 
+/** Strip leading bracketed date tags (e.g. [YYYY-MM-DD], [as of …]) from unified extraction lines. */
+function stripExtractionDatePrefixes(text: string): string {
+  let t = text.trim();
+  const datedPrefix = /^\[[^\]]*\]\s*/u;
+  while (datedPrefix.test(t)) {
+    t = t.replace(datedPrefix, "").trim();
+  }
+  return t;
+}
+
+/** Normalize extraction text for comparing whether world vs user items state the same fact (same `agent_end` batch). */
+function normalizeCoreForPersonalWorldDedup(text: string): string {
+  return stripExtractionDatePrefixes(text)
+    .replace(/\bUser\b/gi, "")
+    .replace(/用户/g, "")
+    .replace(/\s+/g, "")
+    .toLowerCase();
+}
+
+/**
+ * True if two extractions likely duplicate the same fact across personal vs world routing.
+ * Conservative: avoids dropping distinct world facts that merely mention similar words.
+ */
+function personalWorldCoreOverlaps(a: string, b: string): boolean {
+  const ca = normalizeCoreForPersonalWorldDedup(a);
+  const cb = normalizeCoreForPersonalWorldDedup(b);
+  const minLen = 12;
+  if (ca.length < minLen || cb.length < minLen) {
+    return false;
+  }
+  if (ca.includes(cb) || cb.includes(ca)) {
+    return true;
+  }
+  const sa = new Set([...ca]);
+  let inter = 0;
+  for (const ch of cb) {
+    if (sa.has(ch)) inter++;
+  }
+  const ratio = inter / Math.min(ca.length, cb.length);
+  return ratio > 0.55;
+}
+
+/**
+ * Same-turn / same-extractor-call: drop subset-redundant lines (keep longer) before user/world image LLM.
+ * Uses normalized cores; minCoreLen avoids over-merging short fragments.
+ */
+function dedupeExtractionBatchBySubstringContainment(
+  items: LLMExtractionItem[],
+  minCoreLen: number,
+): LLMExtractionItem[] {
+  const out: LLMExtractionItem[] = [];
+  for (const item of items) {
+    const ca = normalizeCoreForPersonalWorldDedup(item.text);
+    if (ca.length < minCoreLen) {
+      out.push(item);
+      continue;
+    }
+    let handled = false;
+    for (let i = 0; i < out.length; i++) {
+      const prev = out[i]!;
+      const cb = normalizeCoreForPersonalWorldDedup(prev.text);
+      if (cb.length < minCoreLen) {
+        continue;
+      }
+      if (ca.includes(cb) || cb.includes(ca)) {
+        out[i] = item.text.length >= prev.text.length ? item : prev;
+        handled = true;
+        break;
+      }
+    }
+    if (!handled) {
+      out.push(item);
+    }
+  }
+  return out;
+}
+
+function filterWorldItemsAgainstUserItems(
+  eventItems: LLMExtractionItem[],
+  userItems: LLMExtractionItem[],
+): LLMExtractionItem[] {
+  if (userItems.length === 0 || eventItems.length === 0) {
+    return eventItems;
+  }
+  return eventItems.filter(
+    (e) => !userItems.some((u) => personalWorldCoreOverlaps(e.text, u.text)),
+  );
+}
+
+/**
+ * Hard-drop lines that the iteration guide expects as empty (trivia, one-shot tasks, pure greetings).
+ * Complements the LLM prompt; blocks mistaken world_fact rows like generic astronomy facts.
+ */
+function isNoiseExtractionText(text: string): boolean {
+  const core = stripExtractionDatePrefixes(text).trim();
+  if (!core) {
+    return true;
+  }
+  if (/^(你好|您好|hi|hello|hey)\b[!！。.?？\s]*$/iu.test(core)) {
+    return true;
+  }
+  if (!/\bUser\b|用户/.test(core)) {
+    if (/地球围绕太阳|地球绕着太阳|围着太阳转|绕太阳/u.test(core)) {
+      return true;
+    }
+    if (/^1\s*\+\s*1\b/u.test(core)) {
+      return true;
+    }
+    if (/python.*list.*tuple|list\s+and\s+tuple.*(区别|difference)/iu.test(core)) {
+      return true;
+    }
+    if (/(帮我)?查一下.*天气|check.*weather/u.test(core)) {
+      return true;
+    }
+    if (/翻译一下这句话|translate\s+(this|the\s+sentence)/iu.test(core)) {
+      return true;
+    }
+    if (/帮我把这段代码|bug\s*修|生成.*ppt|ppt\s*大纲|outline\s*for\s*a\s*ppt/iu.test(core)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function filterNoiseExtractions(items: LLMExtractionItem[]): LLMExtractionItem[] {
+  return items.filter((item) => !isNoiseExtractionText(item.text));
+}
+
+/** Min cosine-similarity (0–1) for treating a candidate insert as a near-duplicate of existing user memory in the same session. */
+function nearDuplicateUserInsertMinScore(cfg: MemoryConfig): number {
+  return Math.min(0.91, Math.max(0.78, cfg.similarityThresholdUserMemory + 0.28));
+}
+
+function nearDuplicateWorldInsertMinScore(cfg: MemoryConfig): number {
+  return Math.min(0.91, Math.max(0.82, cfg.similarityThresholdUserMemory + 0.22));
+}
+
+/** Treat text with/without trailing CJK/Latin sentence punctuation as the same for exact dedup. */
+function userMemoryTextDedupVariants(text: string): string[] {
+  const t = text.trim();
+  const stripped = t.replace(/[。．.!！?？；;]+$/u, "").trim();
+  if (stripped.length === 0) {
+    return [t];
+  }
+  if (stripped === t) {
+    return [t];
+  }
+  return [t, stripped];
+}
+
+async function existsUserSemanticDuplicateAnyVariant(
+  db: MemoryDB,
+  agentId: string,
+  sessionKey: string,
+  category: UserMemoryCategory,
+  memText: string,
+): Promise<boolean> {
+  for (const v of userMemoryTextDedupVariants(memText)) {
+    if (await db.existsSemanticDuplicate(agentId, sessionKey, category, v)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Personal memories must not carry date tags; must start with `User` or `用户` per iteration guide.
+ */
+function normalizePersonalMemoryTextForStore(text: string): string {
+  let t = stripExtractionDatePrefixes(text).trim();
+  if (typeof t.normalize === "function") {
+    t = t.normalize("NFC");
+  }
+  t = t.replace(/\u00a0/g, " ").replace(/\s+/g, " ").trim();
+  if (t.length < 2) {
+    return t;
+  }
+  if (/^User\b/u.test(t) || /^用户/u.test(t)) {
+    return t;
+  }
+  const hasCjk = /\p{Script=Han}/u.test(t);
+  if (hasCjk) {
+    const body = t.replace(/^我(的)?/u, "").trim();
+    if (body.length === 0) {
+      return `用户${t}`;
+    }
+    const joiner = /^[，。！？、：]/.test(body) ? "" : "";
+    return `用户${joiner}${body}`;
+  }
+  return `User ${t}`;
+}
+
 /** User memory from raw user message texts (agent_end user delta). */
 async function captureUserMemoryFromInboundTexts(
   cfg: MemoryConfig,
@@ -1261,7 +1446,7 @@ async function captureUserMemoryFromInboundTexts(
   const toSend = texts.filter((t) => t.length >= 5 && t.length <= cfg.captureMaxChars);
   if (toSend.length === 0) return;
 
-  const extractions = await extractUserMemoriesWithLLM(
+  let extractions = await extractUserMemoriesWithLLM(
     cfg.llm,
     toSend,
     MAX_AUTO_CAPTURE_LLM,
@@ -1271,17 +1456,29 @@ async function captureUserMemoryFromInboundTexts(
   });
   if (extractions.length === 0) return;
 
+  extractions = filterNoiseExtractions(extractions);
+  if (extractions.length === 0) return;
+
   // ---- Always split: User-related items vs event items ----
-  const userItems: LLMExtractionItem[] = [];
-  const eventItems: LLMExtractionItem[] = [];
+  let userItems: LLMExtractionItem[] = [];
+  let eventItems: LLMExtractionItem[] = [];
+  // Match both English "User" and Chinese "用户" to correctly route user preferences
+  const USER_SUBJECT_RE = /\bUser\b|用户/;
   for (const item of extractions) {
-    if (/\bUser\b/.test(item.text)) {
+    if (USER_SUBJECT_RE.test(item.text)) {
       userItems.push(item);
     } else {
       eventItems.push(item);
     }
   }
 
+  // Same `agent_end` batch: do not send facts to world that duplicate user-route extractions
+  eventItems = filterWorldItemsAgainstUserItems(eventItems, userItems);
+
+  // Collapse subset-redundant lines from a single extraction pass (reduces userImage / worldImage churn)
+  userItems = dedupeExtractionBatchBySubstringContainment(userItems, 14);
+  eventItems = dedupeExtractionBatchBySubstringContainment(eventItems, 22);
+
   // ---- Parallel: event-item pipeline & user-item pipeline ----
   const eventPipeline = async () => {
     if (eventItems.length === 0) return;
@@ -1293,6 +1490,18 @@ async function captureUserMemoryFromInboundTexts(
         if (await db.existsSemanticDuplicate(agentId, sessionKey, e.category, text)) {
           continue;
         }
+        const { vectors } = await backend.encodeForStorage(text);
+        if (
+          isWorldFact(e.category) &&
+          (await db.hasHighlySimilarWorldFactInSession(
+            agentId,
+            sessionKey,
+            vectors,
+            nearDuplicateWorldInsertMinScore(cfg),
+          ))
+        ) {
+          continue;
+        }
         await storeOneCaptureItem(agentId, { category: e.category, text, importance: e.importance }, cfg, db, backend, {
           userId,
           sessionId: sessionKey,
@@ -1313,7 +1522,7 @@ async function captureUserMemoryFromInboundTexts(
   
     // 2. Per-item recall: for each event item recall top-3 similar existing world_facts, then dedup
     const recallMinScore = Math.max(0.5, cfg.similarityThresholdUserMemory - 0.35);
-    const PER_ITEM_RECALL = 3;
+    const PER_ITEM_RECALL = 10;
     const candidateMap = new Map<string, MemorySearchResult>();
     for (const er of embeddingResults) {
       const perItemHits = er.vectors.length > 0
@@ -1363,15 +1572,17 @@ async function captureUserMemoryFromInboundTexts(
         continue;
       }
   
+      const worldText = truncateForCapture(action.text, cfg.captureMaxChars);
+
       if (action.action === "update") {
         const hit = existingCandidates.find((c) => c.entry.id === action.memoryId);
         if (hit) {
           await deleteSimilarLogicalMemory(db, agentId, hit.entry.sessionId, hit);
           deleteCount++;
         }
-        const { vectors } = await backend.encodeForStorage(action.text);
+        const { vectors } = await backend.encodeForStorage(worldText);
         const rows = buildChunkRows(
-          { category: WORLD_FACT as MemoryCategory, text: action.text, importance: action.importance },
+          { category: WORLD_FACT as MemoryCategory, text: worldText, importance: action.importance },
           vectors,
           { userId, sessionId: sessionKey },
         );
@@ -1379,9 +1590,19 @@ async function captureUserMemoryFromInboundTexts(
         insertCount++;
       } else {
         // insert
-        const { vectors } = await backend.encodeForStorage(action.text);
+        if (await db.existsSemanticDuplicate(agentId, sessionKey, WORLD_FACT, worldText)) {
+          continue;
+        }
+        const { vectors } = await backend.encodeForStorage(worldText);
+        const wMin = nearDuplicateWorldInsertMinScore(cfg);
+        if (await db.hasHighlySimilarWorldFactInSession(agentId, sessionKey, vectors, wMin)) {
+          console.debug(
+            `[openclaw-memory-alibaba-local] skip world insert (near-duplicate in session, minScore=${wMin})`,
+          );
+          continue;
+        }
         const rows = buildChunkRows(
-          { category: WORLD_FACT as MemoryCategory, text: action.text, importance: action.importance },
+          { category: WORLD_FACT as MemoryCategory, text: worldText, importance: action.importance },
           vectors,
           { userId, sessionId: sessionKey },
         );
@@ -1409,8 +1630,13 @@ async function captureUserMemoryFromInboundTexts(
     if (!cfg.llm) {
       console.warn(`[openclaw-memory-alibaba-local] no LLM configured, user items bypass UserImageExtraction`);
       for (const e of userItems) {
-        const text = truncateForCapture(e.text, cfg.captureMaxChars);
-        if (await db.existsSemanticDuplicate(agentId, sessionKey, e.category, text)) {
+        const text = truncateForCapture(normalizePersonalMemoryTextForStore(e.text), cfg.captureMaxChars);
+        if (await existsUserSemanticDuplicateAnyVariant(db, agentId, sessionKey, e.category, text)) {
+          continue;
+        }
+        const { vectors } = await backend.encodeForStorage(text);
+        const ndMin = nearDuplicateUserInsertMinScore(cfg);
+        if (await db.hasHighlySimilarUserMemoryInSession(agentId, sessionKey, vectors, ndMin)) {
           continue;
         }
         await storeOneCaptureItem(agentId, { category: e.category, text, importance: e.importance }, cfg, db, backend, {
@@ -1424,17 +1650,17 @@ async function captureUserMemoryFromInboundTexts(
     // 1. Batch embed all new extractions
     const embeddingResults: { item: LLMExtractionItem; vectors: number[][] }[] = [];
     for (const item of userItems) {
-      const truncated = truncateForCapture(item.text, cfg.captureMaxChars);
+      const truncated = truncateForCapture(normalizePersonalMemoryTextForStore(item.text), cfg.captureMaxChars);
       const { vectors } = await backend.encodeForStorage(truncated);
       embeddingResults.push({ item: { ...item, text: truncated }, vectors });
     }
 
-    // 2. Recall top-10 similar existing memories for ALL new extractions (agentId global, USER_MEMORY scope)
+    // 2. Recall top similar existing memories for ALL new extractions (agentId global, USER_MEMORY scope)
     const allVectors = embeddingResults.flatMap((r) => r.vectors);
     const recallMinScore = Math.max(0.5, cfg.similarityThresholdUserMemory - 0.35);
     console.debug(`[openclaw-memory-alibaba-local] userImageExtraction recall: ${allVectors.length} query vectors, minScore=${recallMinScore}`);
     const existingCandidates = allVectors.length > 0
-      ? await db.searchMerged(agentId, allVectors, 10, recallMinScore, [...USER_MEMORY_CATEGORIES])
+      ? await db.searchMerged(agentId, allVectors, 40, recallMinScore, [...USER_MEMORY_CATEGORIES])
       : [];
     if (existingCandidates.length > 0) {
       console.debug(`[openclaw-memory-alibaba-local] userImageExtraction recall found ${existingCandidates.length} candidates: ${existingCandidates.map((c) => `[${c.score.toFixed(3)}] ${c.entry.text.slice(0, 60)}`).join(" | ")}`);
@@ -1469,23 +1695,41 @@ async function captureUserMemoryFromInboundTexts(
         continue;
       }
 
+      const memText = truncateForCapture(
+        normalizePersonalMemoryTextForStore(action.text),
+        cfg.captureMaxChars,
+      );
+
+      if (action.action === "insert") {
+        if (await existsUserSemanticDuplicateAnyVariant(db, agentId, sessionKey, action.category, memText)) {
+          continue;
+        }
+      }
+
       if (action.action === "update") {
         const hit = existingCandidates.find((c) => c.entry.id === action.memoryId);
         if (hit) {
           await deleteSimilarLogicalMemory(db, agentId, hit.entry.sessionId, hit);
         }
-        const { vectors } = await backend.encodeForStorage(action.text);
+        const { vectors } = await backend.encodeForStorage(memText);
         const rows = buildChunkRows(
-          { category: action.category, text: action.text, importance: action.importance },
+          { category: action.category, text: memText, importance: action.importance },
           vectors,
           { userId, sessionId: sessionKey },
         );
         await db.storeMany(agentId, rows);
       } else {
         // insert
-        const { vectors } = await backend.encodeForStorage(action.text);
+        const { vectors } = await backend.encodeForStorage(memText);
+        const ndMin = nearDuplicateUserInsertMinScore(cfg);
+        if (await db.hasHighlySimilarUserMemoryInSession(agentId, sessionKey, vectors, ndMin)) {
+          console.debug(
+            `[openclaw-memory-alibaba-local] skip user insert (near-duplicate in session, minScore=${ndMin})`,
+          );
+          continue;
+        }
         const rows = buildChunkRows(
-          { category: action.category, text: action.text, importance: action.importance },
+          { category: action.category, text: memText, importance: action.importance },
           vectors,
           { userId, sessionId: sessionKey },
         );
@@ -1646,21 +1890,16 @@ async function storeOneCaptureItem(
   if (vectors.length === 0) {
     throw new Error("openclaw-memory-alibaba-local: encodeForStorage returned no vectors");
   }
-  const threshold = getThresholdForCategory(cfg, item.category);
   const dedupCategories = getDedupCategories(item.category);
   const rows = buildChunkRows(item, vectors, options);
 
-  if (!cfg.memory_duplication_conflict_process) {
-    const similar = await db.searchMerged(agentId, vectors, 1, threshold, [...dedupCategories]);
-    if (similar.length > 0) {
-      await deleteSimilarLogicalMemory(db, agentId, options?.sessionId, similar[0]!);
-    }
-    const stored = await db.storeMany(agentId, rows);
-    return { action: similar.length > 0 ? "updated" : "created", entry: stored[0]! };
-  }
-
-  // With conflict_process: simple similarity-based dedup (batch merge handles LLM dedup for user memory)
-  const recallMinScore = Math.max(0.5, threshold - 0.35);
+  // Guard against near-exact duplicates only (score >= 0.92).
+  // Lower thresholds (e.g. 0.65) would incorrectly treat similar-but-different
+  // items as duplicates (e.g. "likes apples" vs "likes fish").
+  // Semantic dedup for lower-similarity candidates is handled by the LLM CRUD
+  // pipeline (userPipeline / eventPipeline) when memory_duplication_conflict_process is on.
+  const NEAR_EXACT_THRESHOLD = 0.92;
+  const recallMinScore = Math.max(0.5, NEAR_EXACT_THRESHOLD - 0.15);
   const candidates = await db.searchMerged(
     agentId,
     vectors,
@@ -1668,11 +1907,11 @@ async function storeOneCaptureItem(
     recallMinScore,
     [...dedupCategories],
   );
-  if (candidates.length > 0 && candidates[0]!.score >= threshold) {
+  if (candidates.length > 0 && candidates[0]!.score >= NEAR_EXACT_THRESHOLD) {
     await deleteSimilarLogicalMemory(db, agentId, options?.sessionId, candidates[0]!);
   }
   const stored = await db.storeMany(agentId, rows);
-  return { action: candidates.length > 0 && candidates[0]!.score >= threshold ? "updated" : "created", entry: stored[0]! };
+  return { action: candidates.length > 0 && candidates[0]!.score >= NEAR_EXACT_THRESHOLD ? "updated" : "created", entry: stored[0]! };
 }
 
 // ---------------------------------------------------------------------------
@@ -1791,7 +2030,7 @@ const memoryPlugin = {
         }
 
         const getDbAndBackend = (): { db: MemoryDB; backend: EmbeddingBackend } | null =>
-          backend ? { db, backend } : null;
+          backend && db ? { db, backend } : null;
 
         const memoryAdminOpts = backend
           ? {
@@ -2181,6 +2420,7 @@ const memoryPlugin = {
 
     if (cfg.autoCapture) {
       api.on("agent_end", async (event, ctx) => {
+        console.log("[openclaw-memory-alibaba-local] smoke: agent_end hook invoked");
         if (!db || !backend) {
           return;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-memory-alibaba-local",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "OpenClaw memory plugin: local LanceDB + DashScope-compatible embeddings",
   "type": "module",
   "engines": {

package/prompts.ts

@@ -33,6 +33,7 @@ Rewrite the input into clear, complete sentences and output memory entries.
 3) TEMPORAL: Prefix every entry with a [date] tag — mandatory.
 4) SUBJECT: Every entry must have an explicit subject after the date prefix.
 5) NO SUBSUMPTION: No entry should be a subset of another entry in this batch. If one sentence already covers the information, do not emit a narrower duplicate.
+6) **Single-message User facts**: When one user utterance states several **independent** User facts, still emit **one line per distinct topic**, but never two lines where one is a **clear subset** of the other — merge sub-facts into the broader line for that topic.
 
 # Date Tag Rules
 - Explicit absolute date -> [YYYY-MM-DD], [YYYY-MM], or [YYYY]
@@ -42,9 +43,12 @@ Rewrite the input into clear, complete sentences and output memory entries.
 Do NOT convert relative dates to absolute. No entry may be undated.
 
 # Subject Rules
-- If the API caller's own information is explicitly stated (e.g., "I/my/me") -> use "User" as subject.
+- If the API caller's own information is explicitly stated (e.g., "I/my/me", Chinese 我/我的/本人) -> you MUST use an explicit subject:
+  - English entries: start the sentence (after the date tag) with **User** (e.g. "User's name is …", "User works in …").
+  - Chinese entries: start the sentence (after the date tag) with **用户** (e.g. "用户名字是…", "用户在杭州工作").
 - Otherwise, use actual names/nicknames/roles as stated in the text.
 - Do not infer that a named person is the API caller unless the text explicitly indicates it.
+- **No cross-pipeline duplication**: If a fact is about the API caller, emit it ONLY as a User/用户-subject entry. Do NOT also emit a separate entry that restates the same fact as a third-party or generic sentence in the same batch.
 
 # Sentence Rewrite Rules
 - Clean up casual or fragmented language into well-formed statements.
@@ -64,8 +68,11 @@ Do NOT convert relative dates to absolute. No entry may be undated.
 
 # Exclude
 - Passwords, API keys, credentials
-- Pure small talk ("Bye!", "Take care!")
-- Conversational reactions that carry no new factual information (e.g., "That's great!", "Congrats!", "Sorry to hear that", "Thanks!", expressions of agreement or sympathy without new content)`;
+- Pure small talk ("Bye!", "Take care!", isolated "你好" / "Hi" with no other content)
+- Conversational reactions that carry no new factual information (e.g., "That's great!", "Congrats!", "Sorry to hear that", "Thanks!", expressions of agreement or sympathy without new content)
+- **Standalone general knowledge** not tied to the User's life, plans, preferences, or identity (e.g. "Earth orbits the Sun in one year", "1+1=2", textbook facts) — omit entirely unless the User explicitly relates the fact to themselves
+- **One-off task requests** with no durable personal stake (e.g. "check today's weather", "translate this sentence", "fix this bug", "generate a PPT outline") — omit unless they reveal lasting preferences or constraints
+- **Pure technical Q&A** with no personal profile content (e.g. language syntax comparisons) — omit`;
 
 export const MEMORY_EXTRACTION_FORMAT = `
 
@@ -201,12 +208,18 @@ Only INSERT or UPDATE information that reveals something lasting about the User:
 - One-time commands or ephemeral task instructions (e.g. "User asked to run command X", "User requested to install Y")
 - Meta-conversation actions (e.g. "User inquired about ...", "User cancelled ...")
 - Generic observations with no personal relevance
-- Information that is already fully covered by a Store item
+- Information that is already fully covered by a Store item — **even if wording differs** (same fact → SKIP, do not INSERT another row)
+- **Rephrasings** of the same fact already in Store (e.g. Store has "用户在杭州工作" and batch says "用户的工作地点是杭州" → SKIP)
+- **Aggressive dedup**: If Store already contains the same fact with different wording, punctuation, or sentence order, you MUST SKIP — do not add another row. When in doubt between INSERT and SKIP for personal profile facts, prefer **SKIP**.
 
 # Refinement Principles
 1. **Prefer the richer version**: When a batch item and a Store item describe the same topic, keep whichever has the most information. If the batch adds new details, UPDATE to include them.
-2. **High cohesion**: Only merge entries about the exact same topic. Entries about different topics stay separate.
-3. **Strip date prefixes**: Input text may contain [date] or [as of ...] prefixes — remove them from the output text. User profile memories are evergreen and should not carry temporal tags.
+2. **High cohesion**: Only merge entries about the exact same specific topic. Entries about different topics stay separate.
+3. **Multiple preferences coexist**: Different concrete items under the same category are NOT duplicates. For example, "User likes apples" and "User likes fish" are two separate preferences — INSERT both, do NOT UPDATE or DELETE one for the other. Only UPDATE/DELETE when the new item truly contradicts or refines the old one (e.g. "User no longer likes apples" replaces "User likes apples").
+4. **Strip date prefixes**: Input text may contain [date] or [as of ...] prefixes — remove them from the output text. User profile memories are evergreen and should not carry temporal tags.
+5. **Subject prefix (mandatory)**: Every INSERT/UPDATE output field "text" MUST begin with **User** (English) or **用户** (Chinese) — the same convention as in the extraction stage. Never output first-person "I/我" as the subject for profile facts.
+6. **Contradictions (critical)**: If the batch **replaces or negates** a Store item on the **same habit or stance** (e.g. Store: User runs every morning / 用户晨跑; batch: User now hates running / 用户讨厌跑步 → **DELETE** the old habit and **INSERT** the new stance; do **not** keep both). Diet: "不吃辣" vs "能接受微辣" → **merge** into one current preference and **DELETE** outdated conflicting lines if needed. Relationship: "女朋友小美" vs "已分手" → **DELETE** girlfriend-as-current and **INSERT** breakup / ex status.
+7. **Store hygiene**: If Store already has **multiple** rows that are clearly the **same repeating fact** (near-identical wording or partial duplicates), use **DELETE** on redundant ids and **UPDATE** one survivor — aim for **one row per stable fact topic** when the batch makes that obvious.
 
 # Actions (one per batch index)
 - **INSERT**: New lasting personal info not in Store.
@@ -270,7 +283,9 @@ Only INSERT or UPDATE information that captures a concrete, verifiable fact or e
 1. **Prefer the richer version**: When a batch item and a Store item describe the same topic, keep whichever has the most information. If the batch is richer, DELETE the old Store item and INSERT the batch item. If they are roughly equal, UPDATE to merge details.
 2. **Preserve temporal markers**: Keep [as of ...] or [date] prefixes — world facts are time-sensitive.
 3. **High cohesion**: Only merge entries about the exact same event or fact. Different events stay separate even if related.
-4. **Contradiction = replace**: If a batch item directly contradicts a Store item (e.g. different outcome), DELETE the old item and INSERT the new one.
+4. **Multiple items coexist**: Different concrete items under the same category are NOT duplicates. For example, "likes apples" and "likes fish" are two separate facts — INSERT both. Only DELETE when the new item truly contradicts the old one (e.g. a corrected outcome).
+5. **Contradiction = replace**: If a batch item directly contradicts a Store item (e.g. different outcome), DELETE the old item and INSERT the new one.
+6. **Re-ingestion / replay**: If the batch is essentially the **same article or chat** already captured in Store (user pasted it again), prefer **SKIP** or **UPDATE** to enrich — avoid a second nearly identical INSERT when meaning is unchanged.
 
 # Actions (one per batch index)
 - **INSERT**: New world fact not in Store.