@monotykamary/pi-vcc 0.3.17 → 0.4.1

package/tests/before-compact-hook.test.ts

@@ -1,185 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach, beforeAll, afterAll } from "bun:test";
-import { existsSync, unlinkSync, writeFileSync, readFileSync, mkdtempSync, rmSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-import { registerBeforeCompactHook, PI_VCC_COMPACT_INSTRUCTION } from "../src/hooks/before-compact";
-
-let tmpDir: string;
-let CONFIG_PATH: string;
-const DEBUG_PATH = "/tmp/pi-vcc-debug.json";
-
-beforeAll(() => {
-  tmpDir = mkdtempSync(join(tmpdir(), "pi-vcc-test-"));
-  CONFIG_PATH = join(tmpDir, "pi-vcc-config.json");
-  process.env.PI_VCC_CONFIG_PATH = CONFIG_PATH;
-});
-
-afterAll(() => {
-  delete process.env.PI_VCC_CONFIG_PATH;
-  rmSync(tmpDir, { recursive: true, force: true });
-});
-
-// Minimal ExtensionAPI stub: capture handler + provide ctx with mocked ui.notify
-function createMockPi() {
-  let handler: ((event: any, ctx: any) => any) | undefined;
-  const notifyCalls: Array<{ msg: string; level: string }> = [];
-  const ctx = {
-    hasUI: true,
-    ui: {
-      notify: (msg: string, level: string) => {
-        notifyCalls.push({ msg, level });
-      },
-    },
-  };
-  return {
-    pi: {
-      on: (eventName: string, h: (e: any, c: any) => any) => {
-        if (eventName === "session_before_compact") handler = h;
-      },
-    } as any,
-    invoke: (event: any) => handler!(event, ctx),
-    notifyCalls,
-  };
-}
-
-function setConfig(cfg: Record<string, unknown>) {
-  writeFileSync(CONFIG_PATH, JSON.stringify(cfg));
-}
-
-function makeEvent(branchEntries: any[], customInstructions?: string) {
-  return {
-    type: "session_before_compact",
-    customInstructions,
-    branchEntries,
-    preparation: {
-      previousSummary: undefined,
-      fileOps: { read: [], written: [], edited: [] },
-      tokensBefore: 1000,
-    },
-    signal: new AbortController().signal,
-  };
-}
-
-const msg = (id: string, role: "user" | "assistant" | "toolResult", content = "x") => ({
-  id,
-  type: "message",
-  message: { role, content },
-});
-const comp = (id: string, firstKeptEntryId?: string) => ({ id, type: "compaction", firstKeptEntryId });
-
-describe("registerBeforeCompactHook: cancel paths", () => {
-  beforeEach(() => {
-    if (existsSync(DEBUG_PATH)) unlinkSync(DEBUG_PATH);
-  });
-  afterEach(() => {
-    if (existsSync(CONFIG_PATH)) unlinkSync(CONFIG_PATH);
-    if (existsSync(DEBUG_PATH)) unlinkSync(DEBUG_PATH);
-  });
-
-  test("/pi-vcc with too few live messages cancels and notifies warning", () => {
-    setConfig({ debug: false, overrideDefaultCompaction: false });
-    const { pi, invoke, notifyCalls } = createMockPi();
-    registerBeforeCompactHook(pi);
-
-    const entries = [msg("m1", "user"), msg("m2", "assistant")];
-    expect(invoke(makeEvent(entries, PI_VCC_COMPACT_INSTRUCTION))).toEqual({ cancel: true });
-    expect(notifyCalls).toHaveLength(1);
-    expect(notifyCalls[0].level).toBe("warning");
-    expect(notifyCalls[0].msg).toContain("Too few messages");
-  });
-
-  test("/pi-vcc with no user message compacts all instead of cancelling", () => {
-    setConfig({ debug: false, overrideDefaultCompaction: false });
-    const { pi, invoke, notifyCalls } = createMockPi();
-    registerBeforeCompactHook(pi);
-
-    const entries = [msg("m1", "assistant"), msg("m2", "assistant"), msg("m3", "assistant")];
-    const result = invoke(makeEvent(entries, PI_VCC_COMPACT_INSTRUCTION));
-    // No longer cancels — compacts all to recover from context overflow
-    expect(result.cancel).toBeUndefined();
-    expect(result.compaction).toBeDefined();
-    expect(result.compaction.firstKeptEntryId).toBe("");
-  });
-
-  test("/compact with override=true cancels and notifies (NEW: was silent before)", () => {
-    setConfig({ debug: false, overrideDefaultCompaction: true });
-    const { pi, invoke, notifyCalls } = createMockPi();
-    registerBeforeCompactHook(pi);
-
-    const entries = [msg("m1", "user"), msg("m2", "assistant")];
-    expect(invoke(makeEvent(entries, undefined))).toEqual({ cancel: true });
-    expect(notifyCalls).toHaveLength(1);
-    expect(notifyCalls[0].level).toBe("warning");
-  });
-
-  test("/compact with override=false short-circuits (no notify, returns undefined)", () => {
-    setConfig({ debug: false, overrideDefaultCompaction: false });
-    const { pi, invoke, notifyCalls } = createMockPi();
-    registerBeforeCompactHook(pi);
-
-    const entries = [msg("m1", "user"), msg("m2", "assistant")];
-    expect(invoke(makeEvent(entries, undefined))).toBeUndefined();
-    expect(notifyCalls).toHaveLength(0);
-  });
-
-  test("debug:true writes metrics-only snapshot on cancel with no content leakage", () => {
-    setConfig({ debug: true, overrideDefaultCompaction: false });
-    const { pi, invoke } = createMockPi();
-    registerBeforeCompactHook(pi);
-
-    // Use too_few_live_messages cancel path to test content leakage
-    const entries = [
-      msg("m1", "user", "SECRET_TOKEN_abc123"),
-      msg("m2", "assistant", "sensitive response"),
-    ];
-    expect(invoke(makeEvent(entries, PI_VCC_COMPACT_INSTRUCTION))).toEqual({ cancel: true });
-
-    expect(existsSync(DEBUG_PATH)).toBe(true);
-    const snapshot = JSON.parse(readFileSync(DEBUG_PATH, "utf-8"));
-    expect(snapshot.cancelled).toBe(true);
-    expect(snapshot.reason).toBe("too_few_live_messages");
-
-    // No content leakage
-    const serialized = JSON.stringify(snapshot);
-    expect(serialized).not.toContain("SECRET_TOKEN_abc123");
-    expect(serialized).not.toContain("sensitive response");
-  });
-
-  test("debug:false does NOT write snapshot", () => {
-    setConfig({ debug: false, overrideDefaultCompaction: false });
-    const { pi, invoke } = createMockPi();
-    registerBeforeCompactHook(pi);
-    const entries = [msg("m1", "user"), msg("m2", "assistant")];
-    expect(invoke(makeEvent(entries, PI_VCC_COMPACT_INSTRUCTION))).toEqual({ cancel: true });
-    expect(existsSync(DEBUG_PATH)).toBe(false);
-  });
-});
-
-describe("registerBeforeCompactHook: compact-all path", () => {
-  beforeEach(() => {
-    if (existsSync(DEBUG_PATH)) unlinkSync(DEBUG_PATH);
-  });
-  afterEach(() => {
-    if (existsSync(CONFIG_PATH)) unlinkSync(CONFIG_PATH);
-    if (existsSync(DEBUG_PATH)) unlinkSync(DEBUG_PATH);
-  });
-
-  test("single-user + autonomous tail → cuts at mid-cycle boundary", () => {
-    setConfig({ debug: false, overrideDefaultCompaction: false });
-    const { pi, invoke, notifyCalls } = createMockPi();
-    registerBeforeCompactHook(pi);
-
-    const entries = [
-      msg("m1", "user", "go"),
-      msg("m2", "assistant", "calling tool"),
-      msg("m3", "toolResult", "result"),
-      msg("m4", "assistant", "done"),
-    ];
-    const result = invoke(makeEvent(entries, PI_VCC_COMPACT_INSTRUCTION));
-    expect(result.compaction).toBeDefined();
-    // Single user at idx 0, completed cycle m2→m3 ends at idx 2 (midpoint=2)
-    // Cut after m3, keep from m4 onward
-    expect(result.compaction.firstKeptEntryId).toBe("m4");
-    expect(notifyCalls).toHaveLength(0); // no cancel notify on success
-  });
-});

package/tests/before-compact.test.ts

@@ -1,227 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { buildOwnCut } from "../src/hooks/before-compact";
-
-const msg = (id: string, role: "user" | "assistant" | "toolResult", content = "x") => ({
-  id,
-  type: "message",
-  message: { role, content },
-});
-
-const comp = (id: string, firstKeptEntryId?: string) => ({
-  id,
-  type: "compaction",
-  firstKeptEntryId,
-});
-
-describe("buildOwnCut", () => {
-  test("no prior compaction: cuts at last user message", () => {
-    const r = buildOwnCut([
-      msg("m1", "user", "a"),
-      msg("m2", "assistant", "b"),
-      msg("m3", "user", "c"),
-      msg("m4", "assistant", "d"),
-    ]);
-    expect(r.ok).toBe(true);
-    if (!r.ok) return;
-    expect(r.firstKeptEntryId).toBe("m3");
-    expect(r.messages).toHaveLength(2);
-    expect(r.compactAll).toBe(false);
-  });
-
-  test("cancels with too_few_live_messages when liveMessages <= 2", () => {
-    const r = buildOwnCut([
-      comp("c1", "m1"),
-      msg("m1", "user", "x"),
-      msg("m2", "assistant", "y"),
-    ]);
-    expect(r.ok).toBe(false);
-    if (r.ok) return;
-    expect(r.reason).toBe("too_few_live_messages");
-  });
-
-  test("orphan firstKeptEntryId triggers recovery (collect after compaction)", () => {
-    // Prev compaction set firstKeptEntryId to a non-existent id (e.g. "" sentinel
-    // from a previous compact-all). Recovery should collect msgs after compaction.
-    const r = buildOwnCut([
-      msg("old1", "user", "old"),
-      msg("old2", "assistant", "old"),
-      comp("c1", "ORPHAN_ID"),
-      msg("m1", "user", "a"),
-      msg("m2", "assistant", "b"),
-      msg("m3", "user", "c"),
-      msg("m4", "assistant", "d"),
-    ]);
-    expect(r.ok).toBe(true);
-    if (!r.ok) return;
-    expect(r.firstKeptEntryId).toBe("m3");
-    expect(r.messages).toHaveLength(2);
-  });
-
-  test("resumes from firstKeptEntryId after prior compaction", () => {
-    const r = buildOwnCut([
-      msg("old1", "user", "old"),
-      msg("old2", "assistant", "old"),
-      comp("c1", "m1"),
-      msg("m1", "user", "a"),
-      msg("m2", "assistant", "b"),
-      msg("m3", "user", "c"),
-      msg("m4", "assistant", "d"),
-    ]);
-    expect(r.ok).toBe(true);
-    if (!r.ok) return;
-    expect(r.firstKeptEntryId).toBe("m3");
-    expect(r.messages).toHaveLength(2);
-  });
-
-  test("single user prompt + autonomous tail: cut at mid-cycle boundary", () => {
-    // The agentic scenario: user types 1 prompt, agent runs autonomously
-    // (assistant + toolResult interleaved). No user > idx 0.
-    // Instead of compact-all, find a completed tool-cycle boundary.
-    const r = buildOwnCut([
-      msg("m1", "user", "go"),
-      msg("m2", "assistant", "calling tool"),
-      msg("m3", "toolResult", "result"),
-      msg("m4", "assistant", "more"),
-      msg("m5", "toolResult", "result2"),
-      msg("m6", "assistant", "done"),
-    ]);
-    expect(r.ok).toBe(true);
-    if (!r.ok) return;
-    expect(r.compactAll).toBe(false);
-    // Should cut after the first completed cycle (m2→m3) or the second (m4→m5)
-    // Mid-cycle logic picks nearest to midpoint of 6 = index 3
-    // Cycle 1 ends at m3 (idx 3), cycle 2 ends at m5 (idx 5)
-    // Distance: |3-3|=0 vs |5-3|=2, so picks m3
-    expect(r.firstKeptEntryId).toBe("m4");
-    expect(r.messages).toHaveLength(3); // m1, m2, m3
-  });
-
-  test("no user message: compact-all instead of cancelling", () => {
-    // When there are enough live messages but none are from the user
-    // (e.g., long assistant/tool chain), compact all rather than
-    // cancelling and leaving the session unrecoverable.
-    const r = buildOwnCut([
-      msg("m1", "assistant", "a"),
-      msg("m2", "assistant", "b"),
-      msg("m3", "assistant", "c"),
-    ]);
-    expect(r.ok).toBe(true);
-    if (!r.ok) return;
-    expect(r.compactAll).toBe(true);
-    expect(r.firstKeptEntryId).toBe("");
-    expect(r.messages).toHaveLength(3);
-  });
-
-  test("compact-all then more chat: orphan recovery + normal cut", () => {
-    // After a compact-all (firstKeptEntryId=""), user chats more turns,
-    // next compaction should orphan-recover and find multiple users.
-    const r = buildOwnCut([
-      msg("o1", "user", "old"),
-      msg("o2", "assistant", "old"),
-      comp("c1", ""), // sentinel from prior compact-all
-      msg("u1", "user", "new1"),
-      msg("a1", "assistant", "reply1"),
-      msg("u2", "user", "new2"),
-      msg("a2", "assistant", "reply2"),
-      msg("u3", "user", "new3"),
-      msg("a3", "assistant", "reply3"),
-    ]);
-    expect(r.ok).toBe(true);
-    if (!r.ok) return;
-    expect(r.compactAll).toBe(false);
-    expect(r.firstKeptEntryId).toBe("u3");
-    expect(r.messages).toHaveLength(4); // u1, a1, u2, a2
-  });
-
-  test("compact-all then single user msg + autonomous: cut at mid-cycle boundary", () => {
-    // After compact-all, only 1 user message in orphan range. Should find
-    // a completed tool-cycle boundary instead of compacting all again.
-    const r = buildOwnCut([
-      msg("o1", "user", "old"),
-      comp("c1", ""),
-      msg("u1", "user", "okay"),
-      msg("a1", "assistant", "x"),
-      msg("t1", "toolResult", "y"),
-      msg("a2", "assistant", "z"),
-    ]);
-    expect(r.ok).toBe(true);
-    if (!r.ok) return;
-    // Single user at idx 0 of live range → mid-cycle boundary
-    // Live messages: [u1, a1, t1, a2]. Midpoint=2. Completed cycle ends at t1 (idx 2).
-    expect(r.compactAll).toBe(false);
-    expect(r.firstKeptEntryId).toBe("a2");
-  });
-
-  test("matched tool calls do NOT push cut back to previous user", () => {
-    // Regression: toolResult messages carry toolCallId at the message level,
-    // not as a content part. The old code looked for part.type==="toolResult"
-    // in content (which never matches), causing every toolCall to appear
-    // "unmatched" and pushing the cut back one user turn.
-    const r = buildOwnCut([
-      msg("u1", "user", "first prompt"),
-      msg("a1", "assistant", [{ type: "text", text: "let me check" }, { type: "toolCall", id: "tc_1", name: "read", arguments: { path: "foo.ts" } }]),
-      { id: "t1", type: "message", message: { role: "toolResult", toolCallId: "tc_1", toolName: "read", content: [{ type: "text", text: "file contents" }], isError: false } },
-      msg("u2", "user", "second prompt"),
-      msg("a2", "assistant", [{ type: "text", text: "done" }]),
-    ]);
-    expect(r.ok).toBe(true);
-    if (!r.ok) return;
-    // Cut should be at u2 (second user) since tc_1 has a matching toolResult
-    expect(r.compactAll).toBe(false);
-    expect(r.firstKeptEntryId).toBe("u2");
-    expect(r.messages).toHaveLength(3); // u1, a1, t1
-  });
-
-  test("unmatched tool call still pushes cut back", () => {
-    // When a toolCall genuinely has no toolResult, the cut should still
-    // push back to keep the in-progress turn in the tail.
-    const r = buildOwnCut([
-      msg("u1", "user", "first prompt"),
-      msg("a1", "assistant", "response 1"),
-      msg("u2", "user", "second prompt"),
-      msg("a2", "assistant", "response 2"),
-      msg("u3", "user", "third prompt"),
-      msg("a3", "assistant", [{ type: "text", text: "checking" }, { type: "toolCall", id: "tc_unmatched", name: "bash", arguments: { command: "ls" } }]),
-    ]);
-    expect(r.ok).toBe(true);
-    if (!r.ok) return;
-    // tc_unmatched has no toolResult → push cut back from u3 to u2
-    expect(r.compactAll).toBe(false);
-    expect(r.firstKeptEntryId).toBe("u2");
-  });
-
-  test("Anthropic-style session: many matched toolCalls should not cause compact-all", () => {
-    // Simulates the real Anthropic pattern: 2 user messages with many matched
-    // toolCall/toolResult pairs between them. The bug caused all toolCalls to
-    // appear "unmatched" → cut pushed back to first user → compact-all.
-    const entries: any[] = [
-      msg("u1", "user", "help me find bugs"),
-    ];
-    // Add 5 matched tool cycles (assistant with toolCall + toolResult)
-    for (let i = 1; i <= 5; i++) {
-      entries.push({ id: `a${i}`, type: "message", message: { role: "assistant", content: [
-        { type: "thinking", thinking: `thinking ${i}` },
-        { type: "toolCall", id: `tc_${i}`, name: "read", arguments: { path: `file${i}.ts` } },
-      ] } });
-      entries.push({ id: `t${i}`, type: "message", message: { role: "toolResult", toolCallId: `tc_${i}`, toolName: "read", content: [{ type: "text", text: `file ${i} contents` }], isError: false } });
-    }
-    // Second user message
-    entries.push(msg("u2", "user", "now fix the bug"));
-    // More matched tool cycles after second user
-    for (let i = 6; i <= 8; i++) {
-      entries.push({ id: `a${i}`, type: "message", message: { role: "assistant", content: [
-        { type: "toolCall", id: `tc_${i}`, name: "edit", arguments: { path: `file${i}.ts` } },
-      ] } });
-      entries.push({ id: `t${i}`, type: "message", message: { role: "toolResult", toolCallId: `tc_${i}`, toolName: "edit", content: [{ type: "text", text: `edited file ${i}` }], isError: false } });
-    }
-    entries.push(msg("a9", "assistant", "all done"));
-
-    const r = buildOwnCut(entries);
-    expect(r.ok).toBe(true);
-    if (!r.ok) return;
-    // Cut should be at u2 — all toolCalls after u1 have matching toolResults
-    // and all toolCalls after u2 also have matching toolResults
-    expect(r.compactAll).toBe(false);
-    expect(r.firstKeptEntryId).toBe("u2");
-  });
-});

package/tests/brief.test.ts

@@ -1,215 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { compileBrief } from "../src/core/brief";
-import type { NormalizedBlock } from "../src/types";
-
-describe("compileBrief", () => {
-  it("returns empty string for no blocks", () => {
-    expect(compileBrief([])).toBe("");
-  });
-
-  it("renders user and assistant text", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "user", text: "fix auth bug" },
-      { kind: "assistant", text: "Let me look at the auth module." },
-    ];
-    const r = compileBrief(blocks);
-    expect(r).toContain("[user]");
-    expect(r).toContain("fix auth bug");
-    expect(r).toContain("[assistant]");
-    expect(r).toContain("Let me look at the auth module.");
-  });
-
-  it("renders bash commands as user actions", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "bash", command: "npm test", output: "FAIL noisy output", exitCode: 1, sourceIndex: 2 },
-    ];
-    const r = compileBrief(blocks);
-    expect(r).toContain("[user]\n$ npm test (#2)");
-    expect(r).not.toContain("FAIL noisy output");
-  });
-
-  it("strips filler prefixes but preserves meaningful lead-ins", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "assistant", text: "Okay, I found the root cause." },
-      { kind: "assistant", text: "Actually, the issue is in middleware." },
-      { kind: "assistant", text: "Let me check the logs." },
-    ];
-    const r = compileBrief(blocks);
-    expect(r).toContain("I found the root cause.");
-    expect(r).toContain("the issue is in middleware.");
-    expect(r).toContain("Let me check the logs.");
-  });
-
-  it("collapses tool calls to one-liners under [assistant]", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "assistant", text: "Let me check." },
-      { kind: "tool_call", name: "Read", args: { file_path: "auth.ts" } },
-      { kind: "tool_call", name: "Edit", args: { file_path: "auth.ts" } },
-    ];
-    const r = compileBrief(blocks);
-    expect(r).toContain('* Read "auth.ts"');
-    expect(r).toContain('* Edit "auth.ts"');
-    // Should merge into single [assistant] section
-    const matches = r.match(/\[assistant\]/g);
-    expect(matches?.length).toBe(1);
-  });
-
-  it("hides non-error tool results", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_result", name: "Read", text: "const x = 1;\nconst y = 2;\n// lots of code", isError: false },
-    ];
-    const r = compileBrief(blocks);
-    expect(r).toBe("");
-  });
-
-  it("shows tool errors with first line", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "tool_result", name: "bash", text: "FAIL auth.test.ts\nexpected 200 got 401", isError: true },
-    ];
-    const r = compileBrief(blocks);
-    expect(r).toContain("[tool_error] bash");
-    expect(r).toContain("FAIL auth.test.ts");
-  });
-
-  it("hides thinking blocks", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "thinking", text: "Let me think about this...", redacted: false },
-      { kind: "assistant", text: "Here's what I found." },
-    ];
-    const r = compileBrief(blocks);
-    expect(r).not.toContain("think");
-    expect(r).toContain("Here's what I found.");
-  });
-
-  it("merges adjacent assistant sections", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "assistant", text: "First part." },
-      { kind: "tool_call", name: "Read", args: { file_path: "a.ts" } },
-      // No user/tool_result between these — should merge
-      { kind: "assistant", text: "Second part." },
-      { kind: "tool_call", name: "Read", args: { file_path: "b.ts" } },
-    ];
-    const r = compileBrief(blocks);
-    const matches = r.match(/\[assistant\]/g);
-    expect(matches?.length).toBe(1);
-  });
-
-  it("does NOT merge assistant after user", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "assistant", text: "First." },
-      { kind: "user", text: "Next task." },
-      { kind: "assistant", text: "Second." },
-    ];
-    const r = compileBrief(blocks);
-    const matches = r.match(/\[assistant\]/g);
-    expect(matches?.length).toBe(2);
-  });
-
-  it("truncates long user text", () => {
-    const longText = Array.from({ length: 300 }, (_, i) => `word${i}`).join(" ");
-    const blocks: NormalizedBlock[] = [
-      { kind: "user", text: longText },
-    ];
-    const r = compileBrief(blocks);
-    expect(r).toContain("(truncated)");
-    expect(r).not.toContain("word299");
-  });
-
-  it("truncates long assistant text", () => {
-    const longText = Array.from({ length: 300 }, (_, i) => `word${i}`).join(" ");
-    const blocks: NormalizedBlock[] = [
-      { kind: "assistant", text: longText },
-    ];
-    const r = compileBrief(blocks);
-    expect(r).toContain("(truncated)");
-    expect(r).not.toContain("word299");
-  });
-
-  it("renders a realistic conversation flow", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "user", text: "fix the login bug" },
-      { kind: "thinking", text: "I need to check...", redacted: false },
-      { kind: "assistant", text: "Let me investigate." },
-      { kind: "tool_call", name: "Read", args: { file_path: "login.ts" } },
-      { kind: "tool_result", name: "Read", text: "export function login() { ... }", isError: false },
-      { kind: "tool_call", name: "bash", args: { command: "npm test" } },
-      { kind: "tool_result", name: "bash", text: "FAIL: login test\nExpected true, got false", isError: true },
-      { kind: "assistant", text: "The test is failing because..." },
-      { kind: "tool_call", name: "Edit", args: { file_path: "login.ts" } },
-      { kind: "tool_result", name: "Edit", text: "File edited successfully", isError: false },
-      { kind: "user", text: "test lại đi" },
-      { kind: "assistant", text: "Running tests again." },
-      { kind: "tool_call", name: "bash", args: { command: "npm test" } },
-      { kind: "tool_result", name: "bash", text: "All tests passed", isError: false },
-    ];
-    const r = compileBrief(blocks);
-
-    // Check structure
-    expect(r).toContain("[user]\nfix the login bug");
-    expect(r).toContain('[assistant]\nLet me investigate.\n* Read "login.ts"');
-    expect(r).toContain("[tool_error] bash\nFAIL: login test");
-    expect(r).toContain('[assistant]\nThe test is failing because...\n* Edit "login.ts"');
-    expect(r).toContain("[user]\ntest lại đi");
-    expect(r).toContain('[assistant]\nRunning tests again.\n* bash "npm test"');
-
-    // Hidden content
-    expect(r).not.toContain("think");
-    expect(r).not.toContain("export function login");
-    expect(r).not.toContain("File edited successfully");
-    expect(r).not.toContain("All tests passed");
-  });
-
-  // ── noise filtering tests (aligned with VCC) ──
-
-
-
-
-
-
-
-
-
-  it("suppresses blank lines between consecutive tool-only sections", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "assistant", text: "Checking files." },
-      { kind: "tool_call", name: "Read", args: { file_path: "a.ts" } },
-      { kind: "tool_result", name: "Read", text: "...", isError: false },
-      // tool_result hidden → next tool_call starts new assistant section
-      // but since both are tool-only, no blank line between
-      { kind: "tool_call", name: "Read", args: { file_path: "b.ts" } },
-      { kind: "tool_result", name: "Read", text: "...", isError: false },
-    ];
-    const r = compileBrief(blocks);
-    // The first assistant section has text + tool, so it's NOT tool-only
-    // The second would be tool-only but merges into the first (adjacent assistant)
-    // So all under one [assistant]
-    expect(r.match(/\[assistant\]/g)?.length).toBe(1);
-  });
-
-  it("caps tool calls per [assistant] turn at 8 (keep tail)", () => {
-    const blocks: NormalizedBlock[] = [
-      { kind: "assistant", text: "Working." },
-    ];
-    for (let i = 1; i <= 12; i++) {
-      blocks.push({ kind: "tool_call", name: "bash", args: { command: `echo ${i}` } });
-    }
-    const r = compileBrief(blocks);
-    expect(r).toContain("(4 earlier tool-call entries omitted)");
-    // Last 8 (5..12) kept; first 4 dropped
-    expect(r).not.toContain("echo 1\"");
-    expect(r).not.toContain("echo 4\"");
-    expect(r).toContain("echo 5");
-    expect(r).toContain("echo 12");
-  });
-
-  it("does not cap when tool calls per turn <= 8", () => {
-    const blocks: NormalizedBlock[] = [{ kind: "assistant", text: "ok" }];
-    for (let i = 1; i <= 8; i++) {
-      blocks.push({ kind: "tool_call", name: "bash", args: { command: `c${i}` } });
-    }
-    const r = compileBrief(blocks);
-    expect(r).not.toContain("entries omitted");
-    expect(r).toContain("c1");
-    expect(r).toContain("c8");
-  });
-});