@memtensor/memos-cloud-openclaw-plugin 0.1.8-beta.9 → 0.1.9

package/README.md

@@ -97,6 +97,15 @@ MEMOS_API_KEY=YOUR_TOKEN
 - `MEMOS_CONVERSATION_PREFIX` / `MEMOS_CONVERSATION_SUFFIX` (optional)
 - `MEMOS_CONVERSATION_SUFFIX_MODE` (`none` | `counter`, default: `none`)
 - `MEMOS_CONVERSATION_RESET_ON_NEW` (default: `true`, requires hooks.internal.enabled)
+- `MEMOS_RECALL_FILTER_ENABLED` (default: `false`; run model-based memory filtering before injection)
+- `MEMOS_RECALL_FILTER_BASE_URL` (OpenAI-compatible base URL, e.g. `http://127.0.0.1:11434/v1`)
+- `MEMOS_RECALL_FILTER_API_KEY` (optional; required if your endpoint needs auth)
+- `MEMOS_RECALL_FILTER_MODEL` (model name used to filter recall candidates)
+- `MEMOS_RECALL_FILTER_TIMEOUT_MS` (default: `6000`)
+- `MEMOS_RECALL_FILTER_RETRIES` (default: `0`)
+- `MEMOS_RECALL_FILTER_CANDIDATE_LIMIT` (default: `30` per category)
+- `MEMOS_RECALL_FILTER_MAX_ITEM_CHARS` (default: `500`)
+- `MEMOS_RECALL_FILTER_FAIL_OPEN` (default: `true`; fallback to unfiltered recall on failure)
 
 ## Optional Plugin Config
 In `plugins.entries.memos-cloud-openclaw-plugin.config`:
@@ -127,7 +136,16 @@ In `plugins.entries.memos-cloud-openclaw-plugin.config`:
   "tags": ["openclaw"],
   "agentId": "",
   "multiAgentMode": false,
-  "asyncMode": true
+  "asyncMode": true,
+  "recallFilterEnabled": false,
+  "recallFilterBaseUrl": "http://127.0.0.1:11434/v1",
+  "recallFilterApiKey": "",
+  "recallFilterModel": "qwen2.5:7b",
+  "recallFilterTimeoutMs": 6000,
+  "recallFilterRetries": 0,
+  "recallFilterCandidateLimit": 30,
+  "recallFilterMaxItemChars": 500,
+  "recallFilterFailOpen": true
 }
 ```
 
@@ -135,7 +153,8 @@ In `plugins.entries.memos-cloud-openclaw-plugin.config`:
 - **Recall** (`before_agent_start`)
   - Builds a `/search/memory` request using `user_id`, `query` (= prompt + optional prefix), and optional filters.
   - Default **global recall**: when `recallGlobal=true`, it does **not** pass `conversation_id`.
-  - Formats a MemOS prompt (Role/System/Memory/Skill/Protocols) from `/search/memory` results, then injects via `prependContext`.
+  - Optional second-pass filtering: if `recallFilterEnabled=true`, candidates are sent to your configured model and only returned `keep` items are injected.
+  - Injects a stable MemOS recall protocol via `appendSystemContext`, while the retrieved `<memories>` block remains in `prependContext`.
 
 - **Add** (`agent_end`)
   - Builds a `/add/message` request with the **last turn** by default (user + assistant).

package/README_ZH.md

@@ -99,6 +99,15 @@ MEMOS_API_KEY=YOUR_TOKEN
 - `MEMOS_CONVERSATION_PREFIX` / `MEMOS_CONVERSATION_SUFFIX`（可选）
 - `MEMOS_CONVERSATION_SUFFIX_MODE`（`none` | `counter`，默认 `none`）
 - `MEMOS_CONVERSATION_RESET_ON_NEW`（默认 `true`，需 hooks.internal.enabled）
+- `MEMOS_RECALL_FILTER_ENABLED`（默认 `false`；开启后先用你指定的模型过滤召回记忆再注入）
+- `MEMOS_RECALL_FILTER_BASE_URL`（OpenAI 兼容接口，例如 `http://127.0.0.1:11434/v1`）
+- `MEMOS_RECALL_FILTER_API_KEY`（可选，若你的接口需要鉴权）
+- `MEMOS_RECALL_FILTER_MODEL`（用于筛选记忆的模型名）
+- `MEMOS_RECALL_FILTER_TIMEOUT_MS`（默认 `6000`）
+- `MEMOS_RECALL_FILTER_RETRIES`（默认 `0`）
+- `MEMOS_RECALL_FILTER_CANDIDATE_LIMIT`（默认每类 `30` 条）
+- `MEMOS_RECALL_FILTER_MAX_ITEM_CHARS`（默认 `500`）
+- `MEMOS_RECALL_FILTER_FAIL_OPEN`（默认 `true`；筛选失败时回退为“不过滤”）
 
 ## 可选插件配置
 在 `plugins.entries.memos-cloud-openclaw-plugin.config` 中设置：
