openclaw-memory-alibaba-local 1.0.14 → 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

@@ -525,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 });
         }
       }
@@ -1175,16 +1175,6 @@ async function runAgentEndCapture(
 
   console.debug(`[openclaw-memory-alibaba-local] agentEndCapture fullRows=${fullRows.length} userTexts=${userRawTexts.length} uaLines=${uaLines.length}`);
 
-  // Save cursor BEFORE extraction so that a failure in extraction/storage
-  // does not leave the cursor un-advanced, which would cause duplicate
-  // full_context rows on retry.
-  map[key] = {
-    version: 2,
-    roleCounts: { ...running },
-    lastMessagesLength: messages.length,
-  };
-  saveAgentEndCursorMap(lancedbDir, map);
-
   if (fullRows.length > 0) {
     await db.storeMany(
       agentId,
@@ -1208,6 +1198,205 @@ async function runAgentEndCapture(
     captureUserMemoryFromInboundTexts(cfg, db, backend, agentId, sid, userId, userRawTexts),
     captureSelfImprovingFromLines(cfg, db, backend, agentId, sid, userId, uaLines),
   ]);
+
+  map[key] = {
+    version: 2,
+    roleCounts: { ...running },
+    lastMessagesLength: messages.length,
+  };
+  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). */
@@ -1257,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,
@@ -1267,9 +1456,12 @@ 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) {
@@ -1280,6 +1472,13 @@ async function captureUserMemoryFromInboundTexts(
     }
   }
 
+  // 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;
@@ -1291,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,
@@ -1311,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
@@ -1361,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 },
         );
@@ -1377,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 },
         );
@@ -1407,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, {
@@ -1422,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(" | ")}`);
@@ -1467,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 },
         );
@@ -1784,7 +2030,7 @@ const memoryPlugin = {
         }
 
         const getDbAndBackend = (): { db: MemoryDB; backend: EmbeddingBackend } | null =>
-          backend ? { db, backend } : null;
+          backend && db ? { db, backend } : null;
 
         const memoryAdminOpts = backend
           ? {
@@ -2174,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.14",
+  "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,13 +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 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.
@@ -273,6 +285,7 @@ Only INSERT or UPDATE information that captures a concrete, verifiable fact or e
 3. **High cohesion**: Only merge entries about the exact same event or fact. Different events stay separate even if related.
 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.