fix(reply): don't wedge preflight compaction on benign skip reasons

ottoclaw · claude · ottoclaw · commit 64167432bf0f · 2026-05-25T15:26:27.000-05:00
claude-cli-runtime sessions (provider stays "anthropic" via a per-model
agentRuntime pin) wedged every dispatch when pre-flight compaction returned
a benign skip ("no real conversation messages", "Already compacted", etc.):
the unconditional throw failed the turn and the session could not recover.
Defer to the existing isCompactionSkipReason classifier and return the
session entry instead of throwing.

Co-Authored-By: Claude Opus 4.7 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/src/auto-reply/reply/agent-runner-memory.test.ts b/src/auto-reply/reply/agent-runner-memory.test.ts
@@ -912,6 +912,73 @@ describe("runMemoryFlushIfNeeded", () => {
     expect(compactCall.currentTokenCount).toBe(347_000);
   });
 
+  it.each([
+    "no real conversation messages",
+    "Already compacted",
+    "nothing to compact",
+    "below threshold",
+  ])(
+    "Layer 2: benign compaction skip %j does not wedge a claude-cli-runtime session (provider=anthropic)",
+    async (reason) => {
+      registerMemoryFlushPlanResolverForTest(() => ({
+        softThresholdTokens: 4_000,
+        forceFlushTranscriptBytes: 1_000_000_000,
+        reserveTokensFloor: 20_000,
+        prompt: "Pre-compaction memory flush.\nNO_REPLY",
+        systemPrompt: "Write memory to memory/YYYY-MM-DD.md.",
+        relativePath: "memory/2023-11-14.md",
+      }));
+      // claude-cli session: OpenClaw transcript is empty -> compaction returns a skip reason.
+      compactEmbeddedPiSessionMock.mockReset().mockResolvedValue({
+        ok: false,
+        compacted: false,
+        reason,
+      });
+      const sessionEntry: SessionEntry = {
+        sessionId: "session",
+        updatedAt: Date.now(),
+        totalTokens: 1_207_416, // inflated cache-read sum, over the 1M window
+        totalTokensFresh: true,
+      };
+
+      const run = runPreflightCompactionIfNeeded({
+        cfg: {
+          models: {
+            providers: {
+              anthropic: { models: [{ id: "claude-opus-4-7", contextWindow: 1_048_576 }] },
+            },
+          },
+          agents: {
+            defaults: {
+              // user's setup: claude-cli backend + per-MODEL runtime pin (provider stays "anthropic")
+              cliBackends: { "claude-cli": { command: "/usr/bin/claude" } },
+              models: { "anthropic/claude-opus-4-7": { agentRuntime: { id: "claude-cli" } } },
+              compaction: { memoryFlush: {} },
+            },
+          },
+        } as never,
+        followupRun: createTestFollowupRun({
+          provider: "anthropic",
+          model: "claude-opus-4-7",
+          sessionId: "session",
+          sessionKey: "main",
+        }),
+        defaultModel: "anthropic/claude-opus-4-7",
+        sessionEntry,
+        sessionStore: { main: sessionEntry },
+        sessionKey: "main",
+        storePath: path.join(rootDir, "sessions.json"),
+        isHeartbeat: false,
+        replyOperation: createReplyOperation(),
+      });
+
+      // The over-threshold session must NOT wedge: a benign skip returns the entry so the
+      // turn proceeds. (Pre-fix this threw "Preflight compaction required but failed: <reason>".)
+      await expect(run).resolves.toBeDefined();
+      expect(compactEmbeddedPiSessionMock).toHaveBeenCalled();
+    },
+  );
+
   it("keeps the OpenAI API context window for persisted PI runtime overrides", 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
@@ -45,6 +45,7 @@ import {
   buildEmbeddedRunExecutionParams,
   resolveModelFallbackOptions,
 } from "./agent-runner-utils.js";
+import { isCompactionSkipReason } from "./commands-compact.js";
 import {
   hasAlreadyFlushedForCurrentCompaction,
   resolveMaxActiveTranscriptBytes,
@@ -768,6 +769,14 @@ export async function runPreflightCompactionIfNeeded(params: {
   if (!result?.ok || !result.compacted) {
     const reason = result?.reason ?? "not_compacted";
     logVerbose(`preflightCompaction failed: sessionKey=${params.sessionKey} reason=${reason}`);
+    // A benign compaction *skip* (nothing to compact / below threshold / already
+    // compacted / no real conversation messages) is not a failure — it routinely
+    // happens for provider-owned CLI-runtime sessions, whose OpenClaw-side transcript
+    // is empty. Throwing here wedges every subsequent dispatch on the session. Defer
+    // to the same classifier used by the manual /compact path and proceed.
+    if (isCompactionSkipReason(reason)) {
+      return entry ?? params.sessionEntry;
+    }
     throw new Error(`Preflight compaction required but failed: ${reason}`);
   }
 
diff --git a/src/auto-reply/reply/commands-compact.ts b/src/auto-reply/reply/commands-compact.ts
@@ -51,7 +51,7 @@ function extractCompactInstructions(params: {
   return rest.length ? rest : undefined;
 }
 
-function isCompactionSkipReason(reason?: string): boolean {
+export function isCompactionSkipReason(reason?: string): boolean {
   const text = normalizeOptionalLowercaseString(reason) ?? "";
   return (
     text.includes("nothing to compact") ||

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ function extractCompactInstructions(params: {`
`51`	`51`	`return rest.length ? rest : undefined;`
`52`	`52`	`}`
`53`	`53`
`54`		`-function isCompactionSkipReason(reason?: string): boolean {`
	`54`	`+export function isCompactionSkipReason(reason?: string): boolean {`
`55`	`55`	`const text = normalizeOptionalLowercaseString(reason) ?? "";`
`56`	`56`	`return (`
`57`	`57`	`text.includes("nothing to compact") \|\|`