pi-mega-compact 0.4.0

package/src/embedder.ts

@@ -0,0 +1,111 @@
+/**
+ * embedder.ts — pluggable text embedding for the local vector store.
+ *
+ * Default embedder is a zero-dependency, deterministic hashed n-gram bag
+ * encoder — no native build, no network, no external library, works offline.
+ * It is heuristic-strength (good enough to rank "which checkpoint is relevant
+ * to this query?"), not RAG-grade. A stronger LOCAL embedding backend (your own
+ * localhost ONNX/TEI/Ollama server) can be plugged in via MEGACOMPACT_EMBEDDING_URL
+ * — see httpEmbedder.ts. The `Embedder` interface is the seam both implement;
+ * this extension ships no model and makes no remote call (PREVENT-PI-004).
+ */
+
+import { HttpEmbedder, embeddingConfigFromEnv } from "./httpEmbedder.js";
+
+export type Vector = number[];
+
+/** Common embedding contract. Implementations must be deterministic. */
+export interface Embedder {
+  /** Dimensionality of vectors this embedder produces. */
+  readonly dim: number;
+  embed(text: string): Vector;
+}
+
+/** Normalize a vector to unit length (cosine-sim safe). Returns a new array. */
+export function l2Normalize(v: Vector): Vector {
+  let sumSq = 0;
+  for (const x of v) sumSq += x * x;
+  const norm = Math.sqrt(sumSq);
+  if (norm === 0) return v.map(() => 0);
+  return v.map((x) => x / norm);
+}
+
+/** Cosine similarity in [-1, 1]. Assumes inputs are same dim. */
+export function cosineSimilarity(a: Vector, b: Vector): number {
+  if (a.length !== b.length) return 0;
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+
+/** Stable 32-bit string hash (FNV-1a). */
+function fnv1a(str: string): number {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 0x01000193);
+  }
+  return h >>> 0;
+}
+
+/**
+ * Default embedder: character 3-gram bag-of-counts, hashed into a fixed-dim
+ * vector, L2-normalized. Captures local lexical/structure overlap well enough
+ * for checkpoint relevance ranking.
+ */
+export class TrigramEmbedder implements Embedder {
+  readonly dim: number;
+  private readonly seed: number;
+
+  constructor(dim = 512, seed = 0x9e3779b9) {
+    this.dim = dim;
+    this.seed = seed >>> 0;
+  }
+
+  embed(text: string): Vector {
+    const vec = new Array<number>(this.dim).fill(0);
+    const norm = text.toLowerCase().replace(/\s+/g, " ");
+    if (norm.length === 0) return l2Normalize(vec);
+    // Whole-string + word + char-trigram signals.
+    vec[fnv1a(norm) % this.dim] += 1;
+    for (const word of norm.split(" ")) {
+      if (word.length === 0) continue;
+      vec[fnv1a(word) % this.dim] += 1;
+      for (let i = 0; i + 3 <= word.length; i++) {
+        const gram = word.slice(i, i + 3);
+        const idx = (fnv1a(gram) ^ this.seed) % this.dim;
+        vec[idx] += 1;
+      }
+    }
+    // Edge: very short tokens still get a slot.
+    if (norm.length < 3) vec[fnv1a(norm) % this.dim] += 1;
+    return l2Normalize(vec);
+  }
+}
+
+/**
+ * Select the default embedder used by VectorStore.
+ *
+ * - If MEGACOMPACT_EMBEDDING_URL points at a localhost server, use HttpEmbedder
+ *   (your own local embedding backend — ONNX/TEI/Ollama/etc). This is the
+ *   PREVENT-PI-004-sanctioned "bring your own" path: the endpoint is a
+ *   user-spawned loopback server, so conversation content never leaves the box.
+ * - Otherwise the TrigramEmbedder is the shipped default: zero-dependency,
+ *   deterministic, GPU-free, cross-platform, fully offline.
+ *
+ * The `Embedder` interface is the seam for any LOCAL embedder. Never point it
+ * at a remote provider — that would violate PREVENT-PI-004. A user wanting
+ * semantic-grade dedup should run a local embedding server and set the URL.
+ */
+export function defaultEmbedder(): Embedder {
+  const cfg = embeddingConfigFromEnv();
+  if (cfg) return new HttpEmbedder(cfg);
+  return new TrigramEmbedder();
+}

