@zhushanwen/pi-context-engineering 0.1.0

package/src/__tests__/compressor.test.ts

@@ -0,0 +1,911 @@
+import { describe, it, expect } from "vitest";
+import {
+  compressContext,
+  validateToolPairing,
+  getToolResultText,
+  processMicrocompact,
+  processBudget,
+  findCompactBoundary,
+  type AgentMessage,
+  type ToolCall,
+  type AssistantMessage,
+  type ToolResultMessage,
+  type BashExecutionMessage,
+  type UserMessage,
+  type TextContent,
+  type ThinkingContent,
+  type ContextUsage,
+} from "../compressor";
+import { createRecallStore } from "../recall-store";
+import { createFrozenFreshState } from "../frozen-fresh";
+import { DEFAULT_CONFIG } from "../config";
+
+// ── Test helpers ──
+
+function makeToolResult(text: string, ageMs: number, toolCallId: string): ToolResultMessage {
+  return {
+    role: "toolResult",
+    toolCallId,
+    toolName: "read",
+    content: [{ type: "text" as const, text }],
+    isError: false,
+    timestamp: Date.now() - ageMs,
+  };
+}
+
+function makeAssistant(
+  toolCalls: ToolCall[],
+  thinking?: string,
+  ageMs: number = 0,
+): AssistantMessage {
+  const content: (TextContent | ThinkingContent | ToolCall)[] = [];
+  if (thinking) {
+    content.push({ type: "thinking" as const, thinking });
+  }
+  content.push(...toolCalls);
+  if (toolCalls.length === 0 && !thinking) {
+    content.push({ type: "text" as const, text: "ok" });
+  }
+  return {
+    role: "assistant",
+    content,
+    api: "anthropic-messages",
+    provider: "anthropic",
+    model: "test",
+    usage: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      totalTokens: 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    },
+    stopReason: "stop",
+    timestamp: Date.now() - ageMs,
+  };
+}
+
+function makeUser(text: string, ageMs: number = 0): UserMessage {
+  return { role: "user", content: text, timestamp: Date.now() - ageMs };
+}
+
+function makeCompactionSummary(summary: string, ageMs: number = 0) {
+  return { role: "compactionSummary" as const, summary, tokensBefore: 0, timestamp: Date.now() - ageMs };
+}
+
+function makeBashExecution(output: string, ageMs: number = 0): BashExecutionMessage {
+  return {
+    role: "bashExecution",
+    command: "cat file.txt",
+    output,
+    exitCode: 0,
+    cancelled: false,
+    truncated: false,
+    timestamp: Date.now() - ageMs,
+  };
+}
+
+function tc(id: string, name: string = "read"): ToolCall {
+  return {
+    type: "toolCall" as const,
+    id,
+    name,
+    arguments: { path: "file.ts" } as Record<string, unknown>,
+  };
+}
+
+// ── Tests ──
+
+describe("compressor", () => {
+    const ffState = createFrozenFreshState();
+  const MINUTE = 60 * 1000;
+
+  it("AC-1: 过期清理 — 过期的 ToolResult 被替换，保护 turn 内的保留", () => {
+    const store = createRecallStore();
+    const config = { ...DEFAULT_CONFIG, l0: { ...DEFAULT_CONFIG.l0, keepRecent: 0 } };
+
+    // Turn 1: user(40min) → assistant(tc1) → toolResult(35min, 应过期)
+    // Turn 2: user(20min) → assistant(tc2) → toolResult(15min, 在保护 turn 内)
+    // Turn 3: user(1min)  — 让 Turn 2+3 成为保护 turn (protectRecentTurns=2)
+    const messages: AgentMessage[] = [
+      makeUser("task 1", 40 * MINUTE),
+      makeAssistant([tc("c1")], undefined, 40 * MINUTE),
+      makeToolResult("content of file A", 35 * MINUTE, "c1"),
+      makeUser("task 2", 20 * MINUTE),
+      makeAssistant([tc("c2")], undefined, 20 * MINUTE),
+      makeToolResult("content of file B", 15 * MINUTE, "c2"),
+      makeUser("task 3", 1 * MINUTE),
+    ];
+
+    const result = compressContext(messages, config, store, undefined, ffState);
+
+    expect(result.stats.validationFailed).toBe(false);
+
+    // Turn 1 的 toolResult 应被过期
+    const expired = result.messages[2] as ToolResultMessage;
+    expect(expired.role).toBe("toolResult");
+    const expiredText = getToolResultText(expired);
+    expect(expiredText).toContain("[Tool result expired");
+    expect(expiredText).toContain("ID: ctx-");
+    expect(expiredText).not.toContain("content of file A");
+    expect(result.stats.l0Expired).toBe(1);
+
+    // Turn 2 的 toolResult 应保留原文
+    const kept = result.messages[5] as ToolResultMessage;
+    expect(getToolResultText(kept)).toBe("content of file B");
+
+    // store 中应有一条记录
+    expect(store.size()).toBe(1);
+  });
+
+  it("AC-2: Bash 截断 — 超长 output 被截断", () => {
+    const store = createRecallStore();
+    const longOutput = "x".repeat(10000);
+
+    const messages: AgentMessage[] = [makeBashExecution(longOutput)];
+
+    const result = compressContext(messages, DEFAULT_CONFIG, store, undefined, ffState);
+
+    expect(result.stats.validationFailed).toBe(false);
+    expect(result.stats.l0Truncated).toBe(1);
+
+    const bash = result.messages[0] as BashExecutionMessage;
+    expect(bash.output.length).toBeLessThan(longOutput.length);
+    expect(bash.output).toContain("[truncated");
+    expect(bash.output).toContain("ID: ctx-");
+    expect(bash.output).toContain(`Total: ${longOutput.length} chars`);
+
+    // 首尾内容保留
+    // Tail retention: last bashTruncateChars chars preserved
+    const tailChars = DEFAULT_CONFIG.l0.bashTruncateChars;
+    expect(bash.output).toContain("x".repeat(tailChars));
+
+    expect(store.size()).toBe(1);
+  });
+
+  it("AC-3: Thinking 清理 — 过期的 thinking 被清空", () => {
+    const store = createRecallStore();
+
+    const messages: AgentMessage[] = [
+      makeAssistant([], "deep analysis of the problem...", 6 * MINUTE),
+    ];
+
+    const result = compressContext(messages, DEFAULT_CONFIG, store, undefined, ffState);
+
+    expect(result.stats.validationFailed).toBe(false);
+    expect(result.stats.l0ThinkingCleared).toBe(1);
+
+    const asst = result.messages[0] as AssistantMessage;
+    const thinkingBlock = asst.content.find((c) => c.type === "thinking");
+    expect(thinkingBlock).toBeDefined();
+    expect((thinkingBlock as ThinkingContent).thinking).toBe("[thinking expired]");
+  });
+
+  it("AC-4: 配对校验 — 正常和损坏序列", () => {
+    // 正常序列
+    const good: AgentMessage[] = [
+      makeAssistant([tc("c1")]),
+      makeToolResult("ok", 0, "c1"),
+    ];
+    expect(validateToolPairing(good)).toBe(true);
+
+    // 损坏序列: toolResult 没有对应的 toolCall
+    const orphaned: AgentMessage[] = [
+      makeToolResult("orphan", 0, "c-missing"),
+    ];
+    expect(validateToolPairing(orphaned)).toBe(false);
+
+    // 损坏序列: toolCall 没有对应的 toolResult
+    const unmatched: AgentMessage[] = [
+      makeAssistant([tc("c-unmatched")]),
+    ];
+    expect(validateToolPairing(unmatched)).toBe(false);
+  });
+
+  it("AC-7: L1 摘要 — 长文本被结构化摘要", () => {
+    const store = createRecallStore();
+    const config = { ...DEFAULT_CONFIG, l1: { ...DEFAULT_CONFIG.l1, protectRecentTurns: 0 } };
+
+    // 构造 > 8000 chars 的内容，包含 import/definition 行
+    const headLines = Array.from({ length: 10 }, (_, i) => `// head comment line ${i}`);
+    const middleImportLines = [
+      "import { readFile } from 'fs';",
+      "import { parse } from 'path';",
+    ];
+    const middleDefLines = [
+      "function processData(input: string): string {",
+      "export type Config = { debug: boolean };",
+    ];
+    const junkLines = Array.from({ length: 400 }, () => "  return someValueWithALongerNameToPadLength();");
+    const tailLines = Array.from({ length: 5 }, (_, i) => `// tail comment ${i}`);
+
+    const allLines = [
+      ...headLines,
+      ...middleImportLines,
+      ...junkLines.slice(0, 100),
+      ...middleDefLines,
+      ...junkLines.slice(100),
+      ...tailLines,
+    ];
+    const longContent = allLines.join("\n");
+    expect(longContent.length).toBeGreaterThan(8000);
+
+    const messages: AgentMessage[] = [
+      makeUser("read file"),
+      makeAssistant([tc("c1")]),
+      makeToolResult(longContent, 0, "c1"),
+    ];
+
+    const result = compressContext(messages, config, store, undefined, ffState);
+
+    expect(result.stats.validationFailed).toBe(false);
+    expect(result.stats.l1Condensed).toBe(1);
+
+    const condensed = result.messages[2] as ToolResultMessage;
+    const text = getToolResultText(condensed);
+
+    // 验证摘要格式
+    expect(text).toContain("[Condensed (ID: ctx-");
+    expect(text).toContain("import { readFile }");
+    expect(text).toContain("function processData");
+    expect(text).toContain("export type Config");
+    expect(text).toContain("[...");
+
+    // 摘要应比原文短
+    expect(text.length).toBeLessThan(longContent.length);
+    expect(store.size()).toBeGreaterThanOrEqual(1);
+  });
+
+  it("AC-8: L2 紧急 — 高使用率时强制过期保护 turn 外的 toolResult", () => {
+    const store = createRecallStore();
+    const contextUsage: ContextUsage = {
+      tokens: null,
+      contextWindow: 200000,
+      percent: 0.91,
+    };
+
+    // Turn 1: 20min 前 — 不在 L2 保护范围内 (protectRecentTurns=3, 但有 4 个 turn)
+    // Turn 2-4: 较新 — 保护范围内
+    const messages: AgentMessage[] = [
+      makeUser("t1", 20 * MINUTE),
+      makeAssistant([tc("c1")], undefined, 20 * MINUTE),
+      makeToolResult("content-1", 20 * MINUTE, "c1"), // 20min < 30min → L0 不处理
+      makeUser("t2", 10 * MINUTE),
+      makeAssistant([tc("c2")], undefined, 10 * MINUTE),
+      makeToolResult("content-2", 10 * MINUTE, "c2"),
+      makeUser("t3", 5 * MINUTE),
+      makeAssistant([tc("c3")], undefined, 5 * MINUTE),
+      makeToolResult("content-3", 5 * MINUTE, "c3"),
+      makeUser("t4", 1 * MINUTE),
+    ];
+
+    const result = compressContext(messages, DEFAULT_CONFIG, store, contextUsage, ffState);
+
+    expect(result.stats.validationFailed).toBe(false);
+    expect(result.stats.l2Triggered).toBe(true);
+
+    // Turn 1 的 toolResult (index 2) 应被 L2 强制过期
+    const forced = result.messages[2] as ToolResultMessage;
+    expect(getToolResultText(forced)).toContain("[Tool result expired");
+
+    // Turn 2 的 toolResult (index 5) 应保留
+    const kept = result.messages[5] as ToolResultMessage;
+    expect(getToolResultText(kept)).toBe("content-2");
+  });
+
+  it("AC-10: 全局禁用 — enabled=false 返回原始消息", () => {
+    const store = createRecallStore();
+    const config = { ...DEFAULT_CONFIG, enabled: false };
+
+    const messages: AgentMessage[] = [
+      makeUser("hello"),
+      makeAssistant([tc("c1")]),
+      makeToolResult("big content here", 60 * MINUTE, "c1"),
+    ];
+
+    const result = compressContext(messages, config, store, undefined, ffState);
+
+    // 应返回同一引用
+    expect(result.messages).toBe(messages);
+    expect(result.stats.l0Expired).toBe(0);
+    expect(result.stats.l0Truncated).toBe(0);
+    expect(result.stats.l0ThinkingCleared).toBe(0);
+    expect(result.stats.l1Condensed).toBe(0);
+    expect(result.stats.l2Triggered).toBe(false);
+    expect(result.stats.validationFailed).toBe(false);
+    expect(store.size()).toBe(0);
+  });
+});
+
+// ── Microcompact (AC-1) ──
+
+describe("Microcompact (AC-1)", () => {
+    const _ffState = createFrozenFreshState();
+  const MINUTE = 60 * 1000;
+
+  it("8 个 read toolResult，最后一个 assistant 65 分钟前 → 前 3 个被清理", () => {
+    const now = Date.now();
+    const mcConfig = {
+      enabled: true,
+      gapThresholdMinutes: 60,
+      keepRecent: 5,
+    };
+
+    // assistant 在 65 分钟前
+    const _assistantTs = now - 65 * MINUTE;
+
+    // 8 个 toolResult，每个关联一个 assistant（但 MC 只看最后一个 assistant 的 timestamp）
+    const _messages: AgentMessage[] = [
+      makeUser("task", 70 * MINUTE),
+      makeAssistant([tc("c1")], undefined, 68 * MINUTE),
+      makeToolResult("content-1", 67 * MINUTE, "c1"),
+      makeToolResult("content-2", 66 * MINUTE, "c2"),
+      makeToolResult("content-3", 66 * MINUTE, "c3"),
+      makeToolResult("content-4", 66 * MINUTE, "c4"),
+      makeToolResult("content-5", 66 * MINUTE, "c5"),
+      makeToolResult("content-6", 66 * MINUTE, "c6"),
+      makeToolResult("content-7", 66 * MINUTE, "c7"),
+      makeToolResult("content-8", 66 * MINUTE, "c8"),
+      // 最后一个 assistant 在 65 分钟前
+      { ...makeAssistant([], undefined, 65 * MINUTE), content: [{ type: "text" as const, text: "done" }] },
+    ];
+
+    // 需要给 toolResult 配对 toolCall
+    // 为 c2-c8 添加 assistant toolCall
+    // 重新构造消息序列确保配对正确
+    const pairedMessages: AgentMessage[] = [
+      makeUser("task", 70 * MINUTE),
+      makeAssistant([tc("c1")], undefined, 68 * MINUTE),
+      makeToolResult("content-1", 67 * MINUTE, "c1"),
+      makeAssistant([tc("c2")], undefined, 67 * MINUTE),
+      makeToolResult("content-2", 66 * MINUTE, "c2"),
+      makeAssistant([tc("c3")], undefined, 66 * MINUTE),
+      makeToolResult("content-3", 66 * MINUTE, "c3"),
+      makeAssistant([tc("c4")], undefined, 66 * MINUTE),
+      makeToolResult("content-4", 66 * MINUTE, "c4"),
+      makeAssistant([tc("c5")], undefined, 66 * MINUTE),
+      makeToolResult("content-5", 66 * MINUTE, "c5"),
+      makeAssistant([tc("c6")], undefined, 66 * MINUTE),
+      makeToolResult("content-6", 66 * MINUTE, "c6"),
+      makeAssistant([tc("c7")], undefined, 66 * MINUTE),
+      makeToolResult("content-7", 66 * MINUTE, "c7"),
+      makeAssistant([tc("c8")], undefined, 66 * MINUTE),
+      makeToolResult("content-8", 66 * MINUTE, "c8"),
+      // 最后一个 assistant 在 65 分钟前
+      { ...makeAssistant([], undefined, 65 * MINUTE), content: [{ type: "text" as const, text: "done" }] },
+    ];
+
+    const store = createRecallStore();
+    const { messages: result, stats } = processMicrocompact(pairedMessages, mcConfig, store, now, null);
+
+    expect(stats.triggered).toBe(true);
+    expect(stats.cleared).toBe(3); // 8 - 5 keepRecent = 3
+
+    // 前 3 个 toolResult (index 2, 4, 6) 被清理，包含 recall ID
+    const tr1 = result[2] as ToolResultMessage;
+    expect(getToolResultText(tr1)).toContain("[Old tool result expired");
+    expect(getToolResultText(tr1)).toContain("ID: ctx-");
+
+    const tr2 = result[4] as ToolResultMessage;
+    expect(getToolResultText(tr2)).toContain("[Old tool result expired");
+
+    const tr3 = result[6] as ToolResultMessage;
+    expect(getToolResultText(tr3)).toContain("[Old tool result expired");
+
+    // 后 5 个保留原文 (index 8, 10, 12, 14, 16)
+    const tr4 = result[8] as ToolResultMessage;
+    expect(getToolResultText(tr4)).toBe("content-4");
+
+    const tr5 = result[10] as ToolResultMessage;
+    expect(getToolResultText(tr5)).toBe("content-5");
+  });
+
+  it("30 分钟内不触发 MC", () => {
+    const now = Date.now();
+    const mcConfig = {
+      enabled: true,
+      gapThresholdMinutes: 60,
+      keepRecent: 5,
+    };
+
+    const messages: AgentMessage[] = [
+      makeUser("task", 30 * MINUTE),
+      makeAssistant([tc("c1")], undefined, 30 * MINUTE),
+      makeToolResult("content-1", 29 * MINUTE, "c1"),
+    ];
+
+    const { messages: result, stats } = processMicrocompact(messages, mcConfig, now, null);
+
+    expect(stats.triggered).toBe(false);
+    expect(stats.cleared).toBe(0);
+    expect(getToolResultText(result[2] as ToolResultMessage)).toBe("content-1");
+  });
+
+  it("非 compactable 工具（recall_context）不被清理", () => {
+    const now = Date.now();
+    const mcConfig = {
+      enabled: true,
+      gapThresholdMinutes: 60,
+      keepRecent: 5,
+    };
+
+    const recallResult: ToolResultMessage = {
+      role: "toolResult",
+      toolCallId: "c-recall",
+      toolName: "recall_context",
+      content: [{ type: "text" as const, text: "recalled content here" }],
+      isError: false,
+      timestamp: now - 65 * MINUTE,
+    };
+
+    const messages: AgentMessage[] = [
+      makeUser("task", 70 * MINUTE),
+      makeAssistant([tc("c1"), { type: "toolCall" as const, id: "c-recall", name: "recall_context", arguments: {} }], undefined, 65 * MINUTE),
+      makeToolResult("content-1", 66 * MINUTE, "c1"),
+      recallResult,
+      // 最后一个 assistant 65 分钟前
+      { ...makeAssistant([], undefined, 65 * MINUTE), content: [{ type: "text" as const, text: "done" }] },
+    ];
+
+    const store = createRecallStore();
+    const { messages: result, stats } = processMicrocompact(messages, mcConfig, store, now, null);
+
+    expect(stats.triggered).toBe(true);
+    expect(stats.cleared).toBe(0); // 只有 1 个 compactable，keepRecent=5，不清理
+
+    // recall_context 的结果应保持原样
+    const kept = result[3] as ToolResultMessage;
+    expect(getToolResultText(kept)).toBe("recalled content here");
+  });
+});
+
+// ── Budget (AC-2, AC-3) ──
+
+describe("Budget (AC-2, AC-3)", () => {
+  it("5 个 toolResult 总计 250K chars，最大被持久化", async () => {
+    const store = createRecallStore();
+    const _now = Date.now();
+    const budgetConfig = {
+      enabled: true,
+      maxToolResultCharsPerMessage: 200_000,
+      previewSize: 2000,
+    };
+
+    // 5 个 toolResult: 4x 20K + 1x 170K = 250K total
+    // 最大的 170K 应被持久化
+    const small = "a".repeat(20_000);
+    const big = "B".repeat(170_000);
+
+    const ffState = createFrozenFreshState();
+
+    const messages: AgentMessage[] = [
+      makeUser("task"),
+      makeAssistant([tc("c1"), tc("c2"), tc("c3"), tc("c4"), tc("c5")]),
+      makeToolResult(small, 0, "c1"),
+      makeToolResult(small, 0, "c2"),
+      makeToolResult(small, 0, "c3"),
+      makeToolResult(small, 0, "c4"),
+      makeToolResult(big, 0, "c5"),
+    ];
+
+    const { messages: result, stats } = processBudget(
+      messages, budgetConfig, store, ffState, null,
+    );
+
+    expect(stats.persisted).toBe(1);
+
+    // 最大的 (c5, index 6) 应被持久化
+    const persisted = result[6] as ToolResultMessage;
+    const text = getToolResultText(persisted);
+    expect(text).toContain("[Persisted output");
+    expect(text).toContain("Total: 170000 chars");
+
+    // 原文存入 recall store
+    expect(store.size()).toBe(1);
+
+    // 小的应保留
+    const kept = result[2] as ToolResultMessage;
+    expect(getToolResultText(kept)).toBe(small);
+  });
+});
+
+// ── Compact Boundary (AC-4, AC-7) ──
+
+describe("Compact Boundary (AC-4, AC-7)", () => {
+    const _ffState = createFrozenFreshState();
+  const MINUTE = 60 * 1000;
+
+  it("compactionSummary 在 index 5，之前的 toolResult 不被 MC 处理", () => {
+    const now = Date.now();
+    const mcConfig = {
+      enabled: true,
+      gapThresholdMinutes: 60,
+      keepRecent: 1,
+    };
+
+    // compactionSummary 在 index 5
+    const messages: AgentMessage[] = [
+      makeUser("t0", 120 * MINUTE),       // 0
+      makeAssistant([tc("c0")], undefined, 119 * MINUTE), // 1
+      makeToolResult("old-1", 119 * MINUTE, "c0"), // 2 - 边界前
+      makeUser("t1", 110 * MINUTE),       // 3
+      makeToolResult("old-2", 109 * MINUTE, "c2"), // 4 - 边界前，非 compactable 位置
+      // compactionSummary 边界
+      makeCompactionSummary("summary of prior work", 100 * MINUTE), // 5 - boundary
+      makeAssistant([tc("c3"), tc("c4"), tc("c5"), tc("c6")], undefined, 80 * MINUTE), // 6
+      makeToolResult("fresh-1", 79 * MINUTE, "c3"), // 7 - 边界后
+      makeToolResult("fresh-2", 78 * MINUTE, "c4"), // 8 - 边界后
+      makeToolResult("fresh-3", 77 * MINUTE, "c5"), // 9 - 边界后
+      makeToolResult("fresh-4", 76 * MINUTE, "c6"), // 10 - 边界后
+      makeAssistant([], undefined, 65 * MINUTE), // 11 - 65min 前，触发 MC
+    ];
+
+    const boundary = findCompactBoundary(messages);
+    expect(boundary).toBe(5);
+
+    const store = createRecallStore();
+    const { messages: result, stats } = processMicrocompact(messages, mcConfig, store, now, boundary);
+
+    // MC 应触发（最后一个 assistant 65min 前 > 60min）
+    expect(stats.triggered).toBe(true);
+
+    // 边界前的 toolResult (index 2) 不应被 MC 处理
+    const beforeBoundary = result[2] as ToolResultMessage;
+    expect(getToolResultText(beforeBoundary)).toBe("old-1");
+
+    // 边界后有 4 个 compactable (7,8,9,10)，keepRecent=1 → 清理 3 个
+    expect(stats.cleared).toBe(3);
+    const cleared = result[7] as ToolResultMessage;
+    expect(getToolResultText(cleared)).toContain("[Old tool result expired");
+
+    // 最近 1 个保留
+    const kept = result[10] as ToolResultMessage;
+    expect(getToolResultText(kept)).toBe("fresh-4");
+  });
+
+  it("无 compactionSummary 时正常处理", () => {
+    const messages: AgentMessage[] = [
+      makeUser("t0", 120 * 60 * 1000),
+      makeToolResult("content", 119 * 60 * 1000, "c1"),
+    ];
+
+    const boundary = findCompactBoundary(messages);
+    expect(boundary).toBeNull();
+  });
+});
+
+// ── L1 Protected Turn (AC-5) ──
+
+describe("L1 Protected Turn (AC-5)", () => {
+    const ffState = createFrozenFreshState();
+  const MINUTE = 60 * 1000;
+
+  it("12K chars toolResult 在最近 2 轮内 → 不被 condense，原文保留", () => {
+    const store = createRecallStore();
+    const config = {
+      ...DEFAULT_CONFIG,
+      l1: {
+        ...DEFAULT_CONFIG.l1,
+        summaryThresholdChars: 8000,
+        protectRecentTurns: 2,
+      },
+    };
+
+    // 构造 12K chars 的 toolResult
+    const bigContent = "x".repeat(12_000);
+
+    // Turn 1: user → assistant → toolResult(12K) → 保护范围内（最近 2 轮）
+    const messages: AgentMessage[] = [
+      makeUser("task", 1 * MINUTE),
+      makeAssistant([tc("c1")], undefined, 1 * MINUTE),
+      makeToolResult(bigContent, 0, "c1"),
+      makeUser("followup", 0),
+    ];
+
+    const result = compressContext(messages, config, store, undefined, ffState);
+
+    // 应保留原文
+    const tr = result.messages[2] as ToolResultMessage;
+    expect(getToolResultText(tr)).toBe(bigContent);
+    expect(result.stats.l1Condensed).toBe(0);
+  });
+
+  it("12K chars toolResult 在保护范围外（3 轮之前）→ 被 condense", () => {
+    const store = createRecallStore();
+    const config = {
+      ...DEFAULT_CONFIG,
+      l1: {
+        ...DEFAULT_CONFIG.l1,
+        summaryThresholdChars: 8000,
+        protectRecentTurns: 2,
+      },
+    };
+
+    const bigContent = "line\n".repeat(3000); // ~15K chars
+    expect(bigContent.length).toBeGreaterThan(8000);
+
+    // Turn 1: toolResult 在 Turn 0，protectRecentTurns=2 保护 Turn 1+2
+    const messages: AgentMessage[] = [
+      makeUser("task1", 10 * MINUTE),
+      makeAssistant([tc("c1")], undefined, 10 * MINUTE),
+      makeToolResult(bigContent, 9 * MINUTE, "c1"),
+      makeUser("task2", 5 * MINUTE),
+      makeAssistant([tc("c2")], undefined, 5 * MINUTE),
+      makeToolResult("small", 4 * MINUTE, "c2"),
+      makeUser("task3", 1 * MINUTE),
+    ];
+
+    const result = compressContext(messages, config, store, undefined, ffState);
+
+    // Turn 1 的 toolResult 应被 condense
+    const condensed = result.messages[2] as ToolResultMessage;
+    const text = getToolResultText(condensed);
+    expect(text).toContain("[Condensed (ID: ctx-");
+    expect(result.stats.l1Condensed).toBe(1);
+  });
+
+  it("L2 + compact boundary: compactionSummary 在索引 3，之前的 toolResult 不被 L2 处理", () => {
+    const store = createRecallStore();
+    const contextUsage: ContextUsage = {
+      tokens: null,
+      contextWindow: 200000,
+      percent: 0.95,
+    };
+
+    // compactionSummary 在 index 3
+    const messages: AgentMessage[] = [
+      makeUser("t0", 30 * MINUTE),          // 0
+      makeAssistant([tc("c1")], undefined, 30 * MINUTE), // 1
+      makeToolResult("pre-compact", 29 * MINUTE, "c1"), // 2 - 边界前
+      makeCompactionSummary("summary", 20 * MINUTE), // 3 - boundary
+      makeUser("t1", 15 * MINUTE),          // 4
+      makeAssistant([tc("c2")], undefined, 15 * MINUTE), // 5
+      makeToolResult("post-compact", 14 * MINUTE, "c2"), // 6 - 边界后
+      makeUser("t2", 1 * MINUTE),           // 7
+    ];
+
+    const result = compressContext(messages, DEFAULT_CONFIG, store, contextUsage, ffState);
+
+    // 边界前的 toolResult (index 2) 不被 L2 处理
+    const preCompact = result.messages[2] as ToolResultMessage;
+    expect(getToolResultText(preCompact)).toBe("pre-compact");
+
+    // 边界后的 toolResult (index 6) 应被 L2 处理（如果在保护范围外）
+    // Turn boundaries: [0-3), [3-4), [4-7), [7-8)
+    // L2 protectRecentTurns=3 → Turn 1,2,3 被保护 → Turn 0 的不受 L2 保护
+    // index 6 在 Turn 2 内（保护范围），所以也不应被 L2 处理
+    // 需要构造一个边界后且不在保护范围内的场景
+    // 实际上 index 6 在 Turn 2 (4-7)，protectRecentTurns=3 保护最后 3 轮
+    // 有 4 个 boundary → 保护 Turn 1,2,3 → Turn 0 不保护 → 但 index 2 在 Turn 0 边界前
+    // 所以实际上所有 post-boundary 的都在保护范围内
+    // L2 triggered 应该为 false（没有可 force-expire 的）
+    expect(result.stats.l2Triggered).toBe(false);
+  });
+});
+
+// ── L0 keepRecent ──
+
+describe("L0 keepRecent", () => {
+    const ffState = createFrozenFreshState();
+  const MINUTE = 60 * 1000;
+
+  it("8 个 toolResult 全部超 30 分钟，keepRecent=5，protectRecentTurns=0 → 最新 5 个不过期，前 3 个过期", () => {
+    const store = createRecallStore();
+    const config = {
+      ...DEFAULT_CONFIG,
+      l0: {
+        ...DEFAULT_CONFIG.l0,
+        keepRecent: 5,
+        protectRecentTurns: 0,
+      },
+    };
+
+    const messages: AgentMessage[] = [
+      makeUser("task", 60 * MINUTE),
+      makeAssistant([tc("c1")], undefined, 59 * MINUTE),
+      makeToolResult("content-1", 58 * MINUTE, "c1"),
+      makeAssistant([tc("c2")], undefined, 55 * MINUTE),
+      makeToolResult("content-2", 54 * MINUTE, "c2"),
+      makeAssistant([tc("c3")], undefined, 50 * MINUTE),
+      makeToolResult("content-3", 49 * MINUTE, "c3"),
+      makeAssistant([tc("c4")], undefined, 45 * MINUTE),
+      makeToolResult("content-4", 44 * MINUTE, "c4"),
+      makeAssistant([tc("c5")], undefined, 40 * MINUTE),
+      makeToolResult("content-5", 39 * MINUTE, "c5"),
+      makeAssistant([tc("c6")], undefined, 37 * MINUTE),
+      makeToolResult("content-6", 36 * MINUTE, "c6"),
+      makeAssistant([tc("c7")], undefined, 35 * MINUTE),
+      makeToolResult("content-7", 34 * MINUTE, "c7"),
+      makeAssistant([tc("c8")], undefined, 33 * MINUTE),
+      makeToolResult("content-8", 32 * MINUTE, "c8"),
+      makeUser("end", 0),
+    ];
+
+    const result = compressContext(messages, config, store, undefined, ffState);
+
+    // 前 3 个应过期
+    expect(result.stats.l0Expired).toBe(3);
+
+    const tr1 = result.messages[2] as ToolResultMessage;
+    expect(getToolResultText(tr1)).toContain("[Tool result expired");
+
+    const tr2 = result.messages[4] as ToolResultMessage;
+    expect(getToolResultText(tr2)).toContain("[Tool result expired");
+
+    const tr3 = result.messages[6] as ToolResultMessage;
+    expect(getToolResultText(tr3)).toContain("[Tool result expired");
+
+    // 后 5 个保留原文
+    const tr4 = result.messages[8] as ToolResultMessage;
+    expect(getToolResultText(tr4)).toBe("content-4");
+
+    const tr8 = result.messages[16] as ToolResultMessage;
+    expect(getToolResultText(tr8)).toBe("content-8");
+  });
+});
+
+// ── TC-2-02: Budget per-message isolation ──
+
+describe("Budget per-message isolation (TC-2-02)", () => {
+  it("each user message group evaluated independently", () => {
+    const store = createRecallStore();
+    const ffState = createFrozenFreshState();
+    const budgetConfig = {
+      enabled: true,
+      maxToolResultCharsPerMessage: 200_000,
+      previewSize: 2000,
+    };
+
+    // Group 1: 3x 20K = 60K (under budget)
+    const small = "a".repeat(20_000);
+    // Group 2: 3x 20K = 60K (under budget)
+    const messages: AgentMessage[] = [
+      makeUser("task1"),
+      makeAssistant([tc("c1"), tc("c2"), tc("c3")]),
+      makeToolResult(small, 0, "c1"),
+      makeToolResult(small, 0, "c2"),
+      makeToolResult(small, 0, "c3"),
+      makeUser("task2"),
+      makeAssistant([tc("c4"), tc("c5"), tc("c6")]),
+      makeToolResult(small, 0, "c4"),
+      makeToolResult(small, 0, "c5"),
+      makeToolResult(small, 0, "c6"),
+    ];
+
+    const { stats } = processBudget(messages, budgetConfig, store, ffState, null);
+    expect(stats.persisted).toBe(0);
+    expect(store.size()).toBe(0);
+  });
+});
+
+// ── TC-3-01: Frozen keeps same replacement across turns ──
+
+describe("Frozen replacement across turns (TC-3-01)", () => {
+  it("frozen toolResult uses identical replacement in Turn 2", () => {
+    const store = createRecallStore();
+    const ffState = createFrozenFreshState();
+    const budgetConfig = {
+      enabled: true,
+      maxToolResultCharsPerMessage: 100_000,
+      previewSize: 100,
+    };
+
+    const big = "X".repeat(150_000);
+
+    // Turn 1: big toolResult → persisted, frozen
+    const turn1: AgentMessage[] = [
+      makeUser("task1"),
+      makeAssistant([tc("c1")]),
+      makeToolResult(big, 0, "c1"),
+    ];
+    const r1 = processBudget(turn1, budgetConfig, store, ffState, null);
+    expect(r1.stats.persisted).toBe(1);
+    const text1 = getToolResultText(r1.messages[2] as ToolResultMessage);
+    expect(text1).toContain("[Persisted output");
+
+    // Turn 2: same toolResult present → should use frozen replacement
+    const turn2: AgentMessage[] = [
+      ...r1.messages,
+      makeUser("task2"),
+      makeAssistant([tc("c2")]),
+      makeToolResult("small", 0, "c2"),
+    ];
+    const r2 = processBudget(turn2, budgetConfig, store, ffState, null);
+    const text2 = getToolResultText(r2.messages[2] as ToolResultMessage);
+    // frozen replacement 应该和 turn 1 完全相同
+    expect(text2).toBe(text1);
+    expect(ffState.isFrozen("c1")).toBe(true);
+  });
+});
+
+// ── TC-3-02: Fresh toolResult evaluated normally ──
+
+describe("Fresh evaluation (TC-3-02)", () => {
+  it("new toolResult not in frozen set is evaluated by budget logic", () => {
+    const store = createRecallStore();
+    const ffState = createFrozenFreshState();
+    const budgetConfig = {
+      enabled: true,
+      maxToolResultCharsPerMessage: 100_000,
+      previewSize: 100,
+    };
+
+    const big = "Y".repeat(150_000);
+
+    // 只有一个 fresh toolResult，超预算
+    const messages: AgentMessage[] = [
+      makeUser("task"),
+      makeAssistant([tc("c-new")]),
+      makeToolResult(big, 0, "c-new"),
+    ];
+
+    const { stats } = processBudget(messages, budgetConfig, store, ffState, null);
+    expect(stats.persisted).toBe(1);
+    expect(ffState.isFrozen("c-new")).toBe(true);
+    expect(store.size()).toBe(1);
+    // recall store 有一个条目（budget 持久化的）
+    expect(store.size()).toBe(1);
+  });
+});
+
+// ── TC-9-01: Full pipeline order ──
+
+describe("Full pipeline order (TC-9-01)", () => {
+  it("MC → Budget → L0 → L1 → L2 executes in correct order", () => {
+    const store = createRecallStore();
+    const ffState = createFrozenFreshState();
+    const MINUTE = 60 * 1000;
+
+    const config = {
+      ...DEFAULT_CONFIG,
+      enabled: true,
+      mc: { enabled: true, gapThresholdMinutes: 60, keepRecent: 5 },
+      budget: { enabled: true, maxToolResultCharsPerMessage: 200_000, previewSize: 2000 },
+      l0: { enabled: true, expireMinutes: 30, bashTruncateChars: 4000, thinkingExpireMinutes: 5, protectRecentTurns: 2, keepRecent: 5 },
+      l1: { enabled: true, summaryThresholdChars: 8000, keepHeadLines: 10, keepTailLines: 5, protectRecentTurns: 2 },
+      l2: { enabled: true, emergencyThreshold: 0.9, protectRecentTurns: 1 },
+    };
+
+    const big = "Z".repeat(12_000);
+    const expired = "old-" + "x".repeat(100);
+
+    // 构造 4+ turns，让最老的 toolResult 在 protectRecentTurns 外
+    const messages: AgentMessage[] = [
+      makeUser("task1", 120 * MINUTE),
+      makeAssistant([tc("c1")], undefined, 119 * MINUTE),
+      makeToolResult(expired, 118 * MINUTE, "c1"),   // Turn 1 — L0: expired, outside protected
+      makeUser("task2", 100 * MINUTE),
+      makeAssistant([tc("c2")], undefined, 25 * MINUTE),
+      makeToolResult(big, 24 * MINUTE, "c2"),         // Turn 2 — L1: 12K > 8K, NOT expired (<30min), outside protected turns
+      makeUser("task3", 50 * MINUTE),
+      makeAssistant([tc("c3"), tc("c4")], undefined, 45 * MINUTE),
+      makeToolResult("compactable-1", 44 * MINUTE, "c3"), // Turn 3 — MC candidate
+      makeToolResult("compactable-2", 43 * MINUTE, "c4"), // Turn 3
+      makeUser("task4", 5 * MINUTE),
+      makeAssistant([tc("c5"), tc("c6"), tc("c7")], undefined, 4 * MINUTE),
+      makeToolResult("recent-1", 3 * MINUTE, "c5"),    // Turn 4 — MC keepRecent
+      makeToolResult("recent-2", 2 * MINUTE, "c6"),    // Turn 4
+      makeToolResult("recent-3", 1 * MINUTE, "c7"),    // Turn 4
+    ];
+
+    const contextUsage: ContextUsage = { percent: 0.95, usedTokens: 190000, totalTokens: 200000 };
+    const result = compressContext(messages, config, store, contextUsage, ffState);
+
+    // MC: triggered because last assistant 5min ago < 60min gap → NOT triggered
+    // Wait, last assistant is at 5min, now - 5min < 60min, so MC should NOT trigger
+    // Let's verify stats reflect pipeline
+    expect(result.stats).toBeDefined();
+
+    // L0: expired toolResult at index 2 should be expired
+    expect(result.stats.l0Expired).toBeGreaterThanOrEqual(1);
+
+    // L1: big (12K) at index 4, outside protected 2 turns → condensed
+    expect(result.stats.l1Condensed).toBeGreaterThanOrEqual(1);
+
+    // L2: 95% > 90% → should trigger
+    expect(result.stats.l2Triggered).toBe(true);
+
+    // Validation should pass
+    expect(result.stats.validationFailed).toBe(false);
+  });
+});