ultimate-pi 0.4.0 → 0.4.1

package/vendor/pi-vcc/src/tools/recall.ts

@@ -0,0 +1,109 @@
+import { Type } from "@sinclair/typebox";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { loadAllMessages } from "../core/load-messages";
+import { searchEntries } from "../core/search-entries";
+import { formatRecallOutput } from "../core/format-recall";
+import { getActiveLineageEntryIds } from "../core/lineage";
+import { normalizeRecallScope } from "../core/recall-scope";
+
+const DEFAULT_RECENT = 25;
+const PAGE_SIZE = 5;
+
+export const invalidExpandIndices = (requested: number[], available: Set<number>): number[] =>
+  requested.filter((i) => !Number.isInteger(i) || !available.has(i));
+
+export const registerRecallTool = (pi: ExtensionAPI) => {
+  pi.registerTool({
+    name: "vcc_recall",
+    label: "VCC Recall",
+    description:
+      "Search session history. Defaults to active lineage; use scope:'all' to include off-lineage branches." +
+      " Supports regex queries, paging, and expand indices.",
+    promptSnippet:
+      "vcc_recall: Search history; default scope is active lineage. Use scope:'all' for off-lineage branches.",
+    parameters: Type.Object({
+      query: Type.Optional(
+        Type.String({ description: "Search terms or regex pattern (e.g. 'hook|inject', 'fail.*build'). Multi-word = OR ranked by relevance." }),
+      ),
+      expand: Type.Optional(
+        Type.Array(Type.Number(), { description: "Entry indices to return full untruncated content for" }),
+      ),
+      page: Type.Optional(
+        Type.Number({ description: "Page number (1-based) for paginated search results. Default: 1." }),
+      ),
+      scope: Type.Optional(
+        Type.Union([
+          Type.Literal("lineage"),
+          Type.Literal("all"),
+        ], { description: "Search scope. Default: lineage; all includes off-lineage branches." }),
+      ),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const sessionFile = ctx.sessionManager.getSessionFile();
+      if (!sessionFile) {
+        return {
+          content: [{ type: "text", text: "No session file available." }],
+          details: undefined,
+        };
+      }
+
+      const scope = normalizeRecallScope(params.scope);
+      const lineageEntryIds = scope === "lineage"
+        ? getActiveLineageEntryIds(ctx.sessionManager)
+        : undefined;
+      const expandSet = new Set(params.expand ?? []);
+      const hasExpand = expandSet.size > 0;
+
+      if (hasExpand && !params.query) {
+        const { rendered: fullMsgs } = loadAllMessages(sessionFile, true, lineageEntryIds);
+        const requested = [...expandSet];
+        const byIndex = new Map(fullMsgs.map((m) => [m.index, m]));
+        const invalid = invalidExpandIndices(requested, new Set(byIndex.keys()));
+        if (invalid.length > 0) {
+          return {
+            content: [{ type: "text", text: `Cannot expand indices outside ${scope === "all" ? "session history" : "active lineage"}: ${invalid.join(", ")}` }],
+            details: undefined,
+          };
+        }
+
+        const expanded = requested.map((i) => byIndex.get(i)).filter((m): m is NonNullable<typeof m> => Boolean(m));
+        const output = (scope === "all" ? "Scope: all\n\n" : "") + formatRecallOutput(expanded);
+        return {
+          content: [{ type: "text", text: output }],
+          details: undefined,
+        };
+      }
+
+      const { rendered: msgs, rawMessages } = loadAllMessages(sessionFile, false, lineageEntryIds);
+      const allResults = params.query?.trim()
+        ? searchEntries(msgs, rawMessages, params.query)
+        : msgs.slice(-DEFAULT_RECENT);
+
+      if (params.query?.trim()) {
+        const page = Math.max(1, params.page ?? 1);
+        const start = (page - 1) * PAGE_SIZE;
+        const pageResults = allResults.slice(start, start + PAGE_SIZE);
+        const totalPages = Math.ceil(allResults.length / PAGE_SIZE);
+        const scopeSuffix = scope === "all" ? " (scope: all)" : "";
+        const header = totalPages > 1
+          ? `Page ${page}/${totalPages} (${allResults.length} total matches${scopeSuffix})`
+          : `${allResults.length} matches${scopeSuffix}`;
+        const footer = page < totalPages
+          ? `\n--- Use page:${page + 1}${scope === "all" ? " with scope:'all'" : ""} for more results ---`
+          : "";
+        const output = formatRecallOutput(pageResults, params.query, header) + footer;
+        return {
+          content: [{ type: "text", text: output }],
+          details: undefined,
+        };
+      }
+
+      const output = (scope === "all" ? "Scope: all\n\n" : "") + formatRecallOutput(allResults, params.query);
+      return {
+        content: [{ type: "text", text: output }],
+        details: undefined,
+      };
+    },
+  });
+};
+

package/vendor/pi-vcc/src/types.ts

@@ -0,0 +1,14 @@
+import type { Message } from "@mariozechner/pi-ai";
+
+export interface FileOps {
+  readFiles?: string[];
+  modifiedFiles?: string[];
+  createdFiles?: string[];
+}
+
+export type NormalizedBlock =
+  | { kind: "user"; text: string; sourceIndex?: number }
+  | { kind: "assistant"; text: string; sourceIndex?: number }
+  | { kind: "tool_call"; name: string; args: Record<string, unknown>; sourceIndex?: number }
+  | { kind: "tool_result"; name: string; text: string; isError: boolean; sourceIndex?: number }
+  | { kind: "thinking"; text: string; redacted: boolean; sourceIndex?: number };

package/vendor/pi-vcc/tests/before-compact-hook.test.ts

@@ -0,0 +1,204 @@
+import { describe, test, expect, beforeEach, afterEach, beforeAll, afterAll } from "bun:test";
+import { existsSync, unlinkSync, readFileSync } from "fs";
+import { registerBeforeCompactHook, PI_VCC_COMPACT_INSTRUCTION } from "../src/hooks/before-compact";
+
+const DEBUG_PATH = "/tmp/pi-vcc-debug.json";
+
+let compactionEnvBackup: string | undefined;
+let debugEnvBackup: string | undefined;
+
+beforeAll(() => {
+	compactionEnvBackup = process.env.HARNESS_VCC_COMPACTION;
+	debugEnvBackup = process.env.HARNESS_VCC_DEBUG;
+});
+
+afterAll(() => {
+	if (compactionEnvBackup === undefined) {
+		delete process.env.HARNESS_VCC_COMPACTION;
+	} else {
+		process.env.HARNESS_VCC_COMPACTION = compactionEnvBackup;
+	}
+	if (debugEnvBackup === undefined) {
+		delete process.env.HARNESS_VCC_DEBUG;
+	} else {
+		process.env.HARNESS_VCC_DEBUG = debugEnvBackup;
+	}
+});
+
+function setHarnessEnv(opts: {
+	overrideDefaultCompaction: boolean;
+	debug: boolean;
+}) {
+	process.env.HARNESS_VCC_COMPACTION = opts.overrideDefaultCompaction
+		? "true"
+		: "false";
+	process.env.HARNESS_VCC_DEBUG = opts.debug ? "true" : "false";
+}
+
+// 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 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(DEBUG_PATH)) unlinkSync(DEBUG_PATH);
+	});
+
+	test("/pi-vcc with too few live messages cancels and notifies warning", () => {
+		setHarnessEnv({ 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", () => {
+		setHarnessEnv({ 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));
+		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)", () => {
+		setHarnessEnv({ 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)", () => {
+		setHarnessEnv({ 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", () => {
+		setHarnessEnv({ debug: true, overrideDefaultCompaction: false });
+		const { pi, invoke } = createMockPi();
+		registerBeforeCompactHook(pi);
+
+		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");
+
+		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", () => {
+		setHarnessEnv({ 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(DEBUG_PATH)) unlinkSync(DEBUG_PATH);
+	});
+
+	test("single-user + autonomous tail → returns compaction with empty firstKeptEntryId", () => {
+		setHarnessEnv({ 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();
+		expect(result.compaction.firstKeptEntryId).toBe("");
+		expect(notifyCalls).toHaveLength(0);
+	});
+});

package/vendor/pi-vcc/tests/before-compact.test.ts

@@ -0,0 +1,145 @@
+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: compact all", () => {
+    // The Discord scenario: user types 1 prompt, agent runs autonomously
+    // (assistant + toolResult interleaved). No user > idx 0.
+    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(true);
+    expect(r.firstKeptEntryId).toBe("");
+    expect(r.messages).toHaveLength(6);
+  });
+
+  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: compact 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;
+    expect(r.compactAll).toBe(true);
+    expect(r.firstKeptEntryId).toBe("");
+  });
+});

package/vendor/pi-vcc/tests/brief.test.ts

@@ -0,0 +1,206 @@
+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("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");
+  });
+});