@xdarkicex/openclaw-memory-libravdb 1.6.21 → 1.6.23

package/dist/context-engine.d.ts

@@ -26,22 +26,32 @@ type OpenClawCompatibleCompactResult = {
     reason?: string;
     result?: {
         summary?: string;
+        summaryText?: string;
         firstKeptEntryId?: string;
         tokensBefore: number;
         tokensAfter?: number;
         details?: unknown;
     };
 };
+/**
+ * Normalizes a single kernel message into the kernel-compatible format.
+ */
 export declare function normalizeKernelMessage(message: {
     role: string;
     content: unknown;
     id?: string;
 }): KernelCompatibleMessage;
+/**
+ * Normalizes an array of kernel messages.
+ */
 export declare function normalizeKernelMessages(messages: Array<{
     role: string;
     content: unknown;
     id?: string;
 }>): KernelCompatibleMessage[];
+/**
+ * Normalizes a compact result into the OpenClaw-compatible assemble result format.
+ */
 export declare function normalizeAssembleResult(result: {
     messages?: Array<{
         role: string;
@@ -52,6 +62,9 @@ export declare function normalizeAssembleResult(result: {
     systemPromptAddition?: string;
     debug?: AssembleContextInternalResponse["debug"];
 }, sourceMessages?: OpenClawCompatibleMessage[]): OpenClawCompatibleAssembleResult;
+/**
+ * Builds the context engine factory with the given client getter.
+ */
 export declare function buildContextEngineFactory(runtime: PluginRuntime, cfg: PluginConfig, logger?: LoggerLike): {
     info: {
         id: string;

package/dist/context-engine.js

@@ -24,6 +24,10 @@ function requireSessionId(sessionId, operation) {
     }
     throw new Error(`LibraVDB ${operation} requires a non-empty sessionId; refusing ambiguous request.`);
 }
+/**
+ * Normalizes a compact session response into the OpenClaw-compatible format.
+ * Handles missing/undefined fields and provides sensible defaults.
+ */
 function normalizeCompactResult(response, options = {}) {
     const didCompact = response?.didCompact === true;
     const tokensBefore = normalizeCurrentTokenCount(options.tokensBefore) ?? 0;
@@ -35,6 +39,9 @@ function normalizeCompactResult(response, options = {}) {
             ? response.summaryMethod
             : undefined,
         meanConfidence: typeof response?.meanConfidence === "number" ? response.meanConfidence : undefined,
+        summaryText: typeof response?.summaryText === "string" && response.summaryText.length > 0
+            ? response.summaryText
+            : undefined,
     };
     return {
         ok: true,
@@ -43,10 +50,14 @@ function normalizeCompactResult(response, options = {}) {
         result: {
             tokensBefore,
             ...(details.summaryMethod ? { summary: details.summaryMethod } : {}),
+            ...(details.summaryText ? { summaryText: details.summaryText } : {}),
             details,
         },
     };
 }
+/**
+ * Converts a kernel block to its string representation.
+ */
 function stringifyKernelBlock(block) {
     if (!block || typeof block !== "object") {
         return "";
@@ -80,6 +91,9 @@ function stringifyKernelBlock(block) {
             return typeof record.text === "string" ? record.text : "";
     }
 }
+/**
+ * Normalizes kernel content (string or block array) to a flat string.
+ */
 function normalizeKernelContent(content) {
     if (typeof content === "string") {
         return content;
@@ -89,6 +103,9 @@ function normalizeKernelContent(content) {
     }
     return content.map(stringifyKernelBlock).filter((part) => part.length > 0).join("\n");
 }
+/**
+ * Approximates token count for a text string.
+ */
 function approximateTokenCount(text) {
     if (typeof text === "string") {
         return Math.ceil(text.length / APPROX_CHARS_PER_TOKEN);
@@ -98,13 +115,22 @@ function approximateTokenCount(text) {
     }
     return Math.ceil(normalizeKernelContent(text).length / APPROX_CHARS_PER_TOKEN);
 }
+/**
+ * Approximates tokens for a single message including wrapper overhead.
+ */
 function approximateMessageTokens(message) {
     // Approximate per-message wrapper overhead so trimming is conservative.
     return approximateTokenCount(message.content) + 8;
 }
+/**
+ * Sums approximate tokens across an array of messages.
+ */
 function approximateMessagesTokens(messages) {
     return messages.reduce((sum, message) => sum + approximateMessageTokens(message), 0);
 }
+/**
+ * Selects messages after the pre-prompt boundary for after-turn processing.
+ */
 function selectAfterTurnMessages(messages, prePromptMessageCount, logger) {
     if (typeof prePromptMessageCount !== "number" ||
         !Number.isFinite(prePromptMessageCount) ||
@@ -139,6 +165,9 @@ function normalizeTokenBudget(tokenBudget) {
     }
     return Math.max(1, Math.floor(tokenBudget));
 }
+/**
+ * Resolves the effective assemble budget from token budget configuration.
+ */
 function resolveEffectiveAssembleBudget(tokenBudget) {
     const normalized = normalizeTokenBudget(tokenBudget) ?? 1;
     const proportionalHeadroom = Math.max(1, Math.floor(normalized * ASSEMBLE_BUDGET_HEADROOM_FRACTION));
@@ -151,6 +180,9 @@ function normalizeThresholdFraction(fraction) {
     }
     return Math.min(0.99, Math.max(0.05, fraction));
 }
+/**
+ * Resolves the dynamic compaction threshold from budget and threshold params.
+ */
 function resolveDynamicCompactThreshold(tokenBudget, compactThreshold, compactionThresholdFraction) {
     if (typeof compactThreshold === "number" && Number.isFinite(compactThreshold) && compactThreshold > 0) {
         return Math.max(1, Math.floor(compactThreshold));
@@ -173,18 +205,30 @@ function resolvePredictiveCompactionTarget(params) {
         ? belowThresholdTarget
         : Math.max(1, currentTokenCount - 1);
 }
+/**
+ * Reads a runtime numeric config value with fallback defaults.
+ */
 function readRuntimeNumber(runtimeContext, key) {
     const value = runtimeContext?.[key];
     return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
+/**
+ * Checks if manual compaction was explicitly requested via runtime context.
+ */
 function isManualCompactionRequested(runtimeContext) {
     return runtimeContext?.manualCompaction === true;
 }
+/**
+ * Logs a predictive compaction attempt with phase and sizing info.
+ */
 function logPredictiveCompactionAttempt(params) {
     params.logger.info?.(`LibraVDB predictive compaction trigger phase=${params.phase} sessionId=${params.sessionId} ` +
         `currentTokenCount=${params.currentTokenCount} threshold=${params.threshold} ` +
         `targetSize=${params.targetSize} tokenBudget=${params.tokenBudget ?? "unknown"}`);
 }
+/**
+ * Logs the outcome of a predictive compaction attempt.
+ */
 function logPredictiveCompactionOutcome(params) {
     const message = `LibraVDB predictive compaction ${params.compacted ? "completed" : "did not compact"} ` +
         `phase=${params.phase} sessionId=${params.sessionId} currentTokenCount=${params.currentTokenCount} ` +
@@ -196,6 +240,9 @@ function logPredictiveCompactionOutcome(params) {
     }
     params.logger.warn?.(message);
 }
+/**
+ * Truncates content to fit within token budget, preserving the tail.
+ */
 function truncateContentToTokenBudget(content, tokenBudget) {
     if (tokenBudget <= 0)
         return "";
@@ -206,6 +253,9 @@ function truncateContentToTokenBudget(content, tokenBudget) {
     // Keep the tail so recent tool output / latest answer content is preserved.
     return normalized.slice(normalized.length - maxChars);
 }
+/**
+ * Trims messages from the end to fit within token budget.
+ */
 function trimMessagesToBudget(messages, tokenBudget) {
     if (tokenBudget <= 0 || messages.length === 0) {
         return [];
@@ -235,6 +285,9 @@ function trimMessagesToBudget(messages, tokenBudget) {
     }
     return [{ ...last, content: truncated }];
 }
+/**
+ * Bounds after-turn messages for ingest, trimming if over max tokens.
+ */
 function boundAfterTurnMessagesForIngest(messages, logger, sessionId) {
     const estimatedTokens = approximateMessagesTokens(messages);
     if (estimatedTokens <= AFTER_TURN_INGEST_MAX_TOKENS) {
@@ -247,6 +300,9 @@ function boundAfterTurnMessagesForIngest(messages, logger, sessionId) {
         `forwardedMessages=${bounded.length}`);
     return bounded;
 }
+/**
+ * Enforces token budget invariant by trimming messages and system prompt.
+ */
 function enforceTokenBudgetInvariant(result, tokenBudget) {
     if (typeof tokenBudget !== "number" || !Number.isFinite(tokenBudget) || tokenBudget <= 0) {
         return result;
@@ -286,6 +342,9 @@ function buildBudgetFallbackContext(messages, tokenBudget) {
         promptAuthority: PROMPT_AUTHORITY_PREASSEMBLY_MAY_OVERFLOW,
     };
 }
+/**
+ * Resolves token count for predictive compaction from messages and prompt.
+ */
 function resolvePredictiveCompactionTokenCount(args) {
     const currentTokenCount = normalizeCurrentTokenCount(args.currentTokenCount);
     const sourcePressureEstimate = normalizeCurrentTokenCount(approximateMessagesTokens(args.messages) + approximateTokenCount(args.prompt ?? ""));
@@ -297,6 +356,9 @@ function resolvePredictiveCompactionTokenCount(args) {
     }
     return Math.max(currentTokenCount, sourcePressureEstimate);
 }
+/**
+ * Resolves token count for after-turn predictive compaction.
+ */
 function resolveAfterTurnPredictiveCompactionTokenCount(args) {
     const currentTokenCount = normalizeCurrentTokenCount(args.currentTokenCount);
     const forwardedMessageTokens = normalizeCurrentTokenCount(approximateMessagesTokens(args.messages));
@@ -308,6 +370,9 @@ function resolveAfterTurnPredictiveCompactionTokenCount(args) {
     }
     return Math.max(currentTokenCount, forwardedMessageTokens);
 }
+/**
+ * Normalizes a single kernel message into the kernel-compatible format.
+ */
 export function normalizeKernelMessage(message) {
     return {
         role: message.role,
@@ -315,9 +380,15 @@ export function normalizeKernelMessage(message) {
         ...(typeof message.id === "string" ? { id: message.id } : {}),
     };
 }
+/**
+ * Normalizes an array of kernel messages.
+ */
 export function normalizeKernelMessages(messages) {
     return messages.map((message) => normalizeKernelMessage(message));
 }
+/**
+ * Extracts tokens for exact recall matching from text.
+ */
 function extractExactRecallTokens(text) {
     const tokens = new Set();
     for (const m of text.matchAll(STRUCTURED_MARKER_RE)) {
@@ -339,17 +410,26 @@ function extractExactRecallTokens(text) {
     }
     return Array.from(tokens).slice(0, EXACT_RECALL_MAX_TOKENS);
 }
+/**
+ * Checks if text is an exact recall fact containing the token.
+ */
 function isExactRecallFact(text, token) {
     return (text.includes(token) &&
         /\bmeans\b/i.test(text) &&
         !isQuestionShapedRecallCandidate(text));
 }
+/**
+ * Checks if text appears to be a question-shaped recall candidate.
+ */
 function isQuestionShapedRecallCandidate(text) {
     const normalized = text.trim();
     return (normalized.includes("?") ||
         /\bwhat\s+does\b/i.test(normalized) ||
         /^\s*(?:who|what|when|where|why|how)\b/i.test(normalized));
 }
+/**
+ * Ranks a recall candidate by relevance to the token.
+ */
 function rankExactRecallCandidate(result, token) {
     if (typeof result.text !== "string" || !result.text.includes(token)) {
         return Number.NEGATIVE_INFINITY;
@@ -363,14 +443,22 @@ function rankExactRecallCandidate(result, token) {
         rank -= 25;
     return rank;
 }
+/**
+ * Extracts the exact recall fact text starting at the token marker.
+ * Tool-call patterns are sanitized to prevent loop-priming.
+ */
 function extractExactRecallFactText(text, token) {
     const markerStart = text.indexOf(token);
     if (markerStart < 0)
         return text.trim();
     const tail = text.slice(markerStart).trim();
     const factSentence = tail.match(/^[\s\S]*?\bmeans\b[\s\S]*?[.!?](?:\s|$)/i)?.[0]?.trim();
-    return factSentence ?? tail.split("\n")[0]?.trim() ?? tail;
+    const extracted = factSentence ?? tail.split("\n")[0]?.trim() ?? tail;
+    return sanitizeToolCallPatterns(extracted);
 }
+/**
+ * Escapes special characters in memory fact text for safe rendering.
+ */
 function escapeMemoryFactText(text) {
     return text
         .replaceAll("&", "&amp;")
@@ -382,7 +470,42 @@ function escapeMemoryFactText(text) {
         .replaceAll("\n", "&#10;")
         .replaceAll("\t", "&#9;");
 }
+// Tool-call pattern detection for sanitization
+const TOOL_CALL_BRACKET_RE = /\[tool:([^\]]+)\]/gi;
+const TOOL_CALL_JSON_RE = /\{\s*"name"\s*:\s*"([^"]+)"[^}]*\}/g;
+const TOOL_RESULT_ANNOTATION_RE = /\[tool:[^\]]+\](?:\s*[^{\[]*)?/g;
+/**
+ * Sanitizes text that may contain tool-call syntax to prevent loop-priming.
+ * Replaces executable-looking patterns with neutral summaries rather than
+ * replaying them verbatim, so the model cannot pattern-match and repeat them.
+ */
+function sanitizeToolCallPatterns(text) {
+    let sanitized = text;
+    // Replace [tool:name] patterns with a neutral summary
+    sanitized = sanitized.replace(TOOL_CALL_BRACKET_RE, (_match, toolName) => {
+        return `[historical tool call: ${toolName}]`;
+    });
+    // Replace JSON tool-call objects with a neutral summary
+    sanitized = sanitized.replace(TOOL_CALL_JSON_RE, (_match, toolName) => {
+        return `[historical tool call: ${toolName}]`;
+    });
+    // Replace remaining tool-result annotations
+    sanitized = sanitized.replace(TOOL_RESULT_ANNOTATION_RE, "[historical tool call]");
+    // Detect and summarize repeated tool calls (loop indicator)
+    const toolCallCount = (sanitized.match(/\[historical tool call:\s*([^\]]+)\]/gi) || []).length;
+    if (toolCallCount > 2) {
+        const uniqueTools = new Set([...sanitized.matchAll(/\[historical tool call:\s*([^\]]+)\]/gi)].map((m) => m[1]));
+        if (uniqueTools.size === 1) {
+            // Single tool repeated multiple times — likely a loop, summarize aggressively
+            sanitized = `[Historical tool activity: repeated ${[...uniqueTools][0]} call ${toolCallCount} times. Do not repeat this pattern.]`;
+        }
+    }
+    return sanitized;
+}
 const TRUNCATION_MARKER = "...[truncated]";
+/**
+ * Attempts to truncate an item to fit within token budget.
+ */
 function tryTruncateItem(rawText, tag, attributes, maxTokenBudget) {
     const tagOpen = attributes ? `<${tag}${attributes}>` : `<${tag}>`;
     const tagClose = `</${tag}>`;
@@ -404,6 +527,9 @@ function tryTruncateItem(rawText, tag, attributes, maxTokenBudget) {
         return null;
     return `${tagOpen}${escaped}${TRUNCATION_MARKER}${tagClose}`;
 }
+/**
+ * Builds a wrapped section adaptively injecting items within token budget.
+ */
 function adaptivelyBuildWrappedSection(wrapperOpen, instruction, wrapperClose, items, availableTokenBudget) {
     if (items.length === 0 || availableTokenBudget <= 0)
         return null;
@@ -439,20 +565,32 @@ function adaptivelyBuildWrappedSection(wrapperOpen, instruction, wrapperClose, i
     const sectionTokens = approximateTokenCount(sectionText);
     return { text: sectionText, tokens: sectionTokens, injectedCount };
 }
+/**
+ * Builds a single item element with escaped text content.
+ */
 function buildItemElement(item) {
     return item.attributes
         ? `<${item.tag}${item.attributes}>${escapeMemoryFactText(item.rawText)}</${item.tag}>`
         : `<${item.tag}>${escapeMemoryFactText(item.rawText)}</${item.tag}>`;
 }
+/**
+ * Appends a system prompt addition to existing content.
+ */
 function appendSystemPromptAddition(existing, addition) {
     const trimmedExisting = existing.trim();
     if (trimmedExisting.length === 0)
         return addition;
     return `${trimmedExisting}\n\n${addition}`;
 }
+/**
+ * Checks if messages contain a replay-safe user turn with content.
+ */
 function hasReplaySafeUserTurn(messages) {
     return messages.some((message) => message.role === "user" && normalizeKernelContent(message.content).trim().length > 0);
 }
+/**
+ * Finds the last replay-safe user message from the array.
+ */
 function findLastReplaySafeUserMessage(messages) {
     for (let index = messages.length - 1; index >= 0; index -= 1) {
         const candidate = messages[index];
@@ -469,6 +607,9 @@ function findLastReplaySafeUserMessage(messages) {
     }
     return null;
 }
+/**
+ * Truncates system prompt addition to fit within token budget.
+ */
 function truncateSystemPromptAdditionToTokenBudget(value, tokenBudget) {
     if (tokenBudget <= 0)
         return "";
@@ -477,6 +618,9 @@ function truncateSystemPromptAdditionToTokenBudget(value, tokenBudget) {
         return value;
     return value.slice(0, maxChars);
 }
+/**
+ * Ensures assemble result has a replay-safe user turn, reinjecting if needed.
+ */
 function ensureReplaySafeUserTurn(assembled, sourceMessages, logger, tokenBudget) {
     if (hasReplaySafeUserTurn(assembled.messages))
         return assembled;
@@ -529,6 +673,9 @@ function ensureReplaySafeUserTurn(assembled, sourceMessages, logger, tokenBudget
         estimatedTokens: baseEstimatedTokens + approximateMessageTokens(fallbackUser),
     };
 }
+/**
+ * Normalizes a compact result into the OpenClaw-compatible assemble result format.
+ */
 export function normalizeAssembleResult(result, sourceMessages) {
     let systemPromptAddition = typeof result.systemPromptAddition === "string" ? result.systemPromptAddition : "";
     const messages = [];
@@ -558,8 +705,9 @@ export function normalizeAssembleResult(result, sourceMessages) {
             }
             else {
                 if (content.trim().length > 0) {
+                    const sanitizedContent = sanitizeToolCallPatterns(content);
                     const roleAttr = message.role ? ` role="${escapeMemoryFactText(message.role)}"` : "";
-                    extractedMemoryItems.push(`<memory_item source="recalled"${roleAttr} provenance="durable_memory">${escapeMemoryFactText(content)}</memory_item>`);
+                    extractedMemoryItems.push(`<memory_item source="recalled"${roleAttr} provenance="durable_memory">${escapeMemoryFactText(sanitizedContent)}</memory_item>`);
                 }
             }
         }
@@ -576,6 +724,9 @@ export function normalizeAssembleResult(result, sourceMessages) {
         ...(result.debug != null ? { debug: result.debug } : {}),
     };
 }
+/**
+ * Builds the context engine factory with the given client getter.
+ */
 export function buildContextEngineFactory(runtime, cfg, logger = console) {
     const predictiveContextCache = new Map();
     const PREDICTIVE_CACHE_MAX_SIZE = 100;

package/dist/index.js

@@ -26571,7 +26571,8 @@ function normalizeCompactResult(response, options = {}) {
     clustersDeclined: typeof response?.clustersDeclined === "number" ? response.clustersDeclined : void 0,
     turnsRemoved: typeof response?.turnsRemoved === "number" ? response.turnsRemoved : void 0,
     summaryMethod: typeof response?.summaryMethod === "string" && response.summaryMethod.length > 0 ? response.summaryMethod : void 0,
-    meanConfidence: typeof response?.meanConfidence === "number" ? response.meanConfidence : void 0
+    meanConfidence: typeof response?.meanConfidence === "number" ? response.meanConfidence : void 0,
+    summaryText: typeof response?.summaryText === "string" && response.summaryText.length > 0 ? response.summaryText : void 0
   };
   return {
     ok: true,
@@ -26580,6 +26581,7 @@ function normalizeCompactResult(response, options = {}) {
     result: {
       tokensBefore,
       ...details.summaryMethod ? { summary: details.summaryMethod } : {},
+      ...details.summaryText ? { summaryText: details.summaryText } : {},
       details
     }
   };
@@ -26889,11 +26891,35 @@ function extractExactRecallFactText(text, token) {
   if (markerStart < 0) return text.trim();
   const tail = text.slice(markerStart).trim();
   const factSentence = tail.match(/^[\s\S]*?\bmeans\b[\s\S]*?[.!?](?:\s|$)/i)?.[0]?.trim();
-  return factSentence ?? tail.split("\n")[0]?.trim() ?? tail;
+  const extracted = factSentence ?? tail.split("\n")[0]?.trim() ?? tail;
+  return sanitizeToolCallPatterns(extracted);
 }
 function escapeMemoryFactText(text) {
   return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;").replaceAll("\r", "&#13;").replaceAll("\n", "&#10;").replaceAll("	", "&#9;");
 }
+var TOOL_CALL_BRACKET_RE = /\[tool:([^\]]+)\]/gi;
+var TOOL_CALL_JSON_RE = /\{\s*"name"\s*:\s*"([^"]+)"[^}]*\}/g;
+var TOOL_RESULT_ANNOTATION_RE = /\[tool:[^\]]+\](?:\s*[^{\[]*)?/g;
+function sanitizeToolCallPatterns(text) {
+  let sanitized = text;
+  sanitized = sanitized.replace(TOOL_CALL_BRACKET_RE, (_match, toolName) => {
+    return `[historical tool call: ${toolName}]`;
+  });
+  sanitized = sanitized.replace(TOOL_CALL_JSON_RE, (_match, toolName) => {
+    return `[historical tool call: ${toolName}]`;
+  });
+  sanitized = sanitized.replace(TOOL_RESULT_ANNOTATION_RE, "[historical tool call]");
+  const toolCallCount = (sanitized.match(/\[historical tool call:\s*([^\]]+)\]/gi) || []).length;
+  if (toolCallCount > 2) {
+    const uniqueTools = new Set(
+      [...sanitized.matchAll(/\[historical tool call:\s*([^\]]+)\]/gi)].map((m) => m[1])
+    );
+    if (uniqueTools.size === 1) {
+      sanitized = `[Historical tool activity: repeated ${[...uniqueTools][0]} call ${toolCallCount} times. Do not repeat this pattern.]`;
+    }
+  }
+  return sanitized;
+}
 var TRUNCATION_MARKER = "...[truncated]";
 function tryTruncateItem(rawText, tag, attributes, maxTokenBudget) {
   const tagOpen = attributes ? `<${tag}${attributes}>` : `<${tag}>`;
@@ -27073,8 +27099,9 @@ function normalizeAssembleResult(result, sourceMessages) {
         });
       } else {
         if (content.trim().length > 0) {
+          const sanitizedContent = sanitizeToolCallPatterns(content);
           const roleAttr = message.role ? ` role="${escapeMemoryFactText(message.role)}"` : "";
-          extractedMemoryItems.push(`<memory_item source="recalled"${roleAttr} provenance="durable_memory">${escapeMemoryFactText(content)}</memory_item>`);
+          extractedMemoryItems.push(`<memory_item source="recalled"${roleAttr} provenance="durable_memory">${escapeMemoryFactText(sanitizedContent)}</memory_item>`);
         }
       }
     }
@@ -27619,7 +27646,7 @@ import path2 from "node:path";
 var proxy_exports = {};
 __reExport(proxy_exports, __toESM(require_cjs(), 1));
 
-// node_modules/.pnpm/@xdarkicex+libravdb-contracts@0.3.0/node_modules/@xdarkicex/libravdb-contracts/gen/js/libravdb/ipc/v1/rpc_pb.js
+// node_modules/.pnpm/@xdarkicex+libravdb-contracts@2.0.8/node_modules/@xdarkicex/libravdb-contracts/gen/js/libravdb/ipc/v1/rpc_pb.js
 var IngestMode;
 (function(IngestMode2) {
   IngestMode2[IngestMode2["REPLACE"] = 0] = "REPLACE";
@@ -28962,6 +28989,10 @@ var CompactSessionResponse = class _CompactSessionResponse extends proxy_exports
    * @generated from field: double mean_confidence = 6;
    */
   meanConfidence = 0;
+  /**
+   * @generated from field: string summary_text = 7;
+   */
+  summaryText = "";
   constructor(data) {
     super();
     proxy_exports.proto3.util.initPartial(data, this);
@@ -29010,6 +29041,13 @@ var CompactSessionResponse = class _CompactSessionResponse extends proxy_exports
       kind: "scalar",
       T: 1
       /* ScalarType.DOUBLE */
+    },
+    {
+      no: 7,
+      name: "summary_text",
+      kind: "scalar",
+      T: 9
+      /* ScalarType.STRING */
     }
   ]);
   static fromBinary(bytes, options) {
@@ -30513,6 +30551,13 @@ var CompactSessionRequest = class _CompactSessionRequest extends proxy_exports.M
    * @generated from field: int32 current_token_count = 7;
    */
   currentTokenCount = 0;
+  /**
+   * Model's context window size in tokens. Enables daemon-side 80% threshold
+   * calculation when client doesn't send force=true.
+   *
+   * @generated from field: int32 context_window_size = 8;
+   */
+  contextWindowSize = 0;
   constructor(data) {
     super();
     proxy_exports.proto3.util.initPartial(data, this);
@@ -30568,6 +30613,13 @@ var CompactSessionRequest = class _CompactSessionRequest extends proxy_exports.M
       kind: "scalar",
       T: 5
       /* ScalarType.INT32 */
+    },
+    {
+      no: 8,
+      name: "context_window_size",
+      kind: "scalar",
+      T: 5
+      /* ScalarType.INT32 */
     }
   ]);
   static fromBinary(bytes, options) {
@@ -36312,7 +36364,7 @@ function createGrpcTransport(options) {
   return createTransport(validateNodeTransportOptions(options));
 }
 
-// node_modules/.pnpm/@xdarkicex+libravdb-contracts@0.3.0/node_modules/@xdarkicex/libravdb-contracts/gen/js/libravdb/ipc/v1/rpc_connect.js
+// node_modules/.pnpm/@xdarkicex+libravdb-contracts@2.0.8/node_modules/@xdarkicex/libravdb-contracts/gen/js/libravdb/ipc/v1/rpc_connect.js
 var LibravDB = {
   typeName: "libravdb.ipc.v1.LibravDB",
   methods: {

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.21",
+  "version": "1.6.23",
   "kind": [
     "memory",
     "context-engine"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xdarkicex/openclaw-memory-libravdb",
-  "version": "1.6.21",
+  "version": "1.6.23",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -79,6 +79,6 @@
   "dependencies": {
     "@connectrpc/connect": "^1.7.0",
     "@connectrpc/connect-node": "^1.7.0",
-    "@xdarkicex/libravdb-contracts": "^0.3.0"
+    "@xdarkicex/libravdb-contracts": "^2.0.8"
   }
 }