@vellumai/assistant 0.6.4 → 0.6.5

package/src/context/__tests__/microcompact.test.ts

@@ -0,0 +1,805 @@
+import { describe, expect, test } from "bun:test";
+
+import type {
+  Message,
+  ToolResultContent,
+  ToolUseContent,
+} from "../../providers/types.js";
+import { microcompact } from "../microcompact.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function userText(text: string): Message {
+  return { role: "user", content: [{ type: "text", text }] };
+}
+
+function assistantToolUse(
+  id: string,
+  name: string,
+  input: Record<string, unknown> = {},
+): Message {
+  const block: ToolUseContent = { type: "tool_use", id, name, input };
+  return { role: "assistant", content: [block] };
+}
+
+function toolResult(
+  tool_use_id: string,
+  content: string,
+  extras: Partial<
+    Omit<ToolResultContent, "type" | "tool_use_id" | "content">
+  > = {},
+): Message {
+  const block: ToolResultContent = {
+    type: "tool_result",
+    tool_use_id,
+    content,
+    ...extras,
+  };
+  return { role: "user", content: [block] };
+}
+
+/**
+ * Build a realistic multi-turn conversation where every "exchange" is a
+ * user text message followed by a tool_use + tool_result pair.
+ *
+ * turns[i].tool = the tool name used on turn i.
+ * turns[i].resultBody = the text of the tool_result for that turn.
+ */
+function buildConversation(
+  turns: Array<{ tool: string; resultBody: string; userText?: string }>,
+): Message[] {
+  const out: Message[] = [];
+  for (let i = 0; i < turns.length; i++) {
+    const t = turns[i];
+    const id = `tu-${i}`;
+    out.push(userText(t.userText ?? `user says ${i}`));
+    out.push(assistantToolUse(id, t.tool));
+    out.push(toolResult(id, t.resultBody));
+  }
+  return out;
+}
+
+/** Large payload sized to dominate the token budget. */
+function big(label: string, size = 10_000): string {
+  return `${label}:${"x".repeat(size)}`;
+}
+
+/** Count tool_result blocks whose content equals the cleared placeholder. */
+function countClearedToolResults(messages: Message[]): number {
+  let n = 0;
+  for (const m of messages) {
+    for (const b of m.content) {
+      if (
+        b.type === "tool_result" &&
+        b.content === "[Old tool result content cleared]"
+      ) {
+        n += 1;
+      }
+    }
+  }
+  return n;
+}
+
+function findToolResults(messages: Message[]): ToolResultContent[] {
+  const out: ToolResultContent[] = [];
+  for (const m of messages) {
+    for (const b of m.content) {
+      if (b.type === "tool_result") out.push(b);
+    }
+  }
+  return out;
+}
+
+function findToolUses(messages: Message[]): ToolUseContent[] {
+  const out: ToolUseContent[] = [];
+  for (const m of messages) {
+    for (const b of m.content) {
+      if (b.type === "tool_use") out.push(b);
+    }
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------------------
+// (a) last-N-turns-protected invariant
+// ---------------------------------------------------------------------------
+
+describe("microcompact — protectRecentTurns invariant", () => {
+  test("leaves the last N user turns untouched", () => {
+    const turns = Array.from({ length: 8 }, () => ({
+      tool: "Bash",
+      resultBody: big("stale"),
+    }));
+    const messages = buildConversation(turns);
+
+    // Cleared count *in the stripped region* should be exactly 8 - 4 = 4
+    // when protectRecentTurns = 4 (default).
+    const result = microcompact(messages);
+
+    expect(result.clearedToolResults).toBe(4);
+    expect(result.reclaimedTokens).toBeGreaterThan(0);
+
+    // The last 4 user turns occupy indices 12..23 of a 24-message array
+    // (3 messages per turn × 8 turns). Every tool_result at index >= 12
+    // must still contain the original body.
+    const trs = findToolResults(result.messages);
+    // tool_results are at message indices 2,5,8,...23 — the 4 newest are
+    // at positions 4..7 in this list (i.e. turns 4..7).
+    for (let i = 0; i < 4; i++) {
+      expect(trs[i].content).toBe("[Old tool result content cleared]");
+    }
+    for (let i = 4; i < 8; i++) {
+      expect(trs[i].content.startsWith("stale:")).toBe(true);
+    }
+  });
+
+  test("when history has fewer turns than protectRecentTurns, nothing is cleared", () => {
+    const messages = buildConversation([
+      { tool: "Bash", resultBody: big("stale") },
+      { tool: "Bash", resultBody: big("stale") },
+    ]);
+    const result = microcompact(messages, { protectRecentTurns: 4 });
+    expect(result.clearedToolResults).toBe(0);
+    expect(result.reclaimedTokens).toBe(0);
+    expect(result.messages).toBe(messages);
+  });
+
+  test("tool_result-only user messages do not count as a user turn", () => {
+    // A single exchange where the user sends text, then the model makes 3
+    // separate tool calls. Providers emit one user message per tool_result,
+    // all of which are tool_result-only. Those should not each count as a
+    // user turn — otherwise protectRecentTurns=1 would protect everything.
+    const msgs: Message[] = [
+      userText("first real user turn"),
+      assistantToolUse("tu-1", "Bash"),
+      toolResult("tu-1", big("body-1")),
+      assistantToolUse("tu-2", "Bash"),
+      toolResult("tu-2", big("body-2")),
+      assistantToolUse("tu-3", "Bash"),
+      toolResult("tu-3", big("body-3")),
+      userText("second real user turn"),
+      assistantToolUse("tu-4", "Bash"),
+      toolResult("tu-4", big("body-4")),
+    ];
+    // protectRecentTurns=1 should protect ONLY the "second real user turn"
+    // and its tool_result (tu-4). tu-1..tu-3 should be cleared.
+    const result = microcompact(msgs, { protectRecentTurns: 1 });
+    expect(result.clearedToolResults).toBe(3);
+
+    const trs = findToolResults(result.messages);
+    expect(trs[0].content).toBe("[Old tool result content cleared]");
+    expect(trs[1].content).toBe("[Old tool result content cleared]");
+    expect(trs[2].content).toBe("[Old tool result content cleared]");
+    expect(trs[3].content.startsWith("body-4:")).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// (b) protected tools never cleared
+// ---------------------------------------------------------------------------
+
+describe("microcompact — protected tools", () => {
+  test("never replaces the body of a tool_result from a protected tool", () => {
+    // 6 turns: 1 Task, 1 subagent, 1 skill, 3 Bash — plus 4 protected turns
+    // at the tail to push the first 6 into the stripped region.
+    const turns = [
+      { tool: "Task", resultBody: big("task-result") },
+      { tool: "subagent", resultBody: big("subagent-result") },
+      { tool: "skill", resultBody: big("skill-result") },
+      { tool: "Bash", resultBody: big("bash-1") },
+      { tool: "Bash", resultBody: big("bash-2") },
+      { tool: "Bash", resultBody: big("bash-3") },
+      // Protected tail — 4 recent turns.
+      { tool: "Bash", resultBody: "recent-1" },
+      { tool: "Bash", resultBody: "recent-2" },
+      { tool: "Bash", resultBody: "recent-3" },
+      { tool: "Bash", resultBody: "recent-4" },
+    ];
+    const messages = buildConversation(turns);
+    const result = microcompact(messages);
+
+    // Only the 3 Bash calls in the stripped region should have been cleared.
+    expect(result.clearedToolResults).toBe(3);
+
+    const trs = findToolResults(result.messages);
+    // Turn 0 (Task) — body preserved
+    expect(trs[0].content.startsWith("task-result:")).toBe(true);
+    // Turn 1 (subagent) — body preserved
+    expect(trs[1].content.startsWith("subagent-result:")).toBe(true);
+    // Turn 2 (skill) — body preserved
+    expect(trs[2].content.startsWith("skill-result:")).toBe(true);
+    // Turns 3,4,5 — cleared
+    expect(trs[3].content).toBe("[Old tool result content cleared]");
+    expect(trs[4].content).toBe("[Old tool result content cleared]");
+    expect(trs[5].content).toBe("[Old tool result content cleared]");
+  });
+
+  test("custom protectedTools override the default list", () => {
+    const turns = [
+      { tool: "Task", resultBody: big("task-body") },
+      { tool: "MyTool", resultBody: big("mytool-body") },
+      // Protected tail
+      { tool: "Bash", resultBody: "recent-1" },
+      { tool: "Bash", resultBody: "recent-2" },
+      { tool: "Bash", resultBody: "recent-3" },
+      { tool: "Bash", resultBody: "recent-4" },
+    ];
+    const messages = buildConversation(turns);
+    const result = microcompact(messages, { protectedTools: ["MyTool"] });
+
+    const trs = findToolResults(result.messages);
+    // Task is NO LONGER protected (not in the custom list) — should be cleared.
+    expect(trs[0].content).toBe("[Old tool result content cleared]");
+    // MyTool is protected — body preserved.
+    expect(trs[1].content.startsWith("mytool-body:")).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// (c) idempotency
+// ---------------------------------------------------------------------------
+
+describe("microcompact — idempotency", () => {
+  test("running twice produces zero incremental reclaim", () => {
+    const turns = Array.from({ length: 8 }, () => ({
+      tool: "Bash",
+      resultBody: big("stale"),
+    }));
+    const messages = buildConversation(turns);
+
+    const first = microcompact(messages);
+    expect(first.reclaimedTokens).toBeGreaterThan(0);
+    expect(first.clearedToolResults).toBeGreaterThan(0);
+
+    const second = microcompact(first.messages);
+    expect(second.reclaimedTokens).toBe(0);
+    expect(second.clearedToolResults).toBe(0);
+    // Second pass returns the same reference when there's nothing to do.
+    expect(second.messages).toBe(first.messages);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// (d) minGainTokens no-op
+// ---------------------------------------------------------------------------
+
+describe("microcompact — minGainTokens", () => {
+  test("returns original messages when reclaim is below the floor", () => {
+    // Tiny bodies — stale region exists but compaction saves very little.
+    const turns = Array.from({ length: 8 }, (_, i) => ({
+      tool: "Bash",
+      resultBody: `tiny-${i}`,
+    }));
+    const messages = buildConversation(turns);
+
+    const result = microcompact(messages, { minGainTokens: 10_000 });
+    expect(result.reclaimedTokens).toBe(0);
+    expect(result.clearedToolResults).toBe(0);
+    // Original reference returned verbatim.
+    expect(result.messages).toBe(messages);
+  });
+
+  test("returns compacted messages when reclaim meets the floor", () => {
+    const turns = Array.from({ length: 8 }, () => ({
+      tool: "Bash",
+      resultBody: big("stale"),
+    }));
+    const messages = buildConversation(turns);
+
+    const result = microcompact(messages, { minGainTokens: 100 });
+    expect(result.reclaimedTokens).toBeGreaterThanOrEqual(100);
+    expect(result.messages).not.toBe(messages);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// (e) <ax-tree> block stripping
+// ---------------------------------------------------------------------------
+
+describe("microcompact — ax-tree stripping", () => {
+  test("strips ax-tree blocks from protected tool_results in the stripped region", () => {
+    // Place a protected (Task) tool_result in the stripped region and verify
+    // that its ax-tree is collapsed even though the rest of its body is
+    // preserved.
+    const axTreeBody = `Task output before.\n<ax-tree>\n${"<node/>".repeat(
+      1000,
+    )}\n</ax-tree>\nTask output after.`;
+
+    const turns = [
+      { tool: "Task", resultBody: axTreeBody },
+      // Protected tail
+      { tool: "Bash", resultBody: "recent-1" },
+      { tool: "Bash", resultBody: "recent-2" },
+      { tool: "Bash", resultBody: "recent-3" },
+      { tool: "Bash", resultBody: "recent-4" },
+    ];
+    const messages = buildConversation(turns);
+    const result = microcompact(messages, { minGainTokens: 100 });
+
+    const trs = findToolResults(result.messages);
+    // Task body preserved (it's protected), but ax-tree is collapsed.
+    expect(trs[0].content).not.toContain("<ax-tree>");
+    expect(trs[0].content).not.toContain("</ax-tree>");
+    expect(trs[0].content).toContain("<ax_tree_omitted />");
+    expect(trs[0].content).toContain("Task output before.");
+    expect(trs[0].content).toContain("Task output after.");
+  });
+
+  test("leaves ax-tree blocks in the protected tail untouched", () => {
+    const axTreeBody = `recent output.\n<ax-tree>\n${"<node/>".repeat(
+      500,
+    )}\n</ax-tree>`;
+
+    // Only 2 turns — protectRecentTurns defaults to 4, so everything is
+    // protected and ax-trees must not be touched.
+    const messages = buildConversation([
+      { tool: "Task", resultBody: axTreeBody },
+      { tool: "Task", resultBody: axTreeBody },
+    ]);
+    const result = microcompact(messages);
+
+    const trs = findToolResults(result.messages);
+    expect(trs[0].content).toContain("<ax-tree>");
+    expect(trs[1].content).toContain("<ax-tree>");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// (f) image / file block stubbing
+// ---------------------------------------------------------------------------
+
+describe("microcompact — image/file stubbing", () => {
+  test("replaces image and file blocks in the stripped region with text stubs", () => {
+    const bigBase64 = "A".repeat(20_000);
+
+    const msgs: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "look at these" },
+          {
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: "image/png",
+              data: bigBase64,
+            },
+          },
+          {
+            type: "file",
+            source: {
+              type: "base64",
+              media_type: "application/pdf",
+              data: bigBase64,
+              filename: "report.pdf",
+            },
+          },
+        ],
+      },
+      { role: "assistant", content: [{ type: "text", text: "ok" }] },
+      // Push 4 follow-up user turns so the image-bearing message is in the
+      // stripped region.
+      userText("t1"),
+      { role: "assistant", content: [{ type: "text", text: "r1" }] },
+      userText("t2"),
+      { role: "assistant", content: [{ type: "text", text: "r2" }] },
+      userText("t3"),
+      { role: "assistant", content: [{ type: "text", text: "r3" }] },
+      userText("t4"),
+      { role: "assistant", content: [{ type: "text", text: "r4" }] },
+    ];
+
+    const result = microcompact(msgs);
+
+    expect(result.clearedMedia).toBe(2);
+    expect(result.reclaimedTokens).toBeGreaterThan(0);
+
+    // The image and file blocks should be replaced with text stubs.
+    const first = result.messages[0];
+    expect(first.content[0]).toEqual({ type: "text", text: "look at these" });
+    expect(first.content[1]).toEqual({ type: "text", text: "[image omitted]" });
+    expect(first.content[2]).toEqual({ type: "text", text: "[file omitted]" });
+
+    // No image or file blocks remain anywhere in the output.
+    const hasImageOrFile = result.messages.some((m) =>
+      m.content.some((b) => b.type === "image" || b.type === "file"),
+    );
+    expect(hasImageOrFile).toBe(false);
+  });
+
+  test("leaves image blocks in the protected tail untouched", () => {
+    const bigBase64 = "A".repeat(5_000);
+
+    const msgs: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "recent user turn" },
+          {
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: "image/png",
+              data: bigBase64,
+            },
+          },
+        ],
+      },
+      { role: "assistant", content: [{ type: "text", text: "ok" }] },
+    ];
+
+    const result = microcompact(msgs);
+    expect(result.clearedMedia).toBe(0);
+    expect(result.messages).toBe(msgs);
+
+    const firstBlocks = result.messages[0].content;
+    expect(firstBlocks[1].type).toBe("image");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// (g) tool_use / tool_result pairing invariant
+// ---------------------------------------------------------------------------
+
+describe("microcompact — tool_use/tool_result pairing", () => {
+  test("every tool_use retains a matching tool_result after compaction", () => {
+    const turns = Array.from({ length: 8 }, () => ({
+      tool: "Bash",
+      resultBody: big("stale"),
+    }));
+    const messages = buildConversation(turns);
+    const result = microcompact(messages);
+
+    const tuIds = new Set(findToolUses(result.messages).map((b) => b.id));
+    const trIds = new Set(
+      findToolResults(result.messages).map((b) => b.tool_use_id),
+    );
+
+    expect(tuIds.size).toBe(8);
+    expect(trIds.size).toBe(8);
+    for (const id of tuIds) {
+      expect(trIds.has(id)).toBe(true);
+    }
+  });
+
+  test("message roles and block types are preserved — only bodies mutate", () => {
+    const turns = Array.from({ length: 6 }, () => ({
+      tool: "Bash",
+      resultBody: big("stale"),
+    }));
+    const messages = buildConversation(turns);
+    const result = microcompact(messages);
+
+    expect(result.messages.length).toBe(messages.length);
+    for (let i = 0; i < messages.length; i++) {
+      expect(result.messages[i].role).toBe(messages[i].role);
+      expect(result.messages[i].content.length).toBe(
+        messages[i].content.length,
+      );
+      for (let j = 0; j < messages[i].content.length; j++) {
+        expect(result.messages[i].content[j].type).toBe(
+          messages[i].content[j].type,
+        );
+      }
+    }
+
+    // And every cleared tool_result retains its tool_use_id.
+    const resultTrs = findToolResults(result.messages);
+    const originalTrs = findToolResults(messages);
+    for (let i = 0; i < resultTrs.length; i++) {
+      expect(resultTrs[i].tool_use_id).toBe(originalTrs[i].tool_use_id);
+    }
+  });
+
+  test("preserves is_error flag when clearing", () => {
+    const messages: Message[] = [
+      userText("initial"),
+      assistantToolUse("tu-err", "Bash"),
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "tu-err",
+            content: big("error-body"),
+            is_error: true,
+          },
+        ],
+      },
+      // Push 4 turns to strip the first.
+      userText("t1"),
+      { role: "assistant", content: [{ type: "text", text: "r1" }] },
+      userText("t2"),
+      { role: "assistant", content: [{ type: "text", text: "r2" }] },
+      userText("t3"),
+      { role: "assistant", content: [{ type: "text", text: "r3" }] },
+      userText("t4"),
+      { role: "assistant", content: [{ type: "text", text: "r4" }] },
+    ];
+
+    const result = microcompact(messages);
+    const errBlock = result.messages[2].content[0] as ToolResultContent;
+    expect(errBlock.type).toBe("tool_result");
+    expect(errBlock.content).toBe("[Old tool result content cleared]");
+    expect(errBlock.is_error).toBe(true);
+  });
+
+  test("strips contentBlocks (rich content) from cleared tool_results", () => {
+    const messages: Message[] = [
+      userText("initial"),
+      assistantToolUse("tu-rich", "Bash"),
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "tu-rich",
+            content: big("body"),
+            contentBlocks: [
+              {
+                type: "image",
+                source: {
+                  type: "base64",
+                  media_type: "image/png",
+                  data: "X".repeat(10_000),
+                },
+              },
+            ],
+          } as ToolResultContent,
+        ],
+      },
+      // Push 4 turns to strip the first.
+      userText("t1"),
+      { role: "assistant", content: [{ type: "text", text: "r1" }] },
+      userText("t2"),
+      { role: "assistant", content: [{ type: "text", text: "r2" }] },
+      userText("t3"),
+      { role: "assistant", content: [{ type: "text", text: "r3" }] },
+      userText("t4"),
+      { role: "assistant", content: [{ type: "text", text: "r4" }] },
+    ];
+
+    const result = microcompact(messages);
+    const cleared = result.messages[2].content[0] as ToolResultContent;
+    expect(cleared.contentBlocks).toBeUndefined();
+    expect(cleared.content).toBe("[Old tool result content cleared]");
+  });
+
+  test("preserves text entries in contentBlocks on protected tool_results, drops media", () => {
+    // A protected (Task) tool_result in the stripped region carrying both a
+    // text entry AND an image entry in its `contentBlocks`. Before the P2
+    // fix, BOTH were dropped; text entries can be meaningful (protected-tool
+    // narration) and must survive.
+    const messages: Message[] = [
+      userText("initial"),
+      assistantToolUse("tu-prot", "Task"),
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "tu-prot",
+            content: big("task-body"),
+            contentBlocks: [
+              { type: "text", text: "important narration from subagent" },
+              {
+                type: "image",
+                source: {
+                  type: "base64",
+                  media_type: "image/png",
+                  data: "X".repeat(10_000),
+                },
+              },
+            ],
+          } as ToolResultContent,
+        ],
+      },
+      // Push 4 turns to strip the first.
+      userText("t1"),
+      { role: "assistant", content: [{ type: "text", text: "r1" }] },
+      userText("t2"),
+      { role: "assistant", content: [{ type: "text", text: "r2" }] },
+      userText("t3"),
+      { role: "assistant", content: [{ type: "text", text: "r3" }] },
+      userText("t4"),
+      { role: "assistant", content: [{ type: "text", text: "r4" }] },
+    ];
+
+    const result = microcompact(messages);
+    const preserved = result.messages[2].content[0] as ToolResultContent;
+
+    // Body is preserved (protected tool — ax-tree stripping only, body kept).
+    expect(preserved.type).toBe("tool_result");
+    expect(preserved.content.startsWith("task-body:")).toBe(true);
+
+    // Text contentBlock entry survives.
+    expect(preserved.contentBlocks).toBeDefined();
+    expect(preserved.contentBlocks!.length).toBe(1);
+    expect(preserved.contentBlocks![0]).toEqual({
+      type: "text",
+      text: "important narration from subagent",
+    });
+
+    // Media entry was dropped, which saved tokens.
+    expect(result.reclaimedTokens).toBeGreaterThan(0);
+  });
+
+  test("protected tool_result with only text contentBlocks is a no-op (body unchanged, text kept)", () => {
+    // No media to strip and no ax-tree in body — nothing should change.
+    const messages: Message[] = [
+      userText("initial"),
+      assistantToolUse("tu-prot-txt", "Task"),
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "tu-prot-txt",
+            content: "task body without ax-tree",
+            contentBlocks: [
+              { type: "text", text: "only a text attachment here" },
+            ],
+          } as ToolResultContent,
+        ],
+      },
+      userText("t1"),
+      { role: "assistant", content: [{ type: "text", text: "r1" }] },
+      userText("t2"),
+      { role: "assistant", content: [{ type: "text", text: "r2" }] },
+      userText("t3"),
+      { role: "assistant", content: [{ type: "text", text: "r3" }] },
+      userText("t4"),
+      { role: "assistant", content: [{ type: "text", text: "r4" }] },
+    ];
+
+    const result = microcompact(messages, { minGainTokens: 0 });
+    // No reclaim for the protected tool_result, so it keeps its original text
+    // entries and body.
+    const kept = result.messages[2].content[0] as ToolResultContent;
+    expect(kept.content).toBe("task body without ax-tree");
+    expect(kept.contentBlocks).toBeDefined();
+    expect(kept.contentBlocks!.length).toBe(1);
+    expect(kept.contentBlocks![0]).toEqual({
+      type: "text",
+      text: "only a text attachment here",
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// (h) web_search_tool_result & system_notice classifier
+// ---------------------------------------------------------------------------
+
+describe("microcompact — tool-response-only user message classifier", () => {
+  test("web_search_tool_result-only user messages do not count as a user turn", () => {
+    // Single real user turn followed by an assistant server_tool_use and a
+    // web_search_tool_result-only user message. protectRecentTurns=1 should
+    // still protect the single real user turn plus its trailing assistant
+    // response — NOT wastefully also protect the web_search_tool_result
+    // message (which would push the real tool_result on the prior turn out of
+    // reach).
+    const msgs: Message[] = [
+      userText("first real user turn"),
+      assistantToolUse("tu-old", "Bash"),
+      toolResult("tu-old", big("old-body")),
+      userText("second real user turn"),
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "server_tool_use",
+            id: "srv-1",
+            name: "web_search",
+            input: { query: "x" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "web_search_tool_result",
+            tool_use_id: "srv-1",
+            content: [],
+          },
+        ],
+      },
+      { role: "assistant", content: [{ type: "text", text: "done" }] },
+    ];
+
+    // protectRecentTurns=1 should protect ONLY "second real user turn" and
+    // everything after. tu-old (attached to "first real user turn") should be
+    // cleared.
+    const result = microcompact(msgs, { protectRecentTurns: 1 });
+    expect(result.clearedToolResults).toBe(1);
+
+    const trs = findToolResults(result.messages);
+    expect(trs[0].content).toBe("[Old tool result content cleared]");
+  });
+
+  test("system_notice-only text user messages do not count as a user turn", () => {
+    // System notices (retry nudges / progress checks) are injected as
+    // user-role text blocks wrapped in <system_notice>...</system_notice>.
+    // They must not be treated as real user turns.
+    const msgs: Message[] = [
+      userText("first real user turn"),
+      assistantToolUse("tu-old", "Bash"),
+      toolResult("tu-old", big("old-body")),
+      userText("second real user turn"),
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "some response" }],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "<system_notice>please continue</system_notice>",
+          },
+        ],
+      },
+    ];
+
+    const result = microcompact(msgs, { protectRecentTurns: 1 });
+    expect(result.clearedToolResults).toBe(1);
+
+    const trs = findToolResults(result.messages);
+    expect(trs[0].content).toBe("[Old tool result content cleared]");
+  });
+
+  test("mixed user message (real text + tool_result) still counts as a user turn", () => {
+    // A user message containing both real text AND tool-response blocks is
+    // still a real user turn — don't misclassify.
+    const msgs: Message[] = [
+      userText("older turn"),
+      assistantToolUse("tu-old", "Bash"),
+      toolResult("tu-old", big("old-body")),
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "new user message with context" },
+          {
+            type: "tool_result",
+            tool_use_id: "tu-old",
+            content: "inline result",
+          } as ToolResultContent,
+        ],
+      },
+      { role: "assistant", content: [{ type: "text", text: "response" }] },
+    ];
+
+    // protectRecentTurns=1 should protect the mixed message + trailing
+    // assistant response; the older turn's tool_result should be cleared.
+    const result = microcompact(msgs, { protectRecentTurns: 1 });
+    expect(result.clearedToolResults).toBe(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Summary counters sanity
+// ---------------------------------------------------------------------------
+
+describe("microcompact — counter sanity", () => {
+  test("counts match what was actually cleared", () => {
+    const messages = buildConversation(
+      Array.from({ length: 8 }, () => ({
+        tool: "Bash",
+        resultBody: big("stale"),
+      })),
+    );
+    const result = microcompact(messages);
+    expect(countClearedToolResults(result.messages)).toBe(
+      result.clearedToolResults,
+    );
+  });
+
+  test("empty input returns zero counters and original reference", () => {
+    const result = microcompact([]);
+    expect(result.reclaimedTokens).toBe(0);
+    expect(result.clearedToolResults).toBe(0);
+    expect(result.clearedMedia).toBe(0);
+  });
+});