@sting8k/pi-vcc 0.1.0

package/src/hooks/before-compact.ts

@@ -0,0 +1,141 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { convertToLlm } from "@mariozechner/pi-coding-agent";
+import { readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { compile } from "../core/summarize";
+import type { PiVccCompactionDetails } from "../details";
+
+const CONFIG_PATH = join(homedir(), ".pi", "agent", "pi-vcc-config.json");
+
+const loadConfig = (): { debug?: boolean } => {
+  try { return JSON.parse(readFileSync(CONFIG_PATH, "utf-8")); } catch { return {}; }
+};
+
+const dbg = (data: Record<string, unknown>) => {
+  if (!loadConfig().debug) return;
+  try { writeFileSync("/tmp/pi-vcc-debug.json", JSON.stringify(data, null, 2)); } catch {}
+};
+
+const previewContent = (content: unknown): string => {
+  if (typeof content === "string") return content.slice(0, 300);
+  if (Array.isArray(content)) {
+    return content
+      .map((c: any) => {
+        if (c?.type === "text") return c.text ?? "";
+        if (c?.type === "toolCall") return `[toolCall:${c.name}]`;
+        if (c?.type === "thinking") return `[thinking]`;
+        if (c?.type === "image") return `[image:${c.mimeType}]`;
+        return `[${c?.type ?? "unknown"}]`;
+      })
+      .join("\n")
+      .slice(0, 300);
+  }
+  return "";
+};
+
+interface EntryWithMessage {
+  entry: { id: string; type: string };
+  message: { role: string; content: unknown };
+}
+
+function buildOwnCut(branchEntries: any[]): { messages: any[]; firstKeptEntryId: string } | null {
+  const postCompaction: EntryWithMessage[] = [];
+  for (const e of branchEntries) {
+    if (e.type === "compaction") {
+      postCompaction.length = 0;
+      continue;
+    }
+    if (e.type === "message" && e.message) {
+      postCompaction.push({ entry: e, message: e.message });
+    }
+  }
+
+  if (postCompaction.length <= 2) return null;
+
+  // Summarize all messages, keep only the last user message as context
+  let cutIdx = postCompaction.length - 1;
+
+  // Align to last user message boundary
+  while (cutIdx > 0 && postCompaction[cutIdx].message.role !== "user") {
+    cutIdx--;
+  }
+
+  if (cutIdx <= 0) return null;
+
+  return {
+    messages: postCompaction.slice(0, cutIdx).map((e) => e.message),
+    firstKeptEntryId: postCompaction[cutIdx].entry.id,
+  };
+}
+
+export const registerBeforeCompactHook = (pi: ExtensionAPI) => {
+  pi.on("session_before_compact", (event) => {
+    const { preparation, branchEntries } = event;
+
+    let agentMessages = preparation.messagesToSummarize;
+    let firstKeptEntryId = preparation.firstKeptEntryId;
+
+    // If pi-core's preparation has nothing to summarize, build our own cut
+    if (agentMessages.length === 0) {
+      const ownCut = buildOwnCut(branchEntries as any[]);
+      if (ownCut) {
+        agentMessages = ownCut.messages;
+        firstKeptEntryId = ownCut.firstKeptEntryId;
+      }
+    }
+
+    const messages = convertToLlm(agentMessages);
+
+    const summary = compile({
+      messages,
+      previousSummary: preparation.previousSummary,
+      fileOps: {
+        readFiles: [...preparation.fileOps.read],
+        modifiedFiles: [...preparation.fileOps.written, ...preparation.fileOps.edited],
+      },
+    });
+
+    const branchIds = branchEntries.map((e: any) => e.id);
+    const cutIdx = branchIds.indexOf(firstKeptEntryId);
+    const cutWindow = cutIdx >= 0
+      ? branchEntries.slice(Math.max(0, cutIdx - 3), Math.min(branchEntries.length, cutIdx + 3)).map((e: any) => ({
+          id: e.id,
+          type: e.type,
+          role: e.type === "message" ? e.message?.role : undefined,
+          preview: e.type === "message" ? previewContent(e.message?.content) : undefined,
+        }))
+      : [];
+
+    dbg({
+      usedOwnCut: agentMessages !== preparation.messagesToSummarize,
+      messagesToSummarize: agentMessages.length,
+      messagesPreviewHead: agentMessages.slice(0, 3).map((m: any) => ({ role: m.role, preview: previewContent(m.content) })),
+      messagesPreviewTail: agentMessages.slice(-3).map((m: any) => ({ role: m.role, preview: previewContent(m.content) })),
+      convertedMessages: messages.length,
+      firstKeptEntryId,
+      cutWindow,
+      tokensBefore: preparation.tokensBefore,
+      summaryLength: summary.length,
+      summaryPreview: summary.slice(0, 500),
+      sections: [...summary.matchAll(/^\[(.+?)\]/gm)].map((m) => m[1]),
+    });
+
+    const details: PiVccCompactionDetails = {
+      compactor: "pi-vcc",
+      version: 1,
+      sections: [...summary.matchAll(/^\[(.+?)\]/gm)].map((m) => m[1]),
+      sourceMessageCount: agentMessages.length,
+      previousSummaryUsed: Boolean(preparation.previousSummary),
+    };
+
+    return {
+      compaction: {
+        summary,
+        details,
+        tokensBefore: preparation.tokensBefore,
+        firstKeptEntryId,
+      },
+    };
+  });
+};

package/src/sections.ts

@@ -0,0 +1,11 @@
+export interface SectionData {
+  sessionGoal: string[];
+  keyConversationTurns: string[];
+  actionsTaken: string[];
+  importantEvidence: string[];
+  filesRead: string[];
+  filesModified: string[];
+  filesCreated: string[];
+  outstandingContext: string[];
+  userPreferences: string[];
+}

package/src/tools/recall.ts

@@ -0,0 +1,85 @@
+import { Type } from "@sinclair/typebox";
+import { readFileSync } from "fs";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { renderMessage } from "../core/render-entries";
+import { searchEntries } from "../core/search-entries";
+import { formatRecallOutput } from "../core/format-recall";
+
+const DEFAULT_RECENT = 25;
+const MAX_RESULTS = 50;
+
+const loadAllMessages = (sessionFile: string, full: boolean) => {
+  const content = readFileSync(sessionFile, "utf-8");
+  const entries: any[] = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      entries.push(JSON.parse(line));
+    } catch {}
+  }
+  return entries
+    .filter((e) => e.type === "message" && e.message)
+    .map((e, i) => renderMessage(e.message, i, full));
+};
+
+export const registerRecallTool = (pi: ExtensionAPI) => {
+  pi.registerTool({
+    name: "vcc_recall",
+    label: "VCC Recall",
+    description:
+      "Search full conversation history in this session, including before compaction." +
+      " Use without query to see recent brief history." +
+      " Use with query to search all history." +
+      " Use expand with entry indices to get full content (note: some tool results may already be truncated by Pi core before saving).",
+    promptSnippet:
+      "vcc_recall: Search full conversation history including compacted parts. Use expand:[indices] for full content.",
+    parameters: Type.Object({
+      query: Type.Optional(
+        Type.String({ description: "Search terms to filter history" }),
+      ),
+      expand: Type.Optional(
+        Type.Array(Type.Number(), { description: "Entry indices to return full untruncated content for" }),
+      ),
+    }),
+    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 expandSet = new Set(params.expand ?? []);
+      const hasExpand = expandSet.size > 0;
+
+      if (hasExpand && !params.query) {
+        const fullMsgs = loadAllMessages(sessionFile, true);
+        const expanded = fullMsgs.filter((m) => expandSet.has(m.index));
+        if (expanded.length === 0) {
+          return {
+            content: [{ type: "text", text: `No entries found for indices: ${[...expandSet].join(", ")}` }],
+            details: undefined,
+          };
+        }
+        const output = formatRecallOutput(expanded);
+        return {
+          content: [{ type: "text", text: output }],
+          details: undefined,
+        };
+      }
+
+      const msgs = loadAllMessages(sessionFile, false);
+      const results = params.query?.trim()
+        ? searchEntries(msgs, params.query).slice(0, MAX_RESULTS)
+        : msgs.slice(-DEFAULT_RECENT);
+      const output = formatRecallOutput(results, params.query);
+
+      return {
+        content: [{ type: "text", text: output }],
+        details: undefined,
+      };
+    },
+  });
+};
+