package/src/engine.test.ts

@@ -0,0 +1,123 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { VectorStore } from "./vectorStore.js";
+import { compactSession, recall, mergeSummary, supersededCount } from "./engine.js";
+import type { EngineMessage } from "./types.js";
+
+const baseTmp = mkdtempSync(join(tmpdir(), "mc-engine-"));
+let counter = 0;
+function store() {
+  return new VectorStore({ dedupSim: 0.9, stateDir: join(baseTmp, `run-${counter++}`) });
+}
+
+const SESS = "sess_engine";
+
+function msg(role: EngineMessage["role"], text: string, toolName?: string): EngineMessage {
+  return toolName ? { role, text, toolName, input: text, output: text } : { role, text };
+}
+
+test("compactSession supersedes then persists a checkpoint", () => {
+  const s = store();
+  const messages: EngineMessage[] = [
+    msg("user", "read src/server.ts"),
+    msg("assistant", "ok", "Read"),
+    msg("user", "edit src/server.ts"),
+    msg("assistant", "ok", "Edit"),
+    msg("user", "now fix the bug in src/server.ts"),
+    msg("assistant", "done", "Edit"),
+  ];
+  const r = compactSession({ sessionId: SESS, messages, keepFrom: 4, timestamp: 1 }, s);
+  assert.equal(r.skipped, false);
+  assert.equal(r.deduped, false);
+  assert.match(r.checkpointId ?? "", /^chkpt_001$/);
+  assert.ok(r.summary.length > 0, "summary produced by COLLAPSE");
+  assert.ok(r.regionHash.length > 0);
+  // SUPERSEDE dropped the obsolete first read turn (user read @0 superseded by
+  // the edit @2) — so exactly one superseded message in the compacted slice.
+  assert.equal(supersededCount(messages.slice(0, 4)), 1);
+  assert.equal(r.compactedFrom, 4);
+  // The persisted checkpoint is searchable.
+  assert.equal(s.search(SESS, "bug src/server.ts", 5).length, 1);
+});
+
+test("compactSession is idempotent on identical region (dedup sentinel)", () => {
+  const s = store();
+  const messages: EngineMessage[] = [
+    msg("user", "alpha work on the parser"),
+    msg("assistant", "did it", "Edit"),
+    msg("user", "beta work on the renderer"),
+    msg("assistant", "done", "Edit"),
+  ];
+  const r1 = compactSession({ sessionId: SESS, messages, keepFrom: 4, timestamp: 1 }, s);
+  const r2 = compactSession({ sessionId: SESS, messages, keepFrom: 4, timestamp: 2 }, s);
+  assert.equal(r1.deduped, false);
+  assert.equal(r2.deduped, true);
+  assert.equal(r1.checkpointId, r2.checkpointId);
+  assert.equal(s.search(SESS, "parser", 10).length, 1);
+});
+
+test("compactSession skipped when slice is empty", () => {
+  const s = store();
+  const r = compactSession({ sessionId: SESS, messages: [msg("user", "only tail")], keepFrom: 0 }, s);
+  assert.equal(r.skipped, true);
+  assert.equal(s.search(SESS, "x", 5).length, 0);
+});
+
+test("recall drops already-injected checkpoints", () => {
+  const s = store();
+  compactSession({ sessionId: SESS, messages: [msg("user", "investigated src/vectorStore.ts"), msg("assistant", "ok", "Edit")], keepFrom: 2, timestamp: 1 }, s);
+  const first = recall({ sessionId: SESS, query: "vectorStore", limit: 5, skipInjected: true }, s);
+  assert.equal(first.newHits.length, 1);
+  s.markInjected(SESS, first.hits[0].checkpoint.checkpointId);
+  const second = recall({ sessionId: SESS, query: "vectorStore", limit: 5, skipInjected: true }, s);
+  assert.equal(second.newHits.length, 0);
+  // Without the skip flag, both hits still surface.
+  assert.equal(second.hits.length, 1);
+});
+
+test("mergeSummary accumulates prior + new context", () => {
+  const prior = "<summary>Conversation summary:\n- Key files referenced: src/a.ts.\n</summary>";
+  const next = "<summary>Conversation summary:\n- Key files referenced: src/b.ts.\n</summary>";
+  const merged = mergeSummary(prior, next);
+  assert.ok(merged.includes("src/a.ts"));
+  assert.ok(merged.includes("src/b.ts"));
+  assert.ok(merged.includes("Newly compacted"));
+});
+
+test("supersededCount reports obsolete reads", () => {
+  const messages: EngineMessage[] = [
+    msg("user", "read src/x.ts"),
+    msg("assistant", "ok", "Read"),
+    msg("user", "write src/x.ts"),
+    msg("assistant", "ok", "Edit"),
+  ];
+  assert.equal(supersededCount(messages), 1);
+});
+
+test("compactSession with useExtractive produces topicSummary on checkpoint", () => {
+  const s = store();
+  const messages: EngineMessage[] = [
+    msg("user", "let's refactor the auth module in src/auth.ts"),
+    msg("assistant", "I'll start by reading the current implementation", "Read"),
+    msg("user", "extract the login logic into a separate function"),
+    msg("assistant", "Extracted login() into src/auth.ts:45", "Edit"),
+    msg("user", "now add the session token generation"),
+    msg("assistant", "Added generateSessionToken in src/auth.ts:78", "Edit"),
+  ];
+  const r = compactSession({ sessionId: "sess_extr", messages, keepFrom: 4, timestamp: 1, useExtractiveSummary: true }, s);
+  assert.equal(r.skipped, false);
+  assert.ok(r.checkpointId, "checkpoint created");
+  // The checkpoint should have topicSummary populated
+  const hits = s.search("sess_extr", "auth refactor", 5);
+  assert.ok(hits.length > 0);
+  // topicSummary should be present on the stored checkpoint (via extractive path)
+  assert.ok(hits[0].checkpoint.topicSummary, "topicSummary should be populated when useExtractive is true");
+  assert.ok(hits[0].checkpoint.topicSummary!.length > 0);
+});
+
+test("cleanup", () => {
+  rmSync(baseTmp, { recursive: true, force: true });
+});

