@memtensor/memos-local-openclaw-plugin 0.1.3 → 0.1.5

package/openclaw.plugin.json

@@ -1,57 +1,32 @@
 {
   "id": "memos-local",
+  "name": "MemOS Local Memory",
+  "description": "Full-write local conversation memory with hybrid search (RRF + MMR + recency). Provides memory_search, memory_get, task_summary, memory_timeline, memory_viewer for layered retrieval.",
   "kind": "memory",
+  "version": "0.1.4",
+  "homepage": "https://github.com/MemTensor/MemOS/tree/main/apps/memos-local-openclaw",
   "configSchema": {
     "type": "object",
     "additionalProperties": true,
+    "description": "Configuration for MemOS Local Memory. Use Raw mode to edit embedding/summarizer settings.",
     "properties": {
-      "embedding": {
-        "type": "object",
-        "properties": {
-          "provider": { "type": "string" },
-          "endpoint": { "type": "string" },
-          "apiKey": { "type": "string" },
-          "model": { "type": "string" }
-        }
-      },
-      "summarizer": {
-        "type": "object",
-        "properties": {
-          "provider": { "type": "string" },
-          "endpoint": { "type": "string" },
-          "apiKey": { "type": "string" },
-          "model": { "type": "string" },
-          "temperature": { "type": "number" }
-        }
+      "viewerPort": {
+        "type": "number",
+        "description": "Memory Viewer HTTP port (default 18799)"
       }
     }
   },
-  "uiHints": {
-    "embedding.endpoint": {
-      "label": "Embedding Endpoint",
-      "placeholder": "https://api.openai.com/v1",
-      "help": "OpenAI-compatible embedding API base URL"
-    },
-    "embedding.apiKey": {
-      "label": "Embedding API Key",
-      "sensitive": true,
-      "help": "API key for embedding service (or use ${ENV_VAR})"
-    },
-    "embedding.model": {
-      "label": "Embedding Model",
-      "placeholder": "bge-m3"
-    },
-    "summarizer.endpoint": {
-      "label": "Summarizer Endpoint",
-      "placeholder": "https://api.openai.com/v1"
-    },
-    "summarizer.apiKey": {
-      "label": "Summarizer API Key",
-      "sensitive": true
-    },
-    "summarizer.model": {
-      "label": "Summarizer Model",
-      "placeholder": "gpt-4o-mini"
-    }
+  "requirements": {
+    "node": ">=18.0.0",
+    "openclaw": ">=2026.2.0"
+  },
+  "setup": {
+    "postInstall": "npm install --omit=dev",
+    "notes": [
+      "After install, add to ~/.openclaw/openclaw.json: plugins.slots.memory = \"memos-local\"",
+      "Set agents.defaults.memorySearch.enabled = false to disable OpenClaw's built-in memory",
+      "Restart the gateway: openclaw gateway stop && openclaw gateway start",
+      "Memory Viewer will be available at http://127.0.0.1:18799"
+    ]
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memtensor/memos-local-openclaw-plugin",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "MemOS Local memory plugin for OpenClaw — full-write, hybrid-recall, progressive retrieval",
   "type": "module",
   "main": "index.ts",
@@ -9,11 +9,10 @@
     "index.ts",
     "src",
     "dist",
+    "skill",
     "openclaw.plugin.json",
-    "SKILL.md",
     "README.md",
-    ".env.example",
-    "www"
+    ".env.example"
   ],
   "openclaw": {
     "extensions": [

package/skill/memos-memory-guide/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: memos-memory-guide
+description: Use the MemOS local memory system to search and use the user's past conversations. Use this skill whenever the user refers to past chats, their own preferences or history, or when you need to answer from prior context. When auto-recall returns nothing (long or unclear user query), generate your own short search query and call memory_search. Use task_summary when you need full task context, skill_get for experience guides, and memory_timeline to expand around a memory hit.
+---
+
+# MemOS Local Memory — Agent Guide
+
+This skill describes how to use the MemOS memory tools so you can reliably search and use the user's long-term conversation history.
+
+## How memory is provided each turn
+
+- **Automatic recall (hook):** At the start of each turn, the system runs a memory search using the user's current message and injects relevant past memories into your context. You do not need to call any tool for that.
+- **When that is not enough:** If the user's message is very long, vague, or the automatic search returns **no memories**, you should **generate your own short, focused query** and call `memory_search` yourself. For example:
+  - User sent a long paragraph → extract 1–2 key topics or a short question and search with that.
+  - Auto-recall said "no memories" or you see no memory block → call `memory_search` with a query you derive (e.g. the user's name, a topic they often mention, or a rephrased question).
+- **When you need more detail:** Search results only give excerpts and IDs. Use the tools below to fetch full task context, skill content, or surrounding messages.
+
+## Tools — what they do and when to call
+
+### memory_search
+
+- **What it does:** Searches the user's stored conversation memory by a natural-language query. Returns a list of relevant excerpts with `chunkId` and optionally `task_id`.
+- **When to call:**
+  - The automatic recall did not run or returned nothing (e.g. no `<memory_context>` block, or a note that no memories were found).
+  - The user's query is long or unclear — **generate a short query yourself** (keywords, rephrased question, or a clear sub-question) and call `memory_search(query="...")`.
+  - You need to search with a different angle (e.g. filter by `role='user'` to find what the user said, or use a more specific query).
+- **Parameters:** `query` (required), optional `minScore`, `role` (e.g. `"user"`).
+- **Output:** List of items with role, excerpt, `chunkId`, and sometimes `task_id`. Use those IDs with the tools below when you need more context.
+
+### task_summary
+
+- **What it does:** Returns the full task summary for a given `task_id`: title, status, and the complete narrative summary of that conversation task (steps, decisions, URLs, commands, etc.).
+- **When to call:** A `memory_search` hit included a `task_id` and you need the full story of that task (e.g. what was done, what the user decided, what failed or succeeded).
+- **Parameters:** `taskId` (from a search hit).
+- **Effect:** You get one coherent summary of the whole task instead of isolated excerpts.
+
+### skill_get
+
+- **What it does:** Returns the content of a learned skill (experience guide) by `skillId` or by `taskId`. If you pass `taskId`, the system finds the skill linked to that task.
+- **When to call:** A search hit has a `task_id` and the task is the kind that has a “how to do this again” guide (e.g. a workflow the user has run before). Use this to follow the same approach or reuse steps.
+- **Parameters:** `skillId` (direct) or `taskId` (lookup).
+- **Effect:** You receive the full SKILL.md-style guide. You can then call `skill_install(skillId)` if the user or you want that skill loaded for future turns.
+
+### skill_install
+
+- **What it does:** Installs a skill (by `skillId`) into the workspace so it is loaded in future sessions.
+- **When to call:** After `skill_get` when the skill is useful for ongoing use (e.g. the user’s recurring workflow). Optional; only when you want the skill to be permanently available.
+- **Parameters:** `skillId`.
+
+### memory_timeline
+
+- **What it does:** Expands context around a single memory chunk: returns the surrounding conversation messages (±N turns) so you see what was said before and after that excerpt.
+- **When to call:** A `memory_search` hit is relevant but you need the surrounding dialogue (e.g. who said what next, or the exact follow-up question).
+- **Parameters:** `chunkId` (from a search hit), optional `window` (default 2).
+- **Effect:** You get a short, linear slice of the conversation around that chunk.
+
+### memory_viewer
+
+- **What it does:** Returns the URL of the MemOS Memory Viewer (web UI) where the user can browse, search, and manage their memories.
+- **When to call:** The user asks how to view their memories, open the memory dashboard, or manage stored data.
+- **Parameters:** None.
+- **Effect:** You can tell the user to open that URL in a browser.
+
+## Quick decision flow
+
+1. **No memories in context or auto-recall reported nothing**  
+   → Call `memory_search` with a **self-generated short query** (e.g. key topic or rephrased question).
+
+2. **Search returned hits with `task_id` and you need full context**  
+   → Call `task_summary(taskId)`.
+
+3. **Task has an experience guide you want to follow**  
+   → Call `skill_get(taskId=...)` (or `skill_get(skillId=...)` if you have the id). Optionally `skill_install(skillId)` for future use.
+
+4. **You need the exact surrounding conversation of a hit**  
+   → Call `memory_timeline(chunkId=...)`.
+
+5. **User asks where to see or manage their memories**  
+   → Call `memory_viewer()` and share the URL.
+
+## Writing good search queries
+
+- Prefer **short, focused** queries (a few words or one clear question).
+- Use **concrete terms**: names, topics, tools, or decisions (e.g. “preferred editor”, “deploy script”, “API key setup”).
+- If the user’s message is long, **derive one or two sub-queries** rather than pasting the whole message.
+- Use `role='user'` when you specifically want to find what the user said (e.g. preferences, past questions).

package/src/capture/index.ts

@@ -1,5 +1,4 @@
 import type { ConversationMessage, Role, Logger } from "../types";
-import { DEFAULTS } from "../types";
 
 const SKIP_ROLES: Set<Role> = new Set(["system"]);
 
@@ -10,20 +9,33 @@ const SELF_TOOLS = new Set([
   "memory_viewer",
 ]);
 
+// OpenClaw inbound metadata sentinels — these are AI-facing prefixes,
+// not user content. Must be stripped before storing as memory.
+const INBOUND_META_SENTINELS = [
+  "Conversation info (untrusted metadata):",
+  "Sender (untrusted metadata):",
+  "Thread starter (untrusted, for context):",
+  "Replied message (untrusted, for context):",
+  "Forwarded message context (untrusted metadata):",
+  "Chat history since last reply (untrusted, for context):",
+];
+
+const SENTINEL_FAST_RE = new RegExp(
+  INBOUND_META_SENTINELS.map(s => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"),
+);
+
 /**
- * Filter and extract writable messages from a conversation turn.
+ * Extract writable messages from a conversation turn.
  *
- * - Keep user, assistant, and tool messages
- * - Skip system prompts
- * - Skip tool results from our own memory tools (prevents memory loop)
- * - Truncate long tool results to avoid storage bloat
- * - Strip injected evidence blocks wrapped in [STORED_MEMORY]...[/STORED_MEMORY]
+ * Stores the user's actual text — strips only OpenClaw's injected metadata
+ * prefixes (Sender info, conversation context, etc.) which are not user content.
+ * Only skips: system prompts and our own memory tool results (prevents loop).
  */
 export function captureMessages(
   messages: Array<{ role: string; content: string; toolName?: string }>,
   sessionKey: string,
   turnId: string,
-  evidenceTag: string,
+  _evidenceTag: string,
   log: Logger,
 ): ConversationMessage[] {
   const now = Date.now();
@@ -34,39 +46,24 @@ export function captureMessages(
     if (SKIP_ROLES.has(role)) continue;
     if (!msg.content || msg.content.trim().length === 0) continue;
 
-    if (role === "tool") {
-      if (msg.toolName && SELF_TOOLS.has(msg.toolName)) {
-        log.debug(`Skipping self-tool result: ${msg.toolName}`);
-        continue;
-      }
-
-      let content = msg.content.trim();
-      const maxChars = DEFAULTS.toolResultMaxChars;
-      if (content.length > maxChars) {
-        content = content.slice(0, maxChars) + `\n\n[truncated — original ${content.length} chars]`;
-      }
-
-      const toolLabel = msg.toolName ? `[tool:${msg.toolName}] ` : "[tool] ";
-      result.push({
-        role: "tool",
-        content: toolLabel + content,
-        timestamp: now,
-        turnId,
-        sessionKey,
-        toolName: msg.toolName,
-      });
+    if (role === "tool" && msg.toolName && SELF_TOOLS.has(msg.toolName)) {
+      log.debug(`Skipping self-tool result: ${msg.toolName}`);
       continue;
     }
 
-    const cleaned = stripEvidenceBlocks(msg.content, evidenceTag);
-    if (cleaned.trim().length === 0) continue;
+    let content = msg.content;
+    if (role === "user") {
+      content = stripInboundMetadata(content);
+    }
+    if (!content.trim()) continue;
 
     result.push({
       role,
-      content: cleaned,
+      content,
       timestamp: now,
       turnId,
       sessionKey,
+      toolName: role === "tool" ? msg.toolName : undefined,
     });
   }
 
@@ -74,19 +71,62 @@ export function captureMessages(
   return result;
 }
 
-function stripEvidenceBlocks(text: string, tag: string): string {
-  const openTag = `[${tag}]`;
-  const closeTag = `[/${tag}]`;
-  let result = text;
-  let safety = 0;
-
-  while (result.includes(openTag) && result.includes(closeTag) && safety < 50) {
-    const start = result.indexOf(openTag);
-    const end = result.indexOf(closeTag, start);
-    if (end === -1) break;
-    result = result.slice(0, start) + result.slice(end + closeTag.length);
-    safety++;
+/**
+ * Strip OpenClaw-injected inbound metadata blocks from user messages.
+ *
+ * These blocks have the shape:
+ *   Sender (untrusted metadata):
+ *   ```json
+ *   { "label": "...", "id": "..." }
+ *   ```
+ *
+ * Also strips the envelope timestamp prefix like "[Tue 2026-03-03 21:58 GMT+8] "
+ */
+function stripInboundMetadata(text: string): string {
+  if (!SENTINEL_FAST_RE.test(text)) return text;
+
+  const lines = text.split("\n");
+  const result: string[] = [];
+  let inMetaBlock = false;
+  let inFencedJson = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    if (!inMetaBlock && INBOUND_META_SENTINELS.some(s => s === trimmed)) {
+      if (lines[i + 1]?.trim() === "```json") {
+        inMetaBlock = true;
+        inFencedJson = false;
+        continue;
+      }
+      // Sentinel without fenced JSON — skip this line only
+      continue;
+    }
+
+    if (inMetaBlock) {
+      if (!inFencedJson && trimmed === "```json") {
+        inFencedJson = true;
+        continue;
+      }
+      if (inFencedJson && trimmed === "```") {
+        inMetaBlock = false;
+        inFencedJson = false;
+        continue;
+      }
+      continue;
+    }
+
+    result.push(line);
   }
 
-  return result;
+  let cleaned = result.join("\n").trim();
+
+  // Strip envelope timestamp prefix: "[Tue 2026-03-03 21:58 GMT+8] actual message"
+  cleaned = cleaned.replace(
+    /^\[(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s+\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}(?::\d{2})?\s+[A-Z]{3}[+-]\d{1,2}\]\s*/,
+    "",
+  );
+
+  return cleaned;
 }

package/src/ingest/dedup.ts

@@ -35,3 +35,32 @@ export function findDuplicate(
 
   return null;
 }
+
+/**
+ * Find Top-N most similar chunks above a threshold.
+ * Used for smart dedup: retrieve candidates, then ask LLM to judge.
+ */
+export function findTopSimilar(
+  store: SqliteStore,
+  newVec: number[],
+  threshold: number,
+  topN: number,
+  log: Logger,
+): Array<{ chunkId: string; score: number }> {
+  const all = store.getAllEmbeddings();
+  const scored: Array<{ chunkId: string; score: number }> = [];
+
+  for (const { chunkId, vector } of all) {
+    const sim = cosineSimilarity(newVec, vector);
+    if (sim >= threshold) {
+      scored.push({ chunkId, score: sim });
+    }
+  }
+
+  scored.sort((a, b) => b.score - a.score);
+  const result = scored.slice(0, topN);
+  if (result.length > 0) {
+    log.debug(`findTopSimilar: found ${result.length} candidates above ${threshold} (best=${result[0].score.toFixed(4)})`);
+  }
+  return result;
+}

package/src/ingest/providers/anthropic.ts

@@ -1,6 +1,217 @@
 import type { SummarizerConfig, Logger } from "../../types";
 
-const SYSTEM_PROMPT = `Summarize the text in ONE concise sentence (max 60 tokens). Preserve exact names, commands, error codes. No bullet points, no preamble — output only the sentence.`;
+const SYSTEM_PROMPT = `Summarize the text in ONE concise sentence (max 120 characters). IMPORTANT: Use the SAME language as the input text — if the input is Chinese, write Chinese; if English, write English. Preserve exact names, commands, error codes. No bullet points, no preamble — output only the sentence.`;
+
+const TASK_SUMMARY_PROMPT = `You create a DETAILED task summary from a multi-turn conversation. This summary will be the ONLY record of this conversation, so it must preserve ALL important information.
+
+CRITICAL LANGUAGE RULE: You MUST write in the SAME language as the user's messages. Chinese input → Chinese output. English input → English output. NEVER mix languages.
+
+Output EXACTLY this structure:
+
+📌 Title
+A short, descriptive title (10-30 characters). Like a chat group name.
+
+🎯 Goal
+One sentence: what the user wanted to accomplish.
+
+📋 Key Steps
+- Describe each meaningful step in detail
+- Include the ACTUAL content produced: code snippets, commands, config blocks, formulas, key paragraphs
+- For code: include the function signature and core logic (up to ~30 lines per block), use fenced code blocks
+- For configs: include the actual config values and structure
+- For lists/instructions: include the actual items, not just "provided a list"
+- Merge only truly trivial back-and-forth (like "ok" / "sure")
+- Do NOT over-summarize: "provided a function" is BAD; show the actual function
+
+✅ Result
+What was the final outcome? Include the final version of any code/config/content produced.
+
+💡 Key Details
+- Decisions made, trade-offs discussed, caveats noted, alternative approaches mentioned
+- Specific values: numbers, versions, thresholds, URLs, file paths, model names
+- Omit this section only if there truly are no noteworthy details
+
+RULES:
+- This summary is a KNOWLEDGE BASE ENTRY, not a brief note. Be thorough.
+- PRESERVE verbatim: code, commands, URLs, file paths, error messages, config values, version numbers, names, amounts
+- DISCARD only: greetings, filler, the assistant explaining what it will do before doing it
+- Replace secrets (API keys, tokens, passwords) with [REDACTED]
+- Target length: 30-50% of the original conversation length. Longer conversations need longer summaries.
+- Output summary only, no preamble.`;
+
+export async function summarizeTaskAnthropic(
+  text: string,
+  cfg: SummarizerConfig,
+  log: Logger,
+): Promise<string> {
+  const endpoint = cfg.endpoint ?? "https://api.anthropic.com/v1/messages";
+  const model = cfg.model ?? "claude-3-haiku-20240307";
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "x-api-key": cfg.apiKey ?? "",
+    "anthropic-version": "2023-06-01",
+    ...cfg.headers,
+  };
+
+  const resp = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      model,
+      max_tokens: 4096,
+      temperature: cfg.temperature ?? 0.1,
+      system: TASK_SUMMARY_PROMPT,
+      messages: [{ role: "user", content: text }],
+    }),
+    signal: AbortSignal.timeout(cfg.timeoutMs ?? 60_000),
+  });
+
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`Anthropic task-summarize failed (${resp.status}): ${body}`);
+  }
+
+  const json = (await resp.json()) as { content: Array<{ type: string; text: string }> };
+  return json.content.find((c) => c.type === "text")?.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.
+
+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
+
+Output exactly one word: NEW or SAME`;
+
+export async function judgeNewTopicAnthropic(
+  currentContext: string,
+  newMessage: string,
+  cfg: SummarizerConfig,
+  log: Logger,
+): Promise<boolean> {
+  const endpoint = cfg.endpoint ?? "https://api.anthropic.com/v1/messages";
+  const model = cfg.model ?? "claude-3-haiku-20240307";
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "x-api-key": cfg.apiKey ?? "",
+    "anthropic-version": "2023-06-01",
+    ...cfg.headers,
+  };
+
+  const userContent = `CURRENT CONVERSATION SUMMARY:\n${currentContext}\n\nNEW USER MESSAGE:\n${newMessage}`;
+
+  const resp = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      model,
+      max_tokens: 10,
+      temperature: 0,
+      system: TOPIC_JUDGE_PROMPT,
+      messages: [{ role: "user", content: userContent }],
+    }),
+    signal: AbortSignal.timeout(cfg.timeoutMs ?? 15_000),
+  });
+
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`Anthropic topic-judge failed (${resp.status}): ${body}`);
+  }
+
+  const json = (await resp.json()) as { content: Array<{ type: string; text: string }> };
+  const answer = json.content.find((c) => c.type === "text")?.text?.trim().toUpperCase() ?? "";
+  log.debug(`Topic judge result: "${answer}"`);
+  return answer.startsWith("NEW");
+}
+
+const FILTER_RELEVANT_PROMPT = `You are a memory relevance judge. Given a user's QUERY and a list of CANDIDATE memory summaries, do two things:
+
+1. Select ALL candidates that could be useful for answering the query. When in doubt, INCLUDE the candidate.
+   - For questions about lists, history, or "what/where/who" across multiple items (e.g. "which companies did I work at"), include ALL matching items — do NOT stop at the first match.
+   - For factual lookups (e.g. "what is the SSH port"), a single direct answer is enough.
+2. Judge whether the selected memories are SUFFICIENT to fully answer the query WITHOUT fetching additional context.
+
+IMPORTANT for "sufficient" judgment:
+- sufficient=true ONLY when the memories contain a concrete ANSWER, fact, decision, or actionable information that directly addresses the query.
+- sufficient=false when:
+  - The memories only repeat the same question the user asked before (echo, not answer).
+  - The memories show related topics but lack the specific detail needed.
+  - The memories contain partial information that would benefit from full task context, timeline, or related skills.
+
+Output a JSON object with exactly two fields:
+{"relevant":[1,3,5],"sufficient":true}
+
+- "relevant": array of candidate numbers that are useful. Empty array [] if none are relevant.
+- "sufficient": true ONLY if the memories contain a direct answer; false otherwise.
+
+Output ONLY the JSON object, nothing else.`;
+
+import type { FilterResult } from "./openai";
+export type { FilterResult } from "./openai";
+
+export async function filterRelevantAnthropic(
+  query: string,
+  candidates: Array<{ index: number; summary: string; role: string }>,
+  cfg: SummarizerConfig,
+  log: Logger,
+): Promise<FilterResult> {
+  const endpoint = cfg.endpoint ?? "https://api.anthropic.com/v1/messages";
+  const model = cfg.model ?? "claude-3-haiku-20240307";
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "x-api-key": cfg.apiKey ?? "",
+    "anthropic-version": "2023-06-01",
+    ...cfg.headers,
+  };
+
+  const candidateText = candidates
+    .map((c) => `${c.index}. [${c.role}] ${c.summary}`)
+    .join("\n");
+
+  const resp = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      model,
+      max_tokens: 200,
+      temperature: 0,
+      system: FILTER_RELEVANT_PROMPT,
+      messages: [{ role: "user", content: `QUERY: ${query}\n\nCANDIDATES:\n${candidateText}` }],
+    }),
+    signal: AbortSignal.timeout(cfg.timeoutMs ?? 15_000),
+  });
+
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`Anthropic filter-relevant failed (${resp.status}): ${body}`);
+  }
+
+  const json = (await resp.json()) as { content: Array<{ type: string; text: string }> };
+  const raw = json.content.find((c) => c.type === "text")?.text?.trim() ?? "{}";
+  return parseFilterResult(raw, log);
+}
+
+function parseFilterResult(raw: string, log: Logger): FilterResult {
+  try {
+    const match = raw.match(/\{[\s\S]*\}/);
+    if (match) {
+      const obj = JSON.parse(match[0]);
+      if (obj && Array.isArray(obj.relevant)) {
+        return {
+          relevant: obj.relevant.filter((n: any) => typeof n === "number"),
+          sufficient: obj.sufficient === true,
+        };
+      }
+    }
+  } catch {}
+  log.warn(`filterRelevant: failed to parse LLM output: "${raw}", fallback to all+insufficient`);
+  return { relevant: [], sufficient: false };
+}
 
 export async function summarizeAnthropic(
   text: string,
@@ -39,3 +250,49 @@ export async function summarizeAnthropic(
   };
   return json.content.find((c) => c.type === "text")?.text?.trim() ?? "";
 }
+
+// ─── Smart Dedup ───
+
+import { DEDUP_JUDGE_PROMPT, parseDedupResult } from "./openai";
+import type { DedupResult } from "./openai";
+export type { DedupResult } from "./openai";
+
+export async function judgeDedupAnthropic(
+  newSummary: string,
+  candidates: Array<{ index: number; summary: string; chunkId: string }>,
+  cfg: SummarizerConfig,
+  log: Logger,
+): Promise<DedupResult> {
+  const endpoint = cfg.endpoint ?? "https://api.anthropic.com/v1/messages";
+  const model = cfg.model ?? "claude-3-haiku-20240307";
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "x-api-key": cfg.apiKey ?? "",
+    "anthropic-version": "2023-06-01",
+    ...cfg.headers,
+  };
+
+  const candidateText = candidates.map((c) => `${c.index}. ${c.summary}`).join("\n");
+
+  const resp = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      model,
+      max_tokens: 300,
+      temperature: 0,
+      system: DEDUP_JUDGE_PROMPT,
+      messages: [{ role: "user", content: `NEW MEMORY:\n${newSummary}\n\nEXISTING MEMORIES:\n${candidateText}` }],
+    }),
+    signal: AbortSignal.timeout(cfg.timeoutMs ?? 15_000),
+  });
+
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`Anthropic dedup-judge failed (${resp.status}): ${body}`);
+  }
+
+  const json = (await resp.json()) as { content: Array<{ type: string; text: string }> };
+  const raw = json.content.find((c) => c.type === "text")?.text?.trim() ?? "{}";
+  return parseDedupResult(raw, log);
+}