@monotykamary/pi-vcc 0.3.16

package/tests/before-compact.test.ts

@@ -0,0 +1,227 @@
+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

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

package/tests/build-sections.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect } from "bun:test";
+import { buildSections } from "../src/core/build-sections";
+import type { NormalizedBlock } from "../src/types";
+
+describe("buildSections", () => {
+  it("returns all-empty for no blocks", () => {
+    const r = buildSections({ blocks: [] });
+    expect(r.sessionGoal).toEqual([]);
+    expect(r.outstandingContext).toEqual([]);
+    expect(r.briefTranscript).toBe("");
+  });
+
+  it("populates sections from realistic blocks", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "Fix the auth bug" },
+      { kind: "tool_call", name: "Read", args: { file_path: "auth.ts" } },
+      { kind: "tool_result", name: "Read", text: "const x = 1;", isError: false },
+      { kind: "tool_call", name: "Edit", args: { file_path: "auth.ts" } },
+      { kind: "tool_result", name: "Edit", text: "ok", isError: false },
+      { kind: "assistant", text: "- run tests next" },
+    ];
+    const r = buildSections({ blocks });
+    expect(r.sessionGoal).toContain("Fix the auth bug");
+    expect(r.briefTranscript).toContain('[user]');
+    expect(r.briefTranscript).toContain('* Read "auth.ts"');
+    expect(r.briefTranscript).toContain('* Edit "auth.ts"');
+  });
+
+  it("captures outstanding context from errors", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "tool_result", name: "bash", text: "FAIL: test broken\ndetails here", isError: true },
+    ];
+    const r = buildSections({ blocks });
+    expect(r.outstandingContext.length).toBeGreaterThan(0);
+    expect(r.outstandingContext[0]).toContain("FAIL");
+  });
+
+  it("brief transcript hides tool results but shows errors", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "tool_result", name: "Read", text: "lots of code here ...", isError: false },
+      { kind: "tool_result", name: "bash", text: "Command not found", isError: true },
+    ];
+    const r = buildSections({ blocks });
+    expect(r.briefTranscript).not.toContain("lots of code");
+    expect(r.briefTranscript).toContain("[tool_error] bash");
+    expect(r.briefTranscript).toContain("Command not found");
+  });
+
+  it("brief transcript merges adjacent assistant sections", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "assistant", text: "Part one." },
+      { kind: "tool_call", name: "Read", args: { file_path: "a.ts" } },
+      { kind: "assistant", text: "Part two." },
+    ];
+    const r = buildSections({ blocks });
+    const matches = r.briefTranscript.match(/\[assistant\]/g);
+    expect(matches?.length).toBe(1);
+  });
+});