package/src/engine.ts

@@ -0,0 +1,192 @@
+/**
+ * engine.ts — Layer 4 (PERSIST / checkpoint) orchestration.
+ *
+ * Ties the Sprint 1–2 primitives into the compaction pipeline the extension
+ * calls. Pure of any pi runtime type: it consumes EngineMessage[] and talks to
+ * the on-disk VectorStore. The extension adapts pi messages -> EngineMessage
+ * (see adapt.ts) and reports status.
+ *
+ * Pipeline (mirrors the PLAN Trident stack):
+ *   SUPERSEDE (drop obsolete file reads)
+ *   -> COLLAPSE (summarize the compacted slice)
+ *   -> CLUSTER  (embed + persist a checkpoint to the vector store)
+ */
+
+import { findSuperseded, supersede } from "./supersede.js";
+import { summarizeMessages, mergeCompactSummaries, formatCompactSummary } from "./compact.js";
+import { extractiveSummarize } from "./extractive.js";
+import { estimateSessionTokens } from "./tokens.js";
+import { computeRegionHash, VectorStore, type SearchHit } from "./vectorStore.js";
+import type { EngineMessage } from "./types.js";
+
+export interface CompactInput {
+  sessionId: string;
+  messages: EngineMessage[];
+  /** Index (into `messages`) of the first message to keep verbatim. Everything
+   *  before this is eligible to be compacted. Defaults to `preserveRecent`
+   *  from the tail. */
+  keepFrom?: number;
+  /** Optional explicit summary; when omitted, COLLAPSE heuristics build one. */
+  summary?: string;
+  /** Region text the checkpoint is keyed on (for dedup). Defaults to the
+   *  compacted slice's joined text. */
+  regionText?: string;
+  keyDecisions?: string[];
+  nextSteps?: string[];
+  filesModified?: string[];
+  tokenEstimate?: number;
+  timestamp?: number;
+  /** When true (default), use extractive summary instead of raw concatenation. */
+  useExtractiveSummary?: boolean;
+}
+
+export interface CompactResult {
+  /** True when nothing was compacted (slice empty / below floor). */
+  skipped: boolean;
+  /** True when the region was a duplicate of an already-stored checkpoint. */
+  deduped: boolean;
+  /** Which dedup tier matched: regionHash | summaryHash | contentSimilarity. */
+  dedupReason?: string;
+  checkpointId?: string;
+  summary: string;
+  regionHash: string;
+  tokenEstimate: number;
+  /** Index in `messages` where the compacted slice begins (for the caller to
+   *  build a drop range). */
+  compactedFrom: number;
+}
+
+/** Default store used by the convenience `compactSession`. */
+let defaultStore: VectorStore | undefined;
+export function getDefaultStore(stateDir?: string): VectorStore {
+  if (!defaultStore) defaultStore = new VectorStore({ stateDir });
+  return defaultStore;
+}
+/** Replace the default store (used by tests to inject a temp dir). */
+export function setDefaultStore(store: VectorStore | undefined): void {
+  defaultStore = store;
+}
+
+/**
+ * Run the Trident pipeline over a message slice and persist a checkpoint.
+ *
+ * `messages` is the FULL session view; `keepFrom` marks where the verbatim tail
+ * starts, so indices stay absolute and the caller can map the drop range back
+ * onto the real (pi) message array via adapt.ts. Returns a `skipped` result
+ * when the compactable slice is empty.
+ */
+export function compactSession(input: CompactInput, store: VectorStore = getDefaultStore()): CompactResult {
+  const keepFrom = input.keepFrom ?? input.messages.length;
+  const compactable = input.messages.slice(0, keepFrom);
+  const compactedFrom = keepFrom;
+
+  if (compactable.length === 0) {
+    return {
+      skipped: true,
+      deduped: false,
+      summary: "",
+      regionHash: "",
+      tokenEstimate: 0,
+      compactedFrom,
+    };
+  }
+
+  // LAYER 1 — SUPERSEDE: zero-cost factual pruning of obsolete file reads.
+  const supersededIdx = new Set(findSuperseded(compactable));
+  const keep = compactable.filter((_m, i) => !supersededIdx.has(i));
+
+  // LAYER 2 — COLLAPSE: build (or accept) the summary.
+  // When useExtractiveSummary is enabled (default), use the deterministic
+  // extractive engine that compresses ~70K tokens → ~2K tokens with structured
+  // fields populated. Falls back to legacy concatenation when disabled.
+  const useExtractive = input.useExtractiveSummary !== false;
+  let summary: string;
+  let topicSummary: string | undefined;
+  let keyDecisions: string[];
+  let nextSteps: string[];
+  let filesModified: string[];
+  let tokenEstimate: number;
+
+  if (useExtractive && !input.summary) {
+    const ext = extractiveSummarize(keep);
+    summary = ext.topicSummary;
+    topicSummary = ext.topicSummary;
+    keyDecisions = input.keyDecisions ?? ext.keyDecisions;
+    nextSteps = input.nextSteps ?? ext.nextSteps;
+    filesModified = input.filesModified ?? ext.filesModified;
+    tokenEstimate = input.tokenEstimate ?? ext.tokenEstimate;
+  } else {
+    const collapsed = input.summary ?? summarizeMessages(keep);
+    summary = formatCompactSummary(collapsed);
+    topicSummary = undefined;
+    keyDecisions = input.keyDecisions ?? [];
+    nextSteps = input.nextSteps ?? [];
+    filesModified = input.filesModified ?? [];
+    tokenEstimate = input.tokenEstimate ?? estimateSessionTokens(compactable);
+  }
+
+  // Region text = the compacted slice, used for dedup + embedding.
+  const regionText = input.regionText ?? keep.map((m) => m.text).join("\n");
+  const regionHash = computeRegionHash(regionText);
+
+  const add = store.add({
+    sessionId: input.sessionId,
+    summary,
+    topicSummary,
+    keyDecisions,
+    nextSteps,
+    filesModified,
+    regionText,
+    tokenEstimate,
+    timestamp: input.timestamp ?? 0,
+  });
+
+  return {
+    skipped: false,
+    deduped: add.deduped,
+    dedupReason: add.reason,
+    checkpointId: add.checkpoint.checkpointId,
+    summary,
+    regionHash,
+    tokenEstimate,
+    compactedFrom,
+  };
+}
+
+export interface RecallInput {
+  sessionId: string;
+  query: string;
+  limit?: number;
+  /** Skip checkpoints already injected this session (recall dedup). */
+  skipInjected?: boolean;
+}
+
+export interface RecallResult {
+  hits: SearchHit[];
+  /** Indices into `hits` that were *not* already injected (ready to inline). */
+  newHits: SearchHit[];
+}
+
+/**
+ * Layer 5 (query side, shared by auto-inline + on-demand): search the store and
+ * drop any checkpoint already injected this session. The caller decides how to
+ * inject (Sprint 4 wires injection); this module only does the deduped search.
+ */
+export function recall(input: RecallInput, store: VectorStore = getDefaultStore()): RecallResult {
+  const hits = store.search(input.sessionId, input.query, input.limit ?? 3);
+  const newHits = input.skipInjected === false ? hits : hits.filter((h) => !store.wasInjected(input.sessionId, h.checkpoint.checkpointId));
+  return { hits, newHits };
+}
+
+/** Merge a freshly compacted summary into the prior persisted summary text. */
+export function mergeSummary(existing: string | undefined, next: string): string {
+  return mergeCompactSummaries(existing, next);
+}
+
+/** Exposed for callers that want raw supersede stats (status reporting). */
+export function supersededCount(messages: EngineMessage[]): number {
+  return new Set(findSuperseded(messages)).size;
+}
+
+/** Re-export so the extension has one import surface. */
+export { supersede, summarizeMessages, formatCompactSummary };