package/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 }
+  | { kind: "assistant"; text: string }
+  | { kind: "tool_call"; name: string; args: Record<string, unknown> }
+  | { kind: "tool_result"; name: string; text: string; isError: boolean }
+  | { kind: "thinking"; text: string; redacted: boolean };

package/tests/build-sections.test.ts

@@ -0,0 +1,56 @@
+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.actionsTaken).toEqual([]);
+    expect(r.filesRead).toEqual([]);
+  });
+
+  it("populates sections from realistic blocks", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "Fix the auth bug" },
+      { kind: "tool_call", name: "Read", args: { path: "auth.ts" } },
+      { kind: "tool_result", name: "Read", text: "export function auth() { return checkToken(req.headers.authorization); }", isError: false },
+      { kind: "assistant", text: "The root cause is a null check" },
+      { kind: "tool_call", name: "Edit", args: { 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.filesRead).toContain("auth.ts");
+    expect(r.filesModified).toContain("auth.ts");
+    expect(r.actionsTaken.length).toBeGreaterThan(0);
+    expect(r.actionsTaken[0]).toContain("auth.ts");
+    expect(r.importantEvidence.length).toBeGreaterThan(0);
+    expect(r.importantEvidence[0]).toContain("[Read]");
+    expect(r.keyConversationTurns.length).toBeGreaterThan(0);
+    expect(r.keyConversationTurns.some((t) => t.startsWith("[user]"))).toBe(true);
+    expect(r.keyConversationTurns.some((t) => t.startsWith("[assistant]"))).toBe(true);
+  });
+
+  it("uses fileOps to seed file lists", () => {
+    const r = buildSections({
+      blocks: [],
+      fileOps: { readFiles: ["x.ts"], modifiedFiles: ["y.ts"] },
+    });
+    expect(r.filesRead).toContain("x.ts");
+    expect(r.filesModified).toContain("y.ts");
+  });
+
+  it("collapses repeated tool calls", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "tool_call", name: "Read", args: { path: "a.ts" } },
+      { kind: "tool_call", name: "Read", args: { path: "a.ts" } },
+      { kind: "tool_call", name: "Read", args: { path: "a.ts" } },
+    ];
+    const r = buildSections({ blocks });
+    expect(r.actionsTaken.length).toBe(1);
+    expect(r.actionsTaken[0]).toContain("x3");
+  });
+});
+

