openclaw-memory-alibaba-mysql 0.1.9 → 0.2.1

package/README.md

@@ -1,33 +1,36 @@
-# openclaw_memory_alibaba_mysql
+# openclaw-memory-alibaba-mysql
 
-OpenClaw 记忆插件，使用阿里云 RDS MySQL 向量存储。用户记忆细分为 fact / preference / decision 三类；支持全文记忆与自我改进记忆，抽取方式可选 regex 或 llm。
+OpenClaw 记忆插件，使用阿里云 RDS MySQL 做向量存储。支持用户记忆、全文对话记录、自进化记忆；可与 OpenClaw 的 before_agent_start / agent_end 配合，自动召回与自动落库。
 
-## 记忆分类 (category)
+## 功能概览
 
-| 类型 | category | 说明 |
-|------|----------|------|
-| 用户事实 | `user_memory_fact` | 用户陈述的事实、习惯、身份信息等 |
-| 用户偏好 | `user_memory_preference` | 喜欢/不喜欢、偏好、意愿 |
-| 用户决策 | `user_memory_decision` | 已做的决定、打算、计划 |
+- **用户记忆**：从对话中自动抽取事实、偏好、决策（如「喜欢寿司」「打算用 Python」），支持按向量检索并注入到每轮上下文。
+- **全文记忆**：按消息来源分为用户、助手、系统、工具等 6 类，每类按会话保留一份，每轮更新；只存真实对话内容，不存系统注入的上下文块。
+- **自进化记忆**：从对话中抽取学习要点、错误、需求等，可选参与召回。
+- **冲突与去重**：可选用 LLM 判断新记忆与已有记忆是否矛盾或重复，避免重复、矛盾条目堆积。
+- **时间衰减**：召回时可对旧记忆降权，让近期信息更突出。
+- **工具**：提供 `memory_recall`（按查询搜记忆）、`memory_store`（显式写入）、`memory_forget`（删除）；若只依赖自动召回与自动抓取，可不给 agent 开放 recall/store，仅保留 forget 用于删除。
 
-- **自动抓取 (autoCapture)**：按 `memoryExtractionMethod` 用 regex 或 LLM 从用户/对话中抽取并写入。
-- **memory_store 工具**：可显式指定 `category`，默认 `user_memory_fact`。
-- **召回**：`before_agent_start` 与 `memory_recall` 统一按向量检索用户记忆（及可选 self_improving），注入上下文。
+## 记忆分类
 
----
+| 类型 | 说明 |
+|------|------|
+| 用户事实 / 偏好 / 决策 | 从用户话里抽取的事实、喜好、决定，用于后续对话的上下文 |
+| 全文·用户 / 助手 / 系统 / 工具 / 工具结果 / 其它 | 按消息角色分的完整对话记录，按会话维护、每轮更新 |
+| 自进化（学习 / 错误 / 需求） | 从对话中抽取的可复用经验，可选参与召回 |
 
 ## 配置示例
 
-### 最简配置（只接库 + 向量）
+### 最简配置
 
-只配必填的 MySQL 和 Embedding，其它用默认：自动召回开、自动抓取关、不启用全文/自我改进/记忆衰减。
+只接 MySQL 和向量服务，其余用默认（自动召回 + 自动抓取用户记忆，不开启全文与自进化）：
 
 ```json
 {
   "plugins": {
-    "slots": { "memory": "openclaw_memory_alibaba_mysql" },
+    "slots": { "memory": "openclaw-memory-alibaba-mysql" },
     "entries": {
-      "openclaw_memory_alibaba_mysql": {
+      "openclaw-memory-alibaba-mysql": {
         "enabled": true,
         "config": {
           "mysql": {
@@ -50,16 +53,16 @@ OpenClaw 记忆插件，使用阿里云 RDS MySQL 向量存储。用户记忆细
 }
 ```
 
-### 最全配置（功能全开）
+### 功能全开
 
