@memtensor/memos-local-openclaw-plugin 1.0.8-beta.2 → 1.0.8-beta.3

package/index.ts

@@ -427,6 +427,7 @@ const memosLocalPlugin = {
         body: JSON.stringify({
           memory: {
             sourceChunkId: chunk.id,
+            sourceAgent: chunk.owner || "",
             role: chunk.role,
             content: chunk.content,
             summary: chunk.summary,
@@ -447,6 +448,7 @@ const memosLocalPlugin = {
           id: memoryId,
           sourceChunkId: chunk.id,
           sourceUserId: hubClient.userId,
+          sourceAgent: chunk.owner || "",
           role: chunk.role,
           content: chunk.content,
           summary: chunk.summary ?? "",
@@ -549,6 +551,7 @@ const memosLocalPlugin = {
             summary: h.summary,
             original_excerpt: (h.original_excerpt ?? "").slice(0, 200),
             origin: h.origin || "local",
+            owner: h.owner || "",
           }));
 
           // Hub remote candidates (from HTTP call) + hub-memory candidates (from RecallEngine for Hub role)
@@ -685,6 +688,7 @@ const memosLocalPlugin = {
                 chunkId: h.ref.chunkId, taskId: effectiveTaskId, skillId: h.skillId,
                 role: h.source.role, score: h.score, summary: h.summary,
                 original_excerpt: (h.original_excerpt ?? "").slice(0, 200), origin: h.origin || "local",
+                owner: h.owner || "",
               };
             }),
             ...filteredHubRemoteHits.map((h: any) => ({
@@ -692,6 +696,7 @@ const memosLocalPlugin = {
               role: h.source?.role ?? h.role ?? "assistant", score: h.score ?? 0,
               summary: h.summary ?? "", original_excerpt: (h.excerpt ?? h.summary ?? "").slice(0, 200),
               origin: "hub-remote", ownerName: h.ownerName ?? "", groupName: h.groupName ?? "",
+              sourceAgent: h.sourceAgent ?? "",
             })),
           ];
 
@@ -1872,6 +1877,7 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
         const rawLocalCandidates = localHits.map((h) => ({
           score: h.score, role: h.source.role, summary: h.summary,
           content: (h.original_excerpt ?? "").slice(0, 200), origin: h.origin || "local",
+          owner: h.owner || "",
         }));
         const rawHubCandidates = allHubHits.map((h) => ({
           score: h.score, role: h.source.role, summary: h.summary,
@@ -2079,7 +2085,7 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
         store.recordApiLog("memory_search", { type: "auto_recall", query }, JSON.stringify({
           candidates: rawLocalCandidates,
           hubCandidates: rawHubCandidates,
-          filtered: filteredHits.map(h => ({ score: h.score, role: h.source.role, summary: h.summary, content: h.original_excerpt, origin: h.origin || "local" })),
+          filtered: filteredHits.map(h => ({ score: h.score, role: h.source.role, summary: h.summary, content: h.original_excerpt, origin: h.origin || "local", owner: h.owner || "" })),
         }), recallDur, true);
         telemetry.trackAutoRecall(filteredHits.length, recallDur);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memtensor/memos-local-openclaw-plugin",
-  "version": "1.0.8-beta.2",
+  "version": "1.0.8-beta.3",
   "description": "MemOS Local memory plugin for OpenClaw — full-write, hybrid-recall, progressive retrieval",
   "type": "module",
   "main": "index.ts",

package/src/hub/server.ts

@@ -658,6 +658,7 @@ export class HubServer {
         id: memoryId,
         sourceChunkId,
         sourceUserId: auth.userId,
+        sourceAgent: String(m.sourceAgent || ""),
         role: String(m.role || "assistant"),
         content: String(m.content || ""),
         summary: String(m.summary || ""),
@@ -778,8 +779,8 @@ export class HubServer {
           this.remoteHitMap.set(remoteHitId, { chunkId: id, type: "memory", expiresAt: Date.now() + 10 * 60 * 1000, requesterUserId: auth.userId });
           return {
             remoteHitId, summary: mhit.summary, excerpt: mhit.content.slice(0, 240), hubRank: rank + 1,
-            taskTitle: null, ownerName: mhit.owner_name || "unknown", groupName: mhit.group_name,
-            visibility: mhit.visibility, source: { ts: mhit.created_at, role: mhit.role },
+            taskTitle: null, ownerName: mhit.owner_name || "unknown", sourceAgent: (mhit as any).source_agent || "",
+            groupName: mhit.group_name, visibility: mhit.visibility, source: { ts: mhit.created_at, role: mhit.role },
           };
         }
         let hit = ftsMap.get(id);
@@ -792,8 +793,8 @@ export class HubServer {
         this.remoteHitMap.set(remoteHitId, { chunkId: id, type: "chunk", expiresAt: Date.now() + 10 * 60 * 1000, requesterUserId: auth.userId });
         return {
           remoteHitId, summary: hit!.summary, excerpt: hit!.content.slice(0, 240), hubRank: rank + 1,
-          taskTitle: hit!.task_title, ownerName: hit!.owner_name || "unknown", groupName: hit!.group_name,
-          visibility: hit!.visibility, source: { ts: hit!.created_at, role: hit!.role },
+          taskTitle: hit!.task_title, ownerName: hit!.owner_name || "unknown", sourceAgent: "",
+          groupName: hit!.group_name, visibility: hit!.visibility, source: { ts: hit!.created_at, role: hit!.role },
         };
       }).filter(Boolean);
       return this.json(res, 200, { hits, meta: { totalCandidates: hits.length, searchedGroups: [], includedPublic: true } });

package/src/ingest/providers/anthropic.ts

@@ -148,19 +148,22 @@ SAME — the new message:
 - Reports a result, error, or feedback about the current task
 - Discusses different tools or approaches for the SAME goal (e.g., learning English via BBC → via ChatGPT = SAME)
 - Is a short acknowledgment (ok, thanks, 好的) in response to the current flow
+- Contains pronouns or references (那, 这, 它, 其中, 哪些, those, which, what about, etc.) pointing to items from the current conversation
+- Asks about a sub-topic, tool, detail, dimension, or aspect of the current discussion topic
 
 NEW — the new message:
-- Introduces a subject from a DIFFERENT domain than the current task (e.g., tech → cooking, work → personal life, database → travel)
-- Has NO logical connection to what was being discussed
+- Introduces a subject from a COMPLETELY DIFFERENT domain than the current task (e.g., tech → cooking, work → personal life, database → travel)
+- Has NO logical connection to what was being discussed — no shared entities, events, or themes
 - Starts a request about a different project, system, or life area
 - Begins with a new greeting/reset followed by a different topic
 
 Key principles:
-- If the topic domain clearly changed (e.g., server config → recipe, code review → vacation plan), choose NEW
+- Default to SAME unless the topic domain CLEARLY changed. When in doubt, choose SAME.
+- CRITICAL: Short messages (under ~30 characters) that use pronouns or ask "what about X" / "哪些" / "那XX呢" are almost always follow-ups referring to the current topic. Only mark them NEW if they explicitly name a completely unrelated domain.
 - Different aspects of the SAME project/system are SAME (e.g., Nginx SSL → Nginx gzip = SAME)
-- Different unrelated technologies discussed independently are NEW (e.g., Redis config → cooking recipe = NEW)
-- When unsure, lean toward SAME for closely related topics, but do NOT hesitate to mark NEW for obvious domain shifts
-- Examples: "配置Nginx" → "加gzip压缩" = SAME; "配置Nginx" → "做红烧肉" = NEW; "MySQL配置" → "K8s部署" in same infra project = SAME; "部署服务器" → "年会安排" = NEW
+- Asking about tools, systems, or methods for the current topic is SAME (e.g., "港股调研" → "那处理系统有哪些" = SAME; "数据分析" → "用什么工具" = SAME)
+- Different unrelated domains discussed independently are NEW (e.g., Redis config → cooking recipe = NEW)
+- Examples: "配置Nginx" → "加gzip压缩" = SAME; "配置Nginx" → "做红烧肉" = NEW; "港股调研" → "那处理系统有哪些" = SAME; "部署服务器" → "年会安排" = NEW
 
 Output exactly one word: NEW or SAME`;
 

package/src/ingest/providers/bedrock.ts

@@ -150,19 +150,22 @@ SAME — the new message:
 - Reports a result, error, or feedback about the current task
 - Discusses different tools or approaches for the SAME goal (e.g., learning English via BBC → via ChatGPT = SAME)
 - Is a short acknowledgment (ok, thanks, 好的) in response to the current flow
+- Contains pronouns or references (那, 这, 它, 其中, 哪些, those, which, what about, etc.) pointing to items from the current conversation
+- Asks about a sub-topic, tool, detail, dimension, or aspect of the current discussion topic
 
 NEW — the new message:
-- Introduces a subject from a DIFFERENT domain than the current task (e.g., tech → cooking, work → personal life, database → travel)
-- Has NO logical connection to what was being discussed
+- Introduces a subject from a COMPLETELY DIFFERENT domain than the current task (e.g., tech → cooking, work → personal life, database → travel)
+- Has NO logical connection to what was being discussed — no shared entities, events, or themes
 - Starts a request about a different project, system, or life area
 - Begins with a new greeting/reset followed by a different topic
 
 Key principles:
-- If the topic domain clearly changed (e.g., server config → recipe, code review → vacation plan), choose NEW
+- Default to SAME unless the topic domain CLEARLY changed. When in doubt, choose SAME.
+- CRITICAL: Short messages (under ~30 characters) that use pronouns or ask "what about X" / "哪些" / "那XX呢" are almost always follow-ups referring to the current topic. Only mark them NEW if they explicitly name a completely unrelated domain.
 - Different aspects of the SAME project/system are SAME (e.g., Nginx SSL → Nginx gzip = SAME)
-- Different unrelated technologies discussed independently are NEW (e.g., Redis config → cooking recipe = NEW)
-- When unsure, lean toward SAME for closely related topics, but do NOT hesitate to mark NEW for obvious domain shifts
-- Examples: "配置Nginx" → "加gzip压缩" = SAME; "配置Nginx" → "做红烧肉" = NEW; "MySQL配置" → "K8s部署" in same infra project = SAME; "部署服务器" → "年会安排" = NEW
+- Asking about tools, systems, or methods for the current topic is SAME (e.g., "港股调研" → "那处理系统有哪些" = SAME; "数据分析" → "用什么工具" = SAME)
+- Different unrelated domains discussed independently are NEW (e.g., Redis config → cooking recipe = NEW)
+- Examples: "配置Nginx" → "加gzip压缩" = SAME; "配置Nginx" → "做红烧肉" = NEW; "港股调研" → "那处理系统有哪些" = SAME; "部署服务器" → "年会安排" = NEW
 
 Output exactly one word: NEW or SAME`;
 

package/src/ingest/providers/gemini.ts

@@ -148,19 +148,22 @@ SAME — the new message:
 - Reports a result, error, or feedback about the current task
 - Discusses different tools or approaches for the SAME goal (e.g., learning English via BBC → via ChatGPT = SAME)
 - Is a short acknowledgment (ok, thanks, 好的) in response to the current flow
+- Contains pronouns or references (那, 这, 它, 其中, 哪些, those, which, what about, etc.) pointing to items from the current conversation
+- Asks about a sub-topic, tool, detail, dimension, or aspect of the current discussion topic
 
 NEW — the new message:
-- Introduces a subject from a DIFFERENT domain than the current task (e.g., tech → cooking, work → personal life, database → travel)
-- Has NO logical connection to what was being discussed
+- Introduces a subject from a COMPLETELY DIFFERENT domain than the current task (e.g., tech → cooking, work → personal life, database → travel)
+- Has NO logical connection to what was being discussed — no shared entities, events, or themes
 - Starts a request about a different project, system, or life area
 - Begins with a new greeting/reset followed by a different topic
 
 Key principles:
-- If the topic domain clearly changed (e.g., server config → recipe, code review → vacation plan), choose NEW
+- Default to SAME unless the topic domain CLEARLY changed. When in doubt, choose SAME.
+- CRITICAL: Short messages (under ~30 characters) that use pronouns or ask "what about X" / "哪些" / "那XX呢" are almost always follow-ups referring to the current topic. Only mark them NEW if they explicitly name a completely unrelated domain.
 - Different aspects of the SAME project/system are SAME (e.g., Nginx SSL → Nginx gzip = SAME)
-- Different unrelated technologies discussed independently are NEW (e.g., Redis config → cooking recipe = NEW)
-- When unsure, lean toward SAME for closely related topics, but do NOT hesitate to mark NEW for obvious domain shifts
-- Examples: "配置Nginx" → "加gzip压缩" = SAME; "配置Nginx" → "做红烧肉" = NEW; "MySQL配置" → "K8s部署" in same infra project = SAME; "部署服务器" → "年会安排" = NEW
+- Asking about tools, systems, or methods for the current topic is SAME (e.g., "港股调研" → "那处理系统有哪些" = SAME; "数据分析" → "用什么工具" = SAME)
+- Different unrelated domains discussed independently are NEW (e.g., Redis config → cooking recipe = NEW)
+- Examples: "配置Nginx" → "加gzip压缩" = SAME; "配置Nginx" → "做红烧肉" = NEW; "港股调研" → "那处理系统有哪些" = SAME; "部署服务器" → "年会安排" = NEW
 
 Output exactly one word: NEW or SAME`;
 

package/src/ingest/providers/index.ts

@@ -1,9 +1,9 @@
 import * as fs from "fs";
 import * as path from "path";
 import type { SummarizerConfig, SummaryProvider, Logger, OpenClawAPI } from "../../types";
-import { summarizeOpenAI, summarizeTaskOpenAI, generateTaskTitleOpenAI, judgeNewTopicOpenAI, filterRelevantOpenAI, judgeDedupOpenAI, parseFilterResult, parseDedupResult } from "./openai";
-import type { FilterResult, DedupResult } from "./openai";
-export type { FilterResult, DedupResult } from "./openai";
+import { summarizeOpenAI, summarizeTaskOpenAI, generateTaskTitleOpenAI, judgeNewTopicOpenAI, classifyTopicOpenAI, arbitrateTopicSplitOpenAI, filterRelevantOpenAI, judgeDedupOpenAI, parseFilterResult, parseDedupResult, parseTopicClassifyResult } from "./openai";
+import type { FilterResult, DedupResult, TopicClassifyResult } from "./openai";
+export type { FilterResult, DedupResult, TopicClassifyResult } from "./openai";
 import { summarizeAnthropic, summarizeTaskAnthropic, generateTaskTitleAnthropic, judgeNewTopicAnthropic, filterRelevantAnthropic, judgeDedupAnthropic } from "./anthropic";
 import { summarizeGemini, summarizeTaskGemini, generateTaskTitleGemini, judgeNewTopicGemini, filterRelevantGemini, judgeDedupGemini } from "./gemini";
 import { summarizeBedrock, summarizeTaskBedrock, generateTaskTitleBedrock, judgeNewTopicBedrock, filterRelevantBedrock, judgeDedupBedrock } from "./bedrock";
@@ -287,25 +287,30 @@ export class Summarizer {
   }
 
   async judgeNewTopic(currentContext: string, newMessage: string): Promise<boolean | null> {
-    const chain: SummarizerConfig[] = [];
-    if (this.strongCfg) chain.push(this.strongCfg);
-    if (this.fallbackCfg) chain.push(this.fallbackCfg);
-    if (chain.length === 0 && this.cfg) chain.push(this.cfg);
-    if (chain.length === 0) return null;
+    const result = await this.tryChain("judgeNewTopic", (cfg) =>
+      cfg.provider === "openclaw"
+        ? this.judgeNewTopicOpenClaw(currentContext, newMessage)
+        : callTopicJudge(cfg, currentContext, newMessage, this.log),
+    );
+    return result ?? null;
+  }
 
-    for (let i = 0; i < chain.length; i++) {
-      const modelInfo = `${chain[i].provider}/${chain[i].model ?? "?"}`;
-      try {
-        const result = await callTopicJudge(chain[i], currentContext, newMessage, this.log);
-        modelHealth.recordSuccess("judgeNewTopic", modelInfo);
-        return result;
-      } catch (err) {
-        const level = i < chain.length - 1 ? "warn" : "error";
-        this.log[level](`judgeNewTopic failed (${modelInfo}), ${i < chain.length - 1 ? "trying next" : "no more fallbacks"}: ${err}`);
-        modelHealth.recordError("judgeNewTopic", modelInfo, String(err));
-      }
-    }
-    return null;
+  async classifyTopic(taskState: string, newMessage: string): Promise<TopicClassifyResult | null> {
+    const result = await this.tryChain("classifyTopic", (cfg) =>
+      cfg.provider === "openclaw"
+        ? this.classifyTopicOpenClaw(taskState, newMessage)
+        : callTopicClassifier(cfg, taskState, newMessage, this.log),
+    );
+    return result ?? null;
+  }
+
+  async arbitrateTopicSplit(taskState: string, newMessage: string): Promise<string | null> {
+    const result = await this.tryChain("arbitrateTopicSplit", (cfg) =>
+      cfg.provider === "openclaw"
+        ? this.arbitrateTopicSplitOpenClaw(taskState, newMessage)
+        : callTopicArbitration(cfg, taskState, newMessage, this.log),
+    );
+    return result ?? null;
   }
 
   async filterRelevant(
@@ -346,8 +351,19 @@ export class Summarizer {
 
   static readonly OPENCLAW_TOPIC_JUDGE_PROMPT = `You are a conversation topic change detector.
 Given a CURRENT CONVERSATION SUMMARY and a NEW USER MESSAGE, decide: has the user started a COMPLETELY NEW topic that is unrelated to the current conversation?
+Default to SAME unless the domain clearly changed. If the new message shares the same person, event, entity, or theme with the current conversation, answer SAME.
+CRITICAL: Short messages (under ~30 characters) that use pronouns (那/这/它/哪些) or ask about tools/details/dimensions of the current topic are almost always follow-ups — answer SAME unless they explicitly name a completely unrelated domain.
 Reply with a single word: "NEW" if topic changed, "SAME" if it continues.`;
 
+  static readonly OPENCLAW_TOPIC_CLASSIFIER_PROMPT = `Classify if NEW MESSAGE continues current task or starts an unrelated one.
+Output ONLY JSON: {"d":"S"|"N","c":0.0-1.0}
+d=S(same) or N(new). c=confidence. Default S. Only N if completely unrelated domain.
+Sub-questions, tools, methods, details of current topic = S.`;
+
+  static readonly OPENCLAW_TOPIC_ARBITRATION_PROMPT = `A classifier flagged this message as possibly new topic (low confidence). Is it truly UNRELATED, or a sub-question/follow-up?
+Tools/methods/details of current task = SAME. Shared entity/theme = SAME. Entirely different domain = NEW.
+Reply one word: NEW or SAME`;
+
   static readonly OPENCLAW_FILTER_RELEVANT_PROMPT = `You are a memory relevance judge.
 Given a QUERY and CANDIDATE memories, decide: does each candidate help answer the query?
 RULES:
@@ -433,6 +449,45 @@ Reply with JSON: {"action":"MERGE","mergeTarget":2,"reason":"..."} or {"action":
     return answer.startsWith("NEW");
   }
 
+  private async classifyTopicOpenClaw(taskState: string, newMessage: string): Promise<TopicClassifyResult> {
+    this.requireOpenClawAPI();
+    const prompt = [
+      Summarizer.OPENCLAW_TOPIC_CLASSIFIER_PROMPT,
+      ``,
+      `TASK:\n${taskState}`,
+      `\nMSG:\n${newMessage}`,
+    ].join("\n");
+
+    const response = await this.openclawAPI!.complete({
+      prompt,
+      maxTokens: 60,
+      temperature: 0,
+      model: this.cfg?.model,
+    });
+
+    return parseTopicClassifyResult(response.text.trim(), this.log);
+  }
+
+  private async arbitrateTopicSplitOpenClaw(taskState: string, newMessage: string): Promise<string> {
+    this.requireOpenClawAPI();
+    const prompt = [
+      Summarizer.OPENCLAW_TOPIC_ARBITRATION_PROMPT,
+      ``,
+      `TASK:\n${taskState}`,
+      `\nMSG:\n${newMessage}`,
+    ].join("\n");
+
+    const response = await this.openclawAPI!.complete({
+      prompt,
+      maxTokens: 10,
+      temperature: 0,
+      model: this.cfg?.model,
+    });
+
+    const answer = response.text.trim().toUpperCase();
+    return answer.startsWith("NEW") ? "NEW" : "SAME";
+  }
+
   private async filterRelevantOpenClaw(
     query: string,
     candidates: Array<{ index: number; role: string; content: string; time?: string }>,
@@ -643,6 +698,52 @@ function callJudgeDedup(cfg: SummarizerConfig, newSummary: string, candidates: A
   }
 }
 
+function callTopicClassifier(cfg: SummarizerConfig, taskState: string, newMessage: string, log: Logger): Promise<TopicClassifyResult> {
+  switch (cfg.provider) {
+    case "openai":
+    case "openai_compatible":
+    case "azure_openai":
+    case "zhipu":
+    case "siliconflow":
+    case "deepseek":
+    case "moonshot":
+    case "bailian":
+    case "cohere":
+    case "mistral":
+    case "voyage":
+      return classifyTopicOpenAI(taskState, newMessage, cfg, log);
+    case "anthropic":
+    case "gemini":
+    case "bedrock":
+      return classifyTopicOpenAI(taskState, newMessage, cfg, log);
+    default:
+      throw new Error(`Unknown summarizer provider: ${cfg.provider}`);
+  }
+}
+
+function callTopicArbitration(cfg: SummarizerConfig, taskState: string, newMessage: string, log: Logger): Promise<string> {
+  switch (cfg.provider) {
+    case "openai":
+    case "openai_compatible":
+    case "azure_openai":
+    case "zhipu":
+    case "siliconflow":
+    case "deepseek":
+    case "moonshot":
+    case "bailian":
+    case "cohere":
+    case "mistral":
+    case "voyage":
+      return arbitrateTopicSplitOpenAI(taskState, newMessage, cfg, log);
+    case "anthropic":
+    case "gemini":
+    case "bedrock":
+      return arbitrateTopicSplitOpenAI(taskState, newMessage, cfg, log);
+    default:
+      throw new Error(`Unknown summarizer provider: ${cfg.provider}`);
+  }
+}
+
 // ─── Fallbacks ───
 
 function ruleFallback(text: string): string {

package/src/ingest/providers/openai.ts

@@ -188,19 +188,26 @@ SAME — the new message:
 - Reports a result, error, or feedback about the current task
 - Discusses different tools or approaches for the SAME goal (e.g., learning English via BBC → via ChatGPT = SAME)
 - Is a short acknowledgment (ok, thanks, 好的) in response to the current flow
+- Is a follow-up, update, or different angle on the same news event, person, or story
+- Shares the same core entity (person, company, event) even if the specific detail or angle differs
+- Contains pronouns or references (那, 这, 它, 其中, 哪些, those, which, what about, etc.) pointing to items from the current conversation
+- Asks about a sub-topic, tool, detail, dimension, or aspect of the current discussion topic
 
 NEW — the new message:
-- Introduces a subject from a DIFFERENT domain than the current task (e.g., tech → cooking, work → personal life, database → travel)
-- Has NO logical connection to what was being discussed
+- Introduces a subject from a COMPLETELY DIFFERENT domain than the current task (e.g., tech → cooking, work → personal life, database → travel)
+- Has NO logical connection to what was being discussed — no shared entities, events, or themes
 - Starts a request about a different project, system, or life area
 - Begins with a new greeting/reset followed by a different topic
 
 Key principles:
-- If the topic domain clearly changed (e.g., server config → recipe, code review → vacation plan), choose NEW
+- Default to SAME unless the topic domain CLEARLY changed. When in doubt, choose SAME.
+- CRITICAL: Short messages (under ~30 characters) that use pronouns or ask "what about X" / "哪些" / "那XX呢" are almost always follow-ups referring to the current topic. Only mark them NEW if they explicitly name a completely unrelated domain.
+- If the new message mentions the same person, event, product, or entity as the current task, it is SAME regardless of the angle
 - Different aspects of the SAME project/system are SAME (e.g., Nginx SSL → Nginx gzip = SAME)
-- Different unrelated technologies discussed independently are NEW (e.g., Redis config → cooking recipe = NEW)
-- When unsure, lean toward SAME for closely related topics, but do NOT hesitate to mark NEW for obvious domain shifts
-- Examples: "配置Nginx" → "加gzip压缩" = SAME; "配置Nginx" → "做红烧肉" = NEW; "MySQL配置" → "K8s部署" in same infra project = SAME; "部署服务器" → "年会安排" = NEW
+- Asking about tools, systems, or methods for the current topic is SAME (e.g., "港股调研" → "那处理系统有哪些" = SAME; "数据分析" → "用什么工具" = SAME)
+- Follow-up news about the same event is SAME (e.g., "博士失联" → "博士遗体被找到" = SAME; "产品发布" → "产品销量" = SAME)
+- Different unrelated domains discussed independently are NEW (e.g., Redis config → cooking recipe = NEW)
+- Examples: "配置Nginx" → "加gzip压缩" = SAME; "配置Nginx" → "做红烧肉" = NEW; "港股调研" → "那处理系统有哪些" = SAME; "部署服务器" → "年会安排" = NEW
 
 Output exactly one word: NEW or SAME`;
 
@@ -246,6 +253,134 @@ export async function judgeNewTopicOpenAI(
   return answer.startsWith("NEW");
 }
 
+// ─── Structured Topic Classifier ───
+
+export interface TopicClassifyResult {
+  decision: "NEW" | "SAME";
+  confidence: number;
+  boundaryType: string;
+  reason: string; // may be empty for compact responses
+}
+
+const TOPIC_CLASSIFIER_PROMPT = `Classify if NEW MESSAGE continues current task or starts an unrelated one.
+Output ONLY JSON: {"d":"S"|"N","c":0.0-1.0}
+d=S(same) or N(new). c=confidence. Default S. Only N if completely unrelated domain.
+Sub-questions, tools, methods, details of current topic = S.`;
+
+export async function classifyTopicOpenAI(
+  taskState: string,
+  newMessage: string,
+  cfg: SummarizerConfig,
+  log: Logger,
+): Promise<TopicClassifyResult> {
+  const endpoint = normalizeChatEndpoint(cfg.endpoint ?? "https://api.openai.com/v1/chat/completions");
+  const model = cfg.model ?? "gpt-4o-mini";
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${cfg.apiKey}`,
+    ...cfg.headers,
+  };
+
+  const userContent = `TASK:\n${taskState}\n\nMSG:\n${newMessage}`;
+
+  const resp = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(buildRequestBody(cfg, {
+      model,
+      temperature: 0,
+      max_tokens: 60,
+      messages: [
+        { role: "system", content: TOPIC_CLASSIFIER_PROMPT },
+        { role: "user", content: userContent },
+      ],
+    })),
+    signal: AbortSignal.timeout(cfg.timeoutMs ?? 15_000),
+  });
+
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`OpenAI topic-classifier failed (${resp.status}): ${body}`);
+  }
+
+  const json = (await resp.json()) as { choices: Array<{ message: { content: string } }> };
+  const raw = json.choices[0]?.message?.content?.trim() ?? "";
+  log.debug(`Topic classifier raw: "${raw}"`);
+
+  return parseTopicClassifyResult(raw, log);
+}
+
+const TOPIC_ARBITRATION_PROMPT = `A classifier flagged this message as possibly new topic (low confidence). Is it truly UNRELATED, or a sub-question/follow-up?
+Tools/methods/details of current task = SAME. Shared entity/theme = SAME. Entirely different domain = NEW.
+Reply one word: NEW or SAME`;
+
+export async function arbitrateTopicSplitOpenAI(
+  taskState: string,
+  newMessage: string,
+  cfg: SummarizerConfig,
+  log: Logger,
+): Promise<string> {
+  const endpoint = normalizeChatEndpoint(cfg.endpoint ?? "https://api.openai.com/v1/chat/completions");
+  const model = cfg.model ?? "gpt-4o-mini";
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${cfg.apiKey}`,
+    ...cfg.headers,
+  };
+
+  const userContent = `TASK:\n${taskState}\n\nMSG:\n${newMessage}`;
+
+  const resp = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(buildRequestBody(cfg, {
+      model,
+      temperature: 0,
+      max_tokens: 10,
+      messages: [
+        { role: "system", content: TOPIC_ARBITRATION_PROMPT },
+        { role: "user", content: userContent },
+      ],
+    })),
+    signal: AbortSignal.timeout(cfg.timeoutMs ?? 15_000),
+  });
+
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`OpenAI topic-arbitration failed (${resp.status}): ${body}`);
+  }
+
+  const json = (await resp.json()) as { choices: Array<{ message: { content: string } }> };
+  const answer = json.choices[0]?.message?.content?.trim().toUpperCase() ?? "";
+  log.debug(`Topic arbitration result: "${answer}"`);
+  return answer.startsWith("NEW") ? "NEW" : "SAME";
+}
+
+export function parseTopicClassifyResult(raw: string, log: Logger): TopicClassifyResult {
+  try {
+    const jsonMatch = raw.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      const p = JSON.parse(jsonMatch[0]);
+      const decision: "NEW" | "SAME" =
+        (p.d === "N" || p.decision === "NEW") ? "NEW" : "SAME";
+      const confidence: number =
+        typeof p.c === "number" ? p.c : typeof p.confidence === "number" ? p.confidence : 0.5;
+      return {
+        decision,
+        confidence,
+        boundaryType: p.boundaryType || "",
+        reason: p.reason || "",
+      };
+    }
+  } catch (err) {
+    log.debug(`Failed to parse topic classify JSON: ${err}`);
+  }
+  const upper = raw.toUpperCase();
+  if (upper.startsWith("NEW") || upper.startsWith("N"))
+    return { decision: "NEW", confidence: 0.5, boundaryType: "", reason: "parse fallback" };
+  return { decision: "SAME", confidence: 0.5, boundaryType: "", reason: "parse fallback" };
+}
+
 const FILTER_RELEVANT_PROMPT = `You are a memory relevance judge.
 
 Given a QUERY and CANDIDATE memories, decide: does each candidate's content contain information that would HELP ANSWER the query?