package/src/extractive.test.ts

@@ -0,0 +1,156 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { extractiveSummarize } from "./extractive.js";
+import type { EngineMessage } from "./types.js";
+
+function msg(role: EngineMessage["role"], text: string, toolName?: string): EngineMessage {
+  return toolName ? { role, text, toolName, input: text, output: text } : { role, text };
+}
+
+// ---- Determinism -----------------------------------------------------------
+
+test("extractive summary is deterministic", () => {
+  const messages: EngineMessage[] = [
+    msg("user", "please write src/index.ts"),
+    msg("assistant", "I'll write src/index.ts now."),
+    msg("tool", '{"file_path":"src/index.ts"}', "write"),
+    msg("assistant", "Done."),
+  ];
+  const s1 = extractiveSummarize(messages);
+  const s2 = extractiveSummarize(messages);
+  assert.deepStrictEqual(s1, s2);
+});
+
+// ---- Compression -----------------------------------------------------------
+
+test("extractive summary produces small output", () => {
+  // Build 70 messages (simulating a session)
+  const messages: EngineMessage[] = [];
+  for (let i = 0; i < 70; i++) {
+    messages.push(msg("user", `request ${i}: please help with feature ${i}`));
+    messages.push(msg("assistant", `working on feature ${i} in src/file${i % 5}.ts`));
+    messages.push(msg("tool", `{"file_path":"src/file${i % 5}.ts","content":"..."}`, "write"));
+    messages.push(msg("assistant", `done with feature ${i}`));
+  }
+  const rawText = messages.map((m) => m.text).join("\n");
+  const rawTokens = Math.ceil(rawText.length / 4);
+
+  const summary = extractiveSummarize(messages);
+  const ratio = rawTokens / summary.tokenEstimate;
+
+  // Compression should be at least 5:1 (target is 35:1)
+  assert.ok(ratio >= 5, `compression ratio ${ratio.toFixed(1)}:1 is less than 5:1`);
+  assert.ok(summary.tokenEstimate < 5000, `summary is ${summary.tokenEstimate} tokens (expected < 5000)`);
+});
+
+// ---- Empty input ------------------------------------------------------------
+
+test("empty messages returns minimal summary", () => {
+  const summary = extractiveSummarize([]);
+  assert.equal(summary.topicSummary, "(empty)");
+  assert.equal(summary.keyDecisions.length, 0);
+  assert.equal(summary.nextSteps.length, 0);
+  assert.equal(summary.filesModified.length, 0);
+  assert.equal(summary.tokenEstimate, 0);
+});
+
+// ---- Key decisions ----------------------------------------------------------
+
+test("extracts decisions from assistant messages", () => {
+  const messages: EngineMessage[] = [
+    msg("user", "which database should we use?"),
+    msg("assistant", "I recommend using better-sqlite3 for the local vector store."),
+    msg("assistant", "Let's go with the Trident pipeline architecture."),
+  ];
+  const summary = extractiveSummarize(messages);
+  assert.ok(summary.keyDecisions.length >= 1, "should extract at least 1 decision");
+  assert.ok(
+    summary.keyDecisions.some((d) => d.includes("better-sqlite3")),
+    `decisions: ${JSON.stringify(summary.keyDecisions)}`,
+  );
+});
+
+test("no decisions in tool messages", () => {
+  const messages: EngineMessage[] = [
+    msg("tool", "I recommend something", "bash"),
+  ];
+  const summary = extractiveSummarize(messages);
+  // Tool messages should not be checked for decisions
+  assert.equal(summary.keyDecisions.length, 0);
+});
+
+// ---- Files modified ---------------------------------------------------------
+
+test("extracts files from write/edit tool calls", () => {
+  const messages: EngineMessage[] = [
+    msg("tool", '{"file_path":"/home/user/project/src/index.ts","content":"..."}', "write"),
+    msg("tool", '{"file_path":"/home/user/project/README.md","content":"..."}', "edit"),
+  ];
+  const summary = extractiveSummarize(messages);
+  assert.ok(summary.filesModified.includes("/home/user/project/src/index.ts"));
+  assert.ok(summary.filesModified.includes("/home/user/project/README.md"));
+});
+
+test("extracts files from git commands in bash", () => {
+  const messages: EngineMessage[] = [
+    msg("tool", "git add src/index.ts src/types.ts", "bash"),
+  ];
+  const summary = extractiveSummarize(messages);
+  assert.ok(summary.filesModified.some((f) => f.includes("index.ts")));
+});
+
+// ---- Pending work -----------------------------------------------------------
+
+test("extracts pending work markers", () => {
+  const messages: EngineMessage[] = [
+    msg("user", "run the tests"),
+    msg("assistant", "Tests pass. TODO: add integration tests for the dedup path."),
+  ];
+  const summary = extractiveSummarize(messages);
+  assert.ok(summary.nextSteps.length >= 1, "should find TODO");
+  assert.ok(summary.nextSteps.some((s) => /integration tests/i.test(s)));
+});
+
+// ---- topicSummary structure -------------------------------------------------
+
+test("topicSummary contains scope line", () => {
+  const messages: EngineMessage[] = [
+    msg("user", "hello"),
+    msg("assistant", "hi there"),
+  ];
+  const summary = extractiveSummarize(messages);
+  assert.ok(summary.topicSummary.includes("Conversation: 2 messages"));
+  assert.ok(summary.topicSummary.includes("1 user"));
+  assert.ok(summary.topicSummary.includes("1 assistant"));
+});
+
+test("topicSummary includes tools when present", () => {
+  const messages: EngineMessage[] = [
+    msg("tool", "ok", "write"),
+    msg("tool", "ok", "bash"),
+  ];
+  const summary = extractiveSummarize(messages);
+  assert.ok(summary.topicSummary.includes("Tools:"));
+  assert.ok(summary.topicSummary.includes("write"));
+  assert.ok(summary.topicSummary.includes("bash"));
+});
+
+// ---- Same messages produce same summary ------------------------------------
+
+test("deterministic across invocations with complex input", () => {
+  const messages: EngineMessage[] = [
+    msg("user", "help me refactor the auth module"),
+    msg("assistant", "I'll look at the current auth implementation."),
+    msg("tool", '{"file_path":"src/auth.ts"}', "read"),
+    msg("assistant", "I recommend splitting auth.ts into separate files."),
+    msg("user", "sounds good, go ahead"),
+    msg("assistant", "I'll create src/auth/login.ts and src/auth/register.ts."),
+    msg("tool", '{"file_path":"src/auth/login.ts","content":"..."}', "write"),
+    msg("tool", '{"file_path":"src/auth/register.ts","content":"..."}', "write"),
+    msg("assistant", "Done. TODO: update the import paths in main.ts."),
+  ];
+  const results = Array.from({ length: 5 }, () => extractiveSummarize(messages));
+  for (let i = 1; i < results.length; i++) {
+    assert.deepStrictEqual(results[i], results[0], `run ${i} differs from run 0`);
+  }
+});