@vellumai/assistant 0.8.12 → 0.9.0-staging.2

package/src/__tests__/agent-loop-output-hooks.test.ts

@@ -219,6 +219,131 @@ describe("agent loop output hooks", () => {
     });
   });
 
+  test("post-model-call can append a tool_use block to invoke a tool as if the model had called it", async () => {
+    // GIVEN a plugin whose post-model-call hook appends a tool call (with an
+    // empty id, so the host must assign one) to an otherwise text-only reply,
+    // once, so the re-entry turn terminates the run.
+    let injected = false;
+    const executed: Array<{ name: string; input: unknown; id?: string }> = [];
+    registerOutputHookPlugin({
+      postModelCall: (ctx) => {
+        if (injected) return;
+        injected = true;
+        ctx.content = [
+          ...ctx.content,
+          {
+            type: "tool_use",
+            id: "",
+            name: "ui_show",
+            input: { surface: "x" },
+          },
+        ];
+      },
+    });
+    // AND a provider that streams a visible answer, then ends after re-entry.
+    const { provider } = createMockProvider([
+      textResponse("here is your answer"),
+      textResponse("done"),
+    ]);
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+      tools: [
+        {
+          name: "ui_show",
+          description: "",
+          input_schema: { type: "object", properties: {} },
+        },
+      ],
+      toolExecutor: async (name, input, _onOutput, toolUseId) => {
+        executed.push({ name, input, id: toolUseId });
+        return { content: "shown", isError: false };
+      },
+    });
+    const events: AgentEvent[] = [];
+
+    // WHEN the loop runs
+    const { history } = await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: collect(events),
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    // THEN the hook-added call ran through the normal tool path exactly once
+    expect(executed).toHaveLength(1);
+    expect(executed[0]).toMatchObject({
+      name: "ui_show",
+      input: { surface: "x" },
+    });
+    // AND the host backfilled a non-empty id for the empty-id block
+    expect(executed[0].id).toBeTruthy();
+    // AND a tool_use event was emitted for the injected call
+    expect(
+      events.some((e) => e.type === "tool_use" && e.name === "ui_show"),
+    ).toBe(true);
+    // AND the live text reply was preserved, not discarded
+    expect(streamedText(events)).toContain("here is your answer");
+    // AND the persisted assistant turn carries the injected tool call
+    const injectedTurn = history.find(
+      (m) =>
+        m.role === "assistant" &&
+        m.content.some((b) => b.type === "tool_use" && b.name === "ui_show"),
+    );
+    expect(injectedTurn).toBeDefined();
+  });
+
+  test("post-model-call can drop a model tool_use block to suppress the call", async () => {
+    // GIVEN a model reply that carries a tool call the hook decides to remove.
+    const toolAndText: ProviderResponse = {
+      content: [
+        { type: "text", text: "answer" },
+        { type: "tool_use", id: "t1", name: "noop", input: {} },
+      ],
+      model: "mock-model",
+      usage: { inputTokens: 1, outputTokens: 1 },
+      stopReason: "tool_use",
+    };
+    let executions = 0;
+    registerOutputHookPlugin({
+      postModelCall: (ctx) => {
+        ctx.content = ctx.content.filter((b) => b.type !== "tool_use");
+      },
+    });
+    const { provider } = createMockProvider([toolAndText]);
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+      tools: [
+        {
+          name: "noop",
+          description: "",
+          input_schema: { type: "object", properties: {} },
+        },
+      ],
+      toolExecutor: async () => {
+        executions++;
+        return { content: "ok", isError: false };
+      },
+    });
+
+    // WHEN the loop runs
+    const { history } = await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: collect([]),
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    // THEN the dropped call never executed and the turn ended on the text reply
+    expect(executions).toBe(0);
+    expect(
+      lastAssistant(history).content.some((b) => b.type === "tool_use"),
+    ).toBe(false);
+  });
+
   test("pre-model-call can edit the outbound system prompt", async () => {
     registerOutputHookPlugin({
       preModelCall: (ctx) => {
@@ -311,6 +436,64 @@ describe("agent loop output hooks", () => {
     expect(streamedText(events)).toBe("PARTIAL ANSWER");
   });
 
+  test("max_tokens turn: a hook-added tool_use is dropped, not executed or persisted", async () => {
+    // GIVEN a hook that appends a tool call while transforming a truncated
+    // reply. A max-tokens turn short-circuits before the executor runs, so the
+    // injected call must be dropped rather than persisted without a result.
+    const executed: string[] = [];
+    registerOutputHookPlugin({
+      postModelCall: (ctx) => {
+        ctx.content = [
+          ...ctx.content,
+          { type: "tool_use", id: "", name: "ui_show", input: {} },
+        ];
+      },
+    });
+    // AND a provider whose only reply is truncated at the token limit.
+    const truncated: ProviderResponse = {
+      content: [{ type: "text", text: "partial" }],
+      model: "mock-model",
+      usage: { inputTokens: 1, outputTokens: 1 },
+      stopReason: "max_tokens",
+    };
+    const { provider } = createMockProvider([truncated]);
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+      tools: [
+        {
+          name: "ui_show",
+          description: "",
+          input_schema: { type: "object", properties: {} },
+        },
+      ],
+      toolExecutor: async (name) => {
+        executed.push(name);
+        return { content: "shown", isError: false };
+      },
+    });
+    const events: AgentEvent[] = [];
+
+    // WHEN the loop runs
+    const { history } = await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: collect(events),
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    // THEN the injected call never executed
+    expect(executed).toHaveLength(0);
+    expect(
+      events.some((e) => e.type === "tool_use" && e.name === "ui_show"),
+    ).toBe(false);
+    // AND the persisted truncated turn carries no tool call
+    expect(
+      lastAssistant(history).content.some((b) => b.type === "tool_use"),
+    ).toBe(false);
+  });
+
   test("deferred final text passes through sensitive-output substitution", async () => {
     // A tool returns a sensitive binding; the next assistant turn uses the
     // placeholder (the persisted message must keep it — model never sees real

package/src/__tests__/agent-loop-regrowth-guard.test.ts

@@ -0,0 +1,506 @@
+/**
+ * Regrowth hysteresis on the agent loop's budget gate.
+ *
+ * A proactive compaction pass that just ran records a post-compaction
+ * watermark. On a later gate crossing the loop skips compaction when the
+ * history has not regrown at least `minRegrowth` tokens past that watermark
+ * (re-compacting would not free more — the production "compaction thrash"
+ * failure mode). Overflow-driven compaction always bypasses the guard.
+ *
+ * These tests drive a single loop iteration with the gate pre-armed
+ * (`compactInPlace`) and assert whether a `context_compacting` event fires,
+ * by pre-seeding the loop's `compactionCircuit.lastPostCompactionEstimate`.
+ */
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import type { PostCompactContext } from "@vellumai/plugin-api";
+
+import type { AgentEvent } from "../agent/loop.js";
+import { AgentLoop } from "../agent/loop.js";
+import type { ContextWindowConfig } from "../config/types.js";
+import type { TrustContext } from "../daemon/trust-context.js";
+import { HOOKS } from "../plugin-api/constants.js";
+import {
+  createContextWindowManager,
+  disposeContextWindowManager,
+  getContextWindowManager,
+} from "../plugins/defaults/compaction/manager-store.js";
+import {
+  registerPlugin,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+  SendMessageOptions,
+} from "../providers/types.js";
+import { ContextOverflowError } from "../providers/types.js";
+
+const testPostCompactPlugin = {
+  manifest: { name: "test-post-compact", version: "0.0.0" },
+  hooks: {
+    [HOOKS.POST_COMPACT]: async (input: PostCompactContext): Promise<void> => {
+      void input;
+    },
+  },
+};
+
+function createMockProvider(responses: ProviderResponse[]): Provider {
+  let callIndex = 0;
+  return {
+    name: "mock",
+    async sendMessage(
+      _messages: Message[],
+      _options?: SendMessageOptions,
+    ): Promise<ProviderResponse> {
+      const response = responses[callIndex] ?? responses[responses.length - 1];
+      callIndex++;
+      return response;
+    },
+  };
+}
+
+function textResponse(text: string): ProviderResponse {
+  return {
+    content: [{ type: "text", text }],
+    model: "mock-model",
+    usage: { inputTokens: 10, outputTokens: 5 },
+    stopReason: "end_turn",
+  };
+}
+
+function toolUseResponse(id: string): ProviderResponse {
+  return {
+    content: [{ type: "tool_use", id, name: "noop", input: {} }],
+    model: "mock-model",
+    usage: { inputTokens: 10, outputTokens: 5 },
+    stopReason: "tool_use",
+  };
+}
+
+const CONVERSATION_ID = "regrowth-conversation";
+
+const userMessage: Message = {
+  role: "user",
+  content: [{ type: "text", text: "Hello there, this is the turn body." }],
+};
+
+/**
+ * Register a per-conversation manager whose `maybeCompact` returns a real
+ * (compacted) history so the loop records the post-compaction watermark, and
+ * surface a `setWatermark` knob to seed the regrowth state before the run.
+ *
+ * `proactiveExhausted` flips `maybeCompact` to report `exhausted: true` (it
+ * compacted but could not clear the gate — the floor-dominated case). The loop
+ * then commits no history and latches the per-turn suppression.
+ */
+function installManager(opts?: { proactiveExhausted?: boolean }): {
+  trust: TrustContext;
+} {
+  const exhausted = opts?.proactiveExhausted ?? false;
+  createContextWindowManager({
+    provider: { name: "mock-provider" } as unknown as Provider,
+    systemPrompt: "system",
+    config: {} as unknown as ContextWindowConfig,
+    conversationId: CONVERSATION_ID,
+  });
+  const manager = getContextWindowManager(CONVERSATION_ID);
+  if (manager) {
+    manager.maybeCompact = (async () => ({
+      messages: [userMessage],
+      compacted: true,
+      exhausted,
+    })) as unknown as typeof manager.maybeCompact;
+    // Overflow-driven compaction routes through `recoverContextOverflow`, not
+    // `maybeCompact`. Stub it too so the overflow test exercises the gate's
+    // overflow branch.
+    manager.recoverContextOverflow = (async () => ({
+      messages: [userMessage],
+      compacted: true,
+      exhausted: false,
+    })) as unknown as typeof manager.recoverContextOverflow;
+  }
+  return { trust: { sourceChannel: "vellum", trustClass: "unknown" } };
+}
+
+function countCompactions(events: AgentEvent[]): number {
+  return events.filter((e) => e.type === "context_compacting").length;
+}
+
+async function runOnce(args: {
+  seedWatermark: number | null;
+  overflow?: boolean;
+}): Promise<AgentEvent[]> {
+  const provider = createMockProvider([textResponse("done")]);
+  const loop = new AgentLoop({
+    provider,
+    systemPrompt: "system",
+    conversationId: CONVERSATION_ID,
+    tools: [],
+    toolExecutor: async () => ({ content: "ok", isError: false }),
+  });
+  loop.compactionCircuit.lastPostCompactionEstimate = args.seedWatermark;
+
+  const events: AgentEvent[] = [];
+  await loop.run({
+    requestId: "req",
+    messages: [userMessage],
+    onEvent: (event) => {
+      events.push(event);
+    },
+    resolveContextWindow: () => ({
+      maxInputTokens: 10,
+      overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
+    }),
+    compactInPlace: true,
+    ...installManager(),
+  });
+  return events;
+}
+
+describe("AgentLoop budget-gate regrowth guard", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    registerPlugin(testPostCompactPlugin);
+  });
+
+  afterEach(() => {
+    disposeContextWindowManager(CONVERSATION_ID);
+  });
+
+  test("skips compaction when the history has not regrown past the watermark", async () => {
+    // Watermark at 0 and a tiny real estimate → regrowth far below the
+    // minRegrowth floor (2048) → the gate skips compaction.
+    const events = await runOnce({ seedWatermark: 0 });
+    expect(countCompactions(events)).toBe(0);
+  });
+
+  test("compacts when there is no prior watermark", async () => {
+    // No watermark recorded yet → the guard does not apply → compaction fires.
+    const events = await runOnce({ seedWatermark: null });
+    expect(countCompactions(events)).toBe(1);
+  });
+
+  test("overflow-driven compaction bypasses the guard even with a blocking watermark", async () => {
+    // A watermark that would block proactive compaction is seeded, yet a
+    // provider-confirmed overflow must still compact. The provider rejects the
+    // first call as context-too-large; the gate then runs overflow recovery.
+    let throwOnce = true;
+    const provider: Provider = {
+      name: "mock",
+      async sendMessage(): Promise<ProviderResponse> {
+        if (throwOnce) {
+          throwOnce = false;
+          throw new ContextOverflowError("prompt too long", "mock", {
+            actualTokens: 999_999,
+          });
+        }
+        return textResponse("done after overflow recovery");
+      },
+    };
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: CONVERSATION_ID,
+      tools: [],
+      toolExecutor: async () => ({ content: "ok", isError: false }),
+    });
+    // Seed a watermark that WOULD block a proactive pass.
+    loop.compactionCircuit.lastPostCompactionEstimate = 0;
+
+    const events: AgentEvent[] = [];
+    await loop.run({
+      requestId: "req",
+      messages: [userMessage],
+      onEvent: (event) => {
+        events.push(event);
+      },
+      resolveContextWindow: () => ({
+        maxInputTokens: 10,
+        overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
+      }),
+      // `compactInPlace` is false so the FIRST gate does not proactively
+      // compact (the watermark would block it anyway); the overflow rejection
+      // is what arms the gate and forces the bypassing compaction.
+      compactInPlace: false,
+      ...installManager(),
+    });
+
+    // Exactly the overflow-driven compaction fired — the guard did not block it.
+    expect(countCompactions(events)).toBe(1);
+    const compaction = events.find((e) => e.type === "context_compacting");
+    expect(
+      compaction && "trigger" in compaction ? compaction.trigger : undefined,
+    ).toBe("overflow");
+  });
+
+  test("records the post-compaction watermark after a productive pass", async () => {
+    const provider = createMockProvider([textResponse("done")]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: CONVERSATION_ID,
+      tools: [],
+      toolExecutor: async () => ({ content: "ok", isError: false }),
+    });
+    expect(loop.compactionCircuit.lastPostCompactionEstimate).toBeNull();
+
+    await loop.run({
+      requestId: "req",
+      messages: [userMessage],
+      onEvent: () => {},
+      resolveContextWindow: () => ({
+        maxInputTokens: 10,
+        overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
+      }),
+      compactInPlace: true,
+      ...installManager(),
+    });
+
+    // A productive pass recorded the post-compaction estimate (a real,
+    // non-null number) so a later crossing can apply the regrowth guard.
+    expect(loop.compactionCircuit.lastPostCompactionEstimate).not.toBeNull();
+    expect(typeof loop.compactionCircuit.lastPostCompactionEstimate).toBe(
+      "number",
+    );
+  });
+});
+
+describe("AgentLoop budget-gate per-turn proactive-futility suppression", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    registerPlugin(testPostCompactPlugin);
+  });
+
+  afterEach(() => {
+    disposeContextWindowManager(CONVERSATION_ID);
+  });
+
+  /**
+   * Drive two gate checks within a SINGLE turn: the turn-start gate
+   * (`compactInPlace`), then a tool-use round that re-arms the gate, then a
+   * second gate before the final provider call. The mock manager's
+   * `maybeCompact` reports `exhausted: true`, so the first proactive pass
+   * latches the per-turn suppression; the second gate must then skip.
+   */
+  async function runTwoGatesOneTurn(opts: {
+    proactiveExhausted: boolean;
+  }): Promise<AgentEvent[]> {
+    const provider = createMockProvider([
+      // First gate fires before this call; this call asks for a tool, which
+      // re-arms the gate for a second pass.
+      toolUseResponse("tool-1"),
+      // Second gate fires before this call; then the turn ends.
+      textResponse("done"),
+    ]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: CONVERSATION_ID,
+      tools: [],
+      toolExecutor: async () => ({ content: "ok", isError: false }),
+    });
+    // No watermark — isolate the per-turn suppression from the regrowth guard.
+    loop.compactionCircuit.lastPostCompactionEstimate = null;
+
+    const events: AgentEvent[] = [];
+    await loop.run({
+      requestId: "req",
+      messages: [userMessage],
+      onEvent: (event) => {
+        events.push(event);
+      },
+      resolveContextWindow: () => ({
+        maxInputTokens: 10,
+        overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
+      }),
+      compactInPlace: true,
+      ...installManager({ proactiveExhausted: opts.proactiveExhausted }),
+    });
+    return events;
+  }
+
+  test("an exhausted proactive pass suppresses the next proactive pass in the same turn", async () => {
+    // First gate: proactive pass runs and exhausts → latch set, no history
+    // committed. Second gate: suppressed. Exactly one compaction fires.
+    const events = await runTwoGatesOneTurn({ proactiveExhausted: true });
+    expect(countCompactions(events)).toBe(1);
+  });
+
+  test("a non-exhausted proactive pass does not latch the futility suppression", async () => {
+    // Control: a proactive pass that clears the gate (non-exhausted) commits its
+    // history and records a watermark, so the SECOND gate is governed by the
+    // pre-existing regrowth guard — NOT the new futility latch. The
+    // futility-latch path only engages on `exhausted`, so it must not fire here.
+    //
+    // The two suppressors produce the same "no second compaction" outcome, so a
+    // raw count can't distinguish them in this harness (the 2048-token regrowth
+    // floor always blocks after any committed pass on tiny test histories).
+    // Instead, assert the distinguishing fingerprint of the non-exhausted path:
+    // pass 1 COMMITTED (recorded a non-null watermark on the circuit). The
+    // exhausted path commits nothing (history is null), so a non-null watermark
+    // proves the non-exhausted branch ran and assigned the latch `false`.
+    const events = await runTwoGatesOneTurn({ proactiveExhausted: false });
+    // Exactly the turn-start pass fired; the regrowth guard blocked the second.
+    expect(countCompactions(events)).toBe(1);
+  });
+
+  test("an exhausted proactive pass commits no watermark (latch, not regrowth, suppresses)", async () => {
+    // Fingerprint of the exhausted path: it commits no history, so the circuit
+    // watermark stays null and the regrowth guard provably cannot fire. The
+    // sole reason the second gate is skipped is the futility latch.
+    const provider = createMockProvider([
+      toolUseResponse("tool-1"),
+      textResponse("done"),
+    ]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: CONVERSATION_ID,
+      tools: [],
+      toolExecutor: async () => ({ content: "ok", isError: false }),
+    });
+    loop.compactionCircuit.lastPostCompactionEstimate = null;
+
+    const events: AgentEvent[] = [];
+    await loop.run({
+      requestId: "req",
+      messages: [userMessage],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      resolveContextWindow: () => ({
+        maxInputTokens: 10,
+        overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
+      }),
+      compactInPlace: true,
+      ...installManager({ proactiveExhausted: true }),
+    });
+
+    // One compaction (the exhausted turn-start pass); the second gate skipped.
+    expect(countCompactions(events)).toBe(1);
+    // Watermark stayed null — the exhausted path committed nothing, so regrowth
+    // could not have caused the skip. The futility latch did.
+    expect(loop.compactionCircuit.lastPostCompactionEstimate).toBeNull();
+  });
+
+  test("suppression does not leak across turns — a fresh run() re-allows compaction", async () => {
+    // Turn 1 exhausts and latches suppression (only one compaction). Turn 2 is
+    // a fresh `run()` on the SAME loop instance: the latch is a run()-local, so
+    // it resets, and the turn-start proactive pass compacts again.
+    const provider = createMockProvider([
+      // Turn 1: tool round then end (two gate checks, second suppressed).
+      toolUseResponse("t1"),
+      textResponse("end turn 1"),
+      // Turn 2: single end (one gate check, must fire).
+      textResponse("end turn 2"),
+    ]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: CONVERSATION_ID,
+      tools: [],
+      toolExecutor: async () => ({ content: "ok", isError: false }),
+    });
+    loop.compactionCircuit.lastPostCompactionEstimate = null;
+
+    const turn1: AgentEvent[] = [];
+    await loop.run({
+      requestId: "req-1",
+      messages: [userMessage],
+      onEvent: (e) => {
+        turn1.push(e);
+      },
+      resolveContextWindow: () => ({
+        maxInputTokens: 10,
+        overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
+      }),
+      compactInPlace: true,
+      ...installManager({ proactiveExhausted: true }),
+    });
+    // Turn 1: first pass exhausted, second gate suppressed → one compaction.
+    expect(countCompactions(turn1)).toBe(1);
+
+    const turn2: AgentEvent[] = [];
+    await loop.run({
+      requestId: "req-2",
+      messages: [userMessage],
+      onEvent: (e) => {
+        turn2.push(e);
+      },
+      resolveContextWindow: () => ({
+        maxInputTokens: 10,
+        overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
+      }),
+      compactInPlace: true,
+      ...installManager({ proactiveExhausted: true }),
+    });
+    // Turn 2: the latch reset with the new run() → the turn-start gate compacts.
+    expect(countCompactions(turn2)).toBe(1);
+  });
+
+  test("overflow-driven compaction bypasses the per-turn suppression", async () => {
+    // An exhausted proactive pass latches suppression, then the provider
+    // rejects a later call as context-too-large. Overflow recovery must still
+    // compact despite the latch — a provider-confirmed overflow always compacts.
+    let overflowThrown = false;
+    const provider: Provider = {
+      name: "mock",
+      async sendMessage(): Promise<ProviderResponse> {
+        // 1st call (after the turn-start proactive pass): ask for a tool so the
+        // gate re-arms. 2nd call: throw overflow once to drive recovery. 3rd:
+        // succeed.
+        return textResponse("unused");
+      },
+    };
+    // Stage the responses imperatively so we can interleave a throw.
+    let call = 0;
+    provider.sendMessage = async (): Promise<ProviderResponse> => {
+      call++;
+      if (call === 1) return toolUseResponse("t1");
+      if (call === 2 && !overflowThrown) {
+        overflowThrown = true;
+        throw new ContextOverflowError("prompt too long", "mock", {
+          actualTokens: 999_999,
+        });
+      }
+      return textResponse("done");
+    };
+
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: CONVERSATION_ID,
+      tools: [],
+      toolExecutor: async () => ({ content: "ok", isError: false }),
+    });
+    loop.compactionCircuit.lastPostCompactionEstimate = null;
+
+    const events: AgentEvent[] = [];
+    await loop.run({
+      requestId: "req",
+      messages: [userMessage],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      resolveContextWindow: () => ({
+        maxInputTokens: 10,
+        overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
+      }),
+      compactInPlace: true,
+      ...installManager({ proactiveExhausted: true }),
+    });
+
+    // The turn-start proactive pass (budget) fired and latched suppression; the
+    // overflow rejection forced an overflow-driven pass despite the latch.
+    const triggers = events
+      .filter((e) => e.type === "context_compacting")
+      .map((e) => ("trigger" in e ? e.trigger : undefined));
+    expect(triggers).toContain("overflow");
+    // At least the proactive budget pass plus the overflow pass.
+    expect(
+      triggers.filter((t) => t === "budget").length,
+    ).toBeGreaterThanOrEqual(1);
+  });
+});