@sting8k/pi-vcc 0.1.0

package/README.md

@@ -0,0 +1,149 @@
+# pi-vcc
+
+Algorithmic conversation compactor for [Pi](https://github.com/badlogic/pi-mono). No LLM calls -- produces structured, transcript-preserving summaries using pure extraction and formatting.
+
+Inspired by [VCC](https://github.com/lllyasviel/VCC) (View-oriented Conversation Compiler).
+
+## Why pi-vcc
+
+|  | Pi default | pi-vcc |
+|---|---|---|
+| **Method** | LLM-generated summary | Algorithmic extraction, no LLM |
+| **Determinism** | Non-deterministic, can hallucinate | Same input = same output, always |
+| **Token reduction** | Varies | ~58% measured (30k -> 12.5k) |
+| **History after compaction** | Gone -- agent only sees summary | Fully searchable via `vcc_recall` |
+| **Repeated compactions** | Each rewrite risks losing more | Sections merge and accumulate |
+| **Cost** | Burns tokens on summarization call | Zero -- no API calls |
+| **Structure** | Free-form prose | 7 typed sections (goal, turns, actions, evidence, files, context, prefs) |
+
+### Real session metrics
+
+| Compaction | Before | After | Reduction |
+|---|---|---|---|
+| 1st | 25,832 | 18,974 | 26.5% |
+| 2nd (full cut) | 30,020 | 12,507 | 58.3% |
+| 3rd (merge) | 15,915 | ~8,800 | ~45% |
+
+## Features
+
+- **No LLM** -- purely algorithmic, zero extra API cost
+- **~58% token reduction** with transcript-preserving structured output
+- **Lossless recall** -- `vcc_recall` reads raw session JSONL, history stays searchable across compactions
+- **Incremental merge** -- turns, actions, evidence, files accumulate; only volatile context refreshes
+- **VCC-style tool collapsing** -- tool calls become deduplicated one-liners
+- **Fallback cut** -- works even when Pi core returns nothing to summarize
+- **Redaction** -- strips passwords, API keys, secrets
+- **`/pi-vcc`** -- manual compaction on demand
+
+## Install
+
+```bash
+pi install npm:@sting8k/pi-vcc
+```
+
+Or from GitHub:
+
+```bash
+pi install https://github.com/sting8k/pi-vcc
+```
+
+Or try without installing:
+
+```bash
+pi -e https://github.com/sting8k/pi-vcc
+```
+
+## Usage
+
+Once linked, pi-vcc hooks `session_before_compact` and handles compaction automatically. Output looks like:
+
+```
+[Session Goal]
+- Fix the authentication bug in login flow
+
+[Key Conversation Turns]
+- [user] Fix the auth bug, users can't log in after password reset
+- [assistant] Root cause is a missing token refresh. The session cookie...(truncated)
+
+[Actions Taken]
+- * Read "src/auth/session.ts"
+- * Edit "src/auth/session.ts"
+- * bash "bun test tests/auth.test.ts"
+
+[Important Evidence]
+- [Read] export function refreshSession(token) { if (!token) return null;...(truncated)
+- [bash] Tests: 12 passed, 0 failed
+
+[Files And Changes]
+Modified:
+  - src/auth/session.ts
+Read:
+  - src/auth/session.ts
+
+[Outstanding Context]
+- [bash] ERROR: lint check failed on line 42
+
+[User Preferences]
+- Prefer Vietnamese responses
+```
+
+Use `/pi-vcc` to trigger compaction manually.
+
+## Recall (Lossless History)
+
+Pi's default compaction discards old messages permanently. After compaction, the agent only sees the summary.
+
+`vcc_recall` bypasses this by reading the raw session JSONL file directly. It parses every message entry in the file, renders each one into a searchable `RenderedEntry` with a stable index (matching the message's position in the JSONL), role, truncated summary, and associated file paths. This means entry `#41` always refers to the same message regardless of how many compactions have happened.
+
+**Search** uses multi-term matching -- the query is split into terms and all must appear in the entry's role + summary + file paths. This searches across the entire session including compacted regions:
+
+```
+vcc_recall({ query: "auth token refresh" })   // all terms must match
+```
+
+**Browse** without a query returns the last 25 entries:
+
+```
+vcc_recall()
+```
+
+**Expand** switches to full mode -- entries are rendered without truncation, so you get the complete content for specific indices found via search:
+
+```
+vcc_recall({ expand: [41, 42] })               // full content, no clipping
+```
+
+Typical workflow: search brief -> find relevant entry indices -> expand those indices for full content.
+
+> Some tool results are truncated by Pi core at save time. `expand` returns everything in the JSONL but can't recover what Pi already cut.
+
+## Pipeline
+
+1. **Normalize** -- raw Pi messages -> uniform blocks (user, assistant, tool_call, tool_result, thinking)
+2. **Filter noise** -- strip system messages, empty blocks
+3. **Build sections** -- extract goal, conversation turns (~128 tokens each), deduplicated tool one-liners, tool results as evidence, file paths, blockers, preferences
+4. **Format** -- render into bracketed sections
+5. **Redact** -- strip passwords, API keys, secrets
+6. **Merge** -- if previous summary exists:
+   - Appendable (turns, actions, evidence, files, prefs): deduplicate and combine
+   - Volatile (outstanding context): replace with fresh
+   - Default (session goal): fresh wins
+
+## Debug
+
+Debug logging is off by default. Enable it in `~/.pi/agent/pi-vcc-config.json`:
+
+```json
+{ "debug": true }
+```
+
+When enabled, each compaction writes detailed info to `/tmp/pi-vcc-debug.json` -- message counts, cut boundary, summary preview, sections.
+
+## Related Work
+
+- [VCC](https://github.com/lllyasviel/VCC) -- the original transcript-preserving conversation compiler
+- [Pi](https://github.com/badlogic/pi-mono) -- the AI coding agent this extension is built for
+
+## License
+
+MIT

package/index.ts

@@ -0,0 +1,10 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { registerBeforeCompactHook } from "./src/hooks/before-compact";
+import { registerPiVccCommand } from "./src/commands/pi-vcc";
+import { registerRecallTool } from "./src/tools/recall";
+
+export default (pi: ExtensionAPI) => {
+  registerBeforeCompactHook(pi);
+  registerPiVccCommand(pi);
+  registerRecallTool(pi);
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@sting8k/pi-vcc",
+  "version": "0.1.0",
+  "description": "Structured conversation compactor for pi - replaces default compact summary with an agent-optimized structured format.",
+  "keywords": [
+    "pi-package"
+  ],
+  "homepage": "https://github.com/sting8k/pi-vcc#readme",
+  "bugs": {
+    "url": "https://github.com/sting8k/pi-vcc/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sting8k/pi-vcc.git"
+  },
+  "license": "ISC",
+  "author": "sting8k",
+  "type": "commonjs",
+  "main": "index.ts",
+  "directories": {
+    "test": "tests"
+  },
+  "scripts": {
+    "test": "bun test",
+    "bench": "bun run ./scripts/benchmark-real-sessions.ts"
+  },
+  "dependencies": {
+    "@mariozechner/pi-coding-agent": "*"
+  },
+  "devDependencies": {},
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}

package/scripts/audit-sessions.ts

@@ -0,0 +1,88 @@
+import { basename, dirname } from "node:path";
+import { compile } from "../src/core/summarize";
+import { normalize } from "../src/core/normalize";
+import { filterNoise } from "../src/core/filter-noise";
+import { renderMessage } from "../src/core/render-entries";
+import { prepareSessionSamples } from "../tests/support/real-sessions";
+import { loadSessionMessages } from "../tests/support/load-session";
+
+const SEP = "=".repeat(80);
+const samples = await prepareSessionSamples(10);
+
+for (const sample of samples) {
+  const loaded = loadSessionMessages(sample.copy);
+  const { messages } = loaded;
+
+  const rawBlocks = normalize(messages);
+  const filteredBlocks = filterNoise(rawBlocks);
+  const afterText = compile({ messages });
+
+  const rendered = messages.map((m, i) => renderMessage(m, i));
+  const beforeChars = rendered.reduce((s, e) => s + e.summary.length, 0);
+
+  const project = dirname(sample.source).split("--").filter(Boolean).pop() ?? "unknown";
+
+  const goalSection = afterText.match(/\[Session Goal\]\n([\s\S]*?)(?=\n\n\[|$)/)?.[1] ?? "(empty)";
+  const stateSection = afterText.match(/\[Current State\]\n([\s\S]*?)(?=\n\n\[|$)/)?.[1] ?? "(empty)";
+  const doneSection = afterText.match(/\[What Was Done\]\n([\s\S]*?)(?=\n\n\[|$)/)?.[1] ?? "(empty)";
+  const problemsSection = afterText.match(/\[Open Problems\]\n([\s\S]*?)(?=\n\n\[|$)/)?.[1] ?? "(empty)";
+  const nextSection = afterText.match(/\[Next Best Steps\]\n([\s\S]*?)(?=\n\n\[|$)/)?.[1] ?? "(empty)";
+
+  const doneLines = doneSection.split("\n").filter(l => l.trim());
+  const problemLines = problemsSection.split("\n").filter(l => l.trim());
+
+  // Detect issues
+  const issues: string[] = [];
+
+  // 1. Goal quality
+  const goalLines = goalSection.split("\n").map(l => l.replace(/^- /, "").trim()).filter(Boolean);
+  if (goalLines[0] && goalLines[0].length < 5) issues.push(`GOAL_TOO_SHORT: "${goalLines[0]}"`);
+  if (goalLines.length === 0) issues.push("GOAL_EMPTY");
+
+  // 2. Sensitive data in What Was Done
+  if (/sshpass|password|secret|token=|api[_-]?key/i.test(doneSection)) {
+    issues.push("SENSITIVE_DATA_IN_DONE");
+  }
+
+  // 3. Raw code/minified JS in summary
+  if (/\{[a-zA-Z$_]+:[a-zA-Z$_]+,[a-zA-Z$_]+:/.test(afterText) || /var [a-zA-Z]+=/.test(afterText)) {
+    issues.push("RAW_CODE_LEAK");
+  }
+
+  // 4. Open problems count
+  if (problemLines.length > 10) issues.push(`PROBLEMS_OVERCOUNT: ${problemLines.length}`);
+
+  // 5. Next steps empty
+  if (nextSection === "(empty)") issues.push("NEXT_STEPS_EMPTY");
+
+  // 6. What Was Done too verbose
+  if (doneLines.length > 15) issues.push(`DONE_TOO_VERBOSE: ${doneLines.length} lines`);
+
+  // 7. Summary too large (>10K chars)
+  if (afterText.length > 10000) issues.push(`SUMMARY_TOO_LARGE: ${afterText.length} chars`);
+
+  console.log(SEP);
+  console.log(`PROJECT: ${project}`);
+  console.log(`FILE: ${basename(sample.source)}`);
+  console.log(`Size: ${(sample.size / 1024).toFixed(0)}KB | Msgs: ${messages.length} | Blocks raw: ${rawBlocks.length} -> filtered: ${filteredBlocks.length}`);
+  console.log(`Before: ${beforeChars} chars | After: ${afterText.length} chars | Ratio: ${(beforeChars / afterText.length).toFixed(1)}x`);
+  console.log(`Issues: ${issues.length === 0 ? "NONE" : issues.join(", ")}`);
+  console.log("");
+  console.log("--- GOAL ---");
+  console.log(goalSection.slice(0, 300));
+  console.log("");
+  console.log("--- CURRENT STATE (first 300c) ---");
+  console.log(stateSection.slice(0, 300));
+  console.log("");
+  console.log("--- WHAT WAS DONE (first 5 lines) ---");
+  console.log(doneLines.slice(0, 5).join("\n"));
+  console.log(`... (${doneLines.length} total lines)`);
+  console.log("");
+  console.log("--- OPEN PROBLEMS (first 5 lines) ---");
+  console.log(problemLines.slice(0, 5).join("\n"));
+  console.log(`... (${problemLines.length} total lines)`);
+  console.log("");
+  console.log("--- NEXT STEPS ---");
+  console.log(nextSection.slice(0, 300));
+  console.log("");
+}

package/scripts/benchmark-real-sessions.ts

@@ -0,0 +1,25 @@
+import { performance } from "node:perf_hooks";
+import { basename } from "node:path";
+import { buildCompactReport } from "../src/core/report";
+import { prepareSessionSamples } from "../tests/support/real-sessions";
+import { loadSessionMessages } from "../tests/support/load-session";
+
+const samples = await prepareSessionSamples(2);
+for (const sample of samples) {
+  const loaded = loadSessionMessages(sample.copy);
+  const start = performance.now();
+  const report = buildCompactReport({ messages: loaded.messages });
+  const elapsedMs = performance.now() - start;
+  console.log(JSON.stringify({
+    sourceFile: basename(sample.source),
+    sourceSizeBytes: sample.size,
+    copiedToTemp: true,
+    loadedMessages: loaded.messageCount,
+    skippedMessages: loaded.skippedCount,
+    compileMs: Number(elapsedMs.toFixed(2)),
+    before: report.before,
+    after: report.after,
+    compression: report.compression,
+    recall: report.recall,
+  }, null, 2));
+}

package/scripts/compare-before-after.ts

@@ -0,0 +1,36 @@
+import { basename } from "node:path";
+import { compile } from "../src/core/summarize";
+import { renderMessage } from "../src/core/render-entries";
+import { clip } from "../src/core/content";
+import { prepareSessionSamples } from "../tests/support/real-sessions";
+import { loadSessionMessages } from "../tests/support/load-session";
+
+const SEP = "=".repeat(80);
+const samples = await prepareSessionSamples(2);
+
+for (const sample of samples) {
+  const loaded = loadSessionMessages(sample.copy);
+  const { messages } = loaded;
+
+  const rendered = messages.map((m, i) => renderMessage(m, i));
+  const beforeLines = rendered.map(
+    (e) => `#${e.index} [${e.role}] ${clip(e.summary, 300)}`,
+  );
+  const beforeText = beforeLines.join("\n");
+  const afterText = compile({ messages });
+
+  console.log(SEP);
+  console.log(`FILE: ${basename(sample.source)}`);
+  console.log(`Messages: ${messages.length} | Before chars: ${beforeText.length} | After chars: ${afterText.length}`);
+  console.log(`Compression: ${(beforeText.length / afterText.length).toFixed(1)}x`);
+  console.log(SEP);
+
+  console.log("\n--- BEFORE (raw context, first 40 + last 20 entries) ---\n");
+  for (const line of beforeLines.slice(0, 40)) console.log(line);
+  if (beforeLines.length > 60) console.log(`\n... (${beforeLines.length - 60} entries omitted) ...\n`);
+  for (const line of beforeLines.slice(-20)) console.log(line);
+
+  console.log("\n--- AFTER (pi-vcc compiled summary) ---\n");
+  console.log(afterText);
+  console.log("\n");
+}

package/src/commands/pi-vcc.ts

@@ -0,0 +1,11 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+export const registerPiVccCommand = (pi: ExtensionAPI) => {
+  pi.registerCommand("pi-vcc", {
+    description: "Compact conversation with pi-vcc structured summary",
+    handler: async (_args, ctx) => {
+      ctx.compact();
+      ctx.ui.notify("Compacted with pi-vcc", "info");
+    },
+  });
+};

package/src/core/build-sections.ts

@@ -0,0 +1,119 @@
+import type { FileOps, NormalizedBlock } from "../types";
+import { clip, firstLine, nonEmptyLines } from "./content";
+import { redact } from "./redact";
+import type { SectionData } from "../sections";
+import { extractGoals } from "../extract/goals";
+import { extractFiles } from "../extract/files";
+import { extractFindings } from "../extract/findings";
+import { extractPreferences } from "../extract/preferences";
+import { extractPath } from "./tool-args";
+
+export interface BuildSectionsInput {
+  blocks: NormalizedBlock[];
+  fileOps?: FileOps;
+}
+
+const TOOL_SUMMARY_FIELDS: Record<string, string> = {
+  Read: "file_path", Edit: "file_path", Write: "file_path",
+  read: "file_path", edit: "file_path", write: "file_path",
+  Glob: "pattern", Grep: "pattern",
+};
+
+const toolOneLiner = (name: string, args: Record<string, unknown>): string => {
+  const field = TOOL_SUMMARY_FIELDS[name];
+  if (field && typeof args[field] === "string") {
+    return `* ${name} "${clip(args[field] as string, 60)}"`;
+  }
+  const path = extractPath(args);
+  if (path) return `* ${name} "${clip(path, 60)}"`;
+  if (name === "bash" || name === "Bash") {
+    const cmd = (args.command ?? args.description ?? "") as string;
+    return `* ${name} "${redact(clip(cmd, 80))}"`;
+  }
+  if (typeof args.query === "string") {
+    return `* ${name} "${clip(args.query as string, 60)}"`;
+  }
+  return `* ${name}`;
+};
+
+const extractActionsTaken = (blocks: NormalizedBlock[]): string[] => {
+  const raw: string[] = [];
+  for (const b of blocks) {
+    if (b.kind === "tool_call") raw.push(toolOneLiner(b.name, b.args));
+  }
+  const counts = new Map<string, number>();
+  for (const d of raw) counts.set(d, (counts.get(d) ?? 0) + 1);
+  return [...counts.entries()]
+    .map(([k, v]) => (v > 1 ? `${k} x${v}` : k))
+    .slice(0, 20);
+};
+
+const FILLER_RE = /^(ok|sure|done|got it|alright|let me|i('ll| will)|here'?s|understood)/i;
+const BLOCKER_RE =
+  /\b(fail(ed|s|ure|ing)?|broken|cannot|can't|won't work|does not work|doesn't work|still (broken|failing|wrong)|blocked|blocker|not (fixed|resolved|working)|crash(es|ed|ing)?)\b/i;
+
+const TRUNCATE_TOKENS = 128;
+
+const truncateText = (text: string, limit = TRUNCATE_TOKENS): string => {
+  const words = text.split(/\s+/).filter(Boolean);
+  if (words.length <= limit) return text;
+  return words.slice(0, limit).join(" ") + "...(truncated)";
+};
+
+const extractKeyConversationTurns = (blocks: NormalizedBlock[]): string[] => {
+  const turns: string[] = [];
+  const conversational = blocks.filter(
+    (b) => b.kind === "user" || b.kind === "assistant",
+  );
+  const recent = conversational.slice(-12);
+
+  for (const b of recent) {
+    const text = b.text.trim();
+    if (!text || text.length < 10) continue;
+    if (b.kind === "user" && FILLER_RE.test(text)) continue;
+    const prefix = b.kind === "user" ? "[user] " : "[assistant] ";
+    turns.push(prefix + truncateText(text, TRUNCATE_TOKENS));
+  }
+
+  return turns.slice(-8);
+};
+
+const extractOutstandingContext = (blocks: NormalizedBlock[]): string[] => {
+  const items: string[] = [];
+  const tail = blocks.slice(-20);
+
+  for (const b of tail) {
+    if (b.kind === "tool_result" && b.isError) {
+      items.push(`[${b.name}] ${firstLine(b.text, 150)}`);
+      continue;
+    }
+
+    if (b.kind === "assistant" || b.kind === "user") {
+      for (const line of nonEmptyLines(b.text)) {
+        if (!BLOCKER_RE.test(line)) continue;
+        if (line.length < 15) continue;
+        const clipped = b.kind === "user" ? `[user] ${clip(line, 150)}` : clip(line, 150);
+        if (!items.includes(clipped)) items.push(clipped);
+        break;
+      }
+    }
+  }
+
+  return items.slice(0, 5);
+};
+
+export const buildSections = (input: BuildSectionsInput): SectionData => {
+  const { blocks, fileOps } = input;
+  const fa = extractFiles(blocks, fileOps);
+  return {
+    sessionGoal: extractGoals(blocks),
+    keyConversationTurns: extractKeyConversationTurns(blocks),
+    actionsTaken: extractActionsTaken(blocks),
+    importantEvidence: extractFindings(blocks),
+    filesRead: [...fa.read],
+    filesModified: [...fa.modified],
+    filesCreated: [...fa.created],
+    outstandingContext: extractOutstandingContext(blocks),
+    userPreferences: extractPreferences(blocks),
+  };
+};

package/src/core/content.ts

@@ -0,0 +1,20 @@
+import type { Message } from "@mariozechner/pi-ai";
+
+export const clip = (text: string, max = 200): string =>
+  text.slice(0, max);
+
+export const nonEmptyLines = (text: string): string[] =>
+  text.split("\n").map((line) => line.trim()).filter(Boolean);
+
+export const firstLine = (text: string, max = 200): string =>
+  clip(text.split("\n")[0] ?? "", max);
+
+export const textParts = (content: Message["content"]): string[] => {
+  if (typeof content === "string") return [content];
+  return content
+    .filter((part) => part.type === "text")
+    .map((part) => part.text);
+};
+
+export const textOf = (content: Message["content"]): string =>
+  textParts(content).join("\n");

package/src/core/filter-noise.ts

@@ -0,0 +1,42 @@
+import type { NormalizedBlock } from "../types";
+
+const NOISE_TOOLS = new Set([
+  "TodoWrite", "TodoRead", "ToolSearch", "WebSearch",
+  "AskUser", "ExitSpecMode", "GenerateDroid",
+]);
+
+const NOISE_STRINGS = [
+  "Continue from where you left off.",
+  "No response requested.",
+  "IMPORTANT: TodoWrite was not called yet.",
+];
+
+const XML_WRAPPER_RE = /<(system-reminder|ide_opened_file|command-message|context-window-usage)[^>]*>[\s\S]*?<\/\1>/g;
+
+const isNoiseUserBlock = (text: string): boolean => {
+  const trimmed = text.trim();
+  if (NOISE_STRINGS.some((s) => trimmed.includes(s))) return true;
+  const stripped = trimmed.replace(XML_WRAPPER_RE, "").trim();
+  return stripped.length === 0;
+};
+
+const cleanUserText = (text: string): string =>
+  text.replace(XML_WRAPPER_RE, "").trim();
+
+export const filterNoise = (blocks: NormalizedBlock[]): NormalizedBlock[] => {
+  const out: NormalizedBlock[] = [];
+  for (const b of blocks) {
+    if (b.kind === "thinking") continue;
+    if (b.kind === "tool_call" && NOISE_TOOLS.has(b.name)) continue;
+    if (b.kind === "tool_result" && NOISE_TOOLS.has(b.name)) continue;
+    if (b.kind === "user") {
+      if (isNoiseUserBlock(b.text)) continue;
+      const cleaned = cleanUserText(b.text);
+      if (!cleaned) continue;
+      out.push({ kind: "user", text: cleaned });
+      continue;
+    }
+    out.push(b);
+  }
+  return out;
+};

package/src/core/format-recall.ts

@@ -0,0 +1,23 @@
+import type { RenderedEntry } from "./render-entries";
+
+export const formatRecallOutput = (
+  entries: RenderedEntry[],
+  query?: string,
+): string => {
+  if (entries.length === 0) {
+    return query
+      ? `No matches for "${query}" in session history.`
+      : "No entries in session history.";
+  }
+
+  const header = query
+    ? `Found ${entries.length} matches for "${query}":`
+    : `Session history (${entries.length} entries):`;
+
+  const lines = entries.map((e) => {
+    const fileSuffix = e.files?.length ? ` files:[${e.files.join(", ")}]` : "";
+    return `#${e.index} [${e.role}]${fileSuffix} ${e.summary}`;
+  });
+
+  return `${header}\n\n${lines.join("\n\n")}`;
+};

package/src/core/format.ts

@@ -0,0 +1,34 @@
+import type { SectionData } from "../sections";
+
+const section = (title: string, items: string[]): string => {
+  if (items.length === 0) return "";
+  const body = items.map((i) => `- ${i}`).join("\n");
+  return `[${title}]\n${body}`;
+};
+
+const filesSection = (data: SectionData): string => {
+  const parts: string[] = [];
+  if (data.filesRead.length > 0)
+    parts.push("Read:\n" + data.filesRead.map((f) => `  - ${f}`).join("\n"));
+  if (data.filesModified.length > 0)
+    parts.push("Modified:\n" + data.filesModified.map((f) => `  - ${f}`).join("\n"));
+  if (data.filesCreated.length > 0)
+    parts.push("Created:\n" + data.filesCreated.map((f) => `  - ${f}`).join("\n"));
+  if (parts.length === 0) return "";
+  return `[Files And Changes]\n${parts.join("\n")}`;
+};
+
+export const formatSummary = (data: SectionData): string => {
+  const parts = [
+    section("Session Goal", data.sessionGoal),
+    section("Key Conversation Turns", data.keyConversationTurns),
+    section("Actions Taken", data.actionsTaken),
+    section("Important Evidence", data.importantEvidence),
+    filesSection(data),
+    section("Outstanding Context", data.outstandingContext),
+    section("User Preferences", data.userPreferences),
+  ];
+  return parts.filter(Boolean).join("\n\n");
+};
+
+

package/src/core/normalize.ts

@@ -0,0 +1,62 @@
+import type { Message } from "@mariozechner/pi-ai";
+import type { NormalizedBlock } from "../types";
+import { textOf } from "./content";
+import { sanitize } from "./sanitize";
+
+const normalizeOne = (msg: Message): NormalizedBlock[] => {
+  if (msg.role === "user") {
+    const blocks: NormalizedBlock[] = [];
+    const text = sanitize(textOf(msg.content));
+    if (text) blocks.push({ kind: "user", text });
+    if (typeof msg.content !== "string") {
+      for (const part of msg.content) {
+        if (part.type === "image") {
+          blocks.push({ kind: "user", text: `[image: ${part.mimeType}]` });
+        }
+      }
+    }
+    return blocks.length > 0 ? blocks : [{ kind: "user", text: "" }];
+  }
+
+  if (msg.role === "toolResult") {
+    return [{
+      kind: "tool_result",
+      name: msg.toolName,
+      text: sanitize(textOf(msg.content)),
+      isError: msg.isError,
+    }];
+  }
+
+  if (msg.role === "assistant") {
+    if (typeof msg.content === "string") {
+      return [{ kind: "assistant", text: sanitize(msg.content) }];
+    }
+
+    const blocks: NormalizedBlock[] = [];
+    for (const part of msg.content) {
+      if (part.type === "text") {
+        blocks.push({ kind: "assistant", text: sanitize(part.text) });
+      } else if (part.type === "thinking") {
+        blocks.push({
+          kind: "thinking",
+          text: sanitize(part.thinking),
+          redacted: part.redacted ?? false,
+        });
+      } else if (part.type === "toolCall") {
+        blocks.push({
+          kind: "tool_call",
+          name: part.name,
+          args: part.arguments,
+        });
+      }
+    }
+    return blocks;
+  }
+
+  return [];
+};
+
+export const normalize = (messages: Message[]): NormalizedBlock[] =>
+  messages.flatMap(normalizeOne);
+
+

package/src/core/redact.ts

@@ -0,0 +1,8 @@
+const SENSITIVE_RE =
+  /(?:sshpass\s+-p\s*'[^']*'|sshpass\s+-p\s*"[^"]*"|sshpass\s+-p\s*\S+|password[=:]\s*\S+|api[_-]?key[=:]\s*\S+|secret[=:]\s*\S+|token[=:]\s*[A-Za-z0-9_\-\.]{8,}|-i\s+\S+\.pem\b)/gi;
+
+export const redact = (text: string): string =>
+  text.replace(SENSITIVE_RE, (m) => {
+    const prefix = m.split(/[=:\s]+/)[0];
+    return `${prefix} [REDACTED]`;
+  });