@vellumai/assistant 0.8.10 → 0.8.11-staging.1

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

@@ -19,6 +19,7 @@ import type { LLMConfig } from "../config/schemas/llm.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
 import type { Message, Provider, ToolDefinition } from "../providers/types.js";
+import { ContextOverflowError } from "../providers/types.js";
 
 const conversationCrudRealSnapshot = {
   ...(createRequire(import.meta.url)(
@@ -151,42 +152,106 @@ mock.module("../context/token-estimator.js", () => ({
 let mockReducerStepFn:
   | ((msgs: Message[], cfg: unknown, state: unknown) => unknown)
   | null = null;
+const makeInitialReducerState = () => ({
+  appliedTiers: [] as string[],
+  injectionMode: "full" as const,
+  exhausted: false,
+});
+const runMockReducer = 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,
+  };
+};
 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",
+    createInitialReducerState: makeInitialReducerState,
+    reduceContextOverflow: runMockReducer,
+  }),
+);
+
+// Stand-in for `ContextWindowManager`'s turn-scoped overflow ladder. Threads
+// reducer state across a turn's rungs and delegates each rung to the mocked
+// reducer, mirroring `reduceOverflowOneRung` / `resetOverflowRecovery`.
+// `recoverContextOverflow` adapts a rung into the `ContextWindowResult` the
+// agent loop's compaction path consumes, mirroring the real manager's
+// `overflowStepToResult` so the loop sees the rung's reduced history, injection
+// mode, terminal auto-compress flag, and exhaustion.
+function makeOverflowLadderStub(): {
+  resetOverflowRecovery: () => void;
+  reduceOverflowOneRung: (
+    msgs: Message[],
+    opts: unknown,
+    signal?: AbortSignal,
+  ) => Promise<unknown>;
+  recoverContextOverflow: (
+    msgs: Message[],
+    opts: unknown,
+    signal?: AbortSignal,
+  ) => Promise<unknown>;
+} {
+  let state: unknown;
+  const reduceOverflowOneRung = async (msgs: Message[], opts: unknown) => {
+    if (!state) state = makeInitialReducerState();
+    const step = (await runMockReducer(msgs, opts, state)) as {
+      state: unknown;
+    };
+    state = step.state;
+    return step;
+  };
+  return {
+    resetOverflowRecovery: () => {
+      state = undefined;
+    },
+    reduceOverflowOneRung,
+    recoverContextOverflow: async (msgs: Message[], opts: unknown) => {
+      const step = (await reduceOverflowOneRung(msgs, opts)) as {
+        messages: Message[];
+        estimatedTokens?: number;
         state: {
-          appliedTiers: [
-            "forced_compaction",
-            "tool_result_truncation",
-            "media_stubbing",
-            "injection_downgrade",
-          ],
-          injectionMode: "full",
-          exhausted: true,
-        },
-        estimatedTokens: 1000,
+          appliedTiers: string[];
+          injectionMode: string;
+          exhausted: boolean;
+        };
+        compactionResult?: Record<string, unknown>;
+      };
+      const base = step.compactionResult ?? {
+        compacted: false,
+        messages: step.messages,
+      };
+      return {
+        ...base,
+        messages: step.messages,
+        injectionMode: step.state.injectionMode,
+        autoCompressApplied: step.state.appliedTiers.includes(
+          "auto_compress_latest_turn",
+        ),
+        exhausted: step.state.exhausted,
       };
     },
-  }),
-);
+  };
+}
 
 // Policy: default to fail_gracefully
 let mockOverflowAction: string = "fail_gracefully";
-mock.module("../daemon/context-overflow-policy.js", () => ({
+mock.module("../plugins/defaults/compaction/overflow-policy.js", () => ({
   resolveOverflowAction: () => mockOverflowAction,
 }));
 
@@ -315,6 +380,7 @@ mock.module("../plugins/defaults/history-repair/terminal.js", () => ({
     },
   }),
   deepRepairHistory: (msgs: Message[]) => ({ messages: msgs, stats: {} }),
+  isRepairableOrderingError: () => false,
 }));
 
 const recordUsageMock = mock((..._args: unknown[]) => {});
