@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091926.ebb2d62

package/src/__tests__/conversation-agent-loop-overflow.test.ts

@@ -39,6 +39,20 @@ const conversationRuntimeAssemblyRealSnapshot = {
 
 // ── Module mocks (must precede imports of the module under test) ─────
 
+// The real AgentLoop resolves the per-conversation ContextWindowManager from
+// the compaction store keyed by conversationId. These overflow tests build
+// fake conversations whose manager is a canned stub, so register each stub in a
+// map the mocked store reads from.
+const fakeContextWindowManagers = new Map<string, unknown>();
+mock.module("../plugins/defaults/compaction/manager-store.js", () => ({
+  createContextWindowManager: () => undefined,
+  getContextWindowManager: (conversationId: string) =>
+    fakeContextWindowManagers.get(conversationId),
+  disposeContextWindowManager: (conversationId: string) => {
+    fakeContextWindowManagers.delete(conversationId);
+  },
+}));
+
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
@@ -100,7 +114,7 @@ mock.module("../config/loader.js", () => ({
 // Can be a number (constant), a no-arg function, or a function that
 // receives the messages array for dynamic behavior based on content.
 // Both the calibrated entry point (`estimatePromptTokens`, which backs the
-// preflight overflow gate and the convergence path) and the raw entry point
+// loop's budget gate and the convergence path) and the raw entry point
 // (`estimatePromptTokensRaw`, used by the pre-send calibration capture) are
 // stubbed so either call site can drive the test.
 let mockEstimateTokens: number | ((msgs?: Message[]) => number) = 1000;
@@ -113,7 +127,7 @@ mock.module("../context/token-estimator.js", () => ({
     typeof mockEstimateTokens === "function"
       ? mockEstimateTokens(msgs)
       : mockEstimateTokens,
-  // The preflight overflow gate calls this calibrated wrapper directly, so it
+  // The loop's budget gate calls this calibrated wrapper directly, so it
   // must honor `mockEstimateTokens` too — otherwise the real implementation
   // (which sums tool tokens onto the real calibrated estimate) ignores the
   // per-test value and the overflow scenarios below never trigger.
@@ -137,35 +151,38 @@ mock.module("../context/token-estimator.js", () => ({
 let mockReducerStepFn:
   | ((msgs: Message[], cfg: unknown, state: unknown) => unknown)
   | null = null;
-mock.module("../daemon/context-overflow-reducer.js", () => ({
-  createInitialReducerState: () => ({
-    appliedTiers: [],
-    injectionMode: "full" as const,
-    exhausted: false,
+mock.module(
+  "../plugins/defaults/compaction/context-overflow-reducer.js",
+  () => ({
+    createInitialReducerState: () => ({
+      appliedTiers: [],
+      injectionMode: "full" as const,
+      exhausted: false,
+    }),
+    reduceContextOverflow: async (
+      msgs: Message[],
+      cfg: unknown,
+      state: unknown,
+    ) => {
+      if (mockReducerStepFn) return mockReducerStepFn(msgs, cfg, state);
+      return {
+        messages: msgs,
+        tier: "forced_compaction",
+        state: {
+          appliedTiers: [
+            "forced_compaction",
+            "tool_result_truncation",
+            "media_stubbing",
+            "injection_downgrade",
+          ],
+          injectionMode: "full",
+          exhausted: true,
+        },
+        estimatedTokens: 1000,
+      };
+    },
   }),
-  reduceContextOverflow: async (
-    msgs: Message[],
-    cfg: unknown,
-    state: unknown,
-  ) => {
-    if (mockReducerStepFn) return mockReducerStepFn(msgs, cfg, state);
-    return {
-      messages: msgs,
-      tier: "forced_compaction",
-      state: {
-        appliedTiers: [
-          "forced_compaction",
-          "tool_result_truncation",
-          "media_stubbing",
-          "injection_downgrade",
-        ],
-        injectionMode: "full",
-        exhausted: true,
-      },
-      estimatedTokens: 1000,
-    };
-  },
-}));
+);
 
 // Policy: default to fail_gracefully
 let mockOverflowAction: string = "fail_gracefully";
@@ -202,7 +219,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateMessageMetadata: () => {},
   setLastNotifiedInferenceProfile: () => {},
   getLastUserTimestampBefore: () => 0,
-  getConversationOverrideProfileFromRow: () => undefined,
+  resolveOverrideProfile: () => undefined,
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
@@ -422,10 +439,8 @@ mock.module("../memory/archive-store.js", () => ({
 // ── Imports (after mocks) ────────────────────────────────────────────
 
 import { AgentLoop } from "../agent/loop.js";
-import {
-  type AgentLoopConversationContext,
-  runAgentLoopImpl,
-} from "../daemon/conversation-agent-loop.js";
+import type { Conversation } from "../daemon/conversation.js";
+import { runAgentLoopImpl } from "../daemon/conversation-agent-loop.js";
 import {
   createMockProvider,
   type ScriptedResponse,
@@ -436,13 +451,13 @@ import {
 // ── Test helpers ─────────────────────────────────────────────────────
 
 function makeCtx(
-  overrides?: Partial<AgentLoopConversationContext> & {
+  overrides?: Partial<Conversation> & {
     providerResponses?: ScriptedResponse[];
     loopProvider?: Provider;
     loopTools?: ToolDefinition[];
     toolExecutor?: LoopToolExecutor;
   },
-): AgentLoopConversationContext {
+): Conversation {
   const {
     providerResponses,
     loopProvider,
@@ -465,13 +480,15 @@ function makeCtx(
       providerResponses ?? [textResponse("response")],
       loopProviderName,
     ).provider;
-  const agentLoop = new AgentLoop(provider, "system prompt", {
+  const agentLoop = new AgentLoop({
+    provider: provider,
+    systemPrompt: "system prompt",
     conversationId,
     tools: loopTools ?? [],
     toolExecutor,
   });
 
-  return {
+  const ctx = {
     conversationId: "test-conv",
     messages: [
       { role: "user", content: [{ type: "text", text: "Hello" }] },
@@ -495,13 +512,14 @@ function makeCtx(
         usage: { inputTokens: 0, outputTokens: 0 },
         stopReason: "end_turn",
       }),
-    } as unknown as AgentLoopConversationContext["provider"],
+    } as unknown as Conversation["provider"],
     systemPrompt: "system prompt",
 
     contextWindowManager: {
+      updateConfig: () => {},
       shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
       maybeCompact: async () => ({ compacted: false }),
-    } as unknown as AgentLoopConversationContext["contextWindowManager"],
+    } as unknown as Conversation["contextWindowManager"],
     contextCompactedMessageCount: 0,
     contextCompactedAt: null,
 
@@ -515,8 +533,6 @@ function makeCtx(
     currentTurnSurfaces: [],
 
     workingDir: "/tmp",
-    workspaceTopLevelContext: null,
-    workspaceTopLevelDirty: false,
     channelCapabilities: undefined,
     commandIntent: undefined,
     trustContext: undefined,
@@ -526,15 +542,15 @@ function makeCtx(
     preactivatedSkillIds: undefined,
     skillProjectionState: new Map(),
     skillProjectionCache:
-      new Map() as unknown as AgentLoopConversationContext["skillProjectionCache"],
+      new Map() as unknown as Conversation["skillProjectionCache"],
 
     traceEmitter: {
       emit: () => {},
-    } as unknown as AgentLoopConversationContext["traceEmitter"],
+    } as unknown as Conversation["traceEmitter"],
     profiler: {
       startRequest: () => {},
       emitSummary: () => {},
-    } as unknown as AgentLoopConversationContext["profiler"],
+    } as unknown as Conversation["profiler"],
     usageStats: {
       totalInputTokens: 0,
       totalOutputTokens: 0,
@@ -547,13 +563,12 @@ function makeCtx(
     lastAttachmentWarnings: [],
 
     hasNoClient: false,
-    prompter: {} as unknown as AgentLoopConversationContext["prompter"],
-    queue: {} as unknown as AgentLoopConversationContext["queue"],
+    prompter: {} as unknown as Conversation["prompter"],
+    queue: {} as unknown as Conversation["queue"],
 
     getWorkspaceGitService: () => ({ ensureInitialized: async () => {} }),
     commitTurnChanges: async () => {},
 
-    refreshWorkspaceTopLevelContextIfNeeded: () => {},
     markWorkspaceTopLevelDirty: () => {},
     emitActivityState: () => {},
     getQueueDepth: () => 0,
@@ -580,10 +595,12 @@ function makeCtx(
       }),
       retrackCachedNodes: () => {},
       recordPkbQueryVectors: () => {},
-    } as unknown as AgentLoopConversationContext["graphMemory"],
+    } as unknown as Conversation["graphMemory"],
 
     ...ctxOverrides,
-  } as AgentLoopConversationContext;
+  } as unknown as Conversation;
+  fakeContextWindowManagers.set(conversationId, ctx.contextWindowManager);
+  return ctx;
 }
 
 /**
@@ -651,10 +668,9 @@ beforeEach(() => {
   recordUsageMock.mockClear();
   setAgentLoopExitReasonOnLatestLogMock.mockClear();
   addMessageMock.mockClear();
-  // Reset the plugin registry and re-register every default so the
-  // orchestrator's pipelines (`overflowReduce`, `persistence`, …) dispatch to
-  // the default middleware, which in turn hits the mocked collaborators
-  // (`reduceContextOverflow`, `syncMessageToDisk`, …) these tests install.
+  // Reset the plugin registry and re-register every default so the compaction
+  // pipeline dispatches to the default middleware, which in turn hits the
+  // mocked collaborators (`syncMessageToDisk`, …) these tests install.
   resetPluginRegistryAndRegisterDefaults();
 });
 
@@ -768,9 +784,10 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
           isError: false,
         }),
         contextWindowManager: {
+          updateConfig: () => {},
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+        } as unknown as Conversation["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -797,9 +814,9 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
     const events: ServerMessage[] = [];
     let reducerCalled = false;
 
-    // GIVEN the estimator reports 185k — under the 190k preflight budget
-    // (200k * 0.95), so the turn proceeds to the provider rather than
-    // compacting up front.
+    // GIVEN the estimator reports 185k and the context manager's compaction
+    // is a no-op, so the first call proceeds to the provider without any
+    // up-front reduction.
     mockEstimateTokens = 185_000;
 
     // AND the post-run convergence reducer successfully compacts
@@ -842,9 +859,10 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
     const ctx = makeCtx({
       loopProvider: provider,
       contextWindowManager: {
+        updateConfig: () => {},
         shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
         maybeCompact: async () => ({ compacted: false }),
-      } as unknown as AgentLoopConversationContext["contextWindowManager"],
+      } as unknown as Conversation["contextWindowManager"],
     });
 
     // WHEN the turn runs
@@ -918,9 +936,10 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
       const ctx = makeCtx({
         loopProvider: provider,
         contextWindowManager: {
+          updateConfig: () => {},
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+        } as unknown as Conversation["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -1005,9 +1024,10 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
         loopProvider: provider,
         messages: longHistory,
         contextWindowManager: {
+          updateConfig: () => {},
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async () => ({ compacted: false }),
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+        } as unknown as Conversation["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "analyze this", "msg-1", (msg) =>
@@ -1087,6 +1107,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
           isError: false,
         }),
         contextWindowManager: {
+          updateConfig: () => {},
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async (
             _msgs: Message[],
@@ -1118,7 +1139,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
             }
             return { compacted: false };
           },
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+        } as unknown as Conversation["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -1187,6 +1208,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
           isError: false,
         }),
         contextWindowManager: {
+          updateConfig: () => {},
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async () => {
             compactionCalled = true;
@@ -1211,7 +1233,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
               summaryModel: "mock-model",
             };
           },
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+        } as unknown as Conversation["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -1293,6 +1315,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
           isError: false,
         }),
         contextWindowManager: {
+          updateConfig: () => {},
           shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
           maybeCompact: async () => {
             compactionCalled = true;
@@ -1317,7 +1340,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
               summaryModel: "mock-model",
             };
           },
-        } as unknown as AgentLoopConversationContext["contextWindowManager"],
+        } as unknown as Conversation["contextWindowManager"],
       });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => {
@@ -1360,14 +1383,9 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
 
     // Budget = 200_000 * 0.95 = 190_000
     // Mid-loop threshold = 190_000 * 0.85 = 161_500
-    let estimateCallCount = 0;
-    mockEstimateTokens = () => {
-      estimateCallCount++;
-      // Preflight: below budget
-      if (estimateCallCount === 1) return 100_000;
-      // Every checkpoint call: above threshold — always triggers yield
-      return 170_000;
-    };
+    // Every estimate is above the threshold, so the first-call gate compacts
+    // before the first provider call and every checkpoint trips the yield.
+    mockEstimateTokens = 170_000;
 
     // The convergence reducer reduces tokens enough for the rerun to recover.
     let convergenceReducerCalled = false;
@@ -1410,6 +1428,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
       ],
       toolExecutor: async () => ({ content: "output", isError: false }),
       contextWindowManager: {
+        updateConfig: () => {},
         shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
         maybeCompact: async () => {
           compactionCallCount++;
@@ -1441,7 +1460,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
             summaryModel: "mock-model",
           };
         },
-      } as unknown as AgentLoopConversationContext["contextWindowManager"],
+      } as unknown as Conversation["contextWindowManager"],
     });
 
     await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -1480,16 +1499,11 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
 
     // Budget = 200_000 * 0.95 = 190_000
     // Mid-loop threshold = 190_000 * 0.85 = 161_500
-    let estimateCallCount = 0;
-    mockEstimateTokens = () => {
-      estimateCallCount++;
-      // Preflight: below budget.
-      if (estimateCallCount === 1) return 100_000;
-      // Every checkpoint estimate: above threshold — always trips the
-      // yield. Simulates a long turn where each tool call's result
-      // inflates the context past 85% even after a successful compaction.
-      return 170_000;
-    };
+    // Every estimate is above the threshold: the first-call gate compacts
+    // before the first provider call, and each subsequent checkpoint trips
+    // the yield even after a successful compaction (each tool result inflates
+    // the context back past 85%).
+    mockEstimateTokens = 170_000;
 
     // A single tool round reaches one checkpoint; the in-loop budget gate
     // trips there and compaction runs in place. The loop continues the run
@@ -1518,6 +1532,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
       ],
       toolExecutor: async () => ({ content: "output", isError: false }),
       contextWindowManager: {
+        updateConfig: () => {},
         shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
         maybeCompact: async () => {
           compactionCallCount++;
@@ -1542,7 +1557,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
             summaryModel: "mock-model",
           };
         },
-      } as unknown as AgentLoopConversationContext["contextWindowManager"],
+      } as unknown as Conversation["contextWindowManager"],
     });
 
     await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -1633,6 +1648,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
       ],
       toolExecutor: async () => ({ content: "output", isError: false }),
       contextWindowManager: {
+        updateConfig: () => {},
         shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
         // Under the new architecture (Compaction Re-homing Arc, Bullet 1)
         // the retry budget lives inside `ContextWindowManager._maybeCompact`,
@@ -1660,7 +1676,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
           summaryModel: "mock-model",
           exhausted: true,
         }),
-      } as unknown as AgentLoopConversationContext["contextWindowManager"],
+      } as unknown as Conversation["contextWindowManager"],
     });
 
     await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
@@ -1680,124 +1696,6 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
     );
   });
 
-  // ── Test 8 ────────────────────────────────────────────────────────
-  // BUG: The preflight overflow reducer's budget check uses
-  // step.estimatedTokens (computed on bare ctx.messages) without
-  // accounting for tokens added by applyRuntimeInjections(). This
-  // causes the reducer to stop early when the bare estimate is under
-  // budget, even though post-injection tokens exceed it — leading to
-  // a wasted provider round-trip that gets rejected.
-  //
-  // After fix: the budget check re-estimates on runMessages (with
-  // injections) so the reducer continues to the next tier.
-  test("preflight reducer continues when post-injection tokens exceed budget", async () => {
-    const events: ServerMessage[] = [];
-
-    // Injections add an extra message, bumping the token count.
-    const injectionMessage: Message = {
-      role: "user" as const,
-      content: [
-        {
-          type: "text" as const,
-          text: "injected context " + "x".repeat(500),
-        },
-      ],
-    };
-    mockApplyRuntimeInjections = (msgs) => [...msgs, injectionMessage];
-
-    // Budget = 200_000 * 0.95 = 190_000
-    // The estimator returns different values based on whether the
-    // injection message is present:
-    //   - bare history (no injection msg) → 195_000 (triggers preflight)
-    //   - after tier 1 bare → 185_000 (under budget, would stop early without fix)
-    //   - after tier 1 with injection → 195_000 (still over budget)
-    //   - after tier 2 bare → 170_000
-    //   - after tier 2 with injection → 175_000 (under budget, reducer stops)
-    let reducerCallCount = 0;
-    mockEstimateTokens = (msgs?: Message[]) => {
-      const hasInjection = msgs?.some(
-        (m) =>
-          m.role === "user" &&
-          Array.isArray(m.content) &&
-          m.content.some(
-            (b: { type: string; text?: string }) =>
-              b.type === "text" &&
-              typeof b.text === "string" &&
-              b.text.startsWith("injected context"),
-          ),
-      );
-      if (reducerCallCount === 0) {
-        // Before any reduction: preflight check on runMessages (with injection)
-        return 195_000;
-      }
-      if (reducerCallCount === 1) {
-        // After tier 1
-        return hasInjection ? 195_000 : 185_000;
-      }
-      // After tier 2
-      return hasInjection ? 175_000 : 170_000;
-    };
-
-    mockReducerStepFn = (msgs: Message[]) => {
-      reducerCallCount++;
-      const tier =
-        reducerCallCount === 1 ? "forced_compaction" : "tool_result_truncation";
-      return {
-        messages: msgs,
-        tier,
-        state: {
-          appliedTiers:
-            reducerCallCount === 1
-              ? ["forced_compaction"]
-              : ["forced_compaction", "tool_result_truncation"],
-          injectionMode: "full" as const,
-          exhausted: reducerCallCount >= 2,
-        },
-        // Bare-history estimate (what the reducer sees on ctx.messages)
-        estimatedTokens: reducerCallCount === 1 ? 185_000 : 170_000,
-        compactionResult: {
-          compacted: true,
-          messages: msgs,
-          compactedPersistedMessages: 5,
-          summaryText: "Summary",
-          previousEstimatedInputTokens: 195_000,
-          estimatedInputTokens: reducerCallCount === 1 ? 185_000 : 170_000,
-          maxInputTokens: 200_000,
-          thresholdTokens: 160_000,
-          compactedMessages: 10,
-          summaryCalls: 1,
-          summaryInputTokens: 500,
-          summaryOutputTokens: 200,
-          summaryModel: "mock-model",
-        },
-      };
-    };
-
-    // The preflight overflow reducer runs in the orchestrator before the loop,
-    // so a single successful provider turn is enough to drive the path.
-    const ctx = makeCtx({
-      providerResponses: [textResponse("done")],
-      contextWindowManager: {
-        shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
-        maybeCompact: async () => ({ compacted: false }),
-      } as unknown as AgentLoopConversationContext["contextWindowManager"],
-    });
-
-    await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
-
-    // The reducer must be called twice — the first tier's bare estimate
-    // (185k) is under budget (190k), but post-injection tokens (195k)
-    // still exceed it. Without the fix, the reducer would stop after
-    // tier 1 and the provider call would likely fail.
-    expect(reducerCallCount).toBe(2);
-
-    // Should succeed without errors
-    const conversationError = events.find(
-      (e) => e.type === "conversation_error",
-    );
-    expect(conversationError).toBeUndefined();
-  });
-
   // ── Test 9 ────────────────────────────────────────────────────────
   // When the `auto_compress_latest_turn` rerun (the last layer of the
   // overflow-recovery ladder) still yields at the mid-loop checkpoint,
@@ -1823,28 +1721,30 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
       return 170_000;
     };
 
-    // Convergence reducer becomes exhausted on the second tier so the
-    // loop escalates from convergence to the action-resolution block.
+    // The reduction ladder applies a middle tier first, then escalates to its
+    // terminal auto-compress-latest-turn rung and reports exhaustion. The
+    // terminal rung is what produces a `budget_yield_unrecovered` outcome when
+    // its rerun still yields at the mid-loop checkpoint.
     let reducerCallCount = 0;
     mockReducerStepFn = (msgs: Message[]) => {
       reducerCallCount++;
-      const exhausted = reducerCallCount >= 2;
+      const terminal = reducerCallCount >= 2;
       return {
         messages: msgs,
-        tier: exhausted ? "tool_result_truncation" : "forced_compaction",
+        tier: terminal ? "auto_compress_latest_turn" : "forced_compaction",
         state: {
-          appliedTiers: exhausted
-            ? ["forced_compaction", "tool_result_truncation"]
+          appliedTiers: terminal
+            ? ["forced_compaction", "auto_compress_latest_turn"]
             : ["forced_compaction"],
           injectionMode: "full" as const,
-          exhausted,
+          exhausted: terminal,
         },
-        estimatedTokens: exhausted ? 60_000 : 80_000,
+        estimatedTokens: terminal ? 60_000 : 80_000,
       };
     };
 
-    // The overflow policy directs us into auto_compress_latest_turn so the
-    // emergency compaction + final agentLoop.run path executes.
+    // The overflow policy permits the terminal auto-compress-latest-turn rung,
+    // so the ladder runs it as its final step.
     mockOverflowAction = "auto_compress_latest_turn";
 
     // Every provider call returns a tool_use, so each loop run does a tool
@@ -1854,18 +1754,16 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
       toolUseResponse("tu-1", "bash", { command: "ls" }),
     ]);
 
-    // `maybeCompact` is invoked through three distinct call sites:
-    //   1. Start-of-turn compaction (no `force` option) — return a no-op
-    //      so the start-of-turn pass doesn't perturb state. The mock's
-    //      `shouldCompact` already returns `needed: false`, but the
-    //      orchestrator still invokes the compaction pipeline.
-    //   2. Mid-loop after the initial agent-loop yield (`force: true`) —
-    //      must signal `exhausted: true` so the daemon escalates to the
-    //      convergence reducer instead of looping forever.
-    //   3. auto_compress_latest_turn emergency compaction (`force: true`,
-    //      `minKeepRecentUserTurns: 0`) — succeeds and drops tokens below
-    //      threshold; the subsequent rerun yields again and is classified
-    //      as BUDGET_YIELD_UNRECOVERED.
+    // Forced `maybeCompact` is invoked through the loop's own pre-call budget
+    // gate at two call sites (the reduction-ladder rungs are mocked out, so
+    // their summary calls don't reach this manager):
+    //   1. First-call (turn-start) gate (`force: true`) — the loop owns the
+    //      turn-start compaction. It succeeds, but the mocked estimate stays
+    //      above the mid-loop threshold, so the turn proceeds and the mid-loop
+    //      gate still trips on the next iteration.
+    //   2. Mid-loop after the first tool turn (`force: true`) — must signal
+    //      `exhausted: true` so the daemon escalates to the convergence
+    //      reducer instead of looping forever.
     let forcedMaybeCompactCallCount = 0;
     const ctx = makeCtx({
       loopProvider: provider,
@@ -1881,22 +1779,47 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
       ],
       toolExecutor: async () => ({ content: "output", isError: false }),
       contextWindowManager: {
+        updateConfig: () => {},
         shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
         maybeCompact: async (
           _msgs: Message[],
           _signal: AbortSignal,
           opts?: { force?: boolean },
         ) => {
-          // Start-of-turn calls pass no `force` option; route them to a
-          // no-op so only the mid-loop and emergency paths drive the test.
+          // Only forced compactions drive this test; any non-forced probe is
+          // a no-op.
           if (!opts?.force) {
             return { compacted: false };
           }
           forcedMaybeCompactCallCount++;
           if (forcedMaybeCompactCallCount === 1) {
-            // Mid-loop call — under the new architecture (Compaction
-            // Re-homing Arc, Bullet 1) the manager owns its own retry
-            // budget; signal exhaustion to escalate to convergence.
+            // First-call (turn-start) gate: succeeds, but the mocked estimate
+            // stays above the threshold so the turn proceeds to the call and
+            // the mid-loop gate still trips next iteration.
+            return {
+              compacted: true,
+              messages: [
+                {
+                  role: "user" as const,
+                  content: [{ type: "text", text: "turn-start compacted" }],
+                },
+              ] as Message[],
+              compactedPersistedMessages: 5,
+              summaryText: "Turn-start summary",
+              previousEstimatedInputTokens: 170_000,
+              estimatedInputTokens: 165_000,
+              maxInputTokens: 200_000,
+              thresholdTokens: 160_000,
+              compactedMessages: 10,
+              summaryCalls: 1,
+              summaryInputTokens: 500,
+              summaryOutputTokens: 200,
+              summaryModel: "mock-model",
+            };
+          }
+          if (forcedMaybeCompactCallCount === 2) {
+            // Mid-loop call — the manager owns its own retry budget; signal
+            // exhaustion to escalate to convergence.
             return {
               compacted: true,
               messages: [
@@ -1919,7 +1842,8 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
               exhausted: true,
             };
           }
-          // Emergency compaction call from auto_compress_latest_turn.
+          // Defensive fallback for any additional forced probe; the two gate
+          // call sites above are the only ones this test exercises.
           return {
             compacted: true,
             messages: [
@@ -1929,7 +1853,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
               },
             ] as Message[],
             compactedPersistedMessages: 5,
-            summaryText: "Emergency summary",
+            summaryText: "Fallback summary",
             previousEstimatedInputTokens: 170_000,
             estimatedInputTokens: 90_000,
             maxInputTokens: 200_000,
@@ -1941,7 +1865,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
             summaryModel: "mock-model",
           };
         },
-      } as unknown as AgentLoopConversationContext["contextWindowManager"],
+      } as unknown as Conversation["contextWindowManager"],
     });
 
     await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));