@memtensor/memos-local-openclaw-plugin 0.3.20 → 1.0.1

package/src/ingest/providers/bedrock.ts

@@ -76,16 +76,30 @@ export async function summarizeTaskBedrock(
   return json.output?.message?.content?.[0]?.text?.trim() ?? "";
 }
 
-const TOPIC_JUDGE_PROMPT = `You are a conversation topic boundary detector. Given a summary of the CURRENT conversation and a NEW user message, determine if the new message starts a DIFFERENT topic/task.
+const TOPIC_JUDGE_PROMPT = `You are a conversation topic boundary detector. Given the CURRENT task context (may include opening topic + recent exchanges) and a single NEW user message, decide if the new message belongs to the SAME task or starts a NEW one.
 
 Answer ONLY "NEW" or "SAME".
 
-Rules:
-- "NEW" = the new message is about a completely different subject, project, or task
-- "SAME" = the new message continues, follows up on, or is closely related to the current topic
-- Follow-up questions, clarifications, refinements, bug fixes, or next steps on the same task = SAME
-- Greetings or meta-questions like "你好" or "谢谢" without new substance = SAME
-- A clearly unrelated request (e.g., current topic is deployment, new message asks about cooking) = NEW
+SAME — the new message:
+- Continues, follows up on, refines, or corrects the same subject/project/task
+- Asks a clarification or next-step question about what was just discussed
+- Reports a result, error, or feedback about the current task
+- Discusses different tools, methods, or approaches for the SAME goal (e.g., learning English via BBC → via ChatGPT → via AI tools = all SAME "learning English" task)
+- Mentions a related technology or platform in the context of the current goal
+- Is a short acknowledgment (ok, thanks, 好的, 嗯) in direct response to the current flow
+
+NEW — the new message:
+- Introduces a clearly UNRELATED subject with NO logical connection to the current task
+- The topic has ZERO overlap with any aspect of the current conversation (e.g., from "learning English" to "what's the weather tomorrow")
+- Starts a request about a completely different domain or life area
+- Begins with a new greeting/reset followed by a different topic
+
+Key principles:
+- STRONGLY lean toward SAME — only mark NEW for obvious, unambiguous topic shifts
+- Different aspects, tools, or methods related to the same overall goal are SAME
+- If the new message could reasonably be interpreted as part of the ongoing discussion, choose SAME
+- Only choose NEW when there is absolutely no thematic connection to the current task
+- Examples: "学英语" → "用AI工具学英语" = SAME; "学英语" → "明天天气" = NEW
 
 Output exactly one word: NEW or SAME`;
 
@@ -107,7 +121,7 @@ export async function judgeNewTopicBedrock(
     ...cfg.headers,
   };
 
-  const userContent = `CURRENT CONVERSATION SUMMARY:\n${currentContext}\n\nNEW USER MESSAGE:\n${newMessage}`;
+  const userContent = `CURRENT TASK CONTEXT:\n${currentContext}\n\n---\n\nNEW USER MESSAGE:\n${newMessage}`;
 
   const resp = await fetch(url, {
     method: "POST",

package/src/ingest/providers/gemini.ts

@@ -75,16 +75,30 @@ export async function summarizeTaskGemini(
   return json.candidates?.[0]?.content?.parts?.[0]?.text?.trim() ?? "";
 }
 
-const TOPIC_JUDGE_PROMPT = `You are a conversation topic boundary detector. Given a summary of the CURRENT conversation and a NEW user message, determine if the new message starts a DIFFERENT topic/task.
+const TOPIC_JUDGE_PROMPT = `You are a conversation topic boundary detector. Given the CURRENT task context (may include opening topic + recent exchanges) and a single NEW user message, decide if the new message belongs to the SAME task or starts a NEW one.
 
 Answer ONLY "NEW" or "SAME".
 
-Rules:
-- "NEW" = the new message is about a completely different subject, project, or task
-- "SAME" = the new message continues, follows up on, or is closely related to the current topic
-- Follow-up questions, clarifications, refinements, bug fixes, or next steps on the same task = SAME
-- Greetings or meta-questions like "你好" or "谢谢" without new substance = SAME
-- A clearly unrelated request (e.g., current topic is deployment, new message asks about cooking) = NEW
+SAME — the new message:
+- Continues, follows up on, refines, or corrects the same subject/project/task
+- Asks a clarification or next-step question about what was just discussed
+- Reports a result, error, or feedback about the current task
+- Discusses different tools, methods, or approaches for the SAME goal (e.g., learning English via BBC → via ChatGPT → via AI tools = all SAME "learning English" task)
+- Mentions a related technology or platform in the context of the current goal
+- Is a short acknowledgment (ok, thanks, 好的, 嗯) in direct response to the current flow
+
+NEW — the new message:
+- Introduces a clearly UNRELATED subject with NO logical connection to the current task
+- The topic has ZERO overlap with any aspect of the current conversation (e.g., from "learning English" to "what's the weather tomorrow")
+- Starts a request about a completely different domain or life area
+- Begins with a new greeting/reset followed by a different topic
+
+Key principles:
+- STRONGLY lean toward SAME — only mark NEW for obvious, unambiguous topic shifts
+- Different aspects, tools, or methods related to the same overall goal are SAME
+- If the new message could reasonably be interpreted as part of the ongoing discussion, choose SAME
+- Only choose NEW when there is absolutely no thematic connection to the current task
+- Examples: "学英语" → "用AI工具学英语" = SAME; "学英语" → "明天天气" = NEW
 
 Output exactly one word: NEW or SAME`;
 