@@ -127,7 +136,16 @@ MEMOS_API_KEY=YOUR_TOKEN
   "tags": ["openclaw"],
   "agentId": "",
   "multiAgentMode": false,
-  "asyncMode": true
+  "asyncMode": true,
+  "recallFilterEnabled": false,
+  "recallFilterBaseUrl": "http://127.0.0.1:11434/v1",
+  "recallFilterApiKey": "",
+  "recallFilterModel": "qwen2.5:7b",
+  "recallFilterTimeoutMs": 6000,
+  "recallFilterRetries": 0,
+  "recallFilterCandidateLimit": 30,
+  "recallFilterMaxItemChars": 500,
+  "recallFilterFailOpen": true
 }
 ```
 
@@ -137,7 +155,8 @@ MEMOS_API_KEY=YOUR_TOKEN
   - `user_id`、`query`（= prompt + 可选前缀）
   - 默认**全局召回**：`recallGlobal=true` 时不传 `conversation_id`
   - 可选 `filter` / `knowledgebase_ids`
-- 使用 `/search/memory` 结果按 MemOS 提示词模板（Role/System/Memory/Skill/Protocols）拼装，并通过 `prependContext` 注入
+- （可选）若开启 `recallFilterEnabled`，会先把 `memory/preference/tool_memory` 候选发给你配置的模型做二次筛选，只保留 `keep` 的条目
+- 将稳定的 MemOS 召回协议通过 `appendSystemContext` 注入，而检索到的 `<memories>` 数据块继续通过 `prependContext` 注入
 
 ### 2) 添加（agent_end）
 - 默认只写**最后一轮**（user + assistant）

package/clawdbot.plugin.json

@@ -2,7 +2,7 @@
   "id": "memos-cloud-openclaw-plugin",
   "name": "MemOS Cloud OpenClaw Plugin",
   "description": "MemOS Cloud recall + add memory via lifecycle hooks",
-  "version": "0.1.8-beta.8",
+  "version": "0.1.9",
   "kind": "lifecycle",
   "main": "./index.js",
   "configSchema": {

package/index.js

@@ -2,8 +2,9 @@
 import {
   addMessage,
   buildConfig,
+  extractResultData,
   extractText,
-  formatPromptBlock,
+  formatRecallHookResult,
   USER_QUERY_MARKER,
   searchMemory,
 } from "./lib/memos-cloud-api.js";
@@ -196,6 +197,197 @@ function truncate(text, maxLen) {
   return text.length > maxLen ? `${text.slice(0, maxLen)}...` : text;
 }
 
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function parseModelJson(text) {
+  if (!text || typeof text !== "string") return null;
+  const trimmed = text.trim();
+  if (!trimmed) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    // Some models wrap JSON in markdown code fences.
+  }
+  const fenceMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+  if (fenceMatch?.[1]) {
+    try {
+      return JSON.parse(fenceMatch[1].trim());
+    } catch {
+      return null;
+    }
+  }
+  const first = trimmed.indexOf("{");
+  const last = trimmed.lastIndexOf("}");
+  if (first >= 0 && last > first) {
+    try {
+      return JSON.parse(trimmed.slice(first, last + 1));
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+function normalizeIndexList(value, maxLen) {
+  if (!Array.isArray(value)) return [];
+  const seen = new Set();
+  const out = [];
+  for (const v of value) {
+    if (!Number.isInteger(v)) continue;
+    if (v < 0 || v >= maxLen) continue;
+    if (seen.has(v)) continue;
+    seen.add(v);
+    out.push(v);
+  }
+  return out;
+}
+
+function buildRecallCandidates(data, cfg) {
+  const limit = Number.isFinite(cfg.recallFilterCandidateLimit) ? Math.max(0, cfg.recallFilterCandidateLimit) : 30;
+  const maxChars = Number.isFinite(cfg.recallFilterMaxItemChars) ? Math.max(80, cfg.recallFilterMaxItemChars) : 500;
+  const memoryList = Array.isArray(data?.memory_detail_list) ? data.memory_detail_list : [];
+  const preferenceList = Array.isArray(data?.preference_detail_list) ? data.preference_detail_list : [];
+  const toolList = Array.isArray(data?.tool_memory_detail_list) ? data.tool_memory_detail_list : [];
+
+  const memoryCandidates = memoryList.slice(0, limit).map((item, idx) => ({
+    idx,
+    text: truncate(item?.memory_value || item?.memory_key || "", maxChars),
+    relativity: item?.relativity,
+  }));
+  const preferenceCandidates = preferenceList.slice(0, limit).map((item, idx) => ({
+    idx,
+    text: truncate(item?.preference || "", maxChars),
+    relativity: item?.relativity,
+    preference_type: item?.preference_type || "",
+  }));
+  const toolCandidates = toolList.slice(0, limit).map((item, idx) => ({
+    idx,
+    text: truncate(item?.tool_value || "", maxChars),
+    relativity: item?.relativity,
+  }));
+
+  return {
+    memoryList,
+    preferenceList,
+    toolList,
+    candidatePayload: {
+      memory: memoryCandidates,
+      preference: preferenceCandidates,
+      tool_memory: toolCandidates,
+    },
+  };
+}
+
+function applyRecallDecision(data, decision, lists) {
+  const keep = decision?.keep || {};
+  const memoryIdx = normalizeIndexList(keep.memory, lists.memoryList.length);
+  const preferenceIdx = normalizeIndexList(keep.preference, lists.preferenceList.length);
+  const toolIdx = normalizeIndexList(keep.tool_memory, lists.toolList.length);
+
+  return {
+    ...data,
+    memory_detail_list: memoryIdx.map((idx) => lists.memoryList[idx]),
+    preference_detail_list: preferenceIdx.map((idx) => lists.preferenceList[idx]),
+    tool_memory_detail_list: toolIdx.map((idx) => lists.toolList[idx]),
+  };
+}
+
+async function callRecallFilterModel(cfg, userPrompt, candidatePayload) {
+  const headers = {
+    "Content-Type": "application/json",
+  };
+  if (cfg.recallFilterApiKey) {
+    headers.Authorization = `Bearer ${cfg.recallFilterApiKey}`;
+  }
+
+  const modelInput = {
+    user_query: userPrompt,
+    candidate_memories: candidatePayload,
+    output_schema: {
+      keep: {
+        memory: ["number index"],
+        preference: ["number index"],
+        tool_memory: ["number index"],
+      },
+      reason: "optional short string",
+    },
+  };
+
+  const body = {
+    model: cfg.recallFilterModel,
+    temperature: 0,
+    messages: [
+      {
+        role: "system",
+        content:
+          "You are a strict memory relevance judge. Return JSON only. Keep only items directly useful for answering current user query. If unsure, do not keep.",
+      },
+      {
+        role: "user",
+        content: JSON.stringify(modelInput),
+      },
+    ],
+  };
+
+  let lastError;
+  const retries = Number.isFinite(cfg.recallFilterRetries) ? Math.max(0, cfg.recallFilterRetries) : 0;
+  const timeoutMs = Number.isFinite(cfg.recallFilterTimeoutMs) ? Math.max(1000, cfg.recallFilterTimeoutMs) : 6000;
+
+  for (let attempt = 0; attempt <= retries; attempt += 1) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+      const res = await fetch(`${cfg.recallFilterBaseUrl}/chat/completions`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: controller.signal,
+      });
+      clearTimeout(timeoutId);
+      if (!res.ok) {
+        throw new Error(`HTTP ${res.status}`);
+      }
+      const json = await res.json();
+      const text = json?.choices?.[0]?.message?.content || "";
+      const parsed = parseModelJson(text);
+      if (!parsed || typeof parsed !== "object") {
+        throw new Error("invalid JSON output from recall filter model");
+      }
+      return parsed;
+    } catch (err) {
+      lastError = err;
+      if (attempt < retries) {
+        await sleep(120 * (attempt + 1));
+      }
+    }
+  }
+  throw lastError;
+}
+
+async function maybeFilterRecallData(cfg, data, userPrompt, log) {
+  if (!cfg.recallFilterEnabled) return data;
+  if (!cfg.recallFilterBaseUrl || !cfg.recallFilterModel) {
+    log.warn?.("[memos-cloud] recall filter enabled but missing recallFilterBaseUrl/recallFilterModel; skip filter");
+    return data;
+  }
+  const lists = buildRecallCandidates(data, cfg);
+  const hasCandidates =
+    lists.candidatePayload.memory.length > 0 ||
+    lists.candidatePayload.preference.length > 0 ||
+    lists.candidatePayload.tool_memory.length > 0;
+  if (!hasCandidates) return data;
+
+  try {
+    const decision = await callRecallFilterModel(cfg, userPrompt, lists.candidatePayload);
+    return applyRecallDecision(data, decision, lists);
+  } catch (err) {
+    log.warn?.(`[memos-cloud] recall filter failed: ${String(err)}`);
+    return cfg.recallFilterFailOpen ? data : { ...data, memory_detail_list: [], preference_detail_list: [], tool_memory_detail_list: [] };
+  }
+}
+
 export default {
   id: "memos-cloud-openclaw-plugin",
   name: "MemOS Cloud OpenClaw Plugin",
@@ -243,16 +435,17 @@ export default {
       try {
         const payload = buildSearchPayload(cfg, event.prompt, ctx);
         const result = await searchMemory(cfg, payload);
-        const promptBlock = formatPromptBlock(result, { 
+        const resultData = extractResultData(result);
+        if (!resultData) return;
+        const filteredData = await maybeFilterRecallData(cfg, resultData, event.prompt, log);
+        const hookResult = formatRecallHookResult({ data: filteredData }, {
           wrapTagBlocks: true,
           relativity: payload.relativity,
-          maxItemChars: cfg.maxItemChars
+          maxItemChars: cfg.maxItemChars,
         });
-        if (!promptBlock) return;
+        if (!hookResult.appendSystemContext && !hookResult.prependContext) return;
 
-        return {
-          prependContext: promptBlock,
-        };
+        return hookResult;
       } catch (err) {
         log.warn?.(`[memos-cloud] recall failed: ${String(err)}`);
       }

package/lib/check-update.js

@@ -39,36 +39,6 @@ const ANSI = {
   RED: "\x1b[31m"
 };
 
-function canExecuteCli(cliName, timeoutMs = 8000) {
-  return new Promise((resolve) => {
-    let done = false;
-    const child = spawn(cliName, ["--version"], { shell: true });
-    const timer = setTimeout(() => {
-      if (done) return;
-      done = true;
-      killProcessTree(child);
-      resolve({ ok: false, reason: `timeout after ${timeoutMs}ms` });
-    }, timeoutMs);
-
-    child.on("error", (err) => {
-      if (done) return;
-      done = true;
-      clearTimeout(timer);
-      resolve({ ok: false, reason: err?.message || String(err) });
-    });
-
-    child.on("close", (code) => {
-      if (done) return;
-      done = true;
-      clearTimeout(timer);
-      resolve({
-        ok: code === 0,
-        reason: code === 0 ? "" : `exit code ${code}`,
-      });
-    });
-  });
-}
-
 
 function getPackageVersion() {
   try {
@@ -188,15 +158,6 @@ export function startUpdateChecker(log) {
         return;
       }
 
-      // Check if we have write permission to the plugin directory before attempting update
-      const pluginDir = path.join(__dirname, "..");
-      try {
-        fs.accessSync(pluginDir, fs.constants.W_OK);
-      } catch (err) {
-        log.warn?.(`${ANSI.YELLOW}[memos-cloud] Update available (${latestVersion}), but skipping auto-update due to missing write permissions in ${pluginDir}. Please run manually with sudo.${ANSI.RESET}`);
-        return;
-      }
-
       log.info?.(`${ANSI.YELLOW}[memos-cloud] Update available: ${currentVersion} -> ${latestVersion}. Updating in background...${ANSI.RESET}`);
 
       let dotCount = 0;
@@ -216,14 +177,6 @@ export function startUpdateChecker(log) {
         return "openclaw";
       })();
 
-      const preflight = await canExecuteCli(cliName);
-      if (!preflight.ok) {
-        log.warn?.(
-          `${ANSI.YELLOW}[memos-cloud] Update available (${latestVersion}), but cannot execute CLI '${cliName}' (${preflight.reason}). Please update manually: ${cliName} plugins update memos-cloud-openclaw-plugin${ANSI.RESET}`,
-        );
-        return;
-      }
-
       isUpdating = true;
       const spawnOpts = { shell: true };
       // On Unix, detach the process so we can kill the entire process group on timeout
@@ -231,14 +184,6 @@ export function startUpdateChecker(log) {
         spawnOpts.detached = true;
       }
       const child = spawn(cliName, ["plugins", "update", "memos-cloud-openclaw-plugin"], spawnOpts);
-      let finished = false;
-      const finishUpdateSequence = () => {
-        if (finished) return;
-        finished = true;
-        clearTimeout(updateTimeout);
-        clearInterval(progressInterval);
-        isUpdating = false;
-      };
 
       // Timeout mechanism: forcefully kill the update process if it hangs for more than the configured timeout
       const updateTimeout = setTimeout(() => {
@@ -248,7 +193,8 @@ export function startUpdateChecker(log) {
         // Fallback: if kill failed and the close event never fires, forcefully release the lock after 5 seconds
         setTimeout(() => {
           if (isUpdating) {
-            finishUpdateSequence();
+            clearInterval(progressInterval);
+            isUpdating = false;
           }
         }, 5000);
       }, UPDATE_TIMEOUT);
@@ -274,7 +220,9 @@ export function startUpdateChecker(log) {
       });
 
       child.on("close", (code) => {
-        finishUpdateSequence();
+        clearTimeout(updateTimeout);
+        clearInterval(progressInterval);
+        isUpdating = false;
 
         // Wait for a brief moment to let file system sync if needed
         setTimeout(() => {
@@ -289,13 +237,6 @@ export function startUpdateChecker(log) {
         }, 1000); // Small 1-second buffer for file systems
       });
 
-      child.on("error", (err) => {
-        finishUpdateSequence();
-        log.warn?.(
-          `${ANSI.RED}[memos-cloud] Failed to start auto-update process: ${err?.message || String(err)}. Please run manually: ${cliName} plugins update memos-cloud-openclaw-plugin${ANSI.RESET}`,
-        );
-      });
-
     } catch (error) {
       log.warn?.(`${ANSI.RED}[memos-cloud] Update check failed entirely: ${error.message}${ANSI.RESET}`);
     }

package/lib/memos-cloud-api.js

@@ -27,7 +27,7 @@ function stripQuotes(value) {
   return trimmed;
 }
 
-function extractResultData(result) {
+export function extractResultData(result) {
   if (!result || typeof result !== "object") return null;
   return result.data ?? result.data?.data ?? result.data?.result ?? null;
 }
@@ -120,6 +120,12 @@ function parseBool(value, fallback) {
   return fallback;
 }
 
+function parseNumber(value, fallback) {
+  if (value === undefined || value === null || value === "") return fallback;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : fallback;
+}
+
 export function buildConfig(pluginConfig = {}) {
   const cfg = pluginConfig ?? {};
 
@@ -147,6 +153,15 @@ export function buildConfig(pluginConfig = {}) {
     parseBool(loadEnvVar("MEMOS_MULTI_AGENT_MODE"), false),
   );
 
+  const recallFilterEnabled = parseBool(
+    cfg.recallFilterEnabled,
+    parseBool(loadEnvVar("MEMOS_RECALL_FILTER_ENABLED"), false),
+  );
+  const recallFilterFailOpen = parseBool(
+    cfg.recallFilterFailOpen,
+    parseBool(loadEnvVar("MEMOS_RECALL_FILTER_FAIL_OPEN"), true),
+  );
+
   return {
     baseUrl: baseUrl.replace(/\/+$/, ""),
     apiKey,
@@ -185,6 +200,21 @@ export function buildConfig(pluginConfig = {}) {
     allowKnowledgebaseIds: cfg.allowKnowledgebaseIds ?? [],
     asyncMode: cfg.asyncMode ?? true,
     multiAgentMode,
+    recallFilterEnabled,
+    recallFilterBaseUrl:
+      (cfg.recallFilterBaseUrl ?? loadEnvVar("MEMOS_RECALL_FILTER_BASE_URL") ?? "").replace(/\/+$/, ""),
+    recallFilterApiKey: cfg.recallFilterApiKey ?? loadEnvVar("MEMOS_RECALL_FILTER_API_KEY") ?? "",
+    recallFilterModel: cfg.recallFilterModel ?? loadEnvVar("MEMOS_RECALL_FILTER_MODEL") ?? "",
+    recallFilterTimeoutMs: parseNumber(
+      cfg.recallFilterTimeoutMs ?? loadEnvVar("MEMOS_RECALL_FILTER_TIMEOUT_MS"),
+      6000,
+    ),
+    recallFilterRetries: parseNumber(cfg.recallFilterRetries ?? loadEnvVar("MEMOS_RECALL_FILTER_RETRIES"), 0),
+    recallFilterCandidateLimit:
+      parseNumber(cfg.recallFilterCandidateLimit ?? loadEnvVar("MEMOS_RECALL_FILTER_CANDIDATE_LIMIT"), 30),
+    recallFilterMaxItemChars:
+      parseNumber(cfg.recallFilterMaxItemChars ?? loadEnvVar("MEMOS_RECALL_FILTER_MAX_ITEM_CHARS"), 500),
+    recallFilterFailOpen,
     timeoutMs: cfg.timeoutMs ?? 5000,
     retries: cfg.retries ?? 1,
     throttleMs: cfg.throttleMs ?? 0,
@@ -295,9 +325,7 @@ function wrapCodeBlock(lines, options = {}) {
   return ["```text", ...lines, "```"];
 }
 
-function buildPromptFromData(data, options = {}) {
-  const now = options.currentTime ?? Date.now();
-  const nowText = formatTime(now) || formatTime(Date.now()) || "";
+function buildMemorySections(data, options = {}) {
   const memoryList = data?.memory_detail_list ?? [];
   const preferenceList = data?.preference_detail_list ?? [];
 
@@ -325,8 +353,60 @@ function buildPromptFromData(data, options = {}) {
     })
     .filter(Boolean);
 
-  const hasContent = memoryLines.length > 0 || preferenceLines.length > 0;
+  return { memoryLines, preferenceLines };
+}
 
+const STATIC_RECALL_SYSTEM_PROMPT = [
+  "# Role",
+  "",
+  "You are an intelligent assistant with long-term memory capabilities (MemOS Assistant). Your goal is to combine retrieved memory fragments to provide highly personalized, accurate, and logically rigorous responses.",
+  "",
+  "# System Context",
+  "",
+  "* Current Time: Use the runtime-provided current time as the baseline for freshness checks.",
+  "* Additional memory context for the current turn may be prepended before the original user query as a structured `<memories>` block.",
+  "",
+  "# Memory Data",
+  "",
+  'Below is the information retrieved by MemOS, categorized into "Facts" and "Preferences".',
+  "* **Facts**: May include user attributes, historical conversations, or third-party details.",
+  "* **Special Note**: Content tagged with '[assistant观点]' or '[模型总结]' represents **past AI inference**, **not** direct user statements.",
+  "* **Preferences**: The user's explicit or implicit requirements on response style, format, or reasoning.",
+  "",
+  "# Critical Protocol: Memory Safety",
+  "",
+  "Retrieved memories may contain **AI speculation**, **irrelevant noise**, or **wrong subject attribution**. You must strictly apply the **Four-Step Verdict**. If any step fails, **discard the memory**:",
+  "",
+  "1. **Source Verification**:",
+  "* **Core**: Distinguish direct user statements from AI inference.",
+  "* If a memory has tags like '[assistant观点]' or '[模型总结]', treat it as a **hypothesis**, not a user-grounded fact.",
+  "* *Counterexample*: If memory says '[assistant观点] User loves mangoes' but the user never said that, do not assume it as fact.",
+  "* **Principle: AI summaries are reference-only and have much lower authority than direct user statements.**",
+  "",
+  "2. **Attribution Check**:",
+  "* Is the subject in memory definitely the user?",
+  "* If the memory describes a **third party** (e.g., candidate, interviewee, fictional character, case data), never attribute it to the user.",
+  "",
+  "3. **Strong Relevance Check**:",
+  "* Does the memory directly help answer the current 'Original Query'?",
+  "* If it is only a keyword overlap with different context, ignore it.",
+  "",
+  "4. **Freshness Check**:",
+  "* If memory conflicts with the user's latest intent, prioritize the current 'Original Query' as the highest source of truth.",
+  "",
+  "# Instructions",
+  "",
+  "1. **Review**: Read '<facts>' first and apply the Four-Step Verdict to remove noise and unreliable AI inference.",
+  "2. **Execute**:",
+  "   - Use only memories that pass filtering as context.",
+  "   - Strictly follow style requirements from '<preferences>'.",
+  "3. **Output**: Answer directly. Never mention internal terms such as \"memory store\", \"retrieval\", or \"AI opinions\".",
+  "4. **Attention**: Additional memory context may already be provided before the original user query. Do not read from or write to local `MEMORY.md` or `memory/*` files for reference, as they may be outdated or irrelevant to the current query.",
+].join("\n");
+
+function buildMemoryPrependBlock(data, options = {}) {
+  const { memoryLines, preferenceLines } = buildMemorySections(data, options);
+  const hasContent = memoryLines.length > 0 || preferenceLines.length > 0;
   if (!hasContent) return "";
 
   const memoriesBlock = [
@@ -340,57 +420,17 @@ function buildPromptFromData(data, options = {}) {
     "</memories>",
   ];
 
-  const lines = [
-    "# Role",
-    "",
-    "You are an intelligent assistant with long-term memory capabilities (MemOS Assistant). Your goal is to combine retrieved memory fragments to provide highly personalized, accurate, and logically rigorous responses.",
-    "",
-    "# System Context",
-    "",
-    `* Current Time: ${nowText} (Use this as the baseline for freshness checks)`,
-    "",
-    "# Memory Data",
-    "",
-    'Below is the information retrieved by MemOS, categorized into "Facts" and "Preferences".',
-    "* **Facts**: May include user attributes, historical conversations, or third-party details.",
-    "* **Special Note**: Content tagged with '[assistant观点]' or '[模型总结]' represents **past AI inference**, **not** direct user statements.",
-    "* **Preferences**: The user's explicit or implicit requirements on response style, format, or reasoning.",
-    "",
-    ...wrapCodeBlock(memoriesBlock, options),
-    "",
-    "# Critical Protocol: Memory Safety",
-    "",
-    "Retrieved memories may contain **AI speculation**, **irrelevant noise**, or **wrong subject attribution**. You must strictly apply the **Four-Step Verdict**. If any step fails, **discard the memory**:",
-    "",
-    "1. **Source Verification**:",
-    "* **Core**: Distinguish direct user statements from AI inference.",
-    "* If a memory has tags like '[assistant观点]' or '[模型总结]', treat it as a **hypothesis**, not a user-grounded fact.",
-    "* *Counterexample*: If memory says '[assistant观点] User loves mangoes' but the user never said that, do not assume it as fact.",
-    "* **Principle: AI summaries are reference-only and have much lower authority than direct user statements.**",
-    "",
-    "2. **Attribution Check**:",
-    "* Is the subject in memory definitely the user?",
-    "* If the memory describes a **third party** (e.g., candidate, interviewee, fictional character, case data), never attribute it to the user.",
-    "",
-    "3. **Strong Relevance Check**:",
-    "* Does the memory directly help answer the current 'Original Query'?",
-    "* If it is only a keyword overlap with different context, ignore it.",
-    "",
-    "4. **Freshness Check**:",
-    "* If memory conflicts with the user's latest intent, prioritize the current 'Original Query' as the highest source of truth.",
-    "",
-    "# Instructions",
-    "",
-    "1. **Review**: Read '<facts>' first and apply the Four-Step Verdict to remove noise and unreliable AI inference.",
-    "2. **Execute**:",
-    "   - Use only memories that pass filtering as context.",
-    "   - Strictly follow style requirements from '<preferences>'.",
-    "3. **Output**: Answer directly. Never mention internal terms such as \"memory store\", \"retrieval\", or \"AI opinions\".",
-    "4. **Attention**: Additional memory context is already provided. Do not read from or write to local `MEMORY.md` or `memory/*` files for reference, as they may be outdated or irrelevant to the current query.",
-    USER_QUERY_MARKER,
-  ];
+  return [...wrapCodeBlock(memoriesBlock, options), "", USER_QUERY_MARKER].join("\n");
+}
 
-  return lines.join("\n");
+export function formatPromptBlockFromData(data, options = {}) {
+  if (!data || typeof data !== "object") return "";
+  return buildMemoryPrependBlock(data, options);
+}
+
+export function formatPromptBlock(result, options = {}) {
+  const data = extractResultData(result);
+  return formatPromptBlockFromData(data, options);
 }
 
 export function formatContextBlock(result, options = {}) {
@@ -438,10 +478,20 @@ export function formatContextBlock(result, options = {}) {
   return lines.length > 0 ? lines.join("\n") : "";
 }
 
-export function formatPromptBlock(result, options = {}) {
+export function formatRecallHookResult(result, options = {}) {
   const data = extractResultData(result);
-  if (!data) return "";
-  return buildPromptFromData(data, options);
+  if (!data) {
+    return {
+      appendSystemContext: "",
+      prependContext: "",
+    };
+  }
+
+  return {
+    // Keep this system addendum byte-stable across turns so provider-side prefix caching can hit.
+    appendSystemContext: STATIC_RECALL_SYSTEM_PROMPT,
+    prependContext: buildMemoryPrependBlock(data, options),
+  };
 }
 
 function truncate(text, maxLen) {

package/moltbot.plugin.json

@@ -2,7 +2,7 @@
   "id": "memos-cloud-openclaw-plugin",
   "name": "MemOS Cloud OpenClaw Plugin",
   "description": "MemOS Cloud recall + add memory via lifecycle hooks",
-  "version": "0.1.8-beta.8",
+  "version": "0.1.9",
   "kind": "lifecycle",
   "main": "./index.js",
   "configSchema": {

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "memos-cloud-openclaw-plugin",
   "name": "MemOS Cloud OpenClaw Plugin",
   "description": "MemOS Cloud recall + add memory via lifecycle hooks",
-  "version": "0.1.8-beta.8",
+  "version": "0.1.9",
   "kind": "lifecycle",
   "main": "./index.js",
   "configSchema": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memtensor/memos-cloud-openclaw-plugin",
-  "version": "0.1.8-beta.9",
+  "version": "0.1.9",
   "description": "OpenClaw lifecycle plugin for MemOS Cloud (add + recall memory)",
   "scripts": {
     "sync-version": "node scripts/sync-version.js",