-显式写出 MySQL、Embedding、LLM、自动抓取/召回、全文记忆、自我改进、记忆衰减、相似度阈值、表名等，便于按需裁剪。
+开启全文记忆、自进化、LLM 抽取与冲突处理、时间衰减等：
 
 ```json
 {
   "plugins": {
-    "slots": { "memory": "openclaw_memory_alibaba_mysql" },
+    "slots": { "memory": "openclaw-memory-alibaba-mysql" },
     "entries": {
-      "openclaw_memory_alibaba_mysql": {
+      "openclaw-memory-alibaba-mysql": {
         "enabled": true,
         "config": {
           "mysql": {
@@ -89,7 +92,7 @@ OpenClaw 记忆插件，使用阿里云 RDS MySQL 向量存储。用户记忆细
           "memoryExtractionMethod": "llm",
           "autoRecall": true,
           "autoCapture": true,
-          "captureMaxChars": 500,
+          "captureMaxChars": 5000,
           "enableMemoryDecay": true,
           "tableName": "openclaw_memories"
         }
@@ -99,38 +102,21 @@ OpenClaw 记忆插件，使用阿里云 RDS MySQL 向量存储。用户记忆细
 }
 ```
 
-**配置要点**
+**常用配置说明**
 
-- **必填**：`mysql`（host / user / password / database 等）、`embedding`（apiKey、model）。
-- **memoryExtractionMethod**：`"regex"` 或 `"llm"`，对 user_memory_* 与 self_improving_* 同时生效；选 `"llm"` 需配 `llm`。
-- **enableFullContextMemory** / **enableSelfImprovingMemory**：开启后可写全文记忆、自我改进记忆；全文记忆不参与常规召回。
-- **memory_duplication_conflict_process**：为 true 时用 LLM 做写入前去重/冲突判断，需配 `llm`。
-- **enableMemoryDecay**：为 true 时对召回结果做时间衰减（半衰期与策略使用内置默认：30 天、指数衰减）。
-
----
+- **mysql** / **embedding**：必填，用于连接数据库与生成向量。
+- **llm**：使用「LLM 抽取」或「冲突/去重」时必填。
+- **memoryExtractionMethod**：`"llm"`（默认）或 `"regex"`，控制如何从对话里抽取用户记忆与自改进记忆。
+- **enableFullContextMemory**：是否按角色保存全文对话（每会话每类一份，每轮更新）。
+- **enableSelfImprovingMemory**：是否启用自进化记忆的写入与召回。
+- **memory_duplication_conflict_process**：是否用 LLM 做写入前的去重与矛盾判断。
+- **captureMaxChars**：单条记忆与全文截断的最大字符数，建议 5000 以保留完整当轮对话。
+- **enableMemoryDecay**：召回时是否对旧记忆做时间衰减（近期记忆权重更高）。
+- **tableName**：存储表名，默认 `openclaw_memories`。
 
 ## 环境变量
 
-- `MYSQL_HOST`, `MYSQL_USER`, `MYSQL_PASSWORD`：MySQL 连接（或在 config 里写死，password 支持 `${VAR}`）。
-- `DASHSCOPE_API_KEY`：DashScope 用于 embedding（若 apiKey 使用 `${DASHSCOPE_API_KEY}`）。
-
----
-
-## 测试
-
-```bash
-export MYSQL_HOST=your-host MYSQL_PASSWORD=xxx DASHSCOPE_API_KEY=xxx
-npx tsx test-agent-isolation.ts
-npx tsx test-three-memory-types.ts
-npx tsx test-full-context-memory.ts
-```
-
----
-
-## 文件说明
+配置中可使用占位符引用环境变量，例如 `${MYSQL_PASSWORD}`、`${DASHSCOPE_API_KEY}`。常见需要准备的有：
 
-- `categories.ts`：常量与类型（user_memory_*、self_improving_*、full_context_memory）。
-- `config.ts`：配置解析与默认值。
-- `db.ts`：MemoryDB 建表、store、search、softDelete（向量 COSINE）。
-- `index.ts`：插件注册、memory_recall / memory_store / memory_forget、before_agent_start / agent_end。
-- `prompts.ts`：用户记忆与 self_improving 的 LLM 抽取 Prompt。
+- **MYSQL_HOST**, **MYSQL_USER**, **MYSQL_PASSWORD**：MySQL 连接信息。
+- **DASHSCOPE_API_KEY**：DashScope API Key，用于 embedding（以及 LLM 若使用 DashScope）。

package/categories.ts

