@pi-unipi/compactor 0.1.1

package/src/commands/index.ts

@@ -0,0 +1,248 @@
+/**
+ * All /unipi:compact-* commands
+ *
+ * Commands perform real work by calling tool implementations directly.
+ * Dependencies (sessionDB, contentStore, sessionId) are injected at registration time.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { loadConfig, saveConfig } from "../config/manager.js";
+import { applyPreset, parsePreset } from "../config/presets.js";
+import { getLastCompactionStats } from "../compaction/hooks.js";
+import { compactTool } from "../tools/compact.js";
+import { vccRecall } from "../tools/vcc-recall.js";
+import { ctxStats } from "../tools/ctx-stats.js";
+import { ctxDoctor } from "../tools/ctx-doctor.js";
+import { ctxIndex } from "../tools/ctx-index.js";
+import { ctxSearch } from "../tools/ctx-search.js";
+import { ContentStore } from "../store/index.js";
+import type { SessionDB } from "../session/db.js";
+import type { NormalizedBlock } from "../types.js";
+
+export interface CommandDeps {
+  sessionDB: SessionDB | null;
+  contentStore: ContentStore | null;
+  getSessionId: () => string;
+  getBlocks: () => NormalizedBlock[];
+}
+
+export function registerCommands(pi: ExtensionAPI, deps?: CommandDeps): void {
+  pi.registerCommand("compact", {
+    description: "Trigger manual compaction with stats",
+    handler: async (_args: string, ctx: any) => {
+      const result = compactTool();
+      const stats = getLastCompactionStats();
+      const msg = stats
+        ? `🗜️ Compaction: ${stats.summarized} summarized, ${stats.kept} kept (~${stats.keptTokensEst} tok)\n${result.message}`
+        : `🗜️ ${result.message}`;
+      ctx.ui.notify(msg, "info");
+    },
+  });
+
+  pi.registerCommand("compact-recall", {
+    description: "Search session history (BM25 or regex)",
+    handler: async (args: string, ctx: any) => {
+      const query = args.trim();
+      if (!query) {
+        ctx.ui.notify("Usage: /unipi:compact-recall <query>", "warning");
+        return;
+      }
+      const blocks = deps?.getBlocks() ?? [];
+      if (blocks.length === 0) {
+        ctx.ui.notify("No session history available for search.", "warning");
+        return;
+      }
+      const result = vccRecall(blocks, { query, limit: 10 });
+      if (result.hits.length === 0) {
+        ctx.ui.notify(`No results for "${query}".`, "info");
+        return;
+      }
+      const lines = result.hits.map(
+        (h, i) => `[${i + 1}] score=${h.score.toFixed(2)} kind=${h.kind}\n${h.text.slice(0, 200)}`,
+      );
+      ctx.ui.notify(`Found ${result.total} results:\n${lines.join("\n\n")}`, "info");
+    },
+  });
+
+  pi.registerCommand("compact-stats", {
+    description: "Show context savings dashboard",
+    handler: async (_args: string, ctx: any) => {
+      if (!deps?.sessionDB || !deps?.contentStore) {
+        ctx.ui.notify("Compactor services not initialized.", "error");
+        return;
+      }
+      try {
+        const stats = await ctxStats(deps.sessionDB, deps.contentStore, deps.getSessionId());
+        const lines = [
+          "📊 Compactor Stats",
+          `Session events: ${stats.sessionEvents}`,
+          `Compactions: ${stats.compactions}`,
+          `Tokens saved: ${stats.tokensSaved}`,
+          `Indexed docs: ${stats.indexedDocs} (${stats.indexedChunks} chunks)`,
+          `Sandbox runs: ${stats.sandboxRuns}`,
+          `Search queries: ${stats.searchQueries}`,
+        ];
+        ctx.ui.notify(lines.join("\n"), "info");
+      } catch (err) {
+        ctx.ui.notify(`Stats error: ${err}`, "error");
+      }
+    },
+  });
+
+  pi.registerCommand("compact-doctor", {
+    description: "Run diagnostics checklist",
+    handler: async (_args: string, ctx: any) => {
+      if (!deps?.sessionDB || !deps?.contentStore) {
+        ctx.ui.notify("Compactor services not initialized.", "error");
+        return;
+      }
+      try {
+        const result = await ctxDoctor(deps.sessionDB, deps.contentStore);
+        const icon = (s: string) => (s === "pass" ? "✅" : s === "warn" ? "⚠️" : "❌");
+        const lines = [
+          result.healthy ? "🩺 All checks passed" : "🩺 Issues found",
+          "",
+          ...result.checks.map((c) => `${icon(c.status)} ${c.name}: ${c.message}`),
+        ];
+        ctx.ui.notify(lines.join("\n"), result.healthy ? "info" : "warning");
+      } catch (err) {
+        ctx.ui.notify(`Doctor error: ${err}`, "error");
+      }
+    },
+  });
+
+  pi.registerCommand("compact-settings", {
+    description: "Open TUI settings overlay",
+    handler: async (_args: string, ctx: any) => {
+      try {
+        const { renderSettingsOverlay } = await import("../tui/settings-overlay.js");
+        const result = await ctx.ui.custom(renderSettingsOverlay());
+        if (result) {
+          ctx.ui.notify("Settings saved.", "info");
+        } else {
+          ctx.ui.notify("Settings cancelled.", "info");
+        }
+      } catch (err) {
+        ctx.ui.notify(`Settings overlay error: ${err}`, "error");
+      }
+    },
+  });
+
+  pi.registerCommand("compact-preset", {
+    description: "Apply quick preset (opencode/balanced/verbose/minimal)",
+    handler: async (args: string, ctx: any) => {
+      const presetName = parsePreset(args.trim());
+      if (!presetName) {
+        ctx.ui.notify("Unknown preset. Use: opencode, balanced, verbose, minimal", "error");
+        return;
+      }
+      const config = applyPreset(presetName);
+      const result = saveConfig(config);
+      if (result.success) {
+        ctx.ui.notify(`Applied '${presetName}' preset.`, "info");
+      } else {
+        ctx.ui.notify(`Failed to save preset: ${result.error}`, "error");
+      }
+    },
+  });
+
+  pi.registerCommand("compact-index", {
+    description: "Index current project files into FTS5",
+    handler: async (_args: string, ctx: any) => {
+      if (!deps?.contentStore) {
+        ctx.ui.notify("Content store not initialized. Enable fts5Index in config.", "warning");
+        return;
+      }
+      try {
+        const cwd = (ctx as any).cwd ?? process.cwd();
+        const { readdirSync, readFileSync, statSync } = await import("node:fs");
+        const { join, relative, extname } = await import("node:path");
+
+        const indexable = [".md", ".txt", ".ts", ".js", ".json", ".py", ".sh"];
+        const files: string[] = [];
+
+        const walk = (dir: string, depth = 0) => {
+          if (depth > 3) return;
+          try {
+            for (const entry of readdirSync(dir, { withFileTypes: true })) {
+              if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+              const full = join(dir, entry.name);
+              if (entry.isDirectory()) {
+                walk(full, depth + 1);
+              } else if (indexable.includes(extname(entry.name))) {
+                files.push(full);
+              }
+            }
+          } catch {
+            // skip unreadable dirs
+          }
+        };
+
+        walk(cwd);
+        let totalChunks = 0;
+        for (const file of files.slice(0, 100)) {
+          try {
+            const content = readFileSync(file, "utf-8");
+            if (content.length < 50) continue;
+            const ext = extname(file);
+            const ct = ext === ".md" ? "markdown" : ext === ".json" ? "json" : "plain";
+            const result = await deps.contentStore.index(relative(cwd, file), content, {
+              contentType: ct,
+              source: file,
+            });
+            totalChunks += result.totalChunks;
+          } catch {
+            // skip unreadable files
+          }
+        }
+        ctx.ui.notify(`Indexed ${Math.min(files.length, 100)} files (${totalChunks} chunks).`, "info");
+      } catch (err) {
+        ctx.ui.notify(`Index error: ${err}`, "error");
+      }
+    },
+  });
+
+  pi.registerCommand("compact-search", {
+    description: "Search indexed content",
+    handler: async (args: string, ctx: any) => {
+      const query = args.trim();
+      if (!query) {
+        ctx.ui.notify("Usage: /unipi:compact-search <query>", "warning");
+        return;
+      }
+      if (!deps?.contentStore) {
+        ctx.ui.notify("Content store not initialized.", "warning");
+        return;
+      }
+      try {
+        const results = await ctxSearch({ query, limit: 10 });
+        if (results.length === 0) {
+          ctx.ui.notify(`No results for "${query}".`, "info");
+          return;
+        }
+        const lines = results.map(
+          (r, i) => `[${i + 1}] ${r.title} (rank: ${r.rank.toFixed(3)})\n${r.content.slice(0, 200)}`,
+        );
+        ctx.ui.notify(`Found ${results.length} results:\n${lines.join("\n\n")}`, "info");
+      } catch (err) {
+        ctx.ui.notify(`Search error: ${err}`, "error");
+      }
+    },
+  });
+
+  pi.registerCommand("compact-purge", {
+    description: "Wipe all indexed content from FTS5",
+    handler: async (_args: string, ctx: any) => {
+      if (!deps?.contentStore) {
+        ctx.ui.notify("Content store not initialized.", "warning");
+        return;
+      }
+      try {
+        await deps.contentStore.purge();
+        ctx.ui.notify("All indexed content purged.", "info");
+      } catch (err) {
+        ctx.ui.notify(`Purge error: ${err}`, "error");
+      }
+    },
+  });
+}

package/src/compaction/brief.ts

@@ -0,0 +1,334 @@
+/**
+ * Stage 4: Brief Transcript — truncate and format compacted output
+ */
+
+import type { NormalizedBlock } from "../types.js";
+import { clip, firstLine } from "./content.js";
+import { extractPath } from "./extract/files.js";
+
+const TRUNCATE_USER = 256;
+const TRUNCATE_ASSISTANT = 200;
+
+const SELF_TALK_PREFIX_RE =
+  /^\s*(?:hmm|wait|actually|oh|okay|ok|well|so)[,.!\s-]+/i;
+
+const segmenter = new Intl.Segmenter(undefined, { granularity: "word" });
+
+const isWord = (seg: { segment: string; isWordLike?: boolean }): boolean =>
+  !!seg.isWordLike || /[\p{L}\p{N}]/u.test(seg.segment);
+
+const STOP_WORDS = new Set([
+  "a", "an", "the", "is", "are", "was", "were", "be", "been", "being",
+  "have", "has", "had", "do", "does", "did", "will", "would", "could",
+  "should", "may", "might", "shall", "can", "need", "must",
+  "to", "of", "in", "for", "on", "with", "at", "by", "from", "as",
+  "into", "through", "during", "before", "after", "above", "below",
+  "between", "under", "over",
+  "and", "but", "or", "nor", "not", "so", "yet", "both", "either",
+  "neither", "each", "every", "all", "any", "few", "more", "most",
+  "other", "some", "such", "no",
+  "that", "this", "these", "those", "it", "its",
+  "i", "me", "my", "we", "our", "you", "your", "he", "him", "his",
+  "she", "her", "they", "them", "their", "who", "which", "what",
+  "if", "then", "than", "when", "where", "how", "just", "also",
+]);
+
+const truncateTokens = (text: string, limit: number): string => {
+  const flat = text.replace(/\s+/g, " ").trim();
+  let count = 0;
+  let lastEnd = 0;
+  for (const seg of segmenter.segment(flat)) {
+    if (isWord(seg)) {
+      if (!STOP_WORDS.has(seg.segment.toLowerCase())) {
+        count++;
+        if (count > limit) {
+          return flat.slice(0, lastEnd).trimEnd() + "...(truncated)";
+        }
+      }
+    }
+    lastEnd = seg.index + seg.segment.length;
+  }
+  return flat;
+};
+
+const BASH_CAP = 120;
+const PIPE_TAIL_RE = /\s*\|\s*(?:head|tail|sort|wc|column|tr|cut|awk|uniq|python3|node|bun)(?:\s[^|]*)?$/;
+
+const compressBash = (raw: string): string => {
+  let cmd = raw.split("\n").map((l) => l.trim()).filter(Boolean)[0] ?? raw;
+  cmd = cmd.replace(/^cd\s+\S+\s*&&\s*/, "");
+  for (let i = 0; i < 3; i++) {
+    const stripped = cmd.replace(PIPE_TAIL_RE, "");
+    if (stripped === cmd) break;
+    cmd = stripped;
+  }
+  if (cmd.length > BASH_CAP) {
+    return cmd.slice(0, BASH_CAP - 3) + "...";
+  }
+  return cmd;
+};
+
+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} "${args[field] as string}"`;
+  }
+  const path = extractPath(args);
+  if (path) return `* ${name} "${path}"`;
+  if (name === "bash" || name === "Bash") {
+    const raw = (args.command ?? args.description ?? "") as string;
+    const cmd = compressBash(raw);
+    return `* ${name} "${cmd}"`;
+  }
+  if (typeof args.query === "string") {
+    return `* ${name} "${clip(args.query as string, 60)}"`;
+  }
+  return `* ${name}`;
+};
+
+export interface BriefLine {
+  header: string;
+  lines: string[];
+}
+
+export interface TranscriptEntry {
+  role: "user" | "assistant" | "tool_error";
+  text?: string;
+  tool?: string;
+  cmd?: string;
+  ref?: string;
+  count?: number;
+}
+
+export const buildBriefSections = (blocks: NormalizedBlock[]): BriefLine[] => {
+  const sections: BriefLine[] = [];
+  let lastHeader = "";
+
+  const push = (header: string, line: string) => {
+    if (header === lastHeader && sections.length > 0) {
+      sections[sections.length - 1].lines.push(line);
+      return;
+    }
+    sections.push({ header, lines: [line] });
+    lastHeader = header;
+  };
+
+  for (const b of blocks) {
+    switch (b.kind) {
+      case "user": {
+        if (!b.text.trim()) break;
+        const text = truncateTokens(b.text, TRUNCATE_USER);
+        if (text) {
+          const ref = b.sourceIndex != null ? ` (#${b.sourceIndex})` : "";
+          push("[user]", text + ref);
+        }
+        lastHeader = "[user]";
+        break;
+      }
+      case "assistant": {
+        let raw = b.text;
+        for (let i = 0; i < 2; i++) {
+          const stripped = raw.replace(SELF_TALK_PREFIX_RE, "");
+          if (stripped === raw) break;
+          raw = stripped;
+        }
+        const text = truncateTokens(raw, TRUNCATE_ASSISTANT);
+        if (text) {
+          const ref = b.sourceIndex != null ? ` (#${b.sourceIndex})` : "";
+          push("[assistant]", text + ref);
+        }
+        break;
+      }
+      case "tool_call": {
+        if (!b.name || b.name.trim() === "") break;
+        const ref = b.sourceIndex != null ? ` (#${b.sourceIndex})` : "";
+        const summary = toolOneLiner(b.name, b.args) + ref;
+        push("[assistant]", summary);
+        break;
+      }
+      case "tool_result": {
+        if (b.isError) {
+          const body = firstLine(b.text, 150);
+          if (!body || body === "(no output)") break;
+          const ref = b.sourceIndex != null ? ` (#${b.sourceIndex})` : "";
+          const header = `[tool_error] ${b.name}${ref}`;
+          push(header, body);
+          lastHeader = header;
+        }
+        break;
+      }
+      case "thinking":
+        break;
+    }
+  }
+
+  // Collapse consecutive identical tool lines
+  for (const sec of sections) {
+    if (sec.header !== "[assistant]") continue;
+    const out: string[] = [];
+    for (const line of sec.lines) {
+      if (!line.startsWith("* ")) { out.push(line); continue; }
+      const ref = line.match(/\(#(\d+)\)$/)?.[1] ?? "";
+      const base = ref ? line.slice(0, -(ref.length + 3)).trimEnd() : line;
+      const last = out.length > 0 ? out[out.length - 1] : "";
+      const m = last.match(/^(.*) \((#[\d, #]+)\) x(\d+)$/);
+      if (m && m[1] === base) {
+        out[out.length - 1] = `${base} (${m[2]}, #${ref}) x${parseInt(m[3]) + 1}`;
+      } else if (last.match(/\(#\d+\)$/) && last.replace(/\s*\(#\d+\)$/, "") === base) {
+        const prevRef = last.match(/\(#(\d+)\)$/)?.[1];
+        out[out.length - 1] = `${base} (#${prevRef}, #${ref}) x2`;
+      } else {
+        out.push(line);
+      }
+    }
+    sec.lines = out;
+  }
+
+  // Cap tool calls per [assistant] turn
+  const TOOL_CALLS_PER_TURN = 8;
+  for (const sec of sections) {
+    if (sec.header !== "[assistant]") continue;
+    const toolIdxs = sec.lines
+      .map((l, i) => (l.startsWith("* ") ? i : -1))
+      .filter((i) => i >= 0);
+    if (toolIdxs.length <= TOOL_CALLS_PER_TURN) continue;
+    const dropCount = toolIdxs.length - TOOL_CALLS_PER_TURN;
+    const dropSet = new Set(toolIdxs.slice(0, dropCount));
+    const firstKeptToolIdx = toolIdxs[dropCount];
+    const next: string[] = [];
+    let inserted = false;
+    for (let i = 0; i < sec.lines.length; i++) {
+      if (dropSet.has(i)) continue;
+      if (!inserted && i === firstKeptToolIdx) {
+        next.push(`* (${dropCount} earlier tool-call entries omitted)`);
+        inserted = true;
+      }
+      next.push(sec.lines[i]);
+    }
+    sec.lines = next;
+  }
+
+  // Collapse consecutive identical [tool_error] sections
+  const collapsedErrors: BriefLine[] = [];
+  for (const sec of sections) {
+    const m = sec.header.match(/^\[tool_error\]\s+(\S+?)(?:\s*\(#(\d+)\))?$/);
+    if (!m || sec.lines.length !== 1) {
+      collapsedErrors.push(sec);
+      continue;
+    }
+    const tool = m[1];
+    const ref = m[2];
+    const body = sec.lines[0];
+    const prev = collapsedErrors[collapsedErrors.length - 1];
+    const prevMatch = prev?.header.match(
+      /^\[tool_error\]\s+(\S+?)\s*\(((?:#\d+(?:,\s*)?)+)\)(?:\s*x(\d+))?$/,
+    );
+    if (prev && prevMatch && prevMatch[1] === tool && prev.lines.length === 1 && prev.lines[0] === body) {
+      const refs = prevMatch[2] + (ref ? `, #${ref}` : "");
+      const count = prevMatch[3] ? parseInt(prevMatch[3]) + 1 : 2;
+      prev.header = `[tool_error] ${tool} (${refs}) x${count}`;
+    } else {
+      collapsedErrors.push(sec);
+    }
+  }
+  sections.length = 0;
+  sections.push(...collapsedErrors);
+
+  return sections;
+};
+
+export const stringifyBrief = (sections: BriefLine[]): string => {
+  const out: string[] = [];
+  for (let i = 0; i < sections.length; i++) {
+    const sec = sections[i];
+    if (i > 0) {
+      const prev = sections[i - 1];
+      const prevIsTools = prev.header === "[assistant]" &&
+        prev.lines.every((l) => l.startsWith("* "));
+      const curIsTools = sec.header === "[assistant]" &&
+        sec.lines.every((l) => l.startsWith("* "));
+      if (!(prevIsTools && curIsTools)) {
+        out.push("");
+      }
+    }
+    out.push(sec.header);
+    for (const line of sec.lines) {
+      out.push(line);
+    }
+  }
+  return out.join("\n");
+};
+
+const parseToolLine = (line: string): { tool: string; cmd?: string; ref?: string; count?: number } | null => {
+  const m = line.match(/^\* (\S+)\s*(?:"([^"]*)")?\s*(?:\((#[\d, #]+)\))?\s*(?:x(\d+))?$/);
+  if (!m) return null;
+  return {
+    tool: m[1],
+    cmd: m[2] || undefined,
+    ref: m[3] || undefined,
+    count: m[4] ? parseInt(m[4]) : undefined,
+  };
+};
+
+const extractRef = (text: string): { clean: string; ref?: string } => {
+  const m = text.match(/\s*\(#(\d+)\)$/);
+  if (!m) return { clean: text };
+  return { clean: text.slice(0, m.index).trimEnd(), ref: `#${m[1]}` };
+};
+
+export const sectionsToTranscript = (sections: BriefLine[]): TranscriptEntry[] => {
+  const entries: TranscriptEntry[] = [];
+
+  for (const sec of sections) {
+    if (sec.header === "[user]") {
+      for (const line of sec.lines) {
+        const { clean, ref } = extractRef(line);
+        entries.push({ role: "user", text: clean, ...(ref && { ref }) });
+      }
+    } else if (sec.header === "[assistant]") {
+      for (const line of sec.lines) {
+        if (line.startsWith("* ")) {
+          const parsed = parseToolLine(line);
+          if (parsed) {
+            entries.push({
+              role: "assistant",
+              tool: parsed.tool,
+              ...(parsed.cmd && { cmd: parsed.cmd }),
+              ...(parsed.ref && { ref: parsed.ref }),
+              ...(parsed.count && { count: parsed.count }),
+            });
+          } else {
+            const { clean, ref } = extractRef(line.slice(2));
+            entries.push({ role: "assistant", text: clean, ...(ref && { ref }) });
+          }
+        } else {
+          const { clean, ref } = extractRef(line);
+          entries.push({ role: "assistant", text: clean, ...(ref && { ref }) });
+        }
+      }
+    } else if (sec.header.startsWith("[tool_error]")) {
+      const headerMatch = sec.header.match(/^\[tool_error\]\s+(\S+)\s*(?:\(#(\d+)\))?/);
+      const tool = headerMatch?.[1] ?? "unknown";
+      const ref = headerMatch?.[2] ? `#${headerMatch[2]}` : undefined;
+      for (const line of sec.lines) {
+        entries.push({
+          role: "tool_error",
+          tool,
+          text: line,
+          ...(ref && { ref }),
+        });
+      }
+    }
+  }
+
+  return entries;
+};
+
+export const compileBrief = (blocks: NormalizedBlock[]): string =>
+  stringifyBrief(buildBriefSections(blocks));

package/src/compaction/build-sections.ts

@@ -0,0 +1,77 @@
+/**
+ * Stage 3: Build Sections — Goals, Files, Commits, Blockers, Preferences
+ */
+
+import type { NormalizedBlock } from "../types.js";
+import { clip, clipSentence, firstLine, nonEmptyLines } from "./content.js";
+import { extractGoals } from "./extract/goals.js";
+import { extractFiles } from "./extract/files.js";
+import { extractPreferences, dedupPreferencesAgainstGoals } from "./extract/preferences.js";
+import { extractCommits, formatCommits } from "./extract/commits.js";
+import { buildBriefSections, sectionsToTranscript, stringifyBrief } from "./brief.js";
+import type { SectionData } from "./sections.js";
+export type { SectionData } from "./sections.js";
+
+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 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;
+        if (/^\s*[-*+>]\s/.test(line)) continue;
+        if (/^\s*\(/.test(line)) continue;
+        if (!/^\s*["'`*_]?[A-Z`]/.test(line)) continue;
+        const clipped = b.kind === "user" ? `[user] ${clipSentence(line, 150)}` : clipSentence(line, 150);
+        if (!items.includes(clipped)) items.push(clipped);
+        break;
+      }
+    }
+  }
+
+  return items.slice(0, 5);
+};
+
+const formatFileActivity = (blocks: NormalizedBlock[]): string[] => {
+  const act = extractFiles(blocks);
+  for (const p of act.modified) act.created.delete(p);
+  const lines: string[] = [];
+  const cap = (set: Set<string>, limit: number) => {
+    const arr = [...set];
+    if (arr.length <= limit) return arr.join(", ");
+    return arr.slice(0, limit).join(", ") + ` (+${arr.length - limit} more)`;
+  };
+  if (act.modified.size > 0) lines.push(`Modified: ${cap(act.modified, 10)}`);
+  if (act.created.size > 0) lines.push(`Created: ${cap(act.created, 10)}`);
+  if (act.read.size > 0) lines.push(`Read: ${cap(act.read, 10)}`);
+  return lines;
+};
+
+export const buildSections = (input: { blocks: NormalizedBlock[] }): SectionData => {
+  const { blocks } = input;
+  const briefSections = buildBriefSections(blocks);
+  const sessionGoal = extractGoals(blocks);
+  const userPreferences = dedupPreferencesAgainstGoals(
+    extractPreferences(blocks),
+    sessionGoal,
+  );
+  return {
+    sessionGoal,
+    outstandingContext: extractOutstandingContext(blocks),
+    filesAndChanges: formatFileActivity(blocks),
+    commits: formatCommits(extractCommits(blocks)),
+    userPreferences,
+    briefTranscript: stringifyBrief(briefSections),
+    transcriptEntries: sectionsToTranscript(briefSections),
+  };
+};