package/tests/compile.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect } from "bun:test";
+import { compile } from "../src/core/summarize";
+import {
+  userMsg,
+  assistantText,
+  assistantWithToolCall,
+  toolResult,
+} from "./fixtures";
+
+describe("compile", () => {
+  it("returns empty string for no messages", () => {
+    expect(compile({ messages: [] })).toBe("");
+  });
+
+  it("produces hybrid output with header + brief transcript", () => {
+    const r = compile({
+      messages: [
+        userMsg("Fix login bug"),
+        assistantWithToolCall("Read", { path: "auth.ts" }),
+        assistantText("Found the issue.\n1. Fix validation"),
+      ],
+    });
+    expect(r).toContain("[Session Goal]");
+    expect(r).toContain("Fix login bug");
+    expect(r).toContain("---");
+    expect(r).toContain("[user]\nFix login bug");
+    expect(r).toContain('* Read "auth.ts"');
+    expect(r).toContain("Found the issue.");
+  });
+
+  it("merges previous summary goals", () => {
+    const r = compile({
+      messages: [userMsg("New task")],
+      previousSummary: "[Session Goal]\n- Original goal\n\n---\n\n[user]\nOriginal goal",
+    });
+    expect(r).toContain("- Original goal");
+    expect(r).toContain("- New task");
+  });
+
+  it("appends brief transcript on merge", () => {
+    const previousSummary = [
+      "[Session Goal]\n- Original goal",
+      "---",
+      "[user]\nOriginal goal\n\n[assistant]\n* Read \"old.ts\"",
+    ].join("\n\n");
+    const r = compile({
+      previousSummary,
+      messages: [
+        userMsg("Next step"),
+        assistantWithToolCall("Read", { path: "new.ts" }),
+      ],
+    });
+    expect(r).toContain('* Read "old.ts"');
+    expect(r).toContain('* Read "new.ts"');
+    expect(r).toContain("Next step");
+  });
+
+  it("outstanding context is volatile (fresh only)", () => {
+    const previousSummary = "[Outstanding Context]\n- old blocker\n\n---\n\n[user]\nhi";
+    const r = compile({
+      previousSummary,
+      messages: [userMsg("continue")],
+    });
+    expect(r).not.toContain("old blocker");
+  });
+
+  it("caps long brief transcript with rolling window", () => {
+    // Build a very long previous transcript
+    const longTranscript = Array.from({ length: 200 }, (_, i) =>
+      `[user]\nmessage ${i}`
+    ).join("\n\n");
+    const previousSummary = `[Session Goal]\n- goal\n\n---\n\n${longTranscript}`;
+    const r = compile({
+      previousSummary,
+      messages: [userMsg("latest")],
+    });
+    expect(r).toContain("earlier lines omitted");
+    expect(r).toContain("latest");
+  });
+
+  it("wraps final output including recall note", () => {
+    const r = compile({
+      messages: [userMsg("check final summary wrapping")],
+    });
+    const maxLineLength = Math.max(...r.split("\n").map((line) => line.length));
+    expect(r).toContain("vcc_recall");
+    expect(maxLineLength).toBeLessThanOrEqual(120);
+  });
+});

package/tests/content.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from "bun:test";
+import { textOf, thinkingOf, clip, firstLine } from "../src/core/content";
+
+describe("textOf", () => {
+  it("returns empty string for undefined content", () => {
+    expect(textOf(undefined as any)).toBe("");
+  });
+
+  it("returns empty string for null content", () => {
+    expect(textOf(null as any)).toBe("");
+  });
+
+  it("returns string content as-is", () => {
+    expect(textOf("hello")).toBe("hello");
+  });
+
+  it("extracts text parts from array content", () => {
+    const content = [
+      { type: "text" as const, text: "first" },
+      { type: "toolCall" as const, name: "x", id: "1", arguments: {} },
+      { type: "text" as const, text: "second" },
+    ];
+    expect(textOf(content)).toBe("first\nsecond");
+  });
+
+  it("ignores thinking parts", () => {
+    const content = [
+      { type: "thinking" as const, thinking: "let me think" },
+      { type: "text" as const, text: "here is the answer" },
+    ];
+    expect(textOf(content)).toBe("here is the answer");
+  });
+});
+
+describe("thinkingOf", () => {
+  it("returns empty string for undefined content", () => {
+    expect(thinkingOf(undefined as any)).toBe("");
+  });
+
+  it("returns empty string for string content", () => {
+    expect(thinkingOf("hello")).toBe("");
+  });
+
+  it("extracts thinking parts from array content", () => {
+    const content = [
+      { type: "thinking" as const, thinking: "let me think" },
+      { type: "text" as const, text: "here is the answer" },
+    ];
+    expect(thinkingOf(content)).toBe("let me think");
+  });
+
+  it("joins multiple thinking parts", () => {
+    const content = [
+      { type: "thinking" as const, thinking: "first thought" },
+      { type: "text" as const, text: "answer" },
+      { type: "thinking" as const, thinking: "second thought" },
+    ];
+    expect(thinkingOf(content)).toBe("first thought\nsecond thought");
+  });
+});
+
+describe("textOf", () => {
+  it("returns empty string for undefined content", () => {
+    expect(textOf(undefined as any)).toBe("");
+  });
+});