@@ -405,11 +471,13 @@ mock.module("../daemon/conversation-error.js", () => ({
     /context.?length.?exceeded|prompt.?is.?too.?long|too many.*input.*tokens/i.test(
       msg,
     ),
-}));
-
-mock.module("../daemon/conversation-slash.js", () => ({
-  isProviderOrderingError: (msg: string) =>
-    /ordering|before.*after|messages.*order/i.test(msg),
+  budgetYieldUnrecoveredClassification: () => ({
+    code: "BUDGET_YIELD_UNRECOVERED",
+    userMessage:
+      "I tried to compact this conversation but couldn't fit the next step into the model's context window. Send another message to continue.",
+    retryable: true,
+    errorCategory: "budget_yield_unrecovered",
+  }),
 }));
 
 mock.module("../util/truncate.js", () => ({
@@ -427,6 +495,7 @@ mock.module("../memory/llm-request-log-store.js", () => ({
   recordRequestLog: () => {},
   backfillMessageIdOnLogs: () => {},
   setAgentLoopExitReasonOnLatestLog: setAgentLoopExitReasonOnLatestLogMock,
+  recordSyntheticAgentErrorMessageLog: () => {},
 }));
 
 mock.module("../memory/archive-store.js", () => ({
@@ -599,6 +668,16 @@ function makeCtx(
 
     ...ctxOverrides,
   } as unknown as Conversation;
+  // The convergence driver resolves the turn-scoped overflow ladder off the
+  // manager; give every fake manager the ladder methods unless a test supplied
+  // its own.
+  const manager = ctx.contextWindowManager as unknown as Record<
+    string,
+    unknown
+  >;
+  if (typeof manager.reduceOverflowOneRung !== "function") {
+    Object.assign(manager, makeOverflowLadderStub());
+  }
   fakeContextWindowManagers.set(conversationId, ctx.contextWindowManager);
   return ctx;
 }
@@ -807,9 +886,9 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
   );
 
   // ── Test 2 ────────────────────────────────────────────────────────
-  // When estimation says we're within budget but the provider rejects,
-  // the post-run convergence loop should kick in and recover.
-  // This test should PASS against current code (when no progress is made).
+  // When estimation says we're within budget but the provider rejects, the
+  // loop calibrates the estimator from the rejection and drives the reduction
+  // ladder on the next gate pass, recovering before the rerun.
   test("overflow recovery compacts below limit even when estimation underestimates", async () => {
     const events: ServerMessage[] = [];
     let reducerCalled = false;
@@ -819,7 +898,7 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
     // up-front reduction.
     mockEstimateTokens = 185_000;
 
-    // AND the post-run convergence reducer successfully compacts
+    // AND the reduction ladder successfully compacts on its first rung
     mockReducerStepFn = (msgs: Message[]) => {
       reducerCalled = true;
       return {
@@ -852,7 +931,10 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
     // AND a provider that rejects the first call as too long (revealing the
     // real 242k count the estimator missed), then succeeds on the rerun.
     const { provider, calls } = createMockProvider([
-      new Error("prompt is too long: 242201 tokens > 200000 maximum"),
+      new ContextOverflowError("prompt is too long", "mock-provider", {
+        actualTokens: 242_201,
+        maxTokens: 200_000,
+      }),
       textResponse("recovered"),
     ]);
 
@@ -1374,503 +1456,244 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
   );
 
   // ── Test 8 ────────────────────────────────────────────────────────
-  // When mid-loop compaction exhausts maxAttempts but the agent loop
-  // still yields (yieldedForBudget remains true), the incomplete turn
-  // must escalate to the convergence loop instead of being silently
-  // treated as a completed turn.
-  test("exhausted mid-loop compaction attempts escalate to convergence loop", async () => {
+  /**
+   * Reactive recovery escalates the reduction ladder one rung per provider
+   * rejection and ends the turn with `context_too_large` once the ladder is
+   * exhausted and no auto-compress rung ran.
+   */
+  test("ladder escalation ends the turn with context_too_large when exhausted", async () => {
+    // GIVEN an estimate below the mid-loop threshold, so only the provider's
+    // rejection — not the proactive gate — drives recovery
     const events: ServerMessage[] = [];
+    mockEstimateTokens = 100_000;
 
-    // Budget = 200_000 * 0.95 = 190_000
-    // Mid-loop threshold = 190_000 * 0.85 = 161_500
-    // 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;
+    // AND a ladder that reduces on the first rung and reports exhaustion on
+    // the second without ever applying the terminal auto-compress tier
+    let reducerCallCount = 0;
     mockReducerStepFn = (msgs: Message[]) => {
-      convergenceReducerCalled = true;
+      reducerCallCount++;
+      const exhausted = reducerCallCount >= 2;
       return {
         messages: msgs,
-        tier: "forced_compaction",
+        tier: exhausted ? "injection_downgrade" : "forced_compaction",
         state: {
-          appliedTiers: ["forced_compaction"],
+          appliedTiers: exhausted
+            ? [
+                "forced_compaction",
+                "tool_result_truncation",
+                "media_stubbing",
+                "injection_downgrade",
+              ]
+            : ["forced_compaction"],
           injectionMode: "full",
-          exhausted: true,
+          exhausted,
         },
-        estimatedTokens: 80_000,
+        estimatedTokens: exhausted ? 60_000 : 80_000,
       };
     };
 
-    // Every provider call returns a tool_use, so each loop run does a tool
-    // turn that trips the mid-loop budget gate. On the initial run the gate
-    // calls compaction (which surfaces `exhausted: true`); the convergence
-    // rerun runs without a compaction hook and yields "budget" directly.
-    // With the reducer exhausted, the convergence loop terminates with the
-    // turn still over budget and the orchestrator stamps `context_too_large`.
+    // AND a provider that rejects every call with a context-overflow error
     const { provider, calls } = createMockProvider([
-      toolUseResponse("tu-1", "bash", { command: "ls" }),
+      new ContextOverflowError(
+        "context_length_exceeded: 250000 tokens > 200000 maximum",
+        "mock-provider",
+        { actualTokens: 250_000, maxTokens: 200_000 },
+      ),
     ]);
+    const ctx = makeCtx({ loopProvider: provider });
 
-    let compactionCallCount = 0;
-    const ctx = makeCtx({
-      loopProvider: provider,
-      loopTools: [
-        {
-          name: "bash",
-          description: "Run a shell command",
-          input_schema: {
-            type: "object",
-            properties: { command: { type: "string" } },
-          },
-        },
-      ],
-      toolExecutor: async () => ({ content: "output", isError: false }),
-      contextWindowManager: {
-        updateConfig: () => {},
-        shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
-        maybeCompact: async () => {
-          compactionCallCount++;
-          // Compaction's internal retry budget is exhausted — the
-          // compactor itself ran maxAttempts passes and still couldn't
-          // drop below the auto-threshold. `maybeCompact` surfaces this
-          // via `exhausted: true` so the loop yields "budget" and the
-          // orchestrator escalates straight to the convergence loop
-          // instead of looping on a stuck compactor.
-          return {
-            compacted: true,
-            exhausted: true,
-            messages: [
-              {
-                role: "user" as const,
-                content: [{ type: "text", text: "Hello" }],
-              },
-            ] as Message[],
-            compactedPersistedMessages: 5,
-            summaryText: "Compaction summary",
-            previousEstimatedInputTokens: 170_000,
-            estimatedInputTokens: 165_000, // barely reduced
-            maxInputTokens: 200_000,
-            thresholdTokens: 160_000,
-            compactedMessages: 10,
-            summaryCalls: 1,
-            summaryInputTokens: 500,
-            summaryOutputTokens: 200,
-            summaryModel: "mock-model",
-          };
-        },
-      } as unknown as Conversation["contextWindowManager"],
-    });
-
+    // WHEN the turn runs
     await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
-    // 1 initial auto-compact + 1 mid-loop compaction = 2 total. The
-    // first mid-loop call surfaces `exhausted: true`, so the
-    // orchestrator escalates immediately without retrying maybeCompact
-    // — the retry budget for the compactor itself lives inside
-    // `ContextWindowManager.maybeCompact`.
-    expect(compactionCallCount).toBe(2);
-
-    // Provider calls: 1 initial tool turn (yields budget) + 1 convergence
-    // rerun that recovers. No mid-loop re-entries because the orchestrator
-    // broke out on `exhausted` before re-invoking the loop.
-    expect(calls.length).toBe(2);
+    // THEN two ladder rungs ran (one per rejection before exhaustion) and the
+    // exhausted-ladder rejection ended the turn — three provider calls total
+    expect(reducerCallCount).toBe(2);
+    expect(calls.length).toBe(3);
 
-    // After the compactor exhausted itself, the convergence loop
-    // should have been triggered (contextTooLargeDetected set to true)
-    expect(convergenceReducerCalled).toBe(true);
+    // AND the loop emitted the terminal `context_too_large` exit, which the
+    // daemon surfaced as a classified error and stamped onto the request log
     expect(setAgentLoopExitReasonOnLatestLogMock).toHaveBeenCalledWith(
       "test-conv",
       "context_too_large",
     );
+    const errorEvent = events.find((e) => e.type === "conversation_error");
+    expect(errorEvent).toBeDefined();
+    if (errorEvent && "errorCategory" in errorEvent) {
+      expect(errorEvent.errorCategory).toBe("context_too_large");
+    }
   });
 
   // ── Test 8b ───────────────────────────────────────────────────────
-  // Counterpart to Test 8: when a mid-loop `maybeCompact` returns
-  // productive (`compacted: true`, no `exhausted` flag), the loop
-  // compacts in place and continues the run itself — it never yields
-  // "budget", so the orchestrator does not escalate to the convergence
-  // loop. Mid-loop iteration is now wholly internal to `AgentLoop.run`;
-  // the orchestrator only reacts to the binary `exhausted`/timeout
-  // signal carried back as a "budget" exit.
-  test("productive mid-loop compaction continues in place without escalating", async () => {
+  /**
+   * The common case: a single ladder rung reduces enough that the re-issued
+   * provider call succeeds, so the loop continues the turn in place and ends
+   * normally with no terminal overflow exit and no client-facing error.
+   */
+  test("single-rung recovery succeeds and the turn continues in place", async () => {
+    // GIVEN an estimate below the mid-loop threshold
     const events: ServerMessage[] = [];
+    mockEstimateTokens = 100_000;
 
-    // Budget = 200_000 * 0.95 = 190_000
-    // Mid-loop threshold = 190_000 * 0.85 = 161_500
-    // 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
-    // itself — the following provider call returns plain text and the turn
-    // completes — so the orchestrator never re-enters the convergence loop.
+    // AND a ladder rung that reduces without reporting exhaustion
+    let reducerCallCount = 0;
+    mockReducerStepFn = (msgs: Message[]) => {
+      reducerCallCount++;
+      return {
+        messages: msgs,
+        tier: "forced_compaction",
+        state: {
+          appliedTiers: ["forced_compaction"],
+          injectionMode: "full",
+          exhausted: false,
+        },
+        estimatedTokens: 80_000,
+      };
+    };
+
+    // AND a provider that rejects once, then accepts the re-issued call
     const { provider, calls } = createMockProvider([
-      toolUseResponse("tu-1", "bash", { command: "ls" }),
-      textResponse("final answer"),
+      new ContextOverflowError(
+        "context_length_exceeded: 250000 tokens > 200000 maximum",
+        "mock-provider",
+        { actualTokens: 250_000, maxTokens: 200_000 },
+      ),
+      textResponse("recovered answer"),
     ]);
+    const ctx = makeCtx({ loopProvider: provider });
 
-    // Compaction reports `estimatedInputTokens` well below the 161_500
-    // threshold — the "compaction is productive" signal (no `exhausted`
-    // flag) that lets the loop continue in place.
-    let compactionCallCount = 0;
-    const ctx = makeCtx({
-      loopProvider: provider,
-      loopTools: [
-        {
-          name: "bash",
-          description: "Run a shell command",
-          input_schema: {
-            type: "object",
-            properties: { command: { type: "string" } },
-          },
-        },
-      ],
-      toolExecutor: async () => ({ content: "output", isError: false }),
-      contextWindowManager: {
-        updateConfig: () => {},
-        shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
-        maybeCompact: async () => {
-          compactionCallCount++;
-          return {
-            compacted: true,
-            messages: [
-              {
-                role: "user" as const,
-                content: [{ type: "text", text: "Hello" }],
-              },
-            ] as Message[],
-            compactedPersistedMessages: 5,
-            summaryText: "Compaction summary",
-            previousEstimatedInputTokens: 170_000,
-            estimatedInputTokens: 100_000,
-            maxInputTokens: 200_000,
-            thresholdTokens: 160_000,
-            compactedMessages: 10,
-            summaryCalls: 1,
-            summaryInputTokens: 500,
-            summaryOutputTokens: 200,
-            summaryModel: "mock-model",
-          };
-        },
-      } as unknown as Conversation["contextWindowManager"],
-    });
-
+    // WHEN the turn runs
     await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
-    // 1 initial auto-compact + 1 productive mid-loop compaction.
-    expect(compactionCallCount).toBe(2);
-    // The loop continued in place after compacting: a tool turn followed by
-    // the post-compaction text turn, both within a single run.
+    // THEN one rung ran and the retry succeeded — one rejection + one success
+    expect(reducerCallCount).toBe(1);
     expect(calls.length).toBe(2);
 
-    // No escalation to the convergence loop because the mid-loop
-    // `maybeCompact` returned productive (no `exhausted` flag), and the turn
-    // completed normally.
+    // AND the turn recovered in place: no terminal overflow exit, no error
     expect(setAgentLoopExitReasonOnLatestLogMock).not.toHaveBeenCalledWith(
       "test-conv",
       "context_too_large",
     );
+    expect(setAgentLoopExitReasonOnLatestLogMock).not.toHaveBeenCalledWith(
+      "test-conv",
+      "budget_yield_unrecovered",
+    );
     expect(events.find((e) => e.type === "conversation_error")).toBeUndefined();
   });
 
   // ── Test 9 ────────────────────────────────────────────────────────
-  // When the convergence loop reruns the agent loop and it still yields
-  // at checkpoint (yieldedForBudget), the loop must continue reducing
-  // through additional tiers instead of silently dropping the incomplete
-  // turn.
-  test("post-convergence yieldedForBudget continues reduction", async () => {
+  /**
+   * The ladder climbs through several rungs across successive rejections and
+   * recovers once a later rung reduces the prompt enough for the provider to
+   * accept it, completing the turn without a terminal overflow exit.
+   */
+  test("multi-rung escalation recovers when a later rung fits", async () => {
+    // GIVEN an estimate below the mid-loop threshold
     const events: ServerMessage[] = [];
+    mockEstimateTokens = 100_000;
 
-    // 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 provider call returns a tool_use, so each loop run does a tool
-    // turn that trips the mid-loop budget gate and yields "budget". The
-    // initial run's gate calls compaction (exhausted); the convergence
-    // reruns run without a compaction hook and yield directly.
-    const { provider, calls } = createMockProvider([
-      toolUseResponse("tu-1", "bash", { command: "ls" }),
-    ]);
-
-    // Convergence reducer: first call returns non-exhausted, second returns exhausted
+    // AND a ladder that reduces further on each successive rung
     let reducerCallCount = 0;
     mockReducerStepFn = (msgs: Message[]) => {
       reducerCallCount++;
-      if (reducerCallCount === 1) {
-        return {
-          messages: msgs,
-          tier: "forced_compaction",
-          state: {
-            appliedTiers: ["forced_compaction"],
-            injectionMode: "full",
-            exhausted: false,
-          },
-          estimatedTokens: 80_000,
-        };
-      }
-      // Second call: exhausted
+      const tier =
+        reducerCallCount === 1 ? "forced_compaction" : "tool_result_truncation";
       return {
         messages: msgs,
-        tier: "tool_result_truncation",
+        tier,
         state: {
-          appliedTiers: ["forced_compaction", "tool_result_truncation"],
+          appliedTiers:
+            reducerCallCount === 1
+              ? ["forced_compaction"]
+              : ["forced_compaction", "tool_result_truncation"],
           injectionMode: "full",
-          exhausted: true,
+          exhausted: false,
         },
-        estimatedTokens: 60_000,
+        estimatedTokens: reducerCallCount === 1 ? 80_000 : 60_000,
       };
     };
 
-    const ctx = makeCtx({
-      loopProvider: provider,
-      loopTools: [
-        {
-          name: "bash",
-          description: "Run a shell command",
-          input_schema: {
-            type: "object",
-            properties: { command: { type: "string" } },
-          },
-        },
-      ],
-      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`,
-        // so a single daemon-level call represents the full manager retry
-        // sequence. Signal `exhausted: true` immediately to escalate the
-        // mid-loop to the convergence reducer.
-        maybeCompact: async () => ({
-          compacted: true,
-          messages: [
-            {
-              role: "user" as const,
-              content: [{ type: "text", text: "Hello" }],
-            },
-          ] as Message[],
-          compactedPersistedMessages: 5,
-          summaryText: "Compaction summary",
-          previousEstimatedInputTokens: 170_000,
-          estimatedInputTokens: 165_000,
-          maxInputTokens: 200_000,
-          thresholdTokens: 160_000,
-          compactedMessages: 10,
-          summaryCalls: 1,
-          summaryInputTokens: 500,
-          summaryOutputTokens: 200,
-          summaryModel: "mock-model",
-          exhausted: true,
-        }),
-      } as unknown as Conversation["contextWindowManager"],
-    });
+    // AND a provider that rejects twice, then accepts the third call
+    const { provider, calls } = createMockProvider([
+      new ContextOverflowError(
+        "context_length_exceeded: 250000 tokens > 200000 maximum",
+        "mock-provider",
+        { actualTokens: 250_000, maxTokens: 200_000 },
+      ),
+      new ContextOverflowError(
+        "context_length_exceeded: 230000 tokens > 200000 maximum",
+        "mock-provider",
+        { actualTokens: 230_000, maxTokens: 200_000 },
+      ),
+      textResponse("recovered answer"),
+    ]);
+    const ctx = makeCtx({ loopProvider: provider });
 
+    // WHEN the turn runs
     await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
-    // Reducer should have been called twice: once for first convergence tier,
-    // once more after yieldedForBudget triggered re-entry
+    // THEN two rungs ran across two rejections and the third call recovered
     expect(reducerCallCount).toBe(2);
-
-    // Provider calls: 1 initial run + 2 convergence reruns = 3 calls, each a
-    // tool turn that yields "budget". The mid-loop no longer drives
-    // daemon-level retries — the manager owns its retry budget and signals
-    // exhaustion via the `exhausted` flag.
     expect(calls.length).toBe(3);
-    expect(setAgentLoopExitReasonOnLatestLogMock).toHaveBeenCalledWith(
+
+    // AND no terminal overflow exit or error was surfaced
+    expect(setAgentLoopExitReasonOnLatestLogMock).not.toHaveBeenCalledWith(
       "test-conv",
       "context_too_large",
     );
+    expect(events.find((e) => e.type === "conversation_error")).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,
-  // the turn cannot proceed. Before PR 1 of the Compaction Visibility
-  // workstream this terminated silently — no `agent_loop_exit_reason`,
-  // no client notice, no durable transcript row. Now the loop must:
-  //   1. emit a `conversation_error` event with code
-  //      `BUDGET_YIELD_UNRECOVERED`,
-  //   2. persist a `role="assistant"` notice via the persistence
-  //      pipeline (so reloads keep the message),
-  //   3. stamp `budget_yield_unrecovered` onto the latest llm_request_logs
-  //      row.
+  // ── Test 10 ───────────────────────────────────────────────────────
+  /**
+   * When the ladder applies its terminal `auto_compress_latest_turn` rung,
+   * reports exhaustion, and the provider still rejects, the loop ends the turn
+   * with `budget_yield_unrecovered`. The daemon then emits a classified
+   * `BUDGET_YIELD_UNRECOVERED` error, persists a durable assistant notice, and
+   * stamps the exit reason onto the latest llm_request_logs row.
+   */
   test("budget_yield_unrecovered: classified error emitted, persisted, and stamped", async () => {
+    // GIVEN an estimate below the mid-loop threshold
     const events: ServerMessage[] = [];
+    mockEstimateTokens = 100_000;
 
-    // Every estimate after the very first preflight is above the mid-loop
-    // threshold (190_000 × 0.85 = 161_500). This makes every checkpoint
-    // yield, including the one inside the auto_compress rerun.
-    let estimateCallCount = 0;
-    mockEstimateTokens = () => {
-      estimateCallCount++;
-      if (estimateCallCount === 1) return 100_000;
-      return 170_000;
-    };
-
-    // Convergence reducer becomes exhausted on the second tier so the
-    // loop escalates from convergence to the action-resolution block.
+    // AND a ladder whose terminal rung applies `auto_compress_latest_turn` and
+    // reports exhaustion — the signal that distinguishes
+    // `budget_yield_unrecovered` from `context_too_large`
     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.
+    // AND an overflow policy that permits the terminal auto-compress rung
     mockOverflowAction = "auto_compress_latest_turn";
 
-    // Every provider call returns a tool_use, so each loop run does a tool
-    // turn that trips the mid-loop budget gate and yields "budget" —
-    // including the final auto_compress rerun.
+    // AND a provider that rejects every call with a context-overflow error
     const { provider } = createMockProvider([
-      toolUseResponse("tu-1", "bash", { command: "ls" }),
+      new ContextOverflowError(
+        "context_length_exceeded: 250000 tokens > 200000 maximum",
+        "mock-provider",
+        { actualTokens: 250_000, maxTokens: 200_000 },
+      ),
     ]);
+    const ctx = makeCtx({ loopProvider: provider });
 
-    // Every forced `maybeCompact` is invoked through three distinct call
-    // sites, all owned by the loop's pre-call budget gate / recovery ladder:
-    //   1. First-call (turn-start) gate (`force: true`) — the loop now 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.
-    //   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.
-    let forcedMaybeCompactCallCount = 0;
-    const ctx = makeCtx({
-      loopProvider: provider,
-      loopTools: [
-        {
-          name: "bash",
-          description: "Run a shell command",
-          input_schema: {
-            type: "object",
-            properties: { command: { type: "string" } },
-          },
-        },
-      ],
-      toolExecutor: async () => ({ content: "output", isError: false }),
-      contextWindowManager: {
-        updateConfig: () => {},
-        shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
-        maybeCompact: async (
-          _msgs: Message[],
-          _signal: AbortSignal,
-          opts?: { force?: boolean },
-        ) => {
-          // Only forced compactions drive this test; any non-forced probe is
-          // a no-op.
-          if (!opts?.force) {
-            return { compacted: false };
-          }
-          forcedMaybeCompactCallCount++;
-          if (forcedMaybeCompactCallCount === 1) {
-            // 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: [
-                {
-                  role: "user" as const,
-                  content: [{ type: "text", text: "mid-loop compacted" }],
-                },
-              ] as Message[],
-              compactedPersistedMessages: 5,
-              summaryText: "Mid-loop summary",
-              previousEstimatedInputTokens: 170_000,
-              estimatedInputTokens: 165_000,
-              maxInputTokens: 200_000,
-              thresholdTokens: 160_000,
-              compactedMessages: 10,
-              summaryCalls: 1,
-              summaryInputTokens: 500,
-              summaryOutputTokens: 200,
-              summaryModel: "mock-model",
-              exhausted: true,
-            };
-          }
-          // Emergency compaction call from auto_compress_latest_turn.
-          return {
-            compacted: true,
-            messages: [
-              {
-                role: "user" as const,
-                content: [{ type: "text", text: "compacted" }],
-              },
-            ] as Message[],
-            compactedPersistedMessages: 5,
-            summaryText: "Emergency summary",
-            previousEstimatedInputTokens: 170_000,
-            estimatedInputTokens: 90_000,
-            maxInputTokens: 200_000,
-            thresholdTokens: 160_000,
-            compactedMessages: 10,
-            summaryCalls: 1,
-            summaryInputTokens: 500,
-            summaryOutputTokens: 200,
-            summaryModel: "mock-model",
-          };
-        },
-      } as unknown as Conversation["contextWindowManager"],
-    });
-
+    // WHEN the turn runs
     await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
-    // The classified error is emitted to the client.
+    // THEN the classified error is emitted to the client
     const errorEvents = events.filter((e) => e.type === "conversation_error");
     expect(errorEvents).toHaveLength(1);
     const errorEvent = errorEvents[0];
@@ -1882,17 +1705,23 @@ describe("session-agent-loop overflow recovery (JARVIS-110)", () => {
       throw new Error("conversation_error event missing `code` field");
     }
 
-    // The exit reason is stamped onto the latest llm_request_logs row.
+    // AND the exit reason is stamped onto the latest llm_request_logs row
     expect(setAgentLoopExitReasonOnLatestLogMock).toHaveBeenCalledWith(
       "test-conv",
       "budget_yield_unrecovered",
     );
-
-    // A `role="assistant"` notice is persisted via the persistence pipeline.
-    // The default persistence terminal calls
-    // `addMessage(conversationId, role, content, metadata, addOptions)` —
-    // we look for the call whose role positional arg is "assistant" and
-    // whose content positional arg mentions compaction.
+    // AND it is stamped exactly once. The loop emits the terminal exit inline
+    // as it breaks, then the wrapper records the synthetic yield row and stamps
+    // again; both reaching the stamp would double-stamp two real rows. The
+    // loop's inline emit must be suppressed so only the wrapper's post-row
+    // stamp lands.
+    expect(setAgentLoopExitReasonOnLatestLogMock).toHaveBeenCalledTimes(1);
+
+    // AND a `role="assistant"` notice is persisted via the persistence
+    // pipeline. The default persistence terminal calls
+    // `addMessage(conversationId, role, content, metadata, addOptions)`, so we
+    // look for the call whose role positional arg is "assistant" and whose
+    // content positional arg mentions compaction.
     const assistantPersistCall = addMessageMock.mock.calls.find((call) => {
       const role = call[1];
       const content = call[2];