@@ -20,9 +20,32 @@ export type UserMemoryCategory =
   | typeof USER_MEMORY_PREFERENCE
   | typeof USER_MEMORY_DECISION;
 
-/** Full context (conversation audit / per-message) */
+/** Full context (conversation audit). Legacy single category. */
 export const FULL_CONTEXT_MEMORY = "full_context_memory" as const;
 
+/** Full context by source (user / assistant / system / tool / tool_result / others) */
+export const FULL_CONTEXT_USER = "full_context_user" as const;
+export const FULL_CONTEXT_ASSISTANT = "full_context_assistant" as const;
+export const FULL_CONTEXT_SYSTEM = "full_context_system" as const;
+export const FULL_CONTEXT_TOOL = "full_context_tool" as const;
+export const FULL_CONTEXT_TOOL_RESULT = "full_context_tool_result" as const;
+export const FULL_CONTEXT_OTHERS = "full_context_others" as const;
+
+export const FULL_CONTEXT_SOURCE_CATEGORIES = [
+  FULL_CONTEXT_USER,
+  FULL_CONTEXT_ASSISTANT,
+  FULL_CONTEXT_SYSTEM,
+  FULL_CONTEXT_TOOL,
+  FULL_CONTEXT_TOOL_RESULT,
+  FULL_CONTEXT_OTHERS,
+] as const;
+
+export type FullContextSourceCategory = (typeof FULL_CONTEXT_SOURCE_CATEGORIES)[number];
+
+export function isFullContextSourceCategory(cat: string): cat is FullContextSourceCategory {
+  return FULL_CONTEXT_SOURCE_CATEGORIES.includes(cat as FullContextSourceCategory);
+}
+
 /** Self-improving memory sub-categories */
 export const SELF_IMPROVING_LEARNINGS = "self_improving_learnings" as const;
 export const SELF_IMPROVING_ERRORS = "self_improving_errors" as const;
@@ -40,11 +63,13 @@ export type SelfImprovingCategory = (typeof SELF_IMPROVING_CATEGORIES)[number];
 export type MemoryCategory =
   | UserMemoryCategory
   | typeof FULL_CONTEXT_MEMORY
+  | FullContextSourceCategory
   | SelfImprovingCategory;
 
 export const ALL_CATEGORIES: readonly MemoryCategory[] = [
   ...USER_MEMORY_CATEGORIES,
   FULL_CONTEXT_MEMORY,
+  ...FULL_CONTEXT_SOURCE_CATEGORIES,
   ...SELF_IMPROVING_CATEGORIES,
 ];
 

package/config.ts

