@xdarkicex/openclaw-memory-libravdb 1.6.27 → 1.6.28

package/dist/context-engine.d.ts

@@ -33,6 +33,9 @@ type OpenClawCompatibleCompactResult = {
         details?: unknown;
     };
 };
+type KernelContentNormalizationOptions = {
+    retainOpenClawContext?: boolean;
+};
 /**
  * Normalizes a single kernel message into the kernel-compatible format.
  */
@@ -40,15 +43,20 @@ export declare function normalizeKernelMessage(message: {
     role: string;
     content: unknown;
     id?: string;
-}): KernelCompatibleMessage;
+    [key: string]: unknown;
+}, options?: KernelContentNormalizationOptions): KernelCompatibleMessage;
 /**
  * Normalizes an array of kernel messages.
+ *
+ * Non-user messages whose normalized content is empty or whitespace-only
+ * are dropped. This prevents assistant/system turns that consisted entirely
+ * of stripped metadata from persisting as empty records.
  */
 export declare function normalizeKernelMessages(messages: Array<{
     role: string;
     content: unknown;
     id?: string;
-}>): KernelCompatibleMessage[];
+}>, options?: KernelContentNormalizationOptions): KernelCompatibleMessage[];
 /**
  * Normalizes a compact result into the OpenClaw-compatible assemble result format.
  */

package/dist/context-engine.js

@@ -14,6 +14,15 @@ const EXACT_RECALL_SEARCH_K = 32;
 const EXACT_RECALL_MAX_TOKENS = 4;
 const RESERVED_CURRENT_TURN_TOKENS = 150;
 const AFTER_TURN_INGEST_MAX_TOKENS = 2048;
