fix(agents): don't fail CLI turn when the native harness owns compaction

solomonneas · solomonneas · commit 28f22f0f4958 · 2026-05-28T21:46:36.000-04:00
runCliTurnCompactionLifecycle threw on the Codex app-server's successful
no-op (ok:true, compacted:false) when it owns automatic compaction, failing
the agent run and jamming the session lane (endless 'typing' on large Codex
threads). Treat the owned no-op as benign: skip the throw and the
context-engine fallback so the turn proceeds and the harness self-compacts.
Matches the existing 'Codex owns compaction' contract in the auto-reply
preflight path.
diff --git a/src/agents/command/cli-compaction.test.ts b/src/agents/command/cli-compaction.test.ts
@@ -502,6 +502,83 @@ describe("runCliTurnCompactionLifecycle", () => {
     expect(compactCalls).toHaveLength(0);
   });
 
+  it("does not throw when the native harness owns automatic compaction (ok:true no-op)", async () => {
+    // Regression: Codex app-server returns a successful no-op (ok:true,
+    // compacted:false) for budget-triggered compaction because it owns
+    // automatic compaction. The lifecycle must treat that as benign and let the
+    // turn proceed, not throw "CLI native harness compaction failed" — throwing
+    // fails the agent run and jams the session lane (endless Discord "typing").
+    const sessionKey = "agent:main:codex-owned-skip";
+    const sessionId = "session-codex-owned-skip";
+    const sessionFile = path.join(tmpDir, "session-codex-owned-skip.jsonl");
+    const storePath = path.join(tmpDir, "sessions-codex-owned-skip.json");
+    await writeSessionFile({ sessionFile, sessionId });
+
+    const sessionEntry: SessionEntry = {
+      sessionId,
+      updatedAt: Date.now(),
+      sessionFile,
+      contextTokens: 1_000,
+      totalTokens: 950,
+      totalTokensFresh: true,
+      agentHarnessId: "codex",
+    };
+    const sessionStore: Record<string, SessionEntry> = { [sessionKey]: sessionEntry };
+    await fs.writeFile(storePath, JSON.stringify(sessionStore, null, 2), "utf-8");
+
+    const compactCalls: Array<Parameters<ContextEngine["compact"]>[0]> = [];
+    const compactAgentHarnessSession = vi.fn(async () => ({
+      ok: true,
+      compacted: false,
+      reason: "codex app-server owns automatic compaction",
+    }));
+    const recordCliCompactionInStore = vi.fn(async () => ({
+      ...sessionEntry,
+      compactionCount: 1,
+    }));
+    setCliCompactionTestDeps({
+      resolveContextEngine: async () => buildContextEngine({ compactCalls }),
+      ensureSelectedAgentHarnessPlugin: vi.fn(async () => undefined),
+      maybeCompactAgentHarnessSession: compactAgentHarnessSession as never,
+      createPreparedEmbeddedAgentSettingsManager: async () => ({
+        getCompactionReserveTokens: () => 200,
+        getCompactionKeepRecentTokens: () => 0,
+        applyOverrides: () => {},
+      }),
+      shouldPreemptivelyCompactBeforePrompt: () => ({
+        route: "fits",
+        shouldCompact: false,
+        estimatedPromptTokens: 600,
+        promptBudgetBeforeReserve: 800,
+        overflowTokens: 0,
+        toolResultReducibleChars: 0,
+        effectiveReserveTokens: 200,
+      }),
+      resolveLiveToolResultMaxChars: () => 20_000,
+      recordCliCompactionInStore,
+    });
+
+    const updatedEntry = await runCliTurnCompactionLifecycle({
+      cfg: {} as OpenClawConfig,
+      sessionId,
+      sessionKey,
+      sessionEntry,
+      sessionStore,
+      storePath,
+      sessionAgentId: "main",
+      workspaceDir: tmpDir,
+      agentDir: tmpDir,
+      provider: "codex",
+      model: "gpt-5.5",
+    });
+
+    expect(compactAgentHarnessSession).toHaveBeenCalledTimes(1);
+    // No context-engine fallback, no store rotation: the harness self-compacts.
+    expect(compactCalls).toHaveLength(0);
+    expect(recordCliCompactionInStore).not.toHaveBeenCalled();
+    expect(updatedEntry).toBe(sessionEntry);
+  });
+
   it("passes owning context engines into native harness CLI compaction", async () => {
     const sessionKey = "agent:main:codex-owned-engine";
     const sessionId = "session-codex-owned-engine";
diff --git a/src/agents/command/cli-compaction.ts b/src/agents/command/cli-compaction.ts
@@ -69,6 +69,11 @@ type NativeHarnessCliCompactionOutcome = {
   compacted: boolean;
   result?: EmbeddedAgentCompactResult;
   fallbackToContextEngine?: boolean;
+  // Native harness reported a successful no-op because it owns automatic
+  // compaction itself (e.g. the Codex app-server on non-manual/budget triggers).
+  // Not a failure: the caller must skip the throw and let the harness compact
+  // during the turn, otherwise the agent run errors and the session lane jams.
+  ownedByNativeHarness?: boolean;
   failureReason?: string;
 };
 type CliTranscriptCompactionOutcome = {
@@ -403,12 +408,16 @@ async function compactNativeHarnessCliTranscript(params: {
     const fallbackToContextEngine =
       isUnsupportedNativeHarnessCompaction(result) ||
       isRecoverableNativeHarnessBindingFailure(result);
+    // ok:true with no compaction is a successful no-op (the harness owns
+    // automatic compaction), not a failure — do not throw on it downstream.
+    const ownedByNativeHarness = result?.ok === true;
     log.warn(
       `CLI native harness compaction did not reduce context for ${params.provider}/${params.model}: ${result?.reason ?? "nothing to compact"}`,
     );
     return {
       compacted: false,
       fallbackToContextEngine,
+      ownedByNativeHarness,
       failureReason: result?.reason ?? "native harness compaction did not reduce context",
     };
   }
@@ -520,6 +529,11 @@ export async function runCliTurnCompactionLifecycle(params: {
       compacted = true;
       nativeCompactionResult = nativeOutcome.result;
       useContextEngineCompaction = false;
+    } else if (nativeOutcome.ownedByNativeHarness) {
+      // Harness owns automatic compaction and returned a successful no-op. Skip
+      // both the throw and the context-engine fallback so the turn proceeds and
+      // the harness compacts itself; throwing here jams the session lane.
+      useContextEngineCompaction = false;
     } else if (!nativeOutcome.fallbackToContextEngine) {
       throw new Error(
         `CLI native harness compaction failed for ${params.provider}/${params.model}: ${