@@ -38,7 +38,7 @@ export type MemoryConfig = {
   enableFullContextMemory: boolean;
   /** When false, self_improving_* is not written or recalled. Default false. */
   enableSelfImprovingMemory: boolean;
-  /** How to extract user and self_improving memories in auto-capture: "regex" (default) or "llm". Case-insensitive; invalid values fall back to "regex". When "llm", llm config is required. */
+  /** How to extract user and self_improving memories in auto-capture: "llm" (default) or "regex". Case-insensitive; invalid values fall back to "llm". When "llm", llm config is required. */
   memoryExtractionMethod: "regex" | "llm";
   autoRecall: boolean;
   autoCapture: boolean;
@@ -210,7 +210,7 @@ export const memoryConfigSchema = {
         ? cfg.memoryExtractionMethod.trim().toLowerCase()
         : "";
     const memoryExtractionMethod: "regex" | "llm" =
-      rawMethod === "llm" ? "llm" : "regex";
+      rawMethod === "regex" ? "regex" : "llm";
     const needsLlm = memory_duplication_conflict_process || memoryExtractionMethod === "llm";
     if (needsLlm && (!cfg.llm || typeof cfg.llm !== "object")) {
       throw new Error(

package/db.ts

@@ -23,6 +23,11 @@ export type MemorySearchResult = {
 
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
+/** Strip 4-byte UTF-8 (e.g. emojis) so text is safe for MySQL utf8 charset. Use as-is when table is utf8mb4. */
+function stripFourByteUtf8(text: string): string {
+  return text.replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, "");
+}
+
 export class MemoryDB {
   private pool: Pool | null = null;
   private initPromise: Promise<void> | null = null;
@@ -73,10 +78,12 @@ export class MemoryDB {
           category   VARCHAR(64)   DEFAULT '${USER_MEMORY_FACT}',
           created_at BIGINT        NOT NULL,
           is_deleted TINYINT       NOT NULL DEFAULT 0,
-          INDEX idx_agent_id (agent_id)
-        ) ENGINE=InnoDB
+          INDEX idx_agent_id (agent_id),
+          INDEX idx_agent_session_category (agent_id, session_id, category)
+        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
       `);
       await this.ensureIsDeletedColumn(conn);
+      await this.ensureSessionCategoryIndex(conn);
       await this.tryCreateVectorIndex(conn);
     } finally {
       conn.release();
@@ -95,6 +102,18 @@ export class MemoryDB {
     );
   }
 
+  private async ensureSessionCategoryIndex(conn: mysql.PoolConnection): Promise<void> {
+    const [rows] = await conn.query(
+      `SELECT COUNT(1) AS cnt FROM information_schema.statistics
+       WHERE table_schema = DATABASE() AND table_name = ? AND index_name = 'idx_agent_session_category'`,
+      [this.tableName],
+    );
+    if (((rows as Array<{ cnt: number }>)[0]?.cnt ?? 0) > 0) return;
+    await conn.query(
+      `ALTER TABLE \`${this.tableName}\` ADD INDEX idx_agent_session_category (agent_id, session_id, category)`,
+    );
+  }
+
   private async tryCreateVectorIndex(conn: mysql.PoolConnection): Promise<void> {
     if (this.vectorIndexCreated) {
       return;
@@ -123,18 +142,28 @@ export class MemoryDB {
 
   async store(
     agentId: string,
-    entry: { text: string; vector: number[]; importance: number; category: MemoryCategory },
+    entry: {
+      text: string;
+      vector: number[];
+      importance: number;
+      category: MemoryCategory;
+      userId?: string | null;
+      sessionId?: string | null;
+    },
   ): Promise<MemoryEntry> {
     await this.ensureInitialized();
 
     const id = randomUUID();
     const createdAt = Date.now();
     const vectorStr = JSON.stringify(entry.vector);
+    const userId = entry.userId ?? null;
+    const sessionId = entry.sessionId ?? null;
+    const textSafe = stripFourByteUtf8(entry.text);
 
     await this.pool!.query(
-      `INSERT INTO \`${this.tableName}\` (id, agent_id, text, embedding, importance, category, created_at, is_deleted)
-       VALUES (?, ?, ?, VEC_FROMTEXT(?), ?, ?, ?, 0)`,
-      [id, agentId, entry.text, vectorStr, entry.importance, entry.category, createdAt],
+      `INSERT INTO \`${this.tableName}\` (id, agent_id, user_id, session_id, text, embedding, importance, category, created_at, is_deleted)
+       VALUES (?, ?, ?, ?, ?, VEC_FROMTEXT(?), ?, ?, ?, 0)`,
+      [id, agentId, userId, sessionId, textSafe, vectorStr, entry.importance, entry.category, createdAt],
     );
 
     if (!this.vectorIndexCreated) {
@@ -149,13 +178,92 @@ export class MemoryDB {
     return {
       id,
       agentId,
-      text: entry.text,
+      text: textSafe,
       importance: entry.importance,
       category: entry.category,
       createdAt,
     };
   }
 
+  /**
+   * Upsert for full-context by (agent_id, session_id, category): one row per session per category.
+   * If a row exists, UPDATE it; otherwise INSERT. Returns action and entry.
+   */
+  async storeOrUpdateFullContext(
+    agentId: string,
+    sessionId: string | null,
+    entry: {
+      text: string;
+      vector: number[];
+      importance: number;
+      category: MemoryCategory;
+      userId?: string | null;
+    },
+  ): Promise<{ action: "created" | "updated"; entry: MemoryEntry }> {
+    await this.ensureInitialized();
+
+    const textSafe = stripFourByteUtf8(entry.text);
+    const vectorStr = JSON.stringify(entry.vector);
+    const userId = entry.userId ?? null;
+    const createdAt = Date.now();
+
+    const [existingRows] = await this.pool!.query(
+      `SELECT id FROM \`${this.tableName}\`
+       WHERE agent_id = ? AND category = ? AND is_deleted = 0
+         AND ((? IS NULL AND session_id IS NULL) OR (session_id = ?))
+       LIMIT 1`,
+      [agentId, entry.category, sessionId, sessionId],
+    );
+    const existing = (existingRows as Array<{ id: string }>)[0];
+
+    if (existing) {
+      await this.pool!.query(
+        `UPDATE \`${this.tableName}\` SET text = ?, embedding = VEC_FROMTEXT(?), importance = ?, created_at = ?, user_id = ?
+         WHERE id = ? AND agent_id = ?`,
+        [textSafe, vectorStr, entry.importance, createdAt, userId, existing.id, agentId],
+      );
+      return {
+        action: "updated",
+        entry: {
+          id: existing.id,
+          agentId,
+          text: textSafe,
+          importance: entry.importance,
+          category: entry.category,
+          createdAt,
+        },
+      };
+    }
+
+    const id = randomUUID();
+    await this.pool!.query(
+      `INSERT INTO \`${this.tableName}\` (id, agent_id, user_id, session_id, text, embedding, importance, category, created_at, is_deleted)
+       VALUES (?, ?, ?, ?, ?, VEC_FROMTEXT(?), ?, ?, ?, 0)`,
+      [id, agentId, userId, sessionId, textSafe, vectorStr, entry.importance, entry.category, createdAt],
+    );
+
+    if (!this.vectorIndexCreated) {
+      const conn = await this.pool!.getConnection();
+      try {
+        await this.tryCreateVectorIndex(conn);
+      } finally {
+        conn.release();
+      }
+    }
+
+    return {
+      action: "created",
+      entry: {
+        id,
+        agentId,
+        text: textSafe,
+        importance: entry.importance,
+        category: entry.category,
+        createdAt,
+      },
+    };
+  }
+
   /**
    * Search memories by vector similarity.
    * @param categories - When non-empty, only return rows with category IN (categories). Omit for no category filter.

package/index.ts

@@ -19,11 +19,18 @@ import {
   SELF_IMPROVING_ERRORS,
   SELF_IMPROVING_FEATURE_REQUESTS,
   FULL_CONTEXT_MEMORY,
+  FULL_CONTEXT_USER,
+  FULL_CONTEXT_ASSISTANT,
+  FULL_CONTEXT_SYSTEM,
+  FULL_CONTEXT_TOOL,
+  FULL_CONTEXT_TOOL_RESULT,
+  FULL_CONTEXT_OTHERS,
   type UserMemoryCategory,
   type SelfImprovingCategory,
   type MemoryCategory,
   isUserMemoryCategory,
   isSelfImprovingCategory,
+  isFullContextSourceCategory,
 } from "./categories.js";
 import {
   DEFAULT_CAPTURE_MAX_CHARS,
@@ -146,9 +153,10 @@ function formatRelevantMemoriesContext(
 }
 
 function getThresholdForCategory(cfg: MemoryConfig, category: MemoryCategory): number {
-  return isUserMemoryCategory(category)
-    ? cfg.similarityThresholdUserMemory
-    : cfg.similarityThresholdSelfImproving;
+  if (isUserMemoryCategory(category) || isFullContextSourceCategory(category) || category === FULL_CONTEXT_MEMORY) {
+    return cfg.similarityThresholdUserMemory;
+  }
+  return cfg.similarityThresholdSelfImproving;
 }
 
 /** Apply time decay to recall results: effectiveScore = score * decay(createdAt). Returns new array sorted by effectiveScore desc. */
@@ -388,7 +396,7 @@ New memory text:
 ${newText}
 """
 
-Existing similar memories (up to 10):
+Existing similar memories (up to 20):
 ${candidateList}
 
 Rules:
@@ -468,15 +476,34 @@ function getTextPartsFromMessage(msg: Record<string, unknown>): string[] {
   return parts;
 }
 
-/** From raw agent messages, collect user-only texts and full/conversation lines for each memory type. */
+/** Lines by role for full-context (user / assistant / system / tool / tool_result / others). */
+export type LinesByRole = {
+  user: string[];
+  assistant: string[];
+  system: string[];
+  tool: string[];
+  tool_result: string[];
+  others: string[];
+};
+
+/** From raw agent messages, collect user-only texts, full/conversation lines, and lines grouped by role. */
 function parseMessagesForCapture(messages: unknown[]): {
   userMessageTexts: string[];
   allMessageLines: string[];
   userAndAssistantLines: string[];
+  linesByRole: LinesByRole;
 } {
   const userMessageTexts: string[] = [];
   const allMessageLines: string[] = [];
   const userAndAssistantLines: string[] = [];
+  const linesByRole: LinesByRole = {
+    user: [],
+    assistant: [],
+    system: [],
+    tool: [],
+    tool_result: [],
+    others: [],
+  };
 
   for (const msg of messages) {
     if (!msg || typeof msg !== "object") continue;
@@ -489,9 +516,16 @@ function parseMessagesForCapture(messages: unknown[]): {
     allMessageLines.push(line);
     if (role !== "system") userAndAssistantLines.push(line);
     if (role === "user") userMessageTexts.push(...parts);
+
+    if (role === "user") linesByRole.user.push(line);
+    else if (role === "assistant") linesByRole.assistant.push(line);
+    else if (role === "system") linesByRole.system.push(line);
+    else if (role === "tool") linesByRole.tool.push(line);
+    else if (role === "toolResult" || role === "tool_result") linesByRole.tool_result.push(line);
+    else linesByRole.others.push(line);
   }
 
-  return { userMessageTexts, allMessageLines, userAndAssistantLines };
+  return { userMessageTexts, allMessageLines, userAndAssistantLines, linesByRole };
 }
 
 /** Truncate to max chars and append "..." if needed. */
@@ -514,12 +548,13 @@ function stripInjectedContextBlocks(text: string): string {
   return out;
 }
 
-/** Build list of capture candidates: user (regex/LLM) + optional full-context + optional self-improving. */
+/** Build list of capture candidates: user (regex/LLM) + optional full-context by source + optional self-improving. */
 async function buildCaptureCandidates(
   cfg: MemoryConfig,
   userMessageTexts: string[],
   allMessageLines: string[],
   userAndAssistantLines: string[],
+  linesByRole: LinesByRole,
 ): Promise<CaptureCandidate[]> {
   const candidates: CaptureCandidate[] = [];
 
@@ -542,13 +577,56 @@ async function buildCaptureCandidates(
     }
   }
 
-  // Full-context: all roles, keep injected blocks (full audit trail)
-  if (cfg.enableFullContextMemory && allMessageLines.length > 0) {
-    const fullText = allMessageLines.join("\n");
-    candidates.push({
-      category: FULL_CONTEXT_MEMORY,
-      text: truncateForCapture(fullText, cfg.captureMaxChars),
-    });
+  // Full-context by source. Strip injected blocks from user/assistant so real conversation is stored (injected context can be huge and push out the actual question).
+  if (cfg.enableFullContextMemory) {
+    if (linesByRole.user.length > 0) {
+      const userText = linesByRole.user
+        .map((line) => stripInjectedContextBlocks(line))
+        .filter((s) => s.length > 0)
+        .join("\n");
+      if (userText.length > 0) {
+        candidates.push({
+          category: FULL_CONTEXT_USER,
+          text: truncateForCapture(userText, cfg.captureMaxChars),
+        });
+      }
+    }
+    if (linesByRole.assistant.length > 0) {
+      const assistantText = linesByRole.assistant
+        .map((line) => stripInjectedContextBlocks(line))
+        .filter((s) => s.length > 0)
+        .join("\n");
+      if (assistantText.length > 0) {
+        candidates.push({
+          category: FULL_CONTEXT_ASSISTANT,
+          text: truncateForCapture(assistantText, cfg.captureMaxChars),
+        });
+      }
+    }
+    if (linesByRole.system.length > 0) {
+      candidates.push({
+        category: FULL_CONTEXT_SYSTEM,
+        text: truncateForCapture(linesByRole.system.join("\n"), cfg.captureMaxChars),
+      });
+    }
+    if (linesByRole.tool.length > 0) {
+      candidates.push({
+        category: FULL_CONTEXT_TOOL,
+        text: truncateForCapture(linesByRole.tool.join("\n"), cfg.captureMaxChars),
+      });
+    }
+    if (linesByRole.tool_result.length > 0) {
+      candidates.push({
+        category: FULL_CONTEXT_TOOL_RESULT,
+        text: truncateForCapture(linesByRole.tool_result.join("\n"), cfg.captureMaxChars),
+      });
+    }
+    if (linesByRole.others.length > 0) {
+      candidates.push({
+        category: FULL_CONTEXT_OTHERS,
+        text: truncateForCapture(linesByRole.others.join("\n"), cfg.captureMaxChars),
+      });
+    }
   }
 
   // Self-improving: user + assistant only; strip injected blocks, then extract by regex or LLM
@@ -591,6 +669,7 @@ type StoreOneResult = { action: "created" | "updated"; entry: MemoryEntry };
 function getDedupCategories(category: MemoryCategory): readonly MemoryCategory[] {
   if (isUserMemoryCategory(category)) return USER_MEMORY_CATEGORIES;
   if (category === FULL_CONTEXT_MEMORY) return [FULL_CONTEXT_MEMORY];
+  if (isFullContextSourceCategory(category)) return [category];
   if (isSelfImprovingCategory(category)) return SELF_IMPROVING_CATEGORIES;
   return [category];
 }
@@ -602,29 +681,54 @@ async function storeOneCaptureItem(
   cfg: MemoryConfig,
   db: MemoryDB,
   embeddings: Embeddings,
+  options?: { userId?: string | null; sessionId?: string | null },
 ): Promise<StoreOneResult> {
   const importance = item.importance ?? DEFAULT_IMPORTANCE;
   const vector = await embeddings.embed(item.text);
   const threshold = getThresholdForCategory(cfg, item.category);
   const dedupCategories = getDedupCategories(item.category);
+  const storePayload = {
+    text: item.text,
+    vector,
+    importance,
+    category: item.category,
+    userId: options?.userId ?? null,
+    sessionId: options?.sessionId ?? null,
+  };
+
+  // Full-context by source: upsert by (agent_id, session_id, category) so one row per session per category.
+  if (isFullContextSourceCategory(item.category)) {
+    const { action, entry } = await db.storeOrUpdateFullContext(agentId, options?.sessionId ?? null, {
+      text: storePayload.text,
+      vector: storePayload.vector,
+      importance: storePayload.importance,
+      category: storePayload.category,
+      userId: options?.userId ?? null,
+    });
+    return { action, entry };
+  }
 
   if (!cfg.memory_duplication_conflict_process) {
     const existing = await db.search(agentId, vector, 1, threshold, [...dedupCategories]);
     if (existing.length > 0) await db.softDelete(agentId, existing[0].entry.id);
-    const entry = await db.store(agentId, { text: item.text, vector, importance, category: item.category });
+    const entry = await db.store(agentId, storePayload);
     return { action: existing.length > 0 ? "updated" : "created", entry };
   }
 
-  const recallMinScore = Math.max(0.3, threshold - 0.15);
-  const candidates = await db.search(agentId, vector, 10, recallMinScore, [...dedupCategories]);
+  // Lower recall bar for conflict/dedup for both user_memory_* and self_improving_*:
+  // contradictory or same-topic memories (e.g. "dislikes X" vs "loves X", or revised learnings) often have
+  // only moderate embedding similarity (~0.65–0.8); without this they may not enter the candidate list.
+  const recallMinScore = Math.max(0.5, threshold - 0.35);
+  const conflictCandidateLimit = 20;
+  const candidates = await db.search(agentId, vector, conflictCandidateLimit, recallMinScore, [...dedupCategories]);
   if (candidates.length === 0) {
-    const entry = await db.store(agentId, { text: item.text, vector, importance, category: item.category });
+    const entry = await db.store(agentId, storePayload);
     return { action: "created", entry };
   }
 
   const decision = await decideInsertOrUpdate(cfg.llm!, item.text, candidates);
   if (decision.action === "update") await db.softDelete(agentId, decision.memoryId);
-  const entry = await db.store(agentId, { text: item.text, vector, importance, category: item.category });
+  const entry = await db.store(agentId, storePayload);
   return { action: decision.action === "update" ? "updated" : "created", entry };
 }
 
@@ -711,7 +815,16 @@ const memoryPlugin = {
 
     const writableCategories: MemoryCategory[] = [
       ...USER_MEMORY_CATEGORIES,
-      ...(cfg.enableFullContextMemory ? [FULL_CONTEXT_MEMORY] : []),
+      ...(cfg.enableFullContextMemory
+        ? [
+            FULL_CONTEXT_USER,
+            FULL_CONTEXT_ASSISTANT,
+            FULL_CONTEXT_SYSTEM,
+            FULL_CONTEXT_TOOL,
+            FULL_CONTEXT_TOOL_RESULT,
+            FULL_CONTEXT_OTHERS,
+          ]
+        : []),
       ...(cfg.enableSelfImprovingMemory ? SELF_IMPROVING_CATEGORIES : []),
     ];
     api.registerTool(
@@ -741,7 +854,8 @@ const memoryPlugin = {
             category?: MemoryCategory;
           };
 
-          if (category === FULL_CONTEXT_MEMORY && !cfg.enableFullContextMemory) {
+          const isFullContext = category === FULL_CONTEXT_MEMORY || isFullContextSourceCategory(category);
+          if (isFullContext && !cfg.enableFullContextMemory) {
             return {
               content: [{ type: "text", text: "Full context memory is disabled. Enable enableFullContextMemory in config to use it." }],
               details: { error: "full_context_memory_disabled" },
@@ -755,8 +869,10 @@ const memoryPlugin = {
           }
 
           const agentId = ctx.agentId ?? "default";
+          const userId = (ctx as { requesterSenderId?: string }).requesterSenderId ?? null;
+          const sessionId = (ctx as { sessionId?: string }).sessionId ?? null;
           const item: CaptureCandidate = { category, text, importance };
-          const { action, entry } = await storeOneCaptureItem(agentId, item, cfg, db, embeddings);
+          const { action, entry } = await storeOneCaptureItem(agentId, item, cfg, db, embeddings, { userId, sessionId });
           const preview = text.length > 100 ? text.slice(0, 100) + "..." : text;
           return {
             content: [{ type: "text", text: `${action === "updated" ? "Updated" : "Stored"}: "${preview}"` }],
@@ -881,20 +997,32 @@ const memoryPlugin = {
 
         try {
           const agentId = ctx.agentId ?? "default";
-          const { userMessageTexts, allMessageLines, userAndAssistantLines } = parseMessagesForCapture(
+          const userId = (ctx as { requesterSenderId?: string }).requesterSenderId ?? null;
+          const sessionId = (ctx as { sessionId?: string }).sessionId ?? (event as { sessionId?: string }).sessionId ?? null;
+          const { userMessageTexts, allMessageLines, userAndAssistantLines, linesByRole } = parseMessagesForCapture(
             event.messages,
           );
+          api.logger.info(
+            `openclaw-memory-alibaba-mysql: agent_end messages=${event.messages.length} user=${linesByRole.user.length} assistant=${linesByRole.assistant.length} system=${linesByRole.system.length} tool=${linesByRole.tool.length} tool_result=${linesByRole.tool_result.length} others=${linesByRole.others.length}`,
+          );
+          if (linesByRole.user.length === 0 && event.messages.length > 0) {
+            const roles = (event.messages as Array<Record<string, unknown>>).map((m) => m.role ?? "?");
+            api.logger.warn(
+              `openclaw-memory-alibaba-mysql: no user lines parsed; message roles: ${roles.join(", ")}`,
+            );
+          }
           const toProcess = await buildCaptureCandidates(
             cfg,
             userMessageTexts,
             allMessageLines,
             userAndAssistantLines,
+            linesByRole,
           );
           if (toProcess.length === 0) return;
 
           let stored = 0;
           for (const item of toProcess) {
-            await storeOneCaptureItem(agentId, item, cfg, db, embeddings);
+            await storeOneCaptureItem(agentId, item, cfg, db, embeddings, { userId, sessionId });
             stored++;
           }
           if (stored > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-memory-alibaba-mysql",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "description": "OpenClaw memory plugin using Alibaba Cloud RDS MySQL vector storage",
   "type": "module",
   "license": "MIT",