@vellumai/assistant 0.8.1 → 0.8.2

package/src/__tests__/context-window-manager.test.ts

@@ -1,2481 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import type { ContextWindowConfig } from "../config/types.js";
-import { estimateTextTokens } from "../context/token-estimator.js";
-import {
-  appendTailAnchorToSummary,
-  clampSummaryAtSectionBoundary,
-  CONTEXT_SUMMARY_MARKER,
-  ContextWindowManager,
-  createContextSummaryMessage,
-  extractTailAssistantText,
-  getSummaryFromContextMessage,
-  stripCompactionOnlyInjections,
-} from "../context/window-manager.js";
-import type {
-  ContentBlock,
-  Message,
-  Provider,
-  ProviderResponse,
-  SendMessageOptions,
-} from "../providers/types.js";
-
-function makeConfig(
-  overrides: Partial<ContextWindowConfig> = {},
-): ContextWindowConfig {
-  return {
-    enabled: true,
-    maxInputTokens: 450,
-    targetBudgetRatio: 0.67,
-    compactThreshold: 0.6,
-    summaryBudgetRatio: 0.05,
-    overflowRecovery: {
-      enabled: true,
-      safetyMarginRatio: 0.05,
-      maxAttempts: 3,
-      interactiveLatestTurnCompression: "summarize",
-      nonInteractiveLatestTurnCompression: "truncate",
-    },
-    ...overrides,
-  };
-}
-
-function createProvider(
-  fn: (messages: Message[]) => ProviderResponse | Promise<ProviderResponse>,
-  name: string = "mock",
-): Provider {
-  return {
-    name,
-    async sendMessage(messages: Message[]): Promise<ProviderResponse> {
-      return fn(messages);
-    },
-  };
-}
-
-function message(role: "user" | "assistant", text: string): Message {
-  return { role, content: [{ type: "text", text }] };
-}
-
-describe("ContextWindowManager", () => {
-  test("skips compaction when estimated tokens are below threshold", async () => {
-    const provider = createProvider(() => {
-      throw new Error("should not be called");
-    });
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig(),
-    });
-    const history = [message("user", "hello"), message("assistant", "hi")];
-
-    const result = await manager.maybeCompact(history);
-    expect(result.compacted).toBe(false);
-    expect(result.messages).toEqual(history);
-    expect(result.reason).toBe("below compaction threshold");
-  });
-
-  test("explains forced compaction skip when only one user turn exists", async () => {
-    const provider = createProvider(() => {
-      throw new Error("summarizer should not be called");
-    });
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 10_000,
-        targetBudgetRatio: 0.5,
-      }),
-    });
-    // Only one user turn — there is nothing earlier to summarize, so
-    // forced compaction must still skip but report a clear reason
-    // instead of "conversation already fits within the compaction
-    // target". `force=true` is honored everywhere else.
-    const history = [message("user", "hello"), message("assistant", "hi")];
-
-    const result = await manager.maybeCompact(history, undefined, {
-      force: true,
-    });
-
-    expect(result.compacted).toBe(false);
-    expect(result.messages).toEqual(history);
-    expect(result.reason).toBe(
-      "only one user turn — nothing earlier to compact",
-    );
-  });
-
-  test("forced compaction summarizes when adjustForToolPairs would walk boundary to summary", async () => {
-    let summaryCalls = 0;
-    const provider = createProvider(() => {
-      summaryCalls += 1;
-      return {
-        content: [{ type: "text", text: "## Summary\n- rescue path ran" }],
-        model: "mock-model",
-        usage: { inputTokens: 100, outputTokens: 25 },
-        stopReason: "end_turn",
-      };
-    });
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 10_000,
-        targetBudgetRatio: 0.5,
-      }),
-    });
-    // Conversation starts with consecutive `assistant(tool_use)` →
-    // `user(tool_result + text)` pairs. `collectUserTurnStartIndexes`
-    // includes the mixed user messages (not tool_result-only), so the
-    // earliest `userTurnStarts` entry is the message containing
-    // `tool_result(tool-1)`. Once the projection-optimism clamp
-    // decrements the keep boundary to that user turn,
-    // `adjustForToolPairs` walks the boundary back through the
-    // tool_use/tool_result chain to index 0 — under the old code that
-    // routed `/compact` through the "already fits" skip path. With the
-    // rescue, summarization runs and orphan `tool_result` blocks are
-    // stripped from the kept region.
-    const history: Message[] = [
-      {
-        role: "assistant",
-        content: [{ type: "tool_use", id: "tool-1", name: "x", input: {} }],
-      },
-      {
-        role: "user",
-        content: [
-          { type: "tool_result", tool_use_id: "tool-1", content: "result1" },
-          { type: "text", text: "u1" },
-        ],
-      },
-      {
-        role: "assistant",
-        content: [{ type: "tool_use", id: "tool-2", name: "x", input: {} }],
-      },
-      {
-        role: "user",
-        content: [
-          { type: "tool_result", tool_use_id: "tool-2", content: "result2" },
-          { type: "text", text: "u2" },
-        ],
-      },
-      message("assistant", "a3"),
-      message("user", "u3"),
-      message("assistant", "a4"),
-    ];
-
-    const result = await manager.maybeCompact(history, undefined, {
-      force: true,
-      precomputedEstimate: 50_000,
-    });
-
-    expect(result.compacted).toBe(true);
-    expect(summaryCalls).toBe(1);
-    expect(result.reason).not.toBe(
-      "conversation already fits within the compaction target",
-    );
-    expect(result.reason).not.toBe(
-      "truncated tool results without summarization",
-    );
-    expect(result.compactedMessages).toBeGreaterThan(0);
-
-    // The kept region must not contain orphan tool_result blocks whose
-    // tool_use lives in the compacted region — the LLM API would reject
-    // such messages on the next agent turn.
-    const keptToolUseIds = new Set<string>();
-    for (const msg of result.messages) {
-      if (msg.role !== "assistant") continue;
-      for (const block of msg.content) {
-        if (
-          (block.type === "tool_use" || block.type === "server_tool_use") &&
-          "id" in block
-        ) {
-          keptToolUseIds.add((block as { id: string }).id);
-        }
-      }
-    }
-    for (const msg of result.messages) {
-      if (msg.role !== "user") continue;
-      for (const block of msg.content) {
-        if (
-          (block.type === "tool_result" ||
-            block.type === "web_search_tool_result") &&
-          "tool_use_id" in block
-        ) {
-          expect(keptToolUseIds.has(block.tool_use_id as string)).toBe(true);
-        }
-      }
-    }
-  });
-
-  test("forced compaction summarizes when compactable count is below MIN guard", async () => {
-    let summaryCalls = 0;
-    const provider = createProvider(() => {
-      summaryCalls += 1;
-      return {
-        content: [{ type: "text", text: "## Summary\n- min-bypass ran" }],
-        model: "mock-model",
-        usage: { inputTokens: 100, outputTokens: 25 },
-        stopReason: "end_turn",
-      };
-    });
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 10_000,
-        targetBudgetRatio: 0.5,
-      }),
-    });
-    // Two user turns separated by a single assistant message — the
-    // smallest realistic conversation where a forced compaction has
-    // anything to summarize. After the projection clamp + rescue, the
-    // compactable region is at most one user turn (the first one),
-    // which can fall below `MIN_COMPACTABLE_PERSISTED_MESSAGES`. The
-    // bypass must let summarization run instead of returning
-    // "insufficient compactable persisted messages".
-    const history: Message[] = [message("user", "u1"), message("user", "u2")];
-
-    const result = await manager.maybeCompact(history, undefined, {
-      force: true,
-      precomputedEstimate: 50_000,
-    });
-
-    expect(result.compacted).toBe(true);
-    expect(summaryCalls).toBe(1);
-    expect(result.reason).not.toBe(
-      "insufficient compactable persisted messages",
-    );
-    expect(result.compactedMessages).toBeGreaterThan(0);
-  });
-
-  test("forced compaction summarizes when projection fits but real usage exceeds target", async () => {
-    let summaryCalls = 0;
-    const provider = createProvider(() => {
-      summaryCalls += 1;
-      return {
-        content: [
-          { type: "text", text: "## Summary\n- forced compaction ran" },
-        ],
-        model: "mock-model",
-        usage: { inputTokens: 100, outputTokens: 25 },
-        stopReason: "end_turn",
-      };
-    });
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 10_000,
-        targetBudgetRatio: 0.5,
-      }),
-    });
-    // Tiny live messages so the projection trivially fits target — without
-    // the fix this would route through the "already fits" skip path.
-    const history: Message[] = [
-      message("user", "u1"),
-      message("assistant", "a1"),
-      message("user", "u2"),
-      message("assistant", "a2"),
-    ];
-
-    const result = await manager.maybeCompact(history, undefined, {
-      force: true,
-      // Simulate a live conversation that's well over target. In production
-      // this happens when synthetic tool_result truncation in the projection
-      // is far more aggressive than what the real messages allow.
-      precomputedEstimate: 50_000,
-    });
-
-    expect(result.compacted).toBe(true);
-    expect(summaryCalls).toBe(1);
-    expect(result.reason).not.toBe(
-      "conversation already fits within the compaction target",
-    );
-    expect(result.compactedMessages).toBeGreaterThan(0);
-  });
-
-  test("compacts old turns and keeps recent user turns", async () => {
-    let summaryCalls = 0;
-    const provider = createProvider(() => {
-      summaryCalls += 1;
-      return {
-        content: [
-          { type: "text", text: `## Goals\n- summary call ${summaryCalls}` },
-        ],
-        model: "mock-model",
-        usage: { inputTokens: 100, outputTokens: 25 },
-        stopReason: "end_turn",
-      };
-    });
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({ maxInputTokens: 600 }),
-    });
-    const long = "x".repeat(240);
-    const history: Message[] = [
-      message("user", `u1 ${long}`),
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-      message("assistant", `a2 ${long}`),
-      message("user", `u3 ${long}`),
-      message("assistant", `a3 ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-
-    expect(result.compacted).toBe(true);
-    expect(result.compactedMessages).toBeGreaterThan(0);
-    expect(result.summaryCalls).toBe(summaryCalls);
-    expect(result.summaryInputTokens).toBeGreaterThan(0);
-    expect(result.summaryOutputTokens).toBeGreaterThan(0);
-    expect(result.messages[0].role).toBe("user");
-    expect(
-      getSummaryFromContextMessage(result.messages[0])?.length,
-    ).toBeGreaterThan(0);
-
-    const userTexts = result.messages
-      .filter((m) => m.role === "user")
-      .map((m) => (m.content[0].type === "text" ? m.content[0].text : ""));
-    expect(userTexts.some((text) => text.startsWith("u1 "))).toBe(false);
-    expect(userTexts.some((text) => text.startsWith("u2 "))).toBe(true);
-    expect(userTexts.some((text) => text.startsWith("u3 "))).toBe(true);
-  });
-
-  test("returns cache-aware summary usage from single-pass compaction", async () => {
-    const provider = createProvider(() => {
-      return {
-        content: [
-          { type: "text", text: `## Goals\n- summary of full transcript` },
-        ],
-        model: "claude-opus-4-6",
-        usage: {
-          inputTokens: 5_000,
-          outputTokens: 80,
-          cacheCreationInputTokens: 50,
-          cacheReadInputTokens: 200,
-        },
-        rawResponse: {
-          usage: {
-            cache_creation: {
-              ephemeral_5m_input_tokens: 50,
-              ephemeral_1h_input_tokens: 0,
-            },
-            cache_read_input_tokens: 200,
-          },
-        },
-        stopReason: "end_turn",
-      };
-    });
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 7_000,
-        targetBudgetRatio: 0.41,
-      }),
-    });
-    const long = "q".repeat(6_000);
-    const history: Message[] = [
-      message("user", `u1 ${long}`),
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-      message("assistant", `a2 ${long}`),
-      message("user", `u3 ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-
-    expect(result.compacted).toBe(true);
-    expect(result.summaryCalls).toBe(1);
-    expect(result.summaryCacheCreationInputTokens).toBe(50);
-    expect(result.summaryCacheReadInputTokens).toBe(200);
-    expect(result.summaryRawResponses).toHaveLength(1);
-    expect(result.summaryRawResponses?.[0]).toMatchObject({
-      usage: {
-        cache_creation: { ephemeral_5m_input_tokens: 50 },
-        cache_read_input_tokens: 200,
-      },
-    });
-  });
-
-  test("updates an existing summary message instead of nesting summaries", async () => {
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- updated summary" }],
-      model: "mock-model",
-      usage: { inputTokens: 50, outputTokens: 10 },
-      stopReason: "end_turn",
-    }));
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 300,
-        targetBudgetRatio: 0.58,
-      }),
-    });
-    const long = "y".repeat(220);
-    const history: Message[] = [
-      createContextSummaryMessage("## Goals\n- old summary"),
-      message("user", `older ${long}`),
-      message("assistant", `reply ${long}`),
-      message("user", `latest ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-    expect(result.compacted).toBe(true);
-    expect(result.messages.length).toBeLessThan(history.length + 1);
-    expect(getSummaryFromContextMessage(result.messages[0])).toContain(
-      "updated summary",
-    );
-    expect(
-      result.messages.filter(
-        (m) =>
-          m.role === "user" &&
-          m.content.some(
-            (block) =>
-              block.type === "text" &&
-              block.text.startsWith(CONTEXT_SUMMARY_MARKER),
-          ),
-      ),
-    ).toHaveLength(1);
-  });
-
-  test("falls back to local summary when provider summarization fails", async () => {
-    const provider = createProvider(async () => {
-      throw new Error("provider unavailable");
-    });
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 260,
-        targetBudgetRatio: 0.59,
-      }),
-    });
-    const long = "z".repeat(220);
-    const history = [
-      message("user", `task ${long}`),
-      message("assistant", `result ${long}`),
-      message("user", `followup ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-    expect(result.compacted).toBe(true);
-    expect(result.summaryCalls).toBeGreaterThan(0);
-    expect(result.summaryInputTokens).toBe(0);
-    expect(result.summaryOutputTokens).toBe(0);
-    expect(result.summaryModel).toBe("");
-    expect(result.summaryText).toContain("## Recent Progress");
-  });
-
-  test("marks summaryFailed when the provider throws and fallback runs", async () => {
-    // The agent-loop circuit breaker distinguishes "LLM call failed but
-    // fallback rescued us" from "compaction succeeded end-to-end". The
-    // fallback path must set summaryFailed:true so callers can count
-    // consecutive failures without losing the compacted messages.
-    const provider = createProvider(async () => {
-      throw new Error("provider unavailable");
-    });
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 260,
-        targetBudgetRatio: 0.59,
-      }),
-    });
-    const long = "z".repeat(220);
-    const history = [
-      message("user", `task ${long}`),
-      message("assistant", `result ${long}`),
-      message("user", `followup ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-    expect(result.compacted).toBe(true);
-    expect(result.summaryFailed).toBe(true);
-  });
-
-  test("does not mark summaryFailed on a successful provider call", async () => {
-    const provider = createProvider(() => ({
-      content: [
-        { type: "text", text: "## Goals\n- summary produced by provider" },
-      ],
-      model: "mock-model",
-      usage: { inputTokens: 60, outputTokens: 12 },
-      stopReason: "end_turn",
-    }));
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 260,
-        targetBudgetRatio: 0.59,
-      }),
-    });
-    const long = "z".repeat(220);
-    const history = [
-      message("user", `task ${long}`),
-      message("assistant", `result ${long}`),
-      message("user", `followup ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-    expect(result.compacted).toBe(true);
-    expect(result.summaryFailed).toBe(false);
-  });
-
-  test("serializes file blocks for summary chunks", async () => {
-    const prompts: string[] = [];
-    const provider = createProvider((messages) => {
-      for (const block of messages[0]?.content ?? []) {
-        if (block.type === "text") {
-          prompts.push(block.text);
-        }
-      }
-      return {
-        content: [{ type: "text", text: "## Goals\n- file summarized" }],
-        model: "mock-model",
-        usage: { inputTokens: 60, outputTokens: 12 },
-        stopReason: "end_turn",
-      };
-    });
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 2000,
-        targetBudgetRatio: 0.4,
-        compactThreshold: 0.35,
-      }),
-    });
-    const long = "f".repeat(1500);
-    const history: Message[] = [
-      {
-        role: "user",
-        content: [
-          {
-            type: "file",
-            source: {
-              type: "base64",
-              media_type: "application/pdf",
-              filename: "spec.pdf",
-              data: "a".repeat(4096),
-            },
-            extracted_text: "Critical requirement from attached spec.",
-          },
-        ],
-      },
-      message("assistant", `ack ${long}`),
-      message("user", `followup ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-    expect(result.compacted).toBe(true);
-
-    const combinedPrompts = prompts.join("\n");
-    expect(combinedPrompts).toContain("file: spec.pdf");
-    expect(combinedPrompts).toContain("application/pdf");
-    expect(combinedPrompts).toContain(
-      "Critical requirement from attached spec.",
-    );
-    expect(combinedPrompts).not.toContain("unknown_block");
-  });
-
-  test("passes image blocks to summarizer instead of text metadata", async () => {
-    const receivedBlocks: { type: string; mediaType?: string }[] = [];
-    const provider = createProvider((messages) => {
-      for (const block of messages[0]?.content ?? []) {
-        if (block.type === "image") {
-          receivedBlocks.push({
-            type: "image",
-            mediaType: (block as { source: { media_type: string } }).source
-              .media_type,
-          });
-        } else if (block.type === "text") {
-          receivedBlocks.push({ type: "text" });
-        }
-      }
-      return {
-        content: [
-          {
-            type: "text",
-            text: "## Goals\n- described image: a photo of a cat",
-          },
-        ],
-        model: "mock-model",
-        usage: { inputTokens: 100, outputTokens: 20 },
-        stopReason: "end_turn",
-      };
-    });
-    // Use a large enough maxInputTokens so the image fits in the summarizer
-    // budget after accounting for overhead (system prompt, scaffolding, output).
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "sys",
-      config: makeConfig({
-        maxInputTokens: 5000,
-        compactThreshold: 0.3,
-        targetBudgetRatio: 0.2,
-      }),
-    });
-    const long = "x".repeat(4000);
-    const history: Message[] = [
-      {
-        role: "user",
-        content: [
-          { type: "text", text: "look at this" },
-          {
-            type: "image",
-            source: {
-              type: "base64",
-              media_type: "image/png",
-              data: "iVBORw0KGgo=",
-            },
-          },
-        ],
-      },
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-    expect(result.compacted).toBe(true);
-
-    // The summarizer should have received actual image blocks, not text stubs.
-    const imageBlocks = receivedBlocks.filter((b) => b.type === "image");
-    expect(imageBlocks.length).toBe(1);
-    expect(imageBlocks[0].mediaType).toBe("image/png");
-  });
-
-  test("passes tool_result images to summarizer", async () => {
-    const receivedImageCount = { count: 0 };
-    const provider = createProvider((messages) => {
-      for (const block of messages[0]?.content ?? []) {
-        if (block.type === "image") {
-          receivedImageCount.count++;
-        }
-      }
-      return {
-        content: [
-          { type: "text", text: "## Goals\n- summarized tool output images" },
-        ],
-        model: "mock-model",
-        usage: { inputTokens: 100, outputTokens: 20 },
-        stopReason: "end_turn",
-      };
-    });
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "sys",
-      config: makeConfig({
-        maxInputTokens: 5000,
-        compactThreshold: 0.3,
-        targetBudgetRatio: 0.2,
-      }),
-    });
-    const long = "x".repeat(2000);
-    const history: Message[] = [
-      message("assistant", "let me read that file"),
-      {
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            tool_use_id: "tool_1",
-            content: "file contents",
-            contentBlocks: [
-              {
-                type: "image",
-                source: {
-                  type: "base64",
-                  media_type: "image/jpeg",
-                  data: "iVBORw0KGgo=",
-                },
-              },
-            ],
-            is_error: false,
-          } as import("../providers/types.js").ToolResultContent,
-        ],
-      },
-      message("user", `followup ${long}`),
-      message("assistant", `response ${long}`),
-      message("user", `final ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-    expect(result.compacted).toBe(true);
-    expect(receivedImageCount.count).toBe(1);
-  });
-
-  test("counts compacted persisted messages including tool-result user turns", async () => {
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- compacted summary" }],
-      model: "mock-model",
-      usage: { inputTokens: 75, outputTokens: 20 },
-      stopReason: "end_turn",
-    }));
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 320,
-        targetBudgetRatio: 0.58,
-      }),
-    });
-    const long = "k".repeat(220);
-    const history: Message[] = [
-      message("user", `u1 ${long}`),
-      {
-        role: "assistant",
-        content: [
-          {
-            type: "tool_use",
-            id: "t1",
-            name: "read_file",
-            input: { path: "/tmp/a" },
-          },
-        ],
-      },
-      {
-        role: "user",
-        content: [
-          { type: "tool_result", tool_use_id: "t1", content: "contents" },
-        ],
-      },
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-    expect(result.compacted).toBe(true);
-    expect(result.compactedMessages).toBe(4);
-    // Tool-result-only user messages have DB counterparts and must be
-    // counted so contextCompactedMessageCount indexes the DB correctly.
-    expect(result.compactedPersistedMessages).toBe(4);
-  });
-
-  test("adjusts keep boundary to preserve tool_use/tool_result pairs", async () => {
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- compacted summary" }],
-      model: "mock-model",
-      usage: { inputTokens: 75, outputTokens: 20 },
-      stopReason: "end_turn",
-    }));
-    // Configure budget so compaction keeps only the last user turn,
-    // which would normally split the tool pair because the last user
-    // turn start is a mixed message (tool_result + text) whose matching
-    // tool_use lives in the preceding assistant message.
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 320,
-        targetBudgetRatio: 0.58,
-      }),
-    });
-    const long = "k".repeat(220);
-    const history: Message[] = [
-      message("user", `u1 ${long}`), // index 0: old user turn (long)
-      message("assistant", `a1 ${long}`), // index 1: assistant reply (long)
-      message("user", `u2 ${long}`), // index 2: second user turn (long)
-      {
-        // index 3: assistant with tool_use
-        role: "assistant",
-        content: [
-          {
-            type: "tool_use",
-            id: "t1",
-            name: "read_file",
-            input: { path: "/tmp/a" },
-          },
-        ],
-      },
-      {
-        // index 4: user with tool_result AND text (mixed = user turn start)
-        // Without adjustForToolPairs, the raw boundary would land here,
-        // orphaning the tool_result from its tool_use at index 3.
-        role: "user",
-        content: [
-          { type: "tool_result", tool_use_id: "t1", content: "file contents" },
-          { type: "text", text: "thanks, now continue" },
-        ],
-      },
-    ];
-
-    const result = await manager.maybeCompact(history);
-    expect(result.compacted).toBe(true);
-    // The kept messages must include the tool_use assistant message (index 3)
-    // and tool_result user message (index 4) as a pair, not split them.
-    // Verify no orphaned tool_result blocks exist in the kept messages.
-    const keptMessages = result.messages;
-    for (let i = 0; i < keptMessages.length; i++) {
-      const msg = keptMessages[i];
-      if (msg.role !== "user") continue;
-      for (const block of msg.content) {
-        if (block.type === "tool_result") {
-          // Every tool_result must have a matching tool_use in a preceding assistant message
-          const toolUseId = (block as { tool_use_id: string }).tool_use_id;
-          const hasMatchingToolUse = keptMessages
-            .slice(0, i)
-            .some(
-              (prev) =>
-                prev.role === "assistant" &&
-                prev.content.some(
-                  (b) =>
-                    b.type === "tool_use" &&
-                    (b as { id: string }).id === toolUseId,
-                ),
-            );
-          expect(hasMatchingToolUse).toBe(true);
-        }
-      }
-    }
-  });
-
-  test("counts mixed tool_result+text user messages as persisted", async () => {
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- mixed summary" }],
-      model: "mock-model",
-      usage: { inputTokens: 75, outputTokens: 20 },
-      stopReason: "end_turn",
-    }));
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 320,
-        targetBudgetRatio: 0.58,
-      }),
-    });
-    const long = "k".repeat(220);
-    // Simulates a merged user message (repairHistory merges consecutive same-role
-    // messages), resulting in a user turn with both tool_result and text blocks.
-    const history: Message[] = [
-      message("user", `u1 ${long}`),
-      {
-        role: "assistant",
-        content: [
-          {
-            type: "tool_use",
-            id: "t1",
-            name: "read_file",
-            input: { path: "/tmp/a" },
-          },
-        ],
-      },
-      {
-        role: "user",
-        content: [
-          { type: "tool_result", tool_use_id: "t1", content: "contents" },
-          { type: "text", text: `follow-up question ${long}` },
-        ],
-      },
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-    expect(result.compacted).toBe(true);
-    // The mixed user message should be counted as persisted (4 = u1 + mixed + a_tooluse + a1)
-    expect(result.compactedPersistedMessages).toBe(4);
-  });
-
-  test("returns cache-aware usage metadata for compaction summaries", async () => {
-    const rawResponse = {
-      usage: {
-        cache_creation: { ephemeral_5m_input_tokens: 120 },
-        cache_read_input_tokens: 340,
-      },
-    };
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- cache-aware summary" }],
-      model: "claude-opus-4-6",
-      usage: {
-        inputTokens: 500,
-        outputTokens: 22,
-        cacheCreationInputTokens: 120,
-        cacheReadInputTokens: 340,
-      },
-      rawResponse,
-      stopReason: "end_turn",
-    }));
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 2600,
-        targetBudgetRatio: 0.63,
-      }),
-    });
-    const long = "c".repeat(5000);
-    const history: Message[] = [
-      message("user", `u1 ${long}`),
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-
-    expect(result.compacted).toBe(true);
-    expect(result.summaryCalls).toBe(1);
-    expect(result.summaryInputTokens).toBe(500);
-    expect(result.summaryCacheCreationInputTokens).toBe(120);
-    expect(result.summaryCacheReadInputTokens).toBe(340);
-    expect(result.summaryRawResponses).toEqual([rawResponse]);
-  });
-
-  test("does not parse user-authored summary marker text as internal summary", () => {
-    const userMessage: Message = {
-      role: "user",
-      content: [
-        {
-          type: "text",
-          text: `${CONTEXT_SUMMARY_MARKER}\nI typed this prefix myself`,
-        },
-      ],
-    };
-    expect(getSummaryFromContextMessage(userMessage)).toBeNull();
-  });
-
-  test("skips compaction during cooldown", async () => {
-    const provider = createProvider(() => {
-      throw new Error(
-        "summarizer should not be called while cooldown skip is active",
-      );
-    });
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 260,
-        targetBudgetRatio: 0.74,
-      }),
-    });
-    const long = "c".repeat(220);
-    const history: Message[] = [
-      message("user", `u1 ${long}`),
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history, undefined, {
-      lastCompactedAt: Date.now() - 30_000,
-    });
-    expect(result.compacted).toBe(false);
-    expect(result.reason).toBe("compaction cooldown active");
-  });
-
-  test("ignores cooldown and compacts under severe token pressure", async () => {
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- compacted under pressure" }],
-      model: "mock-model",
-      usage: { inputTokens: 60, outputTokens: 12 },
-      stopReason: "end_turn",
-    }));
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 320,
-        targetBudgetRatio: 0.61,
-      }),
-    });
-    const long = "p".repeat(340);
-    const history: Message[] = [
-      message("user", `u1 ${long}`),
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-      message("assistant", `a2 ${long}`),
-      message("user", `u3 ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history, undefined, {
-      lastCompactedAt: Date.now() - 30_000,
-    });
-    expect(result.compacted).toBe(true);
-    expect(result.reason).toBeUndefined();
-  });
-
-  test("force=true bypasses cooldown for context-too-large recovery", async () => {
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- forced compaction" }],
-      model: "mock-model",
-      usage: { inputTokens: 60, outputTokens: 12 },
-      stopReason: "end_turn",
-    }));
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 260,
-        targetBudgetRatio: 0.74,
-      }),
-    });
-    const long = "c".repeat(220);
-    const history: Message[] = [
-      message("user", `u1 ${long}`),
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-    ];
-
-    // Same setup as the cooldown test, but with force=true — should compact.
-    const result = await manager.maybeCompact(history, undefined, {
-      lastCompactedAt: Date.now() - 30_000,
-      force: true,
-    });
-    expect(result.compacted).toBe(true);
-    expect(result.reason).toBeUndefined();
-  });
-
-  test("image-heavy payload is no longer underestimated as below-threshold", async () => {
-    const provider = createProvider(() => ({
-      content: [
-        { type: "text", text: "## Goals\n- compacted image-heavy history" },
-      ],
-      model: "mock-model",
-      usage: { inputTokens: 75, outputTokens: 20 },
-      stopReason: "end_turn",
-    }));
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 7000,
-        targetBudgetRatio: 0.76,
-        compactThreshold: 0.8,
-      }),
-    });
-
-    const images = Array.from({ length: 5 }, (_, i) => ({
-      type: "image" as const,
-      source: {
-        type: "base64" as const,
-        media_type: "image/png",
-        data: `${String(i)}${"A".repeat(40_000)}`,
-      },
-    }));
-
-    const history: Message[] = [
-      {
-        role: "user",
-        content: [
-          { type: "text", text: "Please analyze these screenshots." },
-          ...images,
-        ],
-      },
-      message("assistant", "Sure, uploading now."),
-    ];
-
-    const result = await manager.maybeCompact(history);
-    expect(result.reason).not.toBe("below compaction threshold");
-
-    // Sanity check for this repro: counting raw base64 as text would exceed threshold.
-    const rawBase64Chars = images.reduce(
-      (sum, img) => sum + img.source.data.length,
-      0,
-    );
-    const rawBase64TokenEquivalent = estimateTextTokens(
-      "A".repeat(rawBase64Chars),
-    );
-    expect(rawBase64TokenEquivalent).toBeGreaterThan(result.thresholdTokens);
-  });
-
-  test("minKeepRecentUserTurns: 0 compacts all messages into summary only", async () => {
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- emergency summary" }],
-      model: "mock-model",
-      usage: { inputTokens: 60, outputTokens: 12 },
-      stopReason: "end_turn",
-    }));
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 260,
-        targetBudgetRatio: 0.28,
-      }),
-    });
-    const long = "e".repeat(220);
-    const history: Message[] = [
-      message("user", `u1 ${long}`),
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history, undefined, {
-      force: true,
-      minKeepRecentUserTurns: 0,
-    });
-    expect(result.compacted).toBe(true);
-    // With minKeepRecentUserTurns=0 and a tight target budget,
-    // pickKeepBoundary drops keepTurns all the way to 0.
-    // All three messages are compacted into a single summary message.
-    expect(result.compactedMessages).toBe(3);
-    expect(result.messages).toHaveLength(1);
-    expect(getSummaryFromContextMessage(result.messages[0])).toContain(
-      "emergency summary",
-    );
-  });
-
-  test("force compaction with loose target override still summarizes persisted messages", async () => {
-    // `pickKeepBoundary` clamps `targetInputTokensOverride` to
-    // `config.targetInputTokens`, so a loose override cannot
-    // short-circuit summarization into the truncate-only early-exit.
-
-    let summaryCalls = 0;
-    const provider = createProvider(() => {
-      summaryCalls += 1;
-      return {
-        content: [{ type: "text", text: "## Goals\n- real summary" }],
-        model: "mock-model",
-        usage: { inputTokens: 80, outputTokens: 20 },
-        stopReason: "end_turn",
-      };
-    });
-
-    // Scaled from prod (max 200k → 1000) preserving key ratios: the
-    // loose override (~0.85×max) is ~17× the post-compaction target
-    // (~0.05×max), so history between the two exercises the clamp.
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 1000,
-        targetBudgetRatio: 0.1,
-        summaryBudgetRatio: 0.05,
-        compactThreshold: 0.3,
-      }),
-    });
-
-    // History in the "no-op zone": above threshold (300), below override (850).
-    const long = "x".repeat(180);
-    const history: Message[] = [
-      message("user", `u1 ${long}`),
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-      message("assistant", `a2 ${long}`),
-      message("user", `u3 ${long}`),
-      message("assistant", `a3 ${long}`),
-      message("user", `u4 ${long}`),
-      message("assistant", `a4 ${long}`),
-      message("user", `u5 ${long}`),
-    ];
-
-    const preflightBudgetAnalog = Math.floor(1000 * 0.85);
-    const result = await manager.maybeCompact(history, undefined, {
-      force: true,
-      targetInputTokensOverride: preflightBudgetAnalog,
-    });
-
-    // Guard: we're actually above the compact threshold.
-    expect(result.previousEstimatedInputTokens).toBeGreaterThan(
-      result.thresholdTokens,
-    );
-
-    // A real summarization happened (not the truncate-only no-op).
-    expect(result.compactedPersistedMessages).toBeGreaterThan(0);
-    expect(summaryCalls).toBeGreaterThan(0);
-  });
-
-  test("force=true compacts below minFloor when a kept turn exceeds target", async () => {
-    // A giant paste in the last user turn means minFloor=1 alone exceeds target.
-    // Under force, pickKeepBoundary should walk keepTurns below minFloor (down to
-    // 0) so the huge block falls into the compacted region and gets summarized
-    // instead of being kept at full size.
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- compressed large paste" }],
-      model: "mock-model",
-      usage: { inputTokens: 120, outputTokens: 20 },
-      stopReason: "end_turn",
-    }));
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({ maxInputTokens: 600, targetBudgetRatio: 0.2 }),
-    });
-    const hugePaste = "p".repeat(4000); // ~1000 tokens, well above targetInputTokens
-    const history: Message[] = [
-      message("user", "u1 small"),
-      message("assistant", "a1 small"),
-      message("user", `u2 ${hugePaste}`),
-    ];
-
-    const result = await manager.maybeCompact(history, undefined, {
-      force: true,
-    });
-
-    expect(result.compacted).toBe(true);
-    // With force=true the kept region is empty; all turns including the oversized
-    // paste were summarized, so the compacted result is just the summary.
-    expect(result.messages).toHaveLength(1);
-    expect(result.compactedMessages).toBe(history.length);
-    expect(getSummaryFromContextMessage(result.messages[0])).toContain(
-      "compressed large paste",
-    );
-    expect(result.estimatedInputTokens).toBeLessThan(
-      result.previousEstimatedInputTokens,
-    );
-  });
-
-  test("force=false honors minFloor even when the kept turn exceeds target", async () => {
-    // Same oversized paste, but without force the algorithm must preserve the
-    // minFloor=1 recent turn (auto mid-loop compaction needs the in-flight turn
-    // intact). Anything compactable before the floor still gets summarized.
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- summary" }],
-      model: "mock-model",
-      usage: { inputTokens: 60, outputTokens: 10 },
-      stopReason: "end_turn",
-    }));
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({ maxInputTokens: 600, targetBudgetRatio: 0.2 }),
-    });
-    const hugePaste = "p".repeat(4000);
-    const history: Message[] = [
-      message("user", "u1 small"),
-      message("assistant", "a1 small"),
-      message("user", "u2 small"),
-      message("assistant", "a2 small"),
-      message("user", `u3 ${hugePaste}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-
-    expect(result.compacted).toBe(true);
-    // The oversized last user turn is retained verbatim; the kept array starts
-    // with the summary followed by the messages from that turn onward.
-    const lastUser = result.messages
-      .filter((m) => m.role === "user")
-      .map((m) => (m.content[0].type === "text" ? m.content[0].text : ""))
-      .find((t) => t.startsWith("u3 "));
-    expect(lastUser).toBeDefined();
-    expect(lastUser!.length).toBeGreaterThan(hugePaste.length);
-  });
-
-  test("shouldCompact returns needed=false with estimatedTokens when below threshold", () => {
-    const provider = createProvider(() => {
-      throw new Error("should not be called");
-    });
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig(),
-    });
-    const history = [message("user", "hello"), message("assistant", "hi")];
-    const result = manager.shouldCompact(history);
-    expect(result.needed).toBe(false);
-    expect(result.estimatedTokens).toBeGreaterThan(0);
-  });
-
-  test("shouldCompact returns needed=true with estimatedTokens when above threshold", () => {
-    const provider = createProvider(() => {
-      throw new Error("should not be called");
-    });
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig(),
-    });
-    const long = "x".repeat(240);
-    const history: Message[] = [
-      message("user", `u1 ${long}`),
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-      message("assistant", `a2 ${long}`),
-      message("user", `u3 ${long}`),
-      message("assistant", `a3 ${long}`),
-    ];
-    const result = manager.shouldCompact(history);
-    expect(result.needed).toBe(true);
-    expect(result.estimatedTokens).toBeGreaterThan(0);
-  });
-
-  test("shouldCompact returns needed=false with zero estimatedTokens when disabled", () => {
-    const provider = createProvider(() => {
-      throw new Error("should not be called");
-    });
-    const long = "x".repeat(240);
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({ enabled: false }),
-    });
-    const history: Message[] = [
-      message("user", `u1 ${long}`),
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-      message("assistant", `a2 ${long}`),
-    ];
-    const result = manager.shouldCompact(history);
-    expect(result.needed).toBe(false);
-    expect(result.estimatedTokens).toBe(0);
-  });
-
-  test("truncates tool results in kept turns to preserve more conversation", async () => {
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- truncation summary" }],
-      model: "mock-model",
-      usage: { inputTokens: 60, outputTokens: 12 },
-      stopReason: "end_turn",
-    }));
-    // Budget is tight enough that full 8K tool results would force dropping turns,
-    // but truncated results (≤6K chars) should allow more turns to be kept.
-    const config = makeConfig({
-      maxInputTokens: 4000,
-      targetBudgetRatio: 0.7,
-    });
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config,
-    });
-
-    const largeToolResult = "x".repeat(8000);
-    const history: Message[] = [
-      message("user", "u1"),
-      {
-        role: "assistant",
-        content: [
-          {
-            type: "tool_use",
-            id: "t1",
-            name: "read_file",
-            input: { path: "/tmp/a" },
-          },
-        ],
-      },
-      {
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            tool_use_id: "t1",
-            content: largeToolResult,
-          },
-        ],
-      },
-      message("assistant", "a1"),
-      message("user", "u2"),
-      {
-        role: "assistant",
-        content: [
-          {
-            type: "tool_use",
-            id: "t2",
-            name: "read_file",
-            input: { path: "/tmp/b" },
-          },
-        ],
-      },
-      {
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            tool_use_id: "t2",
-            content: largeToolResult,
-          },
-        ],
-      },
-      message("assistant", "a2"),
-      message("user", "u3"),
-      {
-        role: "assistant",
-        content: [
-          {
-            type: "tool_use",
-            id: "t3",
-            name: "read_file",
-            input: { path: "/tmp/c" },
-          },
-        ],
-      },
-      {
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            tool_use_id: "t3",
-            content: largeToolResult,
-          },
-        ],
-      },
-      message("assistant", "a3"),
-      message("user", "u4"),
-      message("assistant", "a4"),
-    ];
-
-    const result = await manager.maybeCompact(history, undefined, {
-      force: true,
-    });
-    expect(result.compacted).toBe(true);
-
-    // Verify tool results in output are truncated (should be < 8K chars each).
-    for (const msg of result.messages) {
-      for (const block of msg.content) {
-        if (block.type === "tool_result") {
-          expect(block.content.length).toBeLessThan(8000);
-        }
-      }
-    }
-  });
-
-  test("targetInputTokensOverride reduces retained turns beyond normal compaction", async () => {
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- tight fit summary" }],
-      model: "mock-model",
-      usage: { inputTokens: 60, outputTokens: 12 },
-      stopReason: "end_turn",
-    }));
-
-    // Use generous default target so normal compaction would keep all 3 user turns.
-    const config = makeConfig({
-      maxInputTokens: 1200,
-      targetBudgetRatio: 0.88,
-    });
-    const long = "t".repeat(220);
-    const history: Message[] = [
-      message("user", `u1 ${long}`),
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-      message("assistant", `a2 ${long}`),
-      message("user", `u3 ${long}`),
-      message("assistant", `a3 ${long}`),
-    ];
-
-    // Without override: normal compaction keeps more turns.
-    const normalManager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config,
-    });
-    const normalResult = await normalManager.maybeCompact(history, undefined, {
-      force: true,
-    });
-
-    // With a very tight override target: should keep fewer turns.
-    const tightManager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config,
-    });
-    const tightResult = await tightManager.maybeCompact(history, undefined, {
-      force: true,
-      targetInputTokensOverride: 80,
-    });
-
-    expect(tightResult.compacted).toBe(true);
-    // The tight override should compact more messages than normal.
-    expect(tightResult.compactedMessages).toBeGreaterThan(
-      normalResult.compactedMessages,
-    );
-  });
-
-  test("subtracts summaryOffset only when summary at index 0 was injected from parent", async () => {
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- new child summary" }],
-      model: "mock-model",
-      usage: { inputTokens: 75, outputTokens: 20 },
-      stopReason: "end_turn",
-    }));
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 320,
-        targetBudgetRatio: 0.58,
-      }),
-    });
-    const long = "k".repeat(220);
-    // Parent-injected summary at index 0, plus 2 injected non-persisted
-    // messages, plus 3 child-persisted messages. nonPersistedPrefixCount
-    // includes the summary (set by injectInheritedContext).
-    const history: Message[] = [
-      createContextSummaryMessage("parent summary"),
-      message("user", `injected-u ${long}`),
-      message("assistant", `injected-a ${long}`),
-      message("user", `persisted-u1 ${long}`),
-      message("assistant", `persisted-a1 ${long}`),
-      message("user", `persisted-u2 ${long}`),
-    ];
-    manager.nonPersistedPrefixCount = 3;
-    manager.summaryIsInjected = true;
-
-    const result = await manager.maybeCompact(history, undefined, {
-      force: true,
-    });
-    expect(result.compacted).toBe(true);
-    // 4 messages compacted (2 injected + 2 child-persisted), but only the
-    // 2 child-persisted ones count as DB-persisted.
-    expect(result.compactedMessages).toBe(4);
-    expect(result.compactedPersistedMessages).toBe(2);
-    // Flag clears and prefix drains (both injected messages + summary slot).
-    expect(manager.summaryIsInjected).toBe(false);
-    expect(manager.nonPersistedPrefixCount).toBe(0);
-  });
-
-  test("summary system prompt instructs verbatim thread-anchor preservation", async () => {
-    const capturedSystemPrompts: (string | undefined)[] = [];
-    const provider: Provider = {
-      name: "mock",
-      async sendMessage(
-        _messages: Message[],
-        _tools,
-        systemPrompt,
-      ): Promise<ProviderResponse> {
-        capturedSystemPrompts.push(systemPrompt);
-        return {
-          content: [
-            {
-              type: "text",
-              text: "## Goals\n- preserved thread parent verbatim",
-            },
-          ],
-          model: "mock-model",
-          usage: { inputTokens: 60, outputTokens: 12 },
-          stopReason: "end_turn",
-        };
-      },
-    };
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({ maxInputTokens: 600 }),
-    });
-    const long = "x".repeat(240);
-    // Simulate a Slack-style transcript where an old user "thread parent"
-    // message is about to be compacted while a later reply survives in the
-    // retained tail. The clause being asserted instructs the summarizer to
-    // preserve that parent verbatim — we cannot verify the model's behavior
-    // here (the provider is a stub), so we instead assert the clause itself
-    // reaches the summarizer.
-    const history: Message[] = [
-      message("user", `parent: kickoff plan ${long}`),
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-      message("assistant", `a2 ${long}`),
-      message("user", `reply-in-thread ${long}`),
-      message("assistant", `a3 ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-    expect(result.compacted).toBe(true);
-    expect(capturedSystemPrompts.length).toBeGreaterThan(0);
-    const seenPrompt = capturedSystemPrompts[0];
-    expect(seenPrompt).toBeDefined();
-    expect(seenPrompt).toContain("Thread anchors");
-    expect(seenPrompt).toContain("verbatim");
-  });
-
-  test("summary prompt lists retained-tail thread-reply references", async () => {
-    const capturedMessages: Message[][] = [];
-    const provider: Provider = {
-      name: "mock",
-      async sendMessage(messages: Message[]): Promise<ProviderResponse> {
-        capturedMessages.push(messages);
-        return {
-          content: [{ type: "text", text: "## Goals\n- ok" }],
-          model: "mock-model",
-          usage: { inputTokens: 60, outputTokens: 12 },
-          stopReason: "end_turn",
-        };
-      },
-    };
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({ maxInputTokens: 600 }),
-    });
-    const long = "x".repeat(240);
-    // Compactable region ends before the retained tail, which contains a
-    // Slack-style reply line that cites its parent via `→ M1a2b3c`. The
-    // summary prompt must surface that reference so the Thread-anchors
-    // instruction has something to act on.
-    const history: Message[] = [
-      message("user", `[11/14/23 14:25 @alice]: parent kickoff ${long}`),
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-      message("assistant", `a2 ${long}`),
-      message("user", `[11/14/23 14:28 @bob → M1a2b3c]: reply ${long}`),
-      message("assistant", `a3 ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-    expect(result.compacted).toBe(true);
-    expect(capturedMessages.length).toBeGreaterThan(0);
-    const userPromptText = capturedMessages[0]
-      .flatMap((m) => m.content)
-      .filter(
-        (b): b is Extract<ContentBlock, { type: "text" }> => b.type === "text",
-      )
-      .map((b) => b.text)
-      .join("\n");
-    expect(userPromptText).toContain("### Retained Thread References");
-    expect(userPromptText).toContain("→ M1a2b3c");
-  });
-
-  test("summary prompt lists retained-tail thread-reply references for edited replies", async () => {
-    const capturedMessages: Message[][] = [];
-    const provider: Provider = {
-      name: "mock",
-      async sendMessage(messages: Message[]): Promise<ProviderResponse> {
-        capturedMessages.push(messages);
-        return {
-          content: [{ type: "text", text: "## Goals\n- ok" }],
-          model: "mock-model",
-          usage: { inputTokens: 60, outputTokens: 12 },
-          stopReason: "end_turn",
-        };
-      },
-    };
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({ maxInputTokens: 600 }),
-    });
-    const long = "x".repeat(240);
-    // An edited reply renders with `, edited …` between the parent alias and
-    // the closing bracket: `→ Mxxxxxx, edited MM/DD/YY HH:MM]`. The regex
-    // must still flag these lines so retention works for edited replies.
-    const history: Message[] = [
-      message("user", `[11/14/23 14:25 @alice]: parent kickoff ${long}`),
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-      message("assistant", `a2 ${long}`),
-      message(
-        "user",
-        `[11/14/23 14:28 @bob → M1a2b3c, edited 11/14/23 14:32]: reply ${long}`,
-      ),
-      message("assistant", `a3 ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-    expect(result.compacted).toBe(true);
-    expect(capturedMessages.length).toBeGreaterThan(0);
-    const userPromptText = capturedMessages[0]
-      .flatMap((m) => m.content)
-      .filter(
-        (b): b is Extract<ContentBlock, { type: "text" }> => b.type === "text",
-      )
-      .map((b) => b.text)
-      .join("\n");
-    expect(userPromptText).toContain("### Retained Thread References");
-    expect(userPromptText).toContain("→ M1a2b3c, edited 11/14/23 14:32");
-  });
-
-  test("summary prompt omits retained references when retained tail has no thread markers", async () => {
-    const capturedMessages: Message[][] = [];
-    const provider: Provider = {
-      name: "mock",
-      async sendMessage(messages: Message[]): Promise<ProviderResponse> {
-        capturedMessages.push(messages);
-        return {
-          content: [{ type: "text", text: "## Goals\n- ok" }],
-          model: "mock-model",
-          usage: { inputTokens: 60, outputTokens: 12 },
-          stopReason: "end_turn",
-        };
-      },
-    };
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({ maxInputTokens: 600 }),
-    });
-    const long = "x".repeat(240);
-    const history: Message[] = [
-      message("user", `u1 ${long}`),
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-      message("assistant", `a2 ${long}`),
-      message("user", `u3 ${long}`),
-      message("assistant", `a3 ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-    expect(result.compacted).toBe(true);
-    const userPromptText = capturedMessages[0]
-      .flatMap((m) => m.content)
-      .filter(
-        (b): b is Extract<ContentBlock, { type: "text" }> => b.type === "text",
-      )
-      .map((b) => b.text)
-      .join("\n");
-    expect(userPromptText).not.toContain("### Retained Thread References");
-    expect(userPromptText).not.toMatch(/→ M[0-9a-f]{6}]/);
-  });
-
-  test("does not subtract summaryOffset when summary at index 0 is child-owned from prior compaction", async () => {
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- next child summary" }],
-      model: "mock-model",
-      usage: { inputTokens: 75, outputTokens: 20 },
-      stopReason: "end_turn",
-    }));
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 320,
-        targetBudgetRatio: 0.58,
-      }),
-    });
-    const long = "k".repeat(220);
-    // Post-first-compaction state: child-owned summary at index 0, 2
-    // still-injected messages that survived the first compaction's keep
-    // region, 3 child-persisted messages. nonPersistedPrefixCount reflects
-    // only the 2 remaining injected messages — the summary slot was already
-    // consumed when the flag-gated decrement ran on the prior compaction.
-    const history: Message[] = [
-      createContextSummaryMessage("prior child summary"),
-      message("user", `injected-u ${long}`),
-      message("assistant", `injected-a ${long}`),
-      message("user", `persisted-u1 ${long}`),
-      message("assistant", `persisted-a1 ${long}`),
-      message("user", `persisted-u2 ${long}`),
-    ];
-    manager.nonPersistedPrefixCount = 2;
-    manager.summaryIsInjected = false;
-
-    const result = await manager.maybeCompact(history, undefined, {
-      force: true,
-    });
-    expect(result.compacted).toBe(true);
-    expect(result.compactedMessages).toBe(4);
-    // Regression guard: without the flag gate, the subtraction from the
-    // #24353 fix would double-apply here (nonPersistedPrefixCount - 1),
-    // undercounting injectedInCompactable and inflating
-    // compactedPersistedMessages by 1 (to 3).
-    expect(result.compactedPersistedMessages).toBe(2);
-    expect(manager.nonPersistedPrefixCount).toBe(0);
-  });
-
-  test("Slack origin bumps default minKeepRecentUserTurns to 8", async () => {
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- slack thread context" }],
-      model: "mock-model",
-      usage: { inputTokens: 60, outputTokens: 12 },
-      stopReason: "end_turn",
-    }));
-
-    // Use targetInputTokensOverride so the binary search is forced even
-    // for a small history. Both managers see the same tight budget; the
-    // only knob that varies is conversationOriginChannel.
-    const config = makeConfig({ maxInputTokens: 12_000 });
-    const long = "s".repeat(220);
-    // 9 user turns: enough headroom for Slack's bumped floor of 8 to be
-    // distinguishable from the default floor of 1.
-    const history: Message[] = [];
-    for (let i = 1; i <= 9; i++) {
-      history.push(message("user", `u${i} ${long}`));
-      history.push(message("assistant", `a${i} ${long}`));
-    }
-
-    const slackManager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config,
-    });
-    const slackResult = await slackManager.maybeCompact(history, undefined, {
-      force: true,
-      targetInputTokensOverride: 200,
-      conversationOriginChannel: "slack",
-    });
-
-    const defaultManager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config,
-    });
-    const defaultResult = await defaultManager.maybeCompact(
-      history,
-      undefined,
-      { force: true, targetInputTokensOverride: 200 },
-    );
-
-    expect(slackResult.compacted).toBe(true);
-    expect(defaultResult.compacted).toBe(true);
-    // Default floor (1 user turn) compacts more of the history than the
-    // Slack floor (8 user turns), which preserves more recent context.
-    expect(defaultResult.compactedMessages).toBeGreaterThan(
-      slackResult.compactedMessages,
-    );
-    // Slack keeps 8 of 9 user turns: 16 kept messages, 2 compacted.
-    expect(slackResult.compactedMessages).toBe(2);
-  });
-
-  test("non-Slack origin keeps default minKeepRecentUserTurns of 1", async () => {
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- standard summary" }],
-      model: "mock-model",
-      usage: { inputTokens: 60, outputTokens: 12 },
-      stopReason: "end_turn",
-    }));
-
-    const config = makeConfig({ maxInputTokens: 12_000 });
-    const long = "n".repeat(220);
-    const history: Message[] = [];
-    for (let i = 1; i <= 9; i++) {
-      history.push(message("user", `u${i} ${long}`));
-      history.push(message("assistant", `a${i} ${long}`));
-    }
-
-    // Telegram origin must behave identically to no-channel-hint default.
-    const telegramManager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config,
-    });
-    const telegramResult = await telegramManager.maybeCompact(
-      history,
-      undefined,
-      {
-        force: true,
-        targetInputTokensOverride: 200,
-        conversationOriginChannel: "telegram",
-      },
-    );
-
-    const defaultManager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config,
-    });
-    const defaultResult = await defaultManager.maybeCompact(
-      history,
-      undefined,
-      { force: true, targetInputTokensOverride: 200 },
-    );
-
-    expect(telegramResult.compacted).toBe(true);
-    expect(defaultResult.compacted).toBe(true);
-    expect(telegramResult.compactedMessages).toBe(
-      defaultResult.compactedMessages,
-    );
-  });
-
-  test("explicit minKeepRecentUserTurns wins over Slack default", async () => {
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- emergency override" }],
-      model: "mock-model",
-      usage: { inputTokens: 60, outputTokens: 12 },
-      stopReason: "end_turn",
-    }));
-
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 260,
-        targetBudgetRatio: 0.28,
-      }),
-    });
-    const long = "e".repeat(220);
-    const history: Message[] = [
-      message("user", `u1 ${long}`),
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-    ];
-
-    // Emergency override (`minKeepRecentUserTurns: 0`) must take precedence
-    // over the Slack-bumped default of 8 — this guards the agent loop's
-    // context-too-large recovery path which always passes 0.
-    const result = await manager.maybeCompact(history, undefined, {
-      force: true,
-      minKeepRecentUserTurns: 0,
-      conversationOriginChannel: "slack",
-    });
-    expect(result.compacted).toBe(true);
-    expect(result.compactedMessages).toBe(3);
-    expect(result.messages).toHaveLength(1);
-  });
-
-  test("summary provider call includes callSite: conversationSummarization", async () => {
-    // Regression guard for JARVIS-587: without the callSite, the summary
-    // call fell through to `llm.default` (opus + effort=max + thinking
-    // enabled) and exceeded the 30s plugin pipeline budget on ~150k-token
-    // transcripts. The fix is to route the summary call through the
-    // dedicated `conversationSummarization` call-site config.
-    const capturedOptions: (SendMessageOptions | undefined)[] = [];
-    const provider: Provider = {
-      name: "mock",
-      async sendMessage(
-        _messages: Message[],
-        _tools: unknown,
-        _systemPrompt: unknown,
-        options?: SendMessageOptions,
-      ): Promise<ProviderResponse> {
-        capturedOptions.push(options);
-        return {
-          content: [{ type: "text", text: "## Goals\n- summary" }],
-          model: "mock-model",
-          usage: { inputTokens: 50, outputTokens: 10 },
-          stopReason: "end_turn",
-        };
-      },
-    };
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({ maxInputTokens: 600 }),
-    });
-    const long = "x".repeat(240);
-    const history: Message[] = [
-      message("user", `u1 ${long}`),
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-      message("assistant", `a2 ${long}`),
-      message("user", `u3 ${long}`),
-      message("assistant", `a3 ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-    expect(result.compacted).toBe(true);
-    expect(capturedOptions.length).toBeGreaterThan(0);
-    for (const options of capturedOptions) {
-      expect(options?.config?.callSite).toBe("conversationSummarization");
-    }
-  });
-});
-
-describe("stripCompactionOnlyInjections", () => {
-  test("removes memory, turn_context, and workspace text blocks from user messages", () => {
-    const messages: Message[] = [
-      {
-        role: "user",
-        content: [
-          {
-            type: "text",
-            text: "<memory __injected>\nrecall notes\n</memory>",
-          },
-          {
-            type: "text",
-            text: "<turn_context>\nActor: Alice\n</turn_context>",
-          },
-          { type: "text", text: "real user content" },
-        ],
-      },
-      {
-        role: "assistant",
-        content: [{ type: "text", text: "assistant reply" }],
-      },
-    ];
-    const stripped = stripCompactionOnlyInjections(messages);
-    expect(stripped).toHaveLength(2);
-    const firstText = (stripped[0].content[0] as { text: string }).text;
-    expect(firstText).toBe("real user content");
-    expect(stripped[0].content).toHaveLength(1);
-  });
-
-  test("drops user messages that become empty after stripping", () => {
-    const messages: Message[] = [
-      {
-        role: "user",
-        content: [
-          { type: "text", text: "<memory __injected>\nonly memory\n</memory>" },
-        ],
-      },
-      { role: "user", content: [{ type: "text", text: "real content" }] },
-    ];
-    const stripped = stripCompactionOnlyInjections(messages);
-    expect(stripped).toHaveLength(1);
-    expect((stripped[0].content[0] as { text: string }).text).toBe(
-      "real content",
-    );
-  });
-
-  test("leaves assistant messages and non-text blocks untouched", () => {
-    const messages: Message[] = [
-      {
-        role: "assistant",
-        content: [
-          {
-            type: "text",
-            text: "<turn_context>\nnot really injected\n</turn_context>",
-          },
-        ],
-      },
-      {
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            tool_use_id: "t1",
-            content: "<memory>fake</memory>",
-          },
-          { type: "text", text: "user reply" },
-        ],
-      },
-    ];
-    const stripped = stripCompactionOnlyInjections(messages);
-    expect(stripped).toHaveLength(2);
-    expect((stripped[0].content[0] as { text: string }).text).toContain(
-      "turn_context",
-    );
-    expect(stripped[1].content).toHaveLength(2);
-  });
-
-  test("preserves user prose that merely mentions ambiguous tag names", () => {
-    // Common-word bare tags embedded in legitimate user prose (discussions of
-    // XML, system terminology, etc.) must survive stripping because they are
-    // not shaped like a runtime injection — no leading newline after the
-    // open tag, or other prose surrounds the tag.
-    const messages: Message[] = [
-      {
-        role: "user",
-        content: [
-          {
-            type: "text",
-            text: "<memory> is a tag I'd like to add to my parser",
-          },
-        ],
-      },
-      {
-        role: "user",
-        content: [
-          {
-            type: "text",
-            text: "checking <workspace> usage across the repo, any thoughts?",
-          },
-        ],
-      },
-      {
-        role: "user",
-        content: [
-          {
-            type: "text",
-            text: "what is <knowledge_base> in this context?",
-          },
-        ],
-      },
-      {
-        role: "user",
-        content: [
-          { type: "text", text: "<pkb> sounds like a short name — wrong?" },
-        ],
-      },
-      {
-        role: "user",
-        content: [
-          {
-            type: "text",
-            text: "when the model hits a <system_reminder>, what happens next?",
-          },
-        ],
-      },
-    ];
-    const stripped = stripCompactionOnlyInjections(messages);
-    expect(stripped).toHaveLength(messages.length);
-    for (let i = 0; i < messages.length; i++) {
-      expect(stripped[i].content).toHaveLength(1);
-      expect((stripped[i].content[0] as { text: string }).text).toBe(
-        (messages[i].content[0] as { text: string }).text,
-      );
-    }
-  });
-
-  test("still strips runtime-shaped wrapped blocks for ambiguous tag names", () => {
-    // Bare-tag blocks with a newline after the open tag and a matching close
-    // tag (e.g. `<memory>\n...\n</memory>`) match the wrapped-strip path.
-    // This covers both the current runtime emission shape and blocks
-    // persisted before the `__injected` attribute existed — the prefix list
-    // handles `__injected`-attributed tags, and the wrapped matcher handles
-    // the bare-tag wrap shape.
-    const messages: Message[] = [
-      {
-        role: "user",
-        content: [
-          { type: "text", text: "<memory>\nlegacy recall blob\n</memory>" },
-          { type: "text", text: "actual user content" },
-        ],
-      },
-      {
-        role: "user",
-        content: [
-          {
-            type: "text",
-            text: "<workspace>\nRoot: /home\nFiles: a, b\n</workspace>",
-          },
-          { type: "text", text: "more prose" },
-        ],
-      },
-      {
-        role: "user",
-        content: [
-          {
-            type: "text",
-            text: "<system_reminder>\nread your PKB\n</system_reminder>",
-          },
-          { type: "text", text: "ok" },
-        ],
-      },
-    ];
-    const stripped = stripCompactionOnlyInjections(messages);
-    expect(stripped).toHaveLength(3);
-    for (const msg of stripped) {
-      expect(msg.content).toHaveLength(1);
-    }
-    expect((stripped[0].content[0] as { text: string }).text).toBe(
-      "actual user content",
-    );
-    expect((stripped[1].content[0] as { text: string }).text).toBe(
-      "more prose",
-    );
-    expect((stripped[2].content[0] as { text: string }).text).toBe("ok");
-  });
-
-  test("does not strip a user's inline snippet that is not shaped like an injection", () => {
-    // A user quoting a `<memory>...</memory>` snippet alongside prose in the
-    // SAME text block should survive — the block does not start with
-    // `<memory>\n` (there's surrounding prose) so the wrapped-tag match
-    // does not trigger.
-    const messages: Message[] = [
-      {
-        role: "user",
-        content: [
-          {
-            type: "text",
-            text: "Here's the XML I'm working with: <memory>x</memory> — what do you think?",
-          },
-        ],
-      },
-    ];
-    const stripped = stripCompactionOnlyInjections(messages);
-    expect(stripped).toHaveLength(1);
-    expect((stripped[0].content[0] as { text: string }).text).toContain(
-      "<memory>x</memory>",
-    );
-  });
-});
-
-describe("summarizer input excludes runtime injections", () => {
-  test("maybeCompact does not pass memory/turn_context text to the summarizer", async () => {
-    const seenPrompts: string[] = [];
-    const provider = createProvider((messages) => {
-      for (const msg of messages) {
-        for (const block of msg.content) {
-          if (block.type === "text") seenPrompts.push(block.text);
-        }
-      }
-      return {
-        content: [
-          {
-            type: "text",
-            text: "## Facts Worth Remembering\n- summary produced",
-          },
-        ],
-        model: "mock",
-        usage: { inputTokens: 100, outputTokens: 25 },
-        stopReason: "end_turn",
-      };
-    });
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({
-        maxInputTokens: 2000,
-        targetBudgetRatio: 0.4,
-        compactThreshold: 0.35,
-      }),
-    });
-    const long = "x".repeat(1500);
-    const memoryBlob =
-      "<memory __injected>\nBOB_ATTENDED_STANDUP_YESTERDAY\n</memory>";
-    const turnCtx =
-      "<turn_context>\nACTOR_METADATA_THAT_SHOULD_NOT_LEAK\n</turn_context>";
-    const history: Message[] = [
-      {
-        role: "user",
-        content: [
-          { type: "text", text: memoryBlob },
-          { type: "text", text: turnCtx },
-          { type: "text", text: `u1 ${long}` },
-        ],
-      },
-      message("assistant", `a1 ${long}`),
-      message("user", `u2 ${long}`),
-      message("assistant", `a2 ${long}`),
-      message("user", `u3 ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-    expect(result.compacted).toBe(true);
-    const joined = seenPrompts.join("\n");
-    expect(joined).not.toContain("BOB_ATTENDED_STANDUP_YESTERDAY");
-    expect(joined).not.toContain("ACTOR_METADATA_THAT_SHOULD_NOT_LEAK");
-    expect(joined).not.toContain("<memory __injected>");
-    expect(joined).not.toContain("<turn_context>");
-    // Real conversation content should survive — at least one of the
-    // middle turns (whose header/body is short enough to fit within the
-    // capped transcript budget) should appear in the summarizer input.
-    expect(joined).toMatch(/u2 |a1 /);
-  });
-});
-
-describe("clampSummaryAtSectionBoundary", () => {
-  test("returns the input unchanged when under the limit", () => {
-    const summary = "## Decisions\nWe decided to ship.";
-    expect(clampSummaryAtSectionBoundary(summary, 1000)).toBe(summary);
-  });
-
-  test("truncates at a `## ` boundary when one exists in the allowed region", () => {
-    const keeper = "## Facts\n" + "a".repeat(200);
-    const dropped = "## Open Threads\n" + "b".repeat(500);
-    const summary = `${keeper}\n${dropped}`;
-    const maxChars = keeper.length + 20;
-    const clamped = clampSummaryAtSectionBoundary(summary, maxChars);
-    expect(clamped.endsWith("...")).toBe(true);
-    expect(clamped).not.toContain("## Open Threads");
-    expect(clamped).toContain("## Facts");
-    // No mid-header cut: nothing that looks like a partial heading.
-    expect(/##\s*$/.test(clamped)).toBe(false);
-  });
-
-  test("falls back to a hard cut when no section boundary is past the midpoint", () => {
-    const body = "no section headers in this output " + "z".repeat(1000);
-    const clamped = clampSummaryAtSectionBoundary(body, 100);
-    expect(clamped.endsWith("...")).toBe(true);
-    expect(clamped.length).toBeLessThanOrEqual(100);
-  });
-});
-
-describe("extractTailAssistantText", () => {
-  test("returns the most recent assistant text block", () => {
-    const messages: Message[] = [
-      message("user", "u1"),
-      message("assistant", "a1 first"),
-      message("user", "u2"),
-      message("assistant", "a2 last"),
-    ];
-    expect(extractTailAssistantText(messages)).toBe("a2 last");
-  });
-
-  test("returns null when no assistant text is present", () => {
-    const messages: Message[] = [message("user", "u1"), message("user", "u2")];
-    expect(extractTailAssistantText(messages)).toBeNull();
-  });
-
-  test("skips assistant messages with only tool_use blocks and finds the prior text", () => {
-    const messages: Message[] = [
-      message("assistant", "a1 narration before tool use"),
-      message("user", "u1"),
-      {
-        role: "assistant",
-        content: [
-          {
-            type: "tool_use",
-            id: "tool-1",
-            name: "bash",
-            input: { command: "ls" },
-          } as ContentBlock,
-        ],
-      },
-    ];
-    expect(extractTailAssistantText(messages)).toBe(
-      "a1 narration before tool use",
-    );
-  });
-
-  test("clamps long text from the start so the END is preserved", () => {
-    const longText = "early prefix " + "x".repeat(2000) + " FINAL NEXT STEP";
-    const messages: Message[] = [message("assistant", longText)];
-    const result = extractTailAssistantText(messages, 200);
-    expect(result).not.toBeNull();
-    expect(result!.startsWith("[...truncated]")).toBe(true);
-    expect(result!.endsWith("FINAL NEXT STEP")).toBe(true);
-    // Stripped block size ≈ maxChars; "[...truncated] " adds a fixed prefix.
-    expect(result!.length).toBeLessThanOrEqual(200 + "[...truncated] ".length);
-  });
-
-  test("ignores empty/whitespace-only assistant text", () => {
-    const messages: Message[] = [
-      message("assistant", "real content"),
-      message("assistant", "   \n  "),
-    ];
-    expect(extractTailAssistantText(messages)).toBe("real content");
-  });
-
-  test("returns null for an empty messages array", () => {
-    expect(extractTailAssistantText([])).toBeNull();
-  });
-});
-
-describe("appendTailAnchorToSummary", () => {
-  test("appends a tag-wrapped block after the summary", () => {
-    const out = appendTailAnchorToSummary(
-      "## Goals\n- item",
-      "Next step: file the SSE followup.",
-    );
-    expect(out).toContain("## Goals\n- item");
-    expect(out).toContain(
-      "<verbatim_tail>\nNext step: file the SSE followup.\n</verbatim_tail>",
-    );
-    expect(out.endsWith("</verbatim_tail>")).toBe(true);
-  });
-
-  test("is idempotent: re-applying with new text replaces the prior tail", () => {
-    const first = appendTailAnchorToSummary("body", "tail-1");
-    const second = appendTailAnchorToSummary(first, "tail-2");
-    expect(second).toContain("body");
-    expect(second).toContain("tail-2");
-    expect(second).not.toContain("tail-1");
-    // Exactly one open-tag occurrence — no stacking.
-    expect(second.match(/<verbatim_tail>/g)?.length).toBe(1);
-  });
-});
-
-describe("compaction tail-anchor", () => {
-  test("splices the last assistant text block verbatim into the summary message", async () => {
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- LLM summary" }],
-      model: "mock-model",
-      usage: { inputTokens: 100, outputTokens: 25 },
-      stopReason: "end_turn",
-    }));
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({ maxInputTokens: 600 }),
-    });
-    const long = "x".repeat(240);
-    const distinctiveTail =
-      "Pushed 8fe70d63a0 — next step: file the SSE followup as promised.";
-    // Place `distinctiveTail` as the assistant response for u1 so it lands
-    // at the end of the compactable region. With the same 600-token budget
-    // and 6-message shape as the existing 600-token compaction test above,
-    // the binary search settles on keepTurns=2 (kept = [u2, a2, u3, a3];
-    // compactable = [u1, distinctiveTail]) — exercising the real-world
-    // drift scenario where the model's last narration in a long work span
-    // gets summarized away.
-    const history: Message[] = [
-      message("user", `u1 ${long}`),
-      message("assistant", distinctiveTail),
-      message("user", `u2 ${long}`),
-      message("assistant", `a2 ${long}`),
-      message("user", `u3 ${long}`),
-      message("assistant", `a3 ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-
-    expect(result.compacted).toBe(true);
-    const summaryInner = getSummaryFromContextMessage(result.messages[0]);
-    expect(summaryInner).not.toBeNull();
-    // LLM summary still present.
-    expect(summaryInner).toContain("LLM summary");
-    // Verbatim tail spliced in: distinctive text from the LAST assistant
-    // message in the compactable region (here, `distinctiveTail`).
-    expect(summaryInner).toContain("<verbatim_tail>");
-    expect(summaryInner).toContain(distinctiveTail);
-    expect(summaryInner).toContain("</verbatim_tail>");
-    // summaryText reflects what's persisted in messages[0] for consistency
-    // with downstream consumers (DB, context_compacted event).
-    expect(result.summaryText).toContain(distinctiveTail);
-  });
-
-  test("omits the tail-anchor block when no assistant text exists in compactable region", async () => {
-    // Construct a scenario where the compactable region has assistant
-    // messages with ONLY tool_use blocks (no text) plus user turns. The
-    // anchor should be omitted gracefully.
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- summary" }],
-      model: "mock-model",
-      usage: { inputTokens: 100, outputTokens: 25 },
-      stopReason: "end_turn",
-    }));
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({ maxInputTokens: 600 }),
-    });
-    const long = "x".repeat(240);
-    const history: Message[] = [
-      message("user", `u1 ${long}`),
-      {
-        role: "assistant",
-        content: [
-          {
-            type: "tool_use",
-            id: "tool-1",
-            name: "bash",
-            input: { command: "ls" },
-          } as ContentBlock,
-        ],
-      },
-      {
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            tool_use_id: "tool-1",
-            content: "ls output",
-          } as ContentBlock,
-        ],
-      },
-      message("user", `u2 ${long}`),
-      message("assistant", `a2 ${long}`),
-      message("user", `u3 ${long}`),
-      message("assistant", `a3 ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-
-    expect(result.compacted).toBe(true);
-    const summaryInner = getSummaryFromContextMessage(result.messages[0]);
-    expect(summaryInner).not.toBeNull();
-    // No tail anchor when the only compactable assistant message has no text.
-    // (a2 / a3 are kept verbatim post-compaction since they're recent enough,
-    // so the compactable-region's only assistant message is the tool_use one.)
-    if (summaryInner!.includes("<verbatim_tail>")) {
-      // If a2 ended up in the compactable region after binary search, the
-      // anchor would surface a2's text — which is fine; the assertion that
-      // matters is that the spliced content (when present) is verbatim
-      // content from the compactable region, not noise. Validate the
-      // ordering: anchor must follow LLM summary text.
-      expect(summaryInner!.indexOf("summary")).toBeLessThan(
-        summaryInner!.indexOf("<verbatim_tail>"),
-      );
-    }
-  });
-
-  test("clamps tail-anchor when the last assistant text is longer than the cap", async () => {
-    const provider = createProvider(() => ({
-      content: [{ type: "text", text: "## Goals\n- summary" }],
-      model: "mock-model",
-      usage: { inputTokens: 100, outputTokens: 25 },
-      stopReason: "end_turn",
-    }));
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config: makeConfig({ maxInputTokens: 600 }),
-    });
-    const long = "x".repeat(240);
-    const tailEnd = "FINAL DISTINCTIVE END MARKER";
-    // Long enough to trip TAIL_ANCHOR_MAX_CHARS (=1500) clamping.
-    const longTail = "early body " + "y".repeat(2000) + " " + tailEnd;
-    const history: Message[] = [
-      message("user", `u1 ${long}`),
-      message("assistant", longTail),
-      message("user", `u2 ${long}`),
-      message("assistant", `a2 ${long}`),
-      message("user", `u3 ${long}`),
-      message("assistant", `a3 ${long}`),
-    ];
-
-    const result = await manager.maybeCompact(history);
-
-    expect(result.compacted).toBe(true);
-    const summaryInner = getSummaryFromContextMessage(result.messages[0]);
-    expect(summaryInner).not.toBeNull();
-    if (summaryInner!.includes("<verbatim_tail>")) {
-      // When clamped, the END is preserved (most recent narration).
-      expect(summaryInner).toContain(tailEnd);
-      // And the early prefix is dropped.
-      expect(summaryInner).toContain("[...truncated]");
-      expect(summaryInner).not.toContain("early body");
-    }
-  });
-});