+const OPENCLAW_LEADING_TIMESTAMP_PREFIX_RE = /^\[[A-Za-z]{3} \d{4}-\d{2}-\d{2} \d{2}:\d{2}[^\]]*\] */;
+const OPENCLAW_METADATA_HEADERS = [
+    "Conversation info (untrusted metadata):",
+    "Sender (untrusted metadata):",
+    "Thread starter (untrusted, for context):",
+    "Reply target of current user message (untrusted, for context):",
+    "Forwarded message context (untrusted metadata):",
+    "Chat history since last reply (untrusted, for context):",
+];
 const COMMON_QUERY_WORDS = new Set([
     "what", "does", "mean", "remember", "recall", "about", "this", "that",
     "the", "and", "for", "with", "from", "your", "have", "been", "were",
@@ -96,14 +105,171 @@ function stringifyKernelBlock(block) {
 /**
  * Normalizes kernel content (string or block array) to a flat string.
  */
-function normalizeKernelContent(content) {
-    if (typeof content === "string") {
-        return content;
+function normalizeKernelContent(content, options = {}) {
+    const text = typeof content === "string"
+        ? content
+        : Array.isArray(content)
+            ? content.map(stringifyKernelBlock).filter((part) => part.length > 0).join("\n")
+            : "";
+    return stripOpenClawUntrustedMetadataEnvelope(text, {
+        retainContext: options.retainOpenClawContext === true,
+    });
+}
+function stripOpenClawUntrustedMetadataEnvelope(text, options = {}) {
+    let remaining = text
+        .replace(OPENCLAW_LEADING_TIMESTAMP_PREFIX_RE, "")
+        .replace(/\r\n/g, "\n");
+    // Capture any preamble that precedes the first metadata header.
+    const preambleEnd = findFirstHeaderPosition(remaining);
+    let preamble = "";
+    if (preambleEnd > 0) {
+        const newlineIndex = remaining.lastIndexOf("\n", preambleEnd);
+        preamble = newlineIndex >= 0 ? remaining.slice(0, newlineIndex + 1) : remaining.slice(0, preambleEnd);
+        remaining = remaining.slice(preamble.length);
     }
-    if (!Array.isArray(content)) {
-        return "";
+    const retainedContext = [];
+    let stripped = false;
+    while (true) {
+        const next = stripOneOpenClawMetadataBlock(remaining);
+        if (next.text === remaining) {
+            break;
+        }
+        stripped = true;
+        if (next.context.length > 0) {
+            retainedContext.push(...next.context);
+        }
+        remaining = next.text;
+    }
+    if (!stripped) {
+        return text;
+    }
+    const contextLine = options.retainContext === true
+        ? formatRetainedOpenClawContext(retainedContext)
+        : "";
+    const strippedText = remaining.trimStart();
+    const result = contextLine ? `${contextLine}\n${strippedText}` : strippedText;
+    return preamble ? `${preamble}${result}` : result;
+}
+function findFirstHeaderPosition(text) {
+    let pos = -1;
+    for (const header of OPENCLAW_METADATA_HEADERS) {
+        const p = text.indexOf(header);
+        if (p >= 0 && (pos < 0 || p < pos)) {
+            pos = p;
+        }
+    }
+    return pos;
+}
+function stripOneOpenClawMetadataBlock(text) {
+    const leadingWhitespaceLength = text.length - text.trimStart().length;
+    const offsetText = text.slice(leadingWhitespaceLength);
+    const header = OPENCLAW_METADATA_HEADERS.find((candidate) => offsetText.startsWith(candidate)) ?? null;
+    if (!header) {
+        return { text, context: [] };
+    }
+    const afterHeader = offsetText.slice(header.length);
+    const fenceStartMatch = afterHeader.match(/^\n```(?:json)?\n/i);
+    if (!fenceStartMatch) {
+        const afterHeaderLines = afterHeader.replace(/^\n?/, "").split("\n");
+        const firstBlankIndex = afterHeaderLines.findIndex((line) => line.trim() === "");
+        if (firstBlankIndex < 0) {
+            // No fence and no blank line — cannot positively identify envelope shape.
+            // Return original text unchanged to avoid silently erasing content.
+            return { text, context: [] };
+        }
+        return { text: afterHeaderLines.slice(firstBlankIndex + 1).join("\n"), context: [] };
+    }
+    const bodyStart = header.length + fenceStartMatch[0].length;
+    const fenceEnd = offsetText.indexOf("\n```", bodyStart);
+    if (fenceEnd < 0) {
+        // Unclosed fence — cannot positively identify envelope shape.
+        return { text, context: [] };
+    }
+    const jsonText = offsetText.slice(bodyStart, fenceEnd);
+    const afterFence = fenceEnd + "\n```".length;
+    const trailingNewlineLength = offsetText.slice(afterFence).startsWith("\n") ? 1 : 0;
+    return {
+        text: offsetText.slice(afterFence + trailingNewlineLength),
+        context: summarizeOpenClawMetadataBlock(header, jsonText),
+    };
+}
+function summarizeOpenClawMetadataBlock(header, jsonText) {
+    const parsed = parseJsonRecord(jsonText);
+    if (!parsed) {
+        return [];
+    }
+    if (header === "Conversation info (untrusted metadata):") {
+        const hasIMessageContext = firstString(parsed.chat_guid, parsed.chatGuid, parsed.chat_identifier, parsed.chatIdentifier, parsed.chat_name, parsed.chatName, parsed.service) != null;
+        return [
+            labelValue("channel", firstString(parsed.group_channel, parsed.channel, parsed.group_subject)),
+            labelValue("channel_id", firstString(parsed.chat_id, parsed.channel_id)),
+            labelValue("account_id", firstString(parsed.account_id, parsed.accountId)),
+            labelValue("provider", firstString(parsed.provider, parsed.surface)),
+            labelValue("chat_id", hasIMessageContext ? firstString(parsed.chat_id, parsed.chatId) : undefined),
+            labelValue("chat_guid", firstString(parsed.chat_guid, parsed.chatGuid)),
+            labelValue("chat_identifier", firstString(parsed.chat_identifier, parsed.chatIdentifier)),
+            labelValue("chat_name", firstString(parsed.chat_name, parsed.chatName)),
+            labelValue("is_group", firstString(parsed.is_group, parsed.isGroup, parsed.is_group_chat)),
+            labelValue("chat_type", firstString(parsed.chat_type, parsed.chatType)),
+            labelValue("service", firstString(parsed.service)),
+            labelValue("server_id", firstString(parsed.group_space, parsed.guild_id, parsed.server_id)),
+            labelValue("sender_id", firstString(parsed.sender_id, parsed.user_id)),
+            labelValue("sender", firstString(parsed.sender)),
+            labelValue("emoji_id", firstString(parsed.emoji_id, parsed.server_emoji_id, parsed.guild_emoji_id)),
+            labelValue("emoji", firstString(parsed.emoji_name, parsed.emoji)),
+        ].filter(isNonEmptyString);
+    }
+    if (header === "Sender (untrusted metadata):") {
+        return [
+            labelValue("username", firstString(parsed.username, parsed.tag, parsed.name, parsed.label)),
+            labelValue("user_id", firstString(parsed.id, parsed.user_id, parsed.sender_id)),
+            labelValue("sender", firstString(parsed.sender, parsed.e164)),
+        ].filter(isNonEmptyString);
+    }
+    return [];
+}
+function parseJsonRecord(jsonText) {
+    try {
+        const parsed = JSON.parse(jsonText);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function labelValue(label, value) {
+    return value ? `${label}=${sanitizeOpenClawContextValue(value)}` : "";
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value.trim();
+        }
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return String(value);
+        }
+        if (typeof value === "boolean") {
+            return String(value);
+        }
     }
-    return content.map(stringifyKernelBlock).filter((part) => part.length > 0).join("\n");
+    return undefined;
+}
+function sanitizeOpenClawContextValue(value) {
+    // 120 chars is a conservative bound for a single routing field value
+    // (channel name, server id, etc.). Any field exceeding this is likely
+    // malformed or adversarial input, not useful routing metadata.
+    return value.replace(/[\r\n;]+/g, " ").trim().slice(0, 120);
+}
+function formatRetainedOpenClawContext(values) {
+    const uniqueValues = [...new Set(values.filter(isNonEmptyString))];
+    return uniqueValues.length > 0
+        ? `[OpenClaw context: ${uniqueValues.join("; ")}]`
+        : "";
+}
+function isNonEmptyString(value) {
+    return value.trim().length > 0;
 }
 /**
  * Approximates token count for a text string.
@@ -375,18 +541,24 @@ function resolveAfterTurnPredictiveCompactionTokenCount(args) {
 /**
  * Normalizes a single kernel message into the kernel-compatible format.
  */
-export function normalizeKernelMessage(message) {
+export function normalizeKernelMessage(message, options = {}) {
     return {
         role: message.role,
-        content: normalizeKernelContent(message.content),
-        id: message.id || randomUUID(),
+        content: normalizeKernelContent(message.content, options),
+        id: typeof message.id === "string" ? message.id : randomUUID(),
     };
 }
 /**
  * Normalizes an array of kernel messages.
+ *
+ * Non-user messages whose normalized content is empty or whitespace-only
+ * are dropped. This prevents assistant/system turns that consisted entirely
+ * of stripped metadata from persisting as empty records.
  */
-export function normalizeKernelMessages(messages) {
-    return messages.map((message) => normalizeKernelMessage(message));
+export function normalizeKernelMessages(messages, options = {}) {
+    return messages
+        .map((message) => normalizeKernelMessage(message, options))
+        .filter((message) => message.role === "user" || message.content.trim().length > 0);
 }
 /**
  * Extracts tokens for exact recall matching from text.
@@ -1019,6 +1191,9 @@ export function buildContextEngineFactory(runtime, cfg, logger = console) {
                 sessionKey: args.sessionKey,
             });
             const messages = normalizeKernelMessages(args.messages);
+            const strippedPrompt = args.prompt
+                ? normalizeKernelContent(args.prompt, { retainOpenClawContext: false })
+                : "";
             const lastUserMessage = findLastReplaySafeUserMessage(messages);
             const reservedCurrentTurnTokens = lastUserMessage
                 ? approximateMessageTokens(lastUserMessage)
@@ -1026,7 +1201,7 @@ export function buildContextEngineFactory(runtime, cfg, logger = console) {
             const currentContextTokens = resolvePredictiveCompactionTokenCount({
                 currentTokenCount: args.currentTokenCount,
                 messages,
-                prompt: args.prompt,
+                prompt: strippedPrompt,
             });
             const dynamicCompactThreshold = getDynamicCompactThreshold(args.tokenBudget);
             const predictiveTargetSize = resolvePredictiveCompactionTarget({
@@ -1073,7 +1248,7 @@ export function buildContextEngineFactory(runtime, cfg, logger = console) {
                     sessionId,
                     sessionKey: args.sessionKey,
                     userId,
-                    prompt: args.prompt ?? "",
+                    prompt: strippedPrompt,
                     messages,
                     tokenBudget: args.tokenBudget,
                     config: buildAssemblyConfig(args.tokenBudget),
@@ -1081,7 +1256,7 @@ export function buildContextEngineFactory(runtime, cfg, logger = console) {
                 });
                 const assembled = normalizeAssembleResult(resp, args.messages);
                 let enforced = enforceTokenBudgetInvariant(await augmentWithExactRecall(assembled, {
-                    queryText: args.prompt ?? messages[messages.length - 1]?.content ?? "",
+                    queryText: strippedPrompt || (messages[messages.length - 1]?.content ?? ""),
                     userId,
                     sessionId,
                     tokenBudget: args.tokenBudget,
@@ -1163,7 +1338,7 @@ export function buildContextEngineFactory(runtime, cfg, logger = console) {
             // Load manifest and normalize messages in parallel
             const manifest = manifestStore.load(sessionId, logger);
             const afterTurnMessages = selectAfterTurnMessages(args.messages, args.prePromptMessageCount, logger);
-            const messages = normalizeKernelMessages(afterTurnMessages);
+            const messages = normalizeKernelMessages(afterTurnMessages, { retainOpenClawContext: true });
             // Find overlap: messages already in our manifest
             const overlapIndex = manifestStore.findOverlapIndex(manifest, messages);
             const newMessages = messages.slice(overlapIndex);

package/dist/index.js

@@ -26667,6 +26667,15 @@ var EXACT_RECALL_SEARCH_K = 32;
 var EXACT_RECALL_MAX_TOKENS = 4;
 var RESERVED_CURRENT_TURN_TOKENS = 150;
 var AFTER_TURN_INGEST_MAX_TOKENS = 2048;
+var OPENCLAW_LEADING_TIMESTAMP_PREFIX_RE = /^\[[A-Za-z]{3} \d{4}-\d{2}-\d{2} \d{2}:\d{2}[^\]]*\] */;
+var OPENCLAW_METADATA_HEADERS = [
+  "Conversation info (untrusted metadata):",
+  "Sender (untrusted metadata):",
+  "Thread starter (untrusted, for context):",
+  "Reply target of current user message (untrusted, for context):",
+  "Forwarded message context (untrusted metadata):",
+  "Chat history since last reply (untrusted, for context):"
+];
 var COMMON_QUERY_WORDS = /* @__PURE__ */ new Set([
   "what",
   "does",
@@ -26757,14 +26766,160 @@ function stringifyKernelBlock(block) {
       return typeof record.text === "string" ? record.text : "";
   }
 }
-function normalizeKernelContent(content) {
-  if (typeof content === "string") {
-    return content;
+function normalizeKernelContent(content, options = {}) {
+  const text = typeof content === "string" ? content : Array.isArray(content) ? content.map(stringifyKernelBlock).filter((part) => part.length > 0).join("\n") : "";
+  return stripOpenClawUntrustedMetadataEnvelope(text, {
+    retainContext: options.retainOpenClawContext === true
+  });
+}
+function stripOpenClawUntrustedMetadataEnvelope(text, options = {}) {
+  let remaining = text.replace(OPENCLAW_LEADING_TIMESTAMP_PREFIX_RE, "").replace(/\r\n/g, "\n");
+  const preambleEnd = findFirstHeaderPosition(remaining);
+  let preamble = "";
+  if (preambleEnd > 0) {
+    const newlineIndex = remaining.lastIndexOf("\n", preambleEnd);
+    preamble = newlineIndex >= 0 ? remaining.slice(0, newlineIndex + 1) : remaining.slice(0, preambleEnd);
+    remaining = remaining.slice(preamble.length);
+  }
+  const retainedContext = [];
+  let stripped = false;
+  while (true) {
+    const next = stripOneOpenClawMetadataBlock(remaining);
+    if (next.text === remaining) {
+      break;
+    }
+    stripped = true;
+    if (next.context.length > 0) {
+      retainedContext.push(...next.context);
+    }
+    remaining = next.text;
   }
-  if (!Array.isArray(content)) {
-    return "";
+  if (!stripped) {
+    return text;
+  }
+  const contextLine = options.retainContext === true ? formatRetainedOpenClawContext(retainedContext) : "";
+  const strippedText = remaining.trimStart();
+  const result = contextLine ? `${contextLine}
+${strippedText}` : strippedText;
+  return preamble ? `${preamble}${result}` : result;
+}
+function findFirstHeaderPosition(text) {
+  let pos = -1;
+  for (const header of OPENCLAW_METADATA_HEADERS) {
+    const p = text.indexOf(header);
+    if (p >= 0 && (pos < 0 || p < pos)) {
+      pos = p;
+    }
+  }
+  return pos;
+}
+function stripOneOpenClawMetadataBlock(text) {
+  const leadingWhitespaceLength = text.length - text.trimStart().length;
+  const offsetText = text.slice(leadingWhitespaceLength);
+  const header = OPENCLAW_METADATA_HEADERS.find((candidate) => offsetText.startsWith(candidate)) ?? null;
+  if (!header) {
+    return { text, context: [] };
+  }
+  const afterHeader = offsetText.slice(header.length);
+  const fenceStartMatch = afterHeader.match(/^\n```(?:json)?\n/i);
+  if (!fenceStartMatch) {
+    const afterHeaderLines = afterHeader.replace(/^\n?/, "").split("\n");
+    const firstBlankIndex = afterHeaderLines.findIndex((line) => line.trim() === "");
+    if (firstBlankIndex < 0) {
+      return { text, context: [] };
+    }
+    return { text: afterHeaderLines.slice(firstBlankIndex + 1).join("\n"), context: [] };
+  }
+  const bodyStart = header.length + fenceStartMatch[0].length;
+  const fenceEnd = offsetText.indexOf("\n```", bodyStart);
+  if (fenceEnd < 0) {
+    return { text, context: [] };
+  }
+  const jsonText = offsetText.slice(bodyStart, fenceEnd);
+  const afterFence = fenceEnd + "\n```".length;
+  const trailingNewlineLength = offsetText.slice(afterFence).startsWith("\n") ? 1 : 0;
+  return {
+    text: offsetText.slice(afterFence + trailingNewlineLength),
+    context: summarizeOpenClawMetadataBlock(header, jsonText)
+  };
+}
+function summarizeOpenClawMetadataBlock(header, jsonText) {
+  const parsed = parseJsonRecord(jsonText);
+  if (!parsed) {
+    return [];
+  }
+  if (header === "Conversation info (untrusted metadata):") {
+    const hasIMessageContext = firstString2(
+      parsed.chat_guid,
+      parsed.chatGuid,
+      parsed.chat_identifier,
+      parsed.chatIdentifier,
+      parsed.chat_name,
+      parsed.chatName,
+      parsed.service
+    ) != null;
+    return [
+      labelValue("channel", firstString2(parsed.group_channel, parsed.channel, parsed.group_subject)),
+      labelValue("channel_id", firstString2(parsed.chat_id, parsed.channel_id)),
+      labelValue("account_id", firstString2(parsed.account_id, parsed.accountId)),
+      labelValue("provider", firstString2(parsed.provider, parsed.surface)),
+      labelValue("chat_id", hasIMessageContext ? firstString2(parsed.chat_id, parsed.chatId) : void 0),
+      labelValue("chat_guid", firstString2(parsed.chat_guid, parsed.chatGuid)),
+      labelValue("chat_identifier", firstString2(parsed.chat_identifier, parsed.chatIdentifier)),
+      labelValue("chat_name", firstString2(parsed.chat_name, parsed.chatName)),
+      labelValue("is_group", firstString2(parsed.is_group, parsed.isGroup, parsed.is_group_chat)),
+      labelValue("chat_type", firstString2(parsed.chat_type, parsed.chatType)),
+      labelValue("service", firstString2(parsed.service)),
+      labelValue("server_id", firstString2(parsed.group_space, parsed.guild_id, parsed.server_id)),
+      labelValue("sender_id", firstString2(parsed.sender_id, parsed.user_id)),
+      labelValue("sender", firstString2(parsed.sender)),
+      labelValue("emoji_id", firstString2(parsed.emoji_id, parsed.server_emoji_id, parsed.guild_emoji_id)),
+      labelValue("emoji", firstString2(parsed.emoji_name, parsed.emoji))
+    ].filter(isNonEmptyString);
+  }
+  if (header === "Sender (untrusted metadata):") {
+    return [
+      labelValue("username", firstString2(parsed.username, parsed.tag, parsed.name, parsed.label)),
+      labelValue("user_id", firstString2(parsed.id, parsed.user_id, parsed.sender_id)),
+      labelValue("sender", firstString2(parsed.sender, parsed.e164))
+    ].filter(isNonEmptyString);
+  }
+  return [];
+}
+function parseJsonRecord(jsonText) {
+  try {
+    const parsed = JSON.parse(jsonText);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function labelValue(label, value) {
+  return value ? `${label}=${sanitizeOpenClawContextValue(value)}` : "";
+}
+function firstString2(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim();
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return String(value);
+    }
+    if (typeof value === "boolean") {
+      return String(value);
+    }
   }
-  return content.map(stringifyKernelBlock).filter((part) => part.length > 0).join("\n");
+  return void 0;
+}
+function sanitizeOpenClawContextValue(value) {
+  return value.replace(/[\r\n;]+/g, " ").trim().slice(0, 120);
+}
+function formatRetainedOpenClawContext(values) {
+  const uniqueValues = [...new Set(values.filter(isNonEmptyString))];
+  return uniqueValues.length > 0 ? `[OpenClaw context: ${uniqueValues.join("; ")}]` : "";
+}
+function isNonEmptyString(value) {
+  return value.trim().length > 0;
 }
 function approximateTokenCount(text) {
   if (typeof text === "string") {
@@ -26979,15 +27134,15 @@ function resolveAfterTurnPredictiveCompactionTokenCount(args) {
   }
   return Math.max(currentTokenCount, forwardedMessageTokens);
 }
-function normalizeKernelMessage(message) {
+function normalizeKernelMessage(message, options = {}) {
   return {
     role: message.role,
-    content: normalizeKernelContent(message.content),
-    id: message.id || randomUUID()
+    content: normalizeKernelContent(message.content, options),
+    id: typeof message.id === "string" ? message.id : randomUUID()
   };
 }
-function normalizeKernelMessages(messages) {
-  return messages.map((message) => normalizeKernelMessage(message));
+function normalizeKernelMessages(messages, options = {}) {
+  return messages.map((message) => normalizeKernelMessage(message, options)).filter((message) => message.role === "user" || message.content.trim().length > 0);
 }
 function extractExactRecallTokens(text) {
   const tokens = /* @__PURE__ */ new Set();
@@ -27533,12 +27688,13 @@ function buildContextEngineFactory(runtime, cfg, logger = console) {
         sessionKey: args.sessionKey
       });
       const messages = normalizeKernelMessages(args.messages);
+      const strippedPrompt = args.prompt ? normalizeKernelContent(args.prompt, { retainOpenClawContext: false }) : "";
       const lastUserMessage = findLastReplaySafeUserMessage(messages);
       const reservedCurrentTurnTokens = lastUserMessage ? approximateMessageTokens(lastUserMessage) : RESERVED_CURRENT_TURN_TOKENS;
       const currentContextTokens = resolvePredictiveCompactionTokenCount({
         currentTokenCount: args.currentTokenCount,
         messages,
-        prompt: args.prompt
+        prompt: strippedPrompt
       });
       const dynamicCompactThreshold = getDynamicCompactThreshold(args.tokenBudget);
       const predictiveTargetSize = resolvePredictiveCompactionTarget({
@@ -27586,7 +27742,7 @@ function buildContextEngineFactory(runtime, cfg, logger = console) {
           sessionId,
           sessionKey: args.sessionKey,
           userId,
-          prompt: args.prompt ?? "",
+          prompt: strippedPrompt,
           messages,
           tokenBudget: args.tokenBudget,
           config: buildAssemblyConfig(args.tokenBudget),
@@ -27595,7 +27751,7 @@ function buildContextEngineFactory(runtime, cfg, logger = console) {
         const assembled = normalizeAssembleResult(resp, args.messages);
         let enforced = enforceTokenBudgetInvariant(
           await augmentWithExactRecall(assembled, {
-            queryText: args.prompt ?? messages[messages.length - 1]?.content ?? "",
+            queryText: strippedPrompt || (messages[messages.length - 1]?.content ?? ""),
             userId,
             sessionId,
             tokenBudget: args.tokenBudget,
@@ -27680,7 +27836,7 @@ function buildContextEngineFactory(runtime, cfg, logger = console) {
       });
       const manifest = manifestStore.load(sessionId, logger);
       const afterTurnMessages = selectAfterTurnMessages(args.messages, args.prePromptMessageCount, logger);
-      const messages = normalizeKernelMessages(afterTurnMessages);
+      const messages = normalizeKernelMessages(afterTurnMessages, { retainOpenClawContext: true });
       const overlapIndex = manifestStore.findOverlapIndex(manifest, messages);
       const newMessages = messages.slice(overlapIndex);
       const ingestMessages = boundAfterTurnMessagesForIngest(newMessages, logger, sessionId);

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "libravdb-memory",
   "name": "LibraVDB Memory",
   "description": "Persistent vector memory with three-tier hybrid scoring",
-  "version": "1.6.27",
+  "version": "1.6.28",
   "kind": [
     "memory",
     "context-engine"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xdarkicex/openclaw-memory-libravdb",
-  "version": "1.6.27",
+  "version": "1.6.28",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",