diff --git a/examples/openclaw-plugin/context-engine.ts b/examples/openclaw-plugin/context-engine.ts
index a81390945..f05317b32 100644
--- a/examples/openclaw-plugin/context-engine.ts
+++ b/examples/openclaw-plugin/context-engine.ts
@@ -40,7 +40,13 @@ type CompactResult = {
   ok: boolean;
   compacted: boolean;
   reason?: string;
-  result?: unknown;
+  result?: {
+    summary?: string;
+    firstKeptEntryId?: string;
+    tokensBefore: number;
+    tokensAfter?: number;
+    details?: unknown;
+  };
 };
 
 type ContextEngine = {
@@ -559,8 +565,15 @@ export function createMemoryOpenVikingContextEngine(params: {
             : {}),
         };
       } catch (err) {
+        warnOrInfo(
+          logger,
+          `openviking: assemble failed for session=${OVSessionId}, ` +
+            `tokenBudget=${tokenBudget}, agentId=${resolveAgentId(OVSessionId)}: ${String(err)}`,
+        );
         diag("assemble_error", OVSessionId, {
           error: String(err),
+          tokenBudget,
+          agentId: resolveAgentId(OVSessionId),
         });
         return { messages, estimatedTokens: roughEstimate(messages) };
       }
@@ -678,8 +691,9 @@ export function createMemoryOpenVikingContextEngine(params: {
 
     async compact(compactParams): Promise<CompactResult> {
       const OVSessionId = compactParams.sessionId;
+      const tokenBudget = validTokenBudget(compactParams.tokenBudget) ?? 128_000;
       diag("compact_entry", OVSessionId, {
-        tokenBudget: compactParams.tokenBudget ?? null,
+        tokenBudget,
         force: compactParams.force ?? false,
         currentTokenCount: compactParams.currentTokenCount ?? null,
         compactionTarget: compactParams.compactionTarget ?? null,
@@ -687,11 +701,32 @@ export function createMemoryOpenVikingContextEngine(params: {
           compactParams.customInstructions.trim().length > 0,
       });
 
+      const client = await getClient();
+      const agentId = resolveAgentId(OVSessionId);
+      const tokensBeforeOriginal = validTokenBudget(compactParams.currentTokenCount);
+      let preCommitEstimatedTokens: number | undefined;
+      if (typeof tokensBeforeOriginal !== "number") {
+        try {
+          const preCtx = await client.getSessionContext(OVSessionId, tokenBudget, agentId);
+          if (
+            typeof preCtx.estimatedTokens === "number" &&
+            Number.isFinite(preCtx.estimatedTokens)
+          ) {
+            preCommitEstimatedTokens = preCtx.estimatedTokens;
+          }
+        } catch (preCtxErr) {
+          logger.info(
+            `openviking: compact pre-ctx fetch failed for session=${OVSessionId}, ` +
+              `tokenBudget=${tokenBudget}, agentId=${agentId}: ${String(preCtxErr)}`,
+          );
+        }
+      }
+
+      const tokensBefore = tokensBeforeOriginal ?? preCommitEstimatedTokens ?? -1;
+
       try {
-        const client = await getClient();
-        const agentId = resolveAgentId(OVSessionId);
         logger.info(
-          `openviking: compact committing session=${OVSessionId} (wait=true)`,
+          `openviking: compact committing session=${OVSessionId} (wait=true, tokenBudget=${tokenBudget})`,
         );
         const commitResult = await client.commitSession(OVSessionId, { wait: true, agentId });
         const memCount = totalExtractedMemories(commitResult.memories_extracted);
@@ -714,7 +749,15 @@ export function createMemoryOpenVikingContextEngine(params: {
             ok: false,
             compacted: false,
             reason: "commit_failed",
-            result: commitResult,
+            result: {
+              summary: "",
+              firstKeptEntryId: "",
+              tokensBefore: tokensBefore,
+              tokensAfter: undefined,
+              details: {
+                commit: commitResult,
+              },
+            },
           };
         }
 
@@ -735,7 +778,15 @@ export function createMemoryOpenVikingContextEngine(params: {
             ok: false,
             compacted: false,
             reason: "commit_timeout",
-            result: commitResult,
+            result: {
+              summary: "",
+              firstKeptEntryId: "",
+              tokensBefore: tokensBefore,
+              tokensAfter: undefined,
+              details: {
+                commit: commitResult,
+              },
+            },
           };
         }
 
@@ -744,6 +795,10 @@ export function createMemoryOpenVikingContextEngine(params: {
         );
 
         if (!commitResult.archived) {
+          logger.info(
+            `openviking: compact no archive for session=${OVSessionId}, ` +
+              `tokensBefore=${tokensBefore}, tokensAfter=${tokensBefore}`,
+          );
           diag("compact_result", OVSessionId, {
             ok: true,
             compacted: false,
@@ -752,15 +807,53 @@ export function createMemoryOpenVikingContextEngine(params: {
             archived: commitResult.archived ?? false,
             taskId: commitResult.task_id ?? null,
             memories: memCount,
+            tokensBefore: tokensBefore,
           });
           return {
             ok: true,
             compacted: false,
             reason: "commit_no_archive",
-            result: commitResult,
+            result: {
+              summary: "",
+              tokensBefore: tokensBefore,
+              tokensAfter: tokensBefore >= 0 ? tokensBefore : undefined,
+              details: {
+                commit: commitResult,
+              },
+            },
           };
         }
 
+        let summary = "";
+        let firstKeptEntryId = commitResult.archive_uri?.split("/").pop() ?? "";
+        let tokensAfter: number | undefined;
+        let contextFetchError: string | undefined;
+
+        try {
+          const ctx = await client.getSessionContext(OVSessionId, tokenBudget, agentId);
+          if (typeof ctx.latest_archive_overview === "string") {
+            summary = ctx.latest_archive_overview.trim();
+          }
+          if (
+            typeof ctx.estimatedTokens === "number" &&
+            Number.isFinite(ctx.estimatedTokens)
+          ) {
+            tokensAfter = ctx.estimatedTokens;
+          }
+        } catch (ctxErr) {
+          contextFetchError = String(ctxErr);
+          logger.info(
+            `openviking: compact context fetch failed for session=${OVSessionId}, ` +
+              `tokenBudget=${tokenBudget}, agentId=${agentId}: ${contextFetchError}`,
+          );
+        }
+
+        logger.info(
+          `openviking: compact tokens session=${OVSessionId}, ` +
+            `tokensBefore=${tokensBefore}, tokensAfter=${tokensAfter ?? "unknown"}, ` +
+            `latestArchiveId=${firstKeptEntryId || "none"}`,
+        );
+
         diag("compact_result", OVSessionId, {
           ok: true,
           compacted: true,
@@ -769,12 +862,29 @@ export function createMemoryOpenVikingContextEngine(params: {
           archived: commitResult.archived ?? false,
           taskId: commitResult.task_id ?? null,
           memories: memCount,
+          tokensBefore: tokensBefore,
+          tokensAfter: tokensAfter ?? null,
+          latestArchiveId: firstKeptEntryId || null,
+          summaryPresent: summary.length > 0,
         });
         return {
           ok: true,
           compacted: true,
           reason: "commit_completed",
-          result: commitResult,
+          result: {
+            summary,
+            firstKeptEntryId,
+            tokensBefore,
+            tokensAfter,
+            details: contextFetchError
+              ? {
+                  commit: commitResult,
+                  contextError: contextFetchError,
+                }
+              : {
+                  commit: commitResult,
+                },
+          },
         };
       } catch (err) {
         warnOrInfo(logger, `openviking: compact commit failed for session=${OVSessionId}: ${String(err)}`);
@@ -786,7 +896,13 @@ export function createMemoryOpenVikingContextEngine(params: {
           compacted: false,
           reason: "commit_error",
           result: {
-            error: String(err),
+            summary: "",
+            firstKeptEntryId: "",
+            tokensBefore: tokensBefore,
+            tokensAfter: undefined,
+            details: {
+              error: String(err),
+            },
           },
         };
       }