@joshuaswarren/openclaw-engram 9.0.86 → 9.0.88

package/dist/index.js

@@ -18117,16 +18117,21 @@ var LcmEngine = class {
       budgetChars: effectiveBudget
     });
   }
-  /** Record a compaction event (called from before_compaction hook). */
-  async recordCompaction(sessionId, tokensBefore, tokensAfter) {
+  /** Flush pending summaries before compaction (called from before_compaction hook). */
+  async preCompactionFlush(sessionId) {
     if (!this.config.enabled) return;
     await this.ensureInitialized();
-    const maxTurn = this.archive.getMaxTurnIndex(sessionId);
     try {
       await this.summarizer.summarizeIncremental(sessionId);
     } catch (err) {
       log.debug(`LCM pre-compaction flush error: ${err}`);
     }
+  }
+  /** Record a compaction event with real token counts (called from after_compaction hook). */
+  async recordCompaction(sessionId, tokensBefore, tokensAfter) {
+    if (!this.config.enabled) return;
+    await this.ensureInitialized();
+    const maxTurn = this.archive.getMaxTurnIndex(sessionId);
     this.dag.recordCompaction(sessionId, maxTurn, tokensBefore, tokensAfter);
     log.info(
       `LCM compaction recorded: session=${sessionId}, turn=${maxTurn}, tokens ${tokensBefore}\u2192${tokensAfter}`
@@ -42033,6 +42038,7 @@ Use this context naturally when relevant. Never quote or expose this memory cont
         `skipping legacy typed agent_heartbeat hook for OpenClaw ${runtimeVersion}; published builds from 2026.1.29 onward do not expose it`
       );
     }
+    const lcmTokensBefore = /* @__PURE__ */ new Map();
     api.on(
       "before_compaction",
       async (event, ctx) => {
@@ -42040,8 +42046,24 @@ Use this context naturally when relevant. Never quote or expose this memory cont
         try {
           if (orchestrator.lcmEngine?.enabled) {
             try {
-              const tokensBefore = typeof event.tokensBefore === "number" ? event.tokensBefore : 0;
-              await orchestrator.lcmEngine.recordCompaction(sessionKey, tokensBefore, 0);
+              let tokensBefore = 0;
+              if (typeof event.tokenCount === "number") {
+                tokensBefore = event.tokenCount;
+              } else if (Array.isArray(event.messages)) {
+                for (const msg of event.messages) {
+                  if (typeof msg.content === "string") {
+                    tokensBefore += estimateTokens2(msg.content);
+                  } else if (Array.isArray(msg.content)) {
+                    for (const block of msg.content) {
+                      if (typeof block === "string") tokensBefore += estimateTokens2(block);
+                      else if (block && typeof block === "object" && typeof block.text === "string")
+                        tokensBefore += estimateTokens2(block.text);
+                    }
+                  }
+                }
+              }
+              lcmTokensBefore.set(sessionKey, tokensBefore);
+              await orchestrator.lcmEngine.preCompactionFlush(sessionKey);
             } catch (lcmErr) {
               log.debug(`LCM before_compaction error: ${lcmErr}`);
             }
@@ -42072,9 +42094,24 @@ Use this context naturally when relevant. Never quote or expose this memory cont
         try {
           if (orchestrator.lcmEngine?.enabled) {
             try {
+              let tokensAfter = 0;
+              if (typeof event.tokenCount === "number") {
+                tokensAfter = event.tokenCount;
+              } else {
+                const storedBefore = lcmTokensBefore.get(sessionKey) ?? 0;
+                const msgCountAfter = typeof event.messageCount === "number" ? event.messageCount : 0;
+                const compacted = typeof event.compactedCount === "number" ? event.compactedCount : 0;
+                const msgCountBefore = msgCountAfter + compacted;
+                if (storedBefore > 0 && msgCountBefore > 0) {
+                  tokensAfter = Math.round(storedBefore * (msgCountAfter / msgCountBefore));
+                }
+              }
+              const tokensBefore = lcmTokensBefore.get(sessionKey) ?? 0;
+              lcmTokensBefore.delete(sessionKey);
+              await orchestrator.lcmEngine.recordCompaction(sessionKey, tokensBefore, tokensAfter);
               await orchestrator.lcmEngine.verifyPostCompaction(sessionKey);
             } catch (lcmErr) {
-              log.debug(`LCM after_compaction verify error: ${lcmErr}`);
+              log.debug(`LCM after_compaction error: ${lcmErr}`);
             }
           }
           if (!orchestrator.config.compactionResetEnabled) {