fix(compaction): restrict post-usage marker to structured records

jbetala7 · jbetala7 · commit 26d129370858 · 2026-06-03T12:51:14.000+05:30
ClawSweeper re-review flagged a P1: transcriptLineHasPostUsageCompactionMarker
also matched the post-compaction refresh phrases ("[Post-compaction context
refresh]", "Session was just compacted.") in free message text. Those phrases
are prompt-injected context, not persisted markers, so ordinary user/tool
content echoing them could masquerade as a compaction marker and wrongly drop
stale-usage pressure.

Detect only structured compaction records (type "compaction"/"session.compacted",
the records the runtime actually writes via transcript-file-state / session-manager)
and drop the free-text fallback plus the now-unused collectTranscriptText helper.
Add a regression test proving ordinary transcript text echoing the refresh phrase
(with no structured marker) keeps preflight compaction conservative.
diff --git a/src/auto-reply/reply/agent-runner-memory.test.ts b/src/auto-reply/reply/agent-runner-memory.test.ts
@@ -1662,6 +1662,78 @@ describe("runMemoryFlushIfNeeded", () => {
     expect(compactEmbeddedAgentSessionMock).not.toHaveBeenCalled();
   });
 
+  it("does not treat ordinary transcript text echoing the refresh phrase as a compaction marker", async () => {
+    const sessionFile = path.join(rootDir, "phrase-echo-without-marker.jsonl");
+    // Same stale-usage shape as the marker tests, but the post-compaction phrases
+    // appear only as ordinary user/assistant message text — there is NO structured
+    // {type:"compaction"} record. The estimator must keep the stale usage active and
+    // still compact, instead of being fooled into dropping pressure.
+    await fs.writeFile(
+      sessionFile,
+      [
+        JSON.stringify({
+          message: {
+            role: "assistant",
+            content: [{ type: "text", text: "pre-compaction giant turn" }],
+            usage: { input: 240_000, output: 120_000 },
+          },
+        }),
+        JSON.stringify({
+          message: {
+            role: "tool",
+            content: `pre-compaction stale tool result ${"x".repeat(450_000)}`,
+          },
+        }),
+        JSON.stringify({
+          message: {
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: "[Post-compaction context refresh]\n\nSession was just compacted.",
+              },
+            ],
+          },
+        }),
+      ].join("\n"),
+      "utf8",
+    );
+
+    registerMemoryFlushPlanResolverForTest(() => ({
+      softThresholdTokens: 4_000,
+      forceFlushTranscriptBytes: 1_000_000_000,
+      reserveTokensFloor: 0,
+      prompt: "Pre-compaction memory flush.\nNO_REPLY",
+      systemPrompt: "Write memory to memory/YYYY-MM-DD.md.",
+      relativePath: "memory/2023-11-14.md",
+    }));
+    const sessionEntry: SessionEntry = {
+      sessionId: "session",
+      sessionFile,
+      updatedAt: Date.now(),
+      totalTokensFresh: false,
+    };
+
+    await runPreflightCompactionIfNeeded({
+      cfg: { agents: { defaults: { compaction: { memoryFlush: {} } } } },
+      followupRun: createTestFollowupRun({
+        sessionId: "session",
+        sessionFile,
+        sessionKey: "main",
+      }),
+      defaultModel: "anthropic/claude-opus-4-6",
+      agentCfgContextTokens: 100_000,
+      sessionEntry,
+      sessionStore: { main: sessionEntry },
+      sessionKey: "main",
+      storePath: path.join(rootDir, "sessions.json"),
+      isHeartbeat: false,
+      replyOperation: createReplyOperation(),
+    });
+
+    expect(compactEmbeddedAgentSessionMock).toHaveBeenCalled();
+  });
+
   it("skips OpenClaw preflight compaction for persisted Codex runtime sessions", async () => {
     registerMemoryFlushPlanResolverForTest(() => ({
       softThresholdTokens: 4_000,
diff --git a/src/auto-reply/reply/agent-runner-memory.ts b/src/auto-reply/reply/agent-runner-memory.ts
@@ -360,52 +360,27 @@ function parseUsageFromTranscriptLine(line: string): ReturnType<typeof normalize
   return undefined;
 }
 
-function collectTranscriptText(value: unknown): string {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (!Array.isArray(value)) {
-    return "";
-  }
-  return value
-    .map((item) => {
-      if (!item || typeof item !== "object" || Array.isArray(item)) {
-        return "";
-      }
-      const text = (item as { text?: unknown }).text;
-      return typeof text === "string" ? text : "";
-    })
-    .filter(Boolean)
-    .join("\n");
-}
-
 function transcriptLineHasPostUsageCompactionMarker(line: string): boolean {
   const trimmed = line.trim();
   if (!trimmed) {
     return false;
   }
   try {
+    // Only trust structured compaction records (written by the runtime at
+    // compaction time, e.g. transcript-file-state / session-manager). The
+    // post-compaction refresh phrases are prompt-injected context, so matching
+    // them in free message text would let ordinary user/tool content that
+    // echoes the phrase masquerade as a marker and wrongly drop stale-usage
+    // pressure.
     const parsed = JSON.parse(trimmed) as {
       type?: unknown;
-      message?: { content?: unknown };
-      payload?: { type?: unknown; text?: unknown };
+      payload?: { type?: unknown };
     };
-    if (parsed.type === "compaction" || parsed.type === "session.compacted") {
-      return true;
-    }
-    const payloadType = parsed.payload?.type;
-    if (payloadType === "compaction" || payloadType === "session.compacted") {
-      return true;
-    }
-    const text = [
-      collectTranscriptText(parsed.message?.content),
-      collectTranscriptText(parsed.payload?.text),
-    ]
-      .filter(Boolean)
-      .join("\n");
     return (
-      text.includes("[Post-compaction context refresh]") ||
-      text.includes("Session was just compacted.")
+      parsed.type === "compaction" ||
+      parsed.type === "session.compacted" ||
+      parsed.payload?.type === "compaction" ||
+      parsed.payload?.type === "session.compacted"
     );
   } catch {
     return false;