package/tests/compile.test.ts

@@ -0,0 +1,50 @@
+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 structured output from a conversation", () => {
+    const r = compile({
+      messages: [
+        userMsg("Fix login bug"),
+        assistantWithToolCall("Read", { path: "auth.ts" }),
+        toolResult("Read", "function login() {}"),
+        assistantText("Found the issue.\n1. Fix validation"),
+      ],
+    });
+    expect(r).toContain("[Session Goal]");
+    expect(r).toContain("Fix login bug");
+    expect(r).toContain("[Actions Taken]");
+    expect(r).toContain("[Files And Changes]");
+    expect(r).toContain("auth.ts");
+  });
+
+  it("merges by section instead of appending delta blocks", () => {
+    const r = compile({
+      messages: [assistantText("Current state")],
+      previousSummary: "[Session Goal]\n- Original goal",
+    });
+    expect(r).toContain("[Session Goal]\n- Original goal");
+    expect(r).toContain("[Key Conversation Turns]");
+    expect(r).not.toContain("[Delta Since Last Compaction]");
+  });
+
+  it("passes fileOps through to sections", () => {
+    const r = compile({
+      messages: [userMsg("check")],
+      fileOps: { readFiles: ["config.ts"] },
+    });
+    expect(r).toContain("config.ts");
+  });
+});
+
+

package/tests/extract-decisions.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "bun:test";
+import { extractDecisions } from "../src/extract/decisions";
+import type { NormalizedBlock } from "../src/types";
+
+describe("extractDecisions", () => {
+  it("returns empty for no blocks", () => {
+    expect(extractDecisions([])).toEqual([]);
+  });
+
+  it("captures decision patterns from assistant", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "assistant", text: "I decided to use React for the frontend" },
+    ];
+    expect(extractDecisions(blocks).length).toBe(1);
+  });
+
+  it("captures from user blocks too", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "We must use PostgreSQL for the database" },
+    ];
+    expect(extractDecisions(blocks).length).toBe(1);
+  });
+
+  it("ignores tool_call blocks", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "tool_call", name: "Read", args: { path: "a.ts" } },
+    ];
+    expect(extractDecisions(blocks)).toEqual([]);
+  });
+});

