@memtensor/memos-local-openclaw-plugin 0.1.2 → 0.1.4

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.2",
+  "version": "0.1.4",
   "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/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: memos-local
+description: "Local long-term conversation memory (MemOS). All past conversations are recorded and searchable. Use this skill whenever the conversation involves user-specific information such as identity, preferences, project details, past decisions, or personal facts. Also use it when you cannot fully answer a question or would otherwise need to ask the user for more details — always search memory first, because the answer may already exist in a previous conversation. Similarly, when the user references something from the past (e.g. 'last time', 'as before', 'continue'), search memory to retrieve the relevant context. Start with memory_search for lightweight hits, then drill down with memory_get, task_summary, or memory_timeline as needed."
+metadata: { "openclaw": { "emoji": "🧠" } }
+---
+
+# MemOS — Long-Term Memory (Local)
+
+You have a local long-term memory that records conversation history. When you need historical information, use the tools below to search and drill down, aiming to get **enough to answer** with the **shortest context**.
+
+## Tools
+
+| Tool              | What it does                                                             |
+| ----------------- | ------------------------------------------------------------------------ |
+| `memory_search`   | Lightweight search of conversation history. Returns hit summaries + IDs/refs (information may be truncated/compressed). |
+| `memory_get`      | Fetch the **full original text** of a hit by `chunkId` (use when the summary is insufficient / the original is longer but you only need this one entry). |
+| `task_summary`    | Get the **full task-level context summary** for the task a hit belongs to by `taskId` (use when you judge that more key information may be in other turns of the same task). |
+| `memory_timeline` | Expand the context before and after a hit using its `ref` (use when you need the cause-and-effect / chronological details of a conversation). |
+| `memory_viewer`   | Returns the Memory Viewer URL (http://127.0.0.1:18799). |
+
+## When to Trigger a Search (Trigger)
+
+Trigger a search when any of the following applies:
+
+* The current context is insufficient to answer definitively (missing key parameters/links/paths/versions/decisions, etc.)
+* You are about to ask the user for information (try searching memory first)
+* The user references history ("last time / before / continue / as previously planned")
+* You need user-specific information (preferences, identity, project config, directory structure, deployment method, etc.)
+
+## Layered Retrieval Strategy (Minimum Information → Progressive Completion)
+
+```text
+Step 1: memory_search(query="keywords")
+  - Goal: quickly get 1-6 most relevant hits (summary + chunkId/taskId/ref)
+
+Step 2: Sufficiency check
+  - If hit summaries are enough to support the answer → answer directly, stop drilling down
+  - If summary is insufficient/truncated but "looks useful" → memory_get(chunkId)
+
+Step 3: Related but missing broader context → task_summary(taskId)
+  - Applies when: you judge that missing information may be in other turns of the same task
+  - Note: conversations are split into tasks by topic/time; each hit typically belongs to a taskId
+  - Example: search hits "steps to apply for GPT key", but the summary lacks the website link/prerequisites
+             → calling task_summary retrieves the more complete context and details for that task
+
+Step 4: Still need cause-and-effect / chronological details → memory_timeline(ref)
+  - Applies when: you need to expand several turns before and after a hit to fill in details and context
+
+Step 5: Still insufficient
+  - Identify the specific missing fields and ask the user a minimal follow-up question
+```
+
+## Rules
+
+* **If you don't know the answer, or you are about to ask the user for clarification/details, you MUST call `memory_search` first.** The user may have already provided this information in a previous conversation. Never say "I don't know" or ask the user without searching memory first.
+* Always `memory_search` first, then decide whether to use `memory_get` / `task_summary` / `memory_timeline`
+* `memory_get` is for "summary isn't enough but this hit is very likely the answer" — avoid pulling in excessive irrelevant context
+* `task_summary` is for "hit is relevant, but the answer may be scattered across other parts of the same task" — use the task-level summary to fill in at once
+* `memory_timeline` should only be used when you genuinely need surrounding context — avoid unnecessarily expanding the context window

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/providers/anthropic.ts

@@ -1,6 +1,133 @@
 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");
+}
 
 export async function summarizeAnthropic(
   text: string,

package/src/ingest/providers/bedrock.ts

@@ -1,12 +1,136 @@
 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 summarizeTaskBedrock(
+  text: string,
+  cfg: SummarizerConfig,
+  log: Logger,
+): Promise<string> {
+  const model = cfg.model ?? "anthropic.claude-3-haiku-20240307-v1:0";
+  const endpoint = cfg.endpoint;
+  if (!endpoint) {
+    throw new Error("Bedrock task-summarizer requires 'endpoint'");
+  }
+
+  const url = `${endpoint}/model/${model}/converse`;
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    ...cfg.headers,
+  };
+
+  const resp = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      system: [{ text: TASK_SUMMARY_PROMPT }],
+      messages: [{ role: "user", content: [{ text }] }],
+      inferenceConfig: { temperature: cfg.temperature ?? 0.1, maxTokens: 4096 },
+    }),
+    signal: AbortSignal.timeout(cfg.timeoutMs ?? 60_000),
+  });
+
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`Bedrock task-summarize failed (${resp.status}): ${body}`);
+  }
+
+  const json = (await resp.json()) as { output: { message: { content: Array<{ text: string }> } } };
+  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.
+
+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 judgeNewTopicBedrock(
+  currentContext: string,
+  newMessage: string,
+  cfg: SummarizerConfig,
+  log: Logger,
+): Promise<boolean> {
+  const model = cfg.model ?? "anthropic.claude-3-haiku-20240307-v1:0";
+  const endpoint = cfg.endpoint;
+  if (!endpoint) {
+    throw new Error("Bedrock topic-judge requires 'endpoint'");
+  }
+
+  const url = `${endpoint}/model/${model}/converse`;
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    ...cfg.headers,
+  };
+
+  const userContent = `CURRENT CONVERSATION SUMMARY:\n${currentContext}\n\nNEW USER MESSAGE:\n${newMessage}`;
+
+  const resp = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      system: [{ text: TOPIC_JUDGE_PROMPT }],
+      messages: [{ role: "user", content: [{ text: userContent }] }],
+      inferenceConfig: { temperature: 0, maxTokens: 10 },
+    }),
+    signal: AbortSignal.timeout(cfg.timeoutMs ?? 15_000),
+  });
+
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`Bedrock topic-judge failed (${resp.status}): ${body}`);
+  }
+
+  const json = (await resp.json()) as { output: { message: { content: Array<{ text: string }> } } };
+  const answer = json.output?.message?.content?.[0]?.text?.trim().toUpperCase() ?? "";
+  log.debug(`Topic judge result: "${answer}"`);
+  return answer.startsWith("NEW");
+}
 
-/**
- * AWS Bedrock Converse API adapter.
- * Expects cfg.endpoint to be the full Bedrock invoke URL and
- * authentication handled via AWS SDK credential chain (env vars / IAM role).
- */
 export async function summarizeBedrock(
   text: string,
   cfg: SummarizerConfig,