@@ -105,7 +119,7 @@ export async function judgeNewTopicGemini(
     ...cfg.headers,
   };
 
-  const userContent = `CURRENT CONVERSATION SUMMARY:\n${currentContext}\n\nNEW USER MESSAGE:\n${newMessage}`;
+  const userContent = `CURRENT TASK CONTEXT:\n${currentContext}\n\n---\n\nNEW USER MESSAGE:\n${newMessage}`;
 
   const resp = await fetch(url, {
     method: "POST",

package/src/ingest/providers/index.ts

@@ -1,3 +1,5 @@
+import * as fs from "fs";
+import * as path from "path";
 import type { SummarizerConfig, Logger } from "../../types";
 import { summarizeOpenAI, summarizeTaskOpenAI, judgeNewTopicOpenAI, filterRelevantOpenAI, judgeDedupOpenAI } from "./openai";
 import type { FilterResult, DedupResult } from "./openai";
@@ -6,190 +8,238 @@ import { summarizeAnthropic, summarizeTaskAnthropic, judgeNewTopicAnthropic, fil
 import { summarizeGemini, summarizeTaskGemini, judgeNewTopicGemini, filterRelevantGemini, judgeDedupGemini } from "./gemini";
 import { summarizeBedrock, summarizeTaskBedrock, judgeNewTopicBedrock, filterRelevantBedrock, judgeDedupBedrock } from "./bedrock";
 
+/**
+ * Build a SummarizerConfig from OpenClaw's native model configuration (openclaw.json).
+ * This serves as the final fallback when both strongCfg and plugin summarizer fail or are absent.
+ */
+function loadOpenClawFallbackConfig(log: Logger): SummarizerConfig | undefined {
+  try {
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    const cfgPath = path.join(home, ".openclaw", "openclaw.json");
+    if (!fs.existsSync(cfgPath)) return undefined;
+
+    const raw = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
+
+    const agentModel: string | undefined = raw?.agents?.defaults?.model?.primary;
+    if (!agentModel) return undefined;
+
+    const [providerKey, modelId] = agentModel.includes("/")
+      ? agentModel.split("/", 2)
+      : [undefined, agentModel];
+
+    const providerCfg = providerKey
+      ? raw?.models?.providers?.[providerKey]
+      : Object.values(raw?.models?.providers ?? {})[0] as any;
+    if (!providerCfg) return undefined;
+
+    const baseUrl: string | undefined = providerCfg.baseUrl;
+    const apiKey: string | undefined = providerCfg.apiKey;
+    if (!baseUrl || !apiKey) return undefined;
+
+    const endpoint = baseUrl.endsWith("/chat/completions")
+      ? baseUrl
+      : baseUrl.replace(/\/+$/, "") + "/chat/completions";
+
+    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl}`);
+    return {
+      provider: "openai_compatible",
+      endpoint,
+      apiKey,
+      model: modelId,
+    };
+  } catch (err) {
+    log.debug(`Failed to load OpenClaw fallback config: ${err}`);
+    return undefined;
+  }
+}
+
 export class Summarizer {
+  private strongCfg: SummarizerConfig | undefined;
+  private fallbackCfg: SummarizerConfig | undefined;
+
   constructor(
     private cfg: SummarizerConfig | undefined,
     private log: Logger,
-  ) {}
+    strongCfg?: SummarizerConfig,
+  ) {
+    this.strongCfg = strongCfg;
+    this.fallbackCfg = loadOpenClawFallbackConfig(log);
+  }
 
-  async summarize(text: string): Promise<string> {
-    if (!this.cfg) {
-      return ruleFallback(text);
+  /**
+   * Ordered config chain: strongCfg → cfg → fallbackCfg (OpenClaw native model).
+   * Returns configs that are defined, in priority order.
+   */
+  private getConfigChain(): SummarizerConfig[] {
+    const chain: SummarizerConfig[] = [];
+    if (this.strongCfg) chain.push(this.strongCfg);
+    if (this.cfg) chain.push(this.cfg);
+    if (this.fallbackCfg) chain.push(this.fallbackCfg);
+    return chain;
+  }
+
+  /**
+   * Try calling fn with each config in the chain until one succeeds.
+   * Returns undefined if all fail.
+   */
+  private async tryChain<T>(
+    label: string,
+    fn: (cfg: SummarizerConfig) => Promise<T>,
+  ): Promise<T | undefined> {
+    const chain = this.getConfigChain();
+    for (let i = 0; i < chain.length; i++) {
+      try {
+        return await fn(chain[i]);
+      } catch (err) {
+        const level = i < chain.length - 1 ? "warn" : "error";
+        const modelInfo = `${chain[i].provider}/${chain[i].model ?? "?"}`;
+        this.log[level](`${label} failed (${modelInfo}), ${i < chain.length - 1 ? "trying next" : "no more fallbacks"}: ${err}`);
+      }
     }
+    return undefined;
+  }
 
-    try {
-      return await this.callProvider(text);
-    } catch (err) {
-      this.log.warn(`Summarizer provider failed, using rule fallback: ${err}`);
+  async summarize(text: string): Promise<string> {
+    if (!this.cfg && !this.fallbackCfg) {
       return ruleFallback(text);
     }
+
+    const result = await this.tryChain("summarize", (cfg) => callSummarize(cfg, text, this.log));
+    return result ?? ruleFallback(text);
   }
 
   async summarizeTask(text: string): Promise<string> {
-    if (!this.cfg) {
-      return taskFallback(text);
-    }
-
-    try {
-      return await this.callTaskProvider(text);
-    } catch (err) {
-      this.log.warn(`Task summarizer failed, using fallback: ${err}`);
+    if (!this.cfg && !this.fallbackCfg) {
       return taskFallback(text);
     }
-  }
 
-  private async callProvider(text: string): Promise<string> {
-    const cfg = this.cfg!;
-    switch (cfg.provider) {
-      case "openai":
-      case "openai_compatible":
-        return summarizeOpenAI(text, cfg, this.log);
-      case "anthropic":
-        return summarizeAnthropic(text, cfg, this.log);
-      case "gemini":
-        return summarizeGemini(text, cfg, this.log);
-      case "azure_openai":
-        return summarizeOpenAI(text, cfg, this.log);
-      case "bedrock":
-        return summarizeBedrock(text, cfg, this.log);
-      default:
-        throw new Error(`Unknown summarizer provider: ${cfg.provider}`);
-    }
+    const result = await this.tryChain("summarizeTask", (cfg) => callSummarizeTask(cfg, text, this.log));
+    return result ?? taskFallback(text);
   }
 
-  /**
-   * Ask the LLM whether the new message starts a different topic from the current conversation.
-   * Returns true if it's a new topic, false if it continues the current one.
-   * Returns null if no summarizer is configured (caller should fall back to heuristic).
-   */
   async judgeNewTopic(currentContext: string, newMessage: string): Promise<boolean | null> {
-    if (!this.cfg) return null;
-
-    try {
-      return await this.callTopicJudge(currentContext, newMessage);
-    } catch (err) {
-      this.log.warn(`Topic judge failed: ${err}`);
-      return null;
-    }
-  }
+    if (!this.cfg && !this.fallbackCfg) return null;
 
-  private async callTopicJudge(currentContext: string, newMessage: string): Promise<boolean> {
-    const cfg = this.cfg!;
-    switch (cfg.provider) {
-      case "openai":
-      case "openai_compatible":
-      case "azure_openai":
-        return judgeNewTopicOpenAI(currentContext, newMessage, cfg, this.log);
-      case "anthropic":
-        return judgeNewTopicAnthropic(currentContext, newMessage, cfg, this.log);
-      case "gemini":
-        return judgeNewTopicGemini(currentContext, newMessage, cfg, this.log);
-      case "bedrock":
-        return judgeNewTopicBedrock(currentContext, newMessage, cfg, this.log);
-      default:
-        throw new Error(`Unknown summarizer provider: ${cfg.provider}`);
-    }
+    const result = await this.tryChain("judgeNewTopic", (cfg) => callTopicJudge(cfg, currentContext, newMessage, this.log));
+    return result ?? null;
   }
 
-  /**
-   * Filter search results by LLM relevance judgment.
-   * Returns { relevant: number[], sufficient: boolean } or null if no summarizer configured.
-   */
   async filterRelevant(
     query: string,
     candidates: Array<{ index: number; summary: string; role: string }>,
   ): Promise<FilterResult | null> {
-    if (!this.cfg) return null;
+    if (!this.cfg && !this.fallbackCfg) return null;
     if (candidates.length === 0) return { relevant: [], sufficient: true };
 
-    try {
-      return await this.callFilterRelevant(query, candidates);
-    } catch (err) {
-      this.log.warn(`filterRelevant failed, returning all candidates: ${err}`);
-      return null;
-    }
-  }
-
-  private async callFilterRelevant(
-    query: string,
-    candidates: Array<{ index: number; summary: string; role: string }>,
-  ): Promise<FilterResult> {
-    const cfg = this.cfg!;
-    switch (cfg.provider) {
-      case "openai":
-      case "openai_compatible":
-      case "azure_openai":
-        return filterRelevantOpenAI(query, candidates, cfg, this.log);
-      case "anthropic":
-        return filterRelevantAnthropic(query, candidates, cfg, this.log);
-      case "gemini":
-        return filterRelevantGemini(query, candidates, cfg, this.log);
-      case "bedrock":
-        return filterRelevantBedrock(query, candidates, cfg, this.log);
-      default:
-        throw new Error(`Unknown summarizer provider: ${cfg.provider}`);
-    }
+    const result = await this.tryChain("filterRelevant", (cfg) => callFilterRelevant(cfg, query, candidates, this.log));
+    return result ?? null;
   }
 
-  /**
-   * Judge whether a new memory is DUPLICATE / UPDATE / NEW relative to similar existing memories.
-   * Returns null if no summarizer configured (caller should treat as NEW).
-   */
   async judgeDedup(
     newSummary: string,
     candidates: Array<{ index: number; summary: string; chunkId: string }>,
   ): Promise<DedupResult | null> {
-    if (!this.cfg) return null;
+    if (!this.cfg && !this.fallbackCfg) return null;
     if (candidates.length === 0) return null;
 
-    try {
-      return await this.callJudgeDedup(newSummary, candidates);
-    } catch (err) {
-      this.log.warn(`judgeDedup failed, treating as NEW: ${err}`);
-      return { action: "NEW", reason: "llm_error" };
-    }
+    const result = await this.tryChain("judgeDedup", (cfg) => callJudgeDedup(cfg, newSummary, candidates, this.log));
+    return result ?? { action: "NEW", reason: "all_models_failed" };
   }
 
-  private async callJudgeDedup(
-    newSummary: string,
-    candidates: Array<{ index: number; summary: string; chunkId: string }>,
-  ): Promise<DedupResult> {
-    const cfg = this.cfg!;
-    switch (cfg.provider) {
-      case "openai":
-      case "openai_compatible":
-      case "azure_openai":
-        return judgeDedupOpenAI(newSummary, candidates, cfg, this.log);
-      case "anthropic":
-        return judgeDedupAnthropic(newSummary, candidates, cfg, this.log);
-      case "gemini":
-        return judgeDedupGemini(newSummary, candidates, cfg, this.log);
-      case "bedrock":
-        return judgeDedupBedrock(newSummary, candidates, cfg, this.log);
-      default:
-        throw new Error(`Unknown summarizer provider: ${cfg.provider}`);
-    }
+  getStrongConfig(): SummarizerConfig | undefined {
+    return this.strongCfg;
   }
+}
 
-  private async callTaskProvider(text: string): Promise<string> {
-    const cfg = this.cfg!;
-    switch (cfg.provider) {
-      case "openai":
-      case "openai_compatible":
-      case "azure_openai":
-        return summarizeTaskOpenAI(text, cfg, this.log);
-      case "anthropic":
-        return summarizeTaskAnthropic(text, cfg, this.log);
-      case "gemini":
-        return summarizeTaskGemini(text, cfg, this.log);
-      case "bedrock":
-        return summarizeTaskBedrock(text, cfg, this.log);
-      default:
-        throw new Error(`Unknown summarizer provider: ${cfg.provider}`);
-    }
+// ─── Dispatch helpers ───
+
+function callSummarize(cfg: SummarizerConfig, text: string, log: Logger): Promise<string> {
+  switch (cfg.provider) {
+    case "openai":
+    case "openai_compatible":
+    case "azure_openai":
+      return summarizeOpenAI(text, cfg, log);
+    case "anthropic":
+      return summarizeAnthropic(text, cfg, log);
+    case "gemini":
+      return summarizeGemini(text, cfg, log);
+    case "bedrock":
+      return summarizeBedrock(text, cfg, log);
+    default:
+      throw new Error(`Unknown summarizer provider: ${cfg.provider}`);
+  }
+}
+
+function callSummarizeTask(cfg: SummarizerConfig, text: string, log: Logger): Promise<string> {
+  switch (cfg.provider) {
+    case "openai":
+    case "openai_compatible":
+    case "azure_openai":
+      return summarizeTaskOpenAI(text, cfg, log);
+    case "anthropic":
+      return summarizeTaskAnthropic(text, cfg, log);
+    case "gemini":
+      return summarizeTaskGemini(text, cfg, log);
+    case "bedrock":
+      return summarizeTaskBedrock(text, cfg, log);
+    default:
+      throw new Error(`Unknown summarizer provider: ${cfg.provider}`);
+  }
+}
+
+function callTopicJudge(cfg: SummarizerConfig, currentContext: string, newMessage: string, log: Logger): Promise<boolean> {
+  switch (cfg.provider) {
+    case "openai":
+    case "openai_compatible":
+    case "azure_openai":
+      return judgeNewTopicOpenAI(currentContext, newMessage, cfg, log);
+    case "anthropic":
+      return judgeNewTopicAnthropic(currentContext, newMessage, cfg, log);
+    case "gemini":
+      return judgeNewTopicGemini(currentContext, newMessage, cfg, log);
+    case "bedrock":
+      return judgeNewTopicBedrock(currentContext, newMessage, cfg, log);
+    default:
+      throw new Error(`Unknown summarizer provider: ${cfg.provider}`);
+  }
+}
+
+function callFilterRelevant(cfg: SummarizerConfig, query: string, candidates: Array<{ index: number; summary: string; role: string }>, log: Logger): Promise<FilterResult> {
+  switch (cfg.provider) {
+    case "openai":
+    case "openai_compatible":
+    case "azure_openai":
+      return filterRelevantOpenAI(query, candidates, cfg, log);
+    case "anthropic":
+      return filterRelevantAnthropic(query, candidates, cfg, log);
+    case "gemini":
+      return filterRelevantGemini(query, candidates, cfg, log);
+    case "bedrock":
+      return filterRelevantBedrock(query, candidates, cfg, log);
+    default:
+      throw new Error(`Unknown summarizer provider: ${cfg.provider}`);
   }
 }
 
+function callJudgeDedup(cfg: SummarizerConfig, newSummary: string, candidates: Array<{ index: number; summary: string; chunkId: string }>, log: Logger): Promise<DedupResult> {
+  switch (cfg.provider) {
+    case "openai":
+    case "openai_compatible":
+    case "azure_openai":
+      return judgeDedupOpenAI(newSummary, candidates, cfg, log);
+    case "anthropic":
+      return judgeDedupAnthropic(newSummary, candidates, cfg, log);
+    case "gemini":
+      return judgeDedupGemini(newSummary, candidates, cfg, log);
+    case "bedrock":
+      return judgeDedupBedrock(newSummary, candidates, cfg, log);
+    default:
+      throw new Error(`Unknown summarizer provider: ${cfg.provider}`);
+  }
+}
+
+// ─── Fallbacks ───
+
 function taskFallback(text: string): string {
   const lines = text.split("\n").filter((l) => l.trim().length > 10);
   return lines.slice(0, 30).join("\n").slice(0, 2000);

package/src/ingest/providers/openai.ts

@@ -114,16 +114,30 @@ export async function summarizeOpenAI(
   return json.choices[0]?.message?.content?.trim() ?? "";
 }
 
-const TOPIC_JUDGE_PROMPT = `You are a conversation topic boundary detector. Given a summary of the CURRENT conversation and a NEW user message, determine if the new message starts a DIFFERENT topic/task.
+const TOPIC_JUDGE_PROMPT = `You are a conversation topic boundary detector. Given the CURRENT task context (may include opening topic + recent exchanges) and a single NEW user message, decide if the new message belongs to the SAME task or starts a NEW one.
 
 Answer ONLY "NEW" or "SAME".
 
-Rules:
-- "NEW" = the new message is about a completely different subject, project, or task
-- "SAME" = the new message continues, follows up on, or is closely related to the current topic
-- Follow-up questions, clarifications, refinements, bug fixes, or next steps on the same task = SAME
-- Greetings or meta-questions like "你好" or "谢谢" without new substance = SAME
-- A clearly unrelated request (e.g., current topic is deployment, new message asks about cooking) = NEW
+SAME — the new message:
+- Continues, follows up on, refines, or corrects the same subject/project/task
+- Asks a clarification or next-step question about what was just discussed
+- Reports a result, error, or feedback about the current task
+- Discusses different tools, methods, or approaches for the SAME goal (e.g., learning English via BBC → via ChatGPT → via AI tools = all SAME "learning English" task)
+- Mentions a related technology or platform in the context of the current goal
+- Is a short acknowledgment (ok, thanks, 好的, 嗯) in direct response to the current flow
+
+NEW — the new message:
+- Introduces a clearly UNRELATED subject with NO logical connection to the current task
+- The topic has ZERO overlap with any aspect of the current conversation (e.g., from "learning English" to "what's the weather tomorrow")
+- Starts a request about a completely different domain or life area
+- Begins with a new greeting/reset followed by a different topic
+
+Key principles:
+- STRONGLY lean toward SAME — only mark NEW for obvious, unambiguous topic shifts
+- Different aspects, tools, or methods related to the same overall goal are SAME
+- If the new message could reasonably be interpreted as part of the ongoing discussion, choose SAME
+- Only choose NEW when there is absolutely no thematic connection to the current task
+- Examples: "学英语" → "用AI工具学英语" = SAME; "学英语" → "明天天气" = NEW
 
 Output exactly one word: NEW or SAME`;
 
@@ -141,7 +155,7 @@ export async function judgeNewTopicOpenAI(
     ...cfg.headers,
   };
 
-  const userContent = `CURRENT CONVERSATION SUMMARY:\n${currentContext}\n\nNEW USER MESSAGE:\n${newMessage}`;
+  const userContent = `CURRENT TASK CONTEXT:\n${currentContext}\n\n---\n\nNEW USER MESSAGE:\n${newMessage}`;
 
   const resp = await fetch(endpoint, {
     method: "POST",
@@ -258,21 +272,27 @@ function parseFilterResult(raw: string, log: Logger): FilterResult {
 
 // ─── Smart Dedup: judge whether new memory is DUPLICATE / UPDATE / NEW ───
 
-export const DEDUP_JUDGE_PROMPT = `You are a memory deduplication system. Given a NEW memory summary and several EXISTING memory summaries, determine the relationship.
+export const DEDUP_JUDGE_PROMPT = `You are a memory deduplication system.
+
+LANGUAGE RULE (MUST FOLLOW): You MUST reply in the SAME language as the input memories. 如果输入是中文，reason 和 mergedSummary 必须用中文。If input is English, reply in English. This applies to ALL text fields in your JSON output.
+
+Given a NEW memory summary and several EXISTING memory summaries, determine the relationship.
 
 For each EXISTING memory, the NEW memory is either:
-- "DUPLICATE": NEW is fully covered by an EXISTING memory — no new information at all
-- "UPDATE": NEW contains information that supplements or updates an EXISTING memory (new data, status change, additional detail)
-- "NEW": NEW is a different topic/event despite surface similarity
+- "DUPLICATE": NEW conveys the same intent/meaning as an EXISTING memory, even if worded differently. Examples: "请告诉我你的名字" vs "你希望我怎么称呼你"; "新会话已开始" vs "New session started"; greetings with minor variations. If the core information/intent is the same, it IS a duplicate.
+- "UPDATE": NEW contains meaningful additional information that supplements an EXISTING memory (new data, status change, concrete detail not present before)
+- "NEW": NEW covers a genuinely different topic/event with no semantic overlap
+
+IMPORTANT: Lean toward DUPLICATE when memories share the same intent, topic, or factual content. Only choose NEW when the topics are truly unrelated. Repetitive conversational patterns (greetings, session starts, identity questions, capability descriptions) across different sessions should be treated as DUPLICATE.
 
 Pick the BEST match among all candidates. If none match well, choose "NEW".
 
-Output a single JSON object:
-- If DUPLICATE: {"action":"DUPLICATE","targetIndex":2,"reason":"..."}
-- If UPDATE: {"action":"UPDATE","targetIndex":3,"reason":"...","mergedSummary":"a combined summary preserving all info from both old and new, same language as input"}
-- If NEW: {"action":"NEW","reason":"..."}
+Output a single JSON object (reason and mergedSummary MUST match input language):
+- If DUPLICATE: {"action":"DUPLICATE","targetIndex":2,"reason":"与已有记忆意图相同"}
+- If UPDATE: {"action":"UPDATE","targetIndex":3,"reason":"新记忆补充了额外细节","mergedSummary":"合并后的完整摘要，保留新旧所有信息"}
+- If NEW: {"action":"NEW","reason":"不同主题，无关联"}
 
-CRITICAL: mergedSummary must use the SAME language as the input. Output ONLY the JSON object.`;
+Output ONLY the JSON object, no other text.`;
 
 export interface DedupResult {
   action: "DUPLICATE" | "UPDATE" | "NEW";