package/tests/extract-files.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from "bun:test";
+import { extractFiles } from "../src/extract/files";
+import type { NormalizedBlock } from "../src/types";
+
+describe("extractFiles", () => {
+  it("returns empty sets for no blocks", () => {
+    const r = extractFiles([]);
+    expect(r.read.size).toBe(0);
+    expect(r.modified.size).toBe(0);
+    expect(r.created.size).toBe(0);
+  });
+
+  it("seeds from fileOps", () => {
+    const r = extractFiles([], {
+      readFiles: ["a.ts"],
+      modifiedFiles: ["b.ts"],
+      createdFiles: ["c.ts"],
+    });
+    expect(r.read.has("a.ts")).toBe(true);
+    expect(r.modified.has("b.ts")).toBe(true);
+    expect(r.created.has("c.ts")).toBe(true);
+  });
+
+  it("detects Read tool", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "tool_call", name: "Read", args: { path: "x.ts" } },
+    ];
+    expect(extractFiles(blocks).read.has("x.ts")).toBe(true);
+  });
+
+  it("detects Edit tool as modified", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "tool_call", name: "Edit", args: { path: "y.ts" } },
+    ];
+    expect(extractFiles(blocks).modified.has("y.ts")).toBe(true);
+  });
+
+  it("detects Write tool as both modified and created", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "tool_call", name: "Write", args: { path: "new.ts" } },
+    ];
+    const r = extractFiles(blocks);
+    expect(r.modified.has("new.ts")).toBe(true);
+    expect(r.created.has("new.ts")).toBe(true);
+  });
+
+  it("skips tool_call without path arg", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "tool_call", name: "Read", args: { query: "foo" } },
+    ];
+    expect(extractFiles(blocks).read.size).toBe(0);
+  });
+
+  it("supports file_path arg key", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "tool_call", name: "read_file", args: { file_path: "z.ts" } },
+    ];
+    expect(extractFiles(blocks).read.has("z.ts")).toBe(true);
+  });
+});
+
+

package/tests/extract-findings.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect } from "bun:test";
+import { extractFindings } from "../src/extract/findings";
+import type { NormalizedBlock } from "../src/types";
+
+describe("extractFindings", () => {
+  it("returns empty for no blocks", () => {
+    expect(extractFindings([])).toEqual([]);
+  });
+
+  it("ignores raw tool errors", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "tool_result", name: "Edit", text: "File not found", isError: true },
+    ];
+    expect(extractFindings(blocks)).toEqual([]);
+  });
+
+  it("captures assistant lines matching error patterns", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "assistant", text: "The root cause is a null pointer" },
+    ];
+    expect(extractFindings(blocks).length).toBe(1);
+  });
+
+  it("ignores short lines", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "assistant", text: "error" },
+    ];
+    expect(extractFindings(blocks)).toEqual([]);
+  });
+
+  it("deduplicates findings", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "assistant", text: "found that X is broken" },
+      { kind: "assistant", text: "found that X is broken" },
+    ];
+    expect(extractFindings(blocks).length).toBe(1);
+  });
+});
+

package/tests/extract-goals.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect } from "bun:test";
+import { extractGoals } from "../src/extract/goals";
+import type { NormalizedBlock } from "../src/types";
+
+describe("extractGoals", () => {
+  it("returns empty for no blocks", () => {
+    expect(extractGoals([])).toEqual([]);
+  });
+
+  it("returns empty when no user blocks", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "assistant", text: "hello" },
+    ];
+    expect(extractGoals(blocks)).toEqual([]);
+  });
+
+  it("extracts first user message lines as goals", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "Fix login bug\nCheck auth flow" },
+    ];
+    const goals = extractGoals(blocks);
+    expect(goals).toEqual(["Fix login bug", "Check auth flow"]);
+  });
+
+  it("takes max 3 lines from first user block", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "fix the login bug\ncheck auth flow\nupdate the tests\nrefactor utils\nclean up" },
+    ];
+    expect(extractGoals(blocks)).toHaveLength(3);
+  });
+
+  it("ignores subsequent user blocks", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "first goal" },
+      { kind: "assistant", text: "ok" },
+      { kind: "user", text: "second request" },
+    ];
+    expect(extractGoals(blocks)).toEqual(["first goal"]);
+  });
+
+  it("detects scope change with explicit pivot keywords", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "Fix login bug" },
+      { kind: "assistant", text: "ok" },
+      { kind: "user", text: "Actually, instead let's refactor the auth module" },
+    ];
+    const goals = extractGoals(blocks);
+    expect(goals).toContain("Fix login bug");
+    expect(goals).toContain("[Scope change]");
+    expect(goals.some((g) => g.includes("refactor"))).toBe(true);
+  });
+
+  it("detects scope change from new task statements", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "Fix login bug" },
+      { kind: "assistant", text: "done" },
+      { kind: "user", text: "Now implement the user registration flow" },
+    ];
+    const goals = extractGoals(blocks);
+    expect(goals).toContain("[Scope change]");
+  });
+
+  it("keeps latest scope change only", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "Fix login bug" },
+      { kind: "assistant", text: "done" },
+      { kind: "user", text: "Actually, fix the signup page instead" },
+      { kind: "assistant", text: "ok" },
+      { kind: "user", text: "Change of plan, implement password reset" },
+    ];
+    const goals = extractGoals(blocks);
+    const scopeIdx = goals.indexOf("[Scope change]");
+    expect(goals[scopeIdx + 1]).toContain("password reset");
+  });
+
+  it("skips noise short user messages as goals", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "ok" },
+      { kind: "assistant", text: "hello" },
+      { kind: "user", text: "Fix the authentication module" },
+    ];
+    const goals = extractGoals(blocks);
+    expect(goals[0]).toContain("Fix the authentication");
+    expect(goals.some((g) => g === "ok")).toBe(false);
+  });
+});

package/tests/extract-preferences.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "bun:test";
+import { extractPreferences } from "../src/extract/preferences";
+import type { NormalizedBlock } from "../src/types";
+
+describe("extractPreferences", () => {
+  it("returns empty for no blocks", () => {
+    expect(extractPreferences([])).toEqual([]);
+  });
+
+  it("captures preference patterns from user", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "I prefer TypeScript over JavaScript" },
+    ];
+    expect(extractPreferences(blocks).length).toBe(1);
+  });
+
+  it("ignores assistant blocks", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "assistant", text: "I always use best practices" },
+    ];
+    expect(extractPreferences(blocks)).toEqual([]);
+  });
+
+  it("captures please use pattern", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "please use bun instead of node" },
+    ];
+    expect(extractPreferences(blocks).length).toBe(1);
+  });
+});

package/tests/filter-noise.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect } from "bun:test";
+import { filterNoise } from "../src/core/filter-noise";
+import type { NormalizedBlock } from "../src/types";
+
+describe("filterNoise", () => {
+  it("removes thinking blocks", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "thinking", text: "hmm", redacted: false },
+      { kind: "assistant", text: "hello" },
+    ];
+    expect(filterNoise(blocks)).toEqual([{ kind: "assistant", text: "hello" }]);
+  });
+
+  it("removes noise tool calls and results", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "tool_call", name: "TodoWrite", args: {} },
+      { kind: "tool_result", name: "TodoWrite", text: "ok", isError: false },
+      { kind: "tool_call", name: "Read", args: { path: "x.ts" } },
+    ];
+    const result = filterNoise(blocks);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual({ kind: "tool_call", name: "Read", args: { path: "x.ts" } });
+  });
+
+  it("removes user blocks that are pure XML wrappers", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "<system-reminder>some noise</system-reminder>" },
+      { kind: "user", text: "Fix the bug" },
+    ];
+    const result = filterNoise(blocks);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toEqual({ kind: "user", text: "Fix the bug" });
+  });
+
+  it("cleans XML wrappers from user text but keeps real content", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "<system-reminder>noise</system-reminder>\nFix the login" },
+    ];
+    const result = filterNoise(blocks);
+    expect(result).toHaveLength(1);
+    expect((result[0] as any).text).toBe("Fix the login");
+  });
+
+  it("removes known noise strings", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "user", text: "Continue from where you left off." },
+      { kind: "user", text: "real task" },
+    ];
+    const result = filterNoise(blocks);
+    expect(result).toHaveLength(1);
+    expect((result[0] as any).text).toBe("real task");
+  });
+
+  it("preserves non-noise tool calls", () => {
+    const blocks: NormalizedBlock[] = [
+      { kind: "tool_call", name: "Edit", args: { path: "a.ts" } },
+      { kind: "tool_result", name: "Edit", text: "ok", isError: false },
+    ];
+    expect(filterNoise(blocks)).toHaveLength(2);
+  });
+});