pi-mega-compact 0.11.3 → 0.11.5

package/src/store/migrate.test.ts

@@ -1,158 +0,0 @@
-/**
- * migrate + recall integration test — Sprint 8 acceptance proofs.
- *
- * 1. Migration is lossless: a v0.1.0 `<sess>.checkpoints.json.gz` roundtrips
- *    into SQLite with checkpoint count + regionHash set identical, and the JSON
- *    file is retained as a DR snapshot.
- * 2. Cross-process recall: compact in one VectorStore, then recall via a FRESH
- *    VectorStore over the SAME stateDir (re-opens the same sqlite.db file) — the
- *    checkpoint must reappear. Mirrors Sprint 6.1's durability requirement.
- *
- * Uses MEGACOMPACT_STATE_DIR overrides; never the real user state dir.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { VectorStore, vectorMarkInjected, vectorWasInjected, vectorSearch } from "../vectorStore.js";
-import { writeGzJson } from "../store.js";
-import type { StoredCheckpoint } from "../store.js";
-import { migrateJsonToSqlite, readLegacyCheckpointFile } from "../store/migrate.js";
-import { listCheckpoints, closeStore } from "../store/sqlite.js";
-
-const baseTmp = mkdtempSync(join(tmpdir(), "mc-migrate-"));
-let counter = 0;
-function stateDir() {
-  return join(baseTmp, `run-${counter++}`);
-}
-function msgVec(): number[] {
-  // Deterministic 8-dim vector.
-  return [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8];
-}
-function fakeCheckpoints(sessionId: string): StoredCheckpoint[] {
-  return [
-    {
-      checkpointId: "chkpt_001",
-      sessionId,
-      summary: "Investigated the vector store and added a cosine helper.",
-      topicSummary: "Added cosine similarity helper to vector store.",
-      summaryHash: "a1b2c3d4e5f6a7b8",
-      keyDecisions: ["use linear scan"],
-      nextSteps: ["add tests"],
-      filesModified: ["src/vectorStore.ts"],
-      tokenEstimate: 1200,
-      regionHash: "r1",
-      embedding: msgVec(),
-      timestamp: 1,
-    },
-    {
-      checkpointId: "chkpt_002",
-      sessionId,
-      summary: "Refactored the recall path to dedupe against the window.",
-      topicSummary: "Recall dedup against injected set.",
-      summaryHash: "b2c3d4e5f6a7b8c9",
-      keyDecisions: [],
-      nextSteps: [],
-      filesModified: ["src/recall.ts"],
-      tokenEstimate: 900,
-      regionHash: "r2",
-      embedding: msgVec().map((v) => v + 0.01),
-      timestamp: 2,
-    },
-  ];
-}
-
-test("migration: v0.1.0 JSON checkpoints migrate losslessly into SQLite", () => {
-  const dir = stateDir();
-  const sid = "sess_migrate_lossless";
-  // Write a legacy JSON checkpoint file (the format v0.1.0 shipped).
-  writeGzJson(join(dir, `${sid}.checkpoints.json.gz`), fakeCheckpoints(sid));
-
-  const result = migrateJsonToSqlite(dir);
-  assert.equal(result.sessionsScanned, 1);
-  assert.equal(result.checkpointsMigrated, 2);
-  assert.equal(result.alreadyPresent, 0);
-
-  // SQLite now has both checkpoints, regionHash preserved.
-  const migrated = listCheckpoints(sid, dir);
-  assert.equal(migrated.length, 2, "both checkpoints present");
-  assert.ok(migrated.every((c) => c.regionHash && c.regionHash.length > 0), "regionHash preserved");
-  assert.deepEqual(migrated.map((c) => c.checkpointId).sort(), ["chkpt_001", "chkpt_002"]);
-
-  // content_hash columns populated (needed by Sprint 9).
-  const legacy = readLegacyCheckpointFile(sid, dir);
-  assert.equal(legacy.length, 2, "legacy file intact (DR snapshot retained)");
-  assert.ok(existsSync(join(dir, `${sid}.checkpoints.json.gz`)), "JSON DR snapshot retained");
-
-  closeStore(dir);
-});
-
-test("migration: re-running is idempotent (no duplicates)", () => {
-  const dir = stateDir();
-  const sid = "sess_migrate_idem";
-  writeGzJson(join(dir, `${sid}.checkpoints.json.gz`), fakeCheckpoints(sid));
-  migrateJsonToSqlite(dir);
-  const r2 = migrateJsonToSqlite(dir);
-  assert.equal(r2.checkpointsMigrated, 0, "nothing new migrated");
-  assert.equal(r2.alreadyPresent, 2, "both counted as already present");
-  assert.equal(listCheckpoints(sid, dir).length, 2);
-  closeStore(dir);
-});
-
-test("cross-process recall: fresh VectorStore over same dir recalls prior checkpoint", () => {
-  const dir = stateDir();
-  const sid = "sess_xproc";
-
-  // Process A: compact a checkpoint into the store.
-  const a = new VectorStore({ stateDir: dir });
-  const added = a.add({
-    sessionId: sid,
-    summary: "Cross-process recall proof: persisted in process A.",
-    topicSummary: "Persisted checkpoint in process A.",
-    regionText: "cross process recall proof session A write path",
-    tokenEstimate: 500,
-    timestamp: 1,
-  });
-  assert.equal(added.deduped, false);
-  assert.equal(added.checkpoint.checkpointId, "chkpt_001");
-
-  // Force a clean reopen (simulates a new process opening the same file).
-  closeStore(dir);
-
-  // Process B: brand-new VectorStore, same stateDir.
-  const b = new VectorStore({ stateDir: dir });
-  const hits = vectorSearch(b, sid, "cross process recall proof", 5);
-  assert.equal(hits.length, 1, "checkpoint survives cross-process reopen");
-  assert.equal(hits[0].checkpoint.checkpointId, "chkpt_001");
-  assert.ok(hits[0].score > 0.5, "recall is relevant");
-
-  closeStore(dir);
-});
-
-test("cross-process recall: injected state persists across reopen", () => {
-  const dir = stateDir();
-  const sid = "sess_xproc_inj";
-  const a = new VectorStore({ stateDir: dir });
-  const added = a.add({
-    sessionId: sid,
-    summary: "A checkpoint to inject and remember across processes.",
-    topicSummary: "Injected checkpoint.",
-    regionText: "injected state persists across process reopen test",
-    timestamp: 1,
-  });
-  vectorMarkInjected(a, sid, added.checkpoint.checkpointId);
-  assert.equal(vectorWasInjected(a, sid, added.checkpoint.checkpointId), true);
-
-  closeStore(dir);
-
-  const b = new VectorStore({ stateDir: dir });
-  assert.equal(vectorWasInjected(b, sid, added.checkpoint.checkpointId), true, "injection remembered");
-
-  closeStore(dir);
-});
-
-test("cleanup", () => {
-  rmSync(baseTmp, { recursive: true, force: true });
-});

package/src/store/pgOpenGuard.test.ts

@@ -1,89 +0,0 @@
-/**
- * pgOpenGuard.test.ts — the PGlite open must never hang a turn.
- *
- * Regression cover for the wedge: a stalled `await new PGlite(...)` was cached
- * in initPromise, so every later caller awaited a promise that could not settle
- * and the pi turn awaiting it never ended.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { withOpenTimeout, pgOpenTimeoutMs, DEFAULT_PG_OPEN_TIMEOUT_MS } from "./pgOpenGuard.js";
-
-test("a never-settling open resolves to undefined instead of hanging", async () => {
-  const never = new Promise<string>(() => {
-    /* deliberately never settles — the wedge */
-  });
-  const reasons: string[] = [];
-  const t0 = Date.now();
-
-  const result = await withOpenTimeout(never, (r) => reasons.push(r), 50);
-
-  assert.equal(result, undefined, "caller gets undefined and can fall back");
-  assert.ok(Date.now() - t0 < 5_000, "returned promptly rather than hanging");
-  assert.equal(reasons.length, 1, "onTimeout fired exactly once");
-  assert.match(reasons[0], /timed out after 50ms/);
-});
-
-test("a successful open passes its value through untouched", async () => {
-  const reasons: string[] = [];
-  const result = await withOpenTimeout(Promise.resolve("pg"), (r) => reasons.push(r), 5_000);
-  assert.equal(result, "pg");
-  assert.deepEqual(reasons, [], "no timeout reported on the happy path");
-});
-
-test("a rejected open propagates so the corrupt-dir retry still runs", async () => {
-  const reasons: string[] = [];
-  await assert.rejects(
-    () => withOpenTimeout(Promise.reject(new Error("Aborted()")), (r) => reasons.push(r), 5_000),
-    /Aborted/,
-    "rejection reaches the caller's catch, which owns the wipe-and-retry path",
-  );
-  assert.deepEqual(reasons, [], "a rejection is not reported as a timeout");
-});
-
-test("an abandoned open is closed if it settles after the timeout", async () => {
-  let closed = false;
-  let release: (v: { close: () => void }) => void = () => {};
-  const late = new Promise<{ close: () => void }>((r) => {
-    release = r;
-  });
-
-  const result = await withOpenTimeout(late, () => {}, 25);
-  assert.equal(result, undefined, "timed out first");
-
-  // The open finally completes, long after we stopped waiting for it.
-  release({
-    close: () => {
-      closed = true;
-    },
-  });
-  await late;
-  await new Promise((r) => setImmediate(r));
-
-  assert.ok(closed, "the orphaned instance was closed, not left holding the dataDir");
-});
-
-test("timeout of 0 disables the guard (unbounded, original behavior)", async () => {
-  const result = await withOpenTimeout(Promise.resolve("pg"), () => {}, 0);
-  assert.equal(result, "pg");
-});
-
-test("pgOpenTimeoutMs honors the env override and rejects junk", async () => {
-  const prev = process.env.MEGACOMPACT_PGLITE_OPEN_TIMEOUT_MS;
-  try {
-    process.env.MEGACOMPACT_PGLITE_OPEN_TIMEOUT_MS = "1234";
-    assert.equal(pgOpenTimeoutMs(), 1234);
-
-    process.env.MEGACOMPACT_PGLITE_OPEN_TIMEOUT_MS = "0";
-    assert.equal(pgOpenTimeoutMs(), 0, "0 is a valid opt-out, not junk");
-
-    for (const junk of ["", "   ", "abc", "-5"]) {
-      process.env.MEGACOMPACT_PGLITE_OPEN_TIMEOUT_MS = junk;
-      assert.equal(pgOpenTimeoutMs(), DEFAULT_PG_OPEN_TIMEOUT_MS, `junk "${junk}" falls back`);
-    }
-  } finally {
-    if (prev === undefined) delete process.env.MEGACOMPACT_PGLITE_OPEN_TIMEOUT_MS;
-    else process.env.MEGACOMPACT_PGLITE_OPEN_TIMEOUT_MS = prev;
-  }
-});

package/src/store/phase01.test.ts

@@ -1,88 +0,0 @@
-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 { dataInvariantStats } from "./sqlite.js";
-
-const baseTmp = mkdtempSync(join(tmpdir(), "mc-p01-"));
-
-let counter = 0;
-function store(opts: { dedupSim?: number } = {}) {
-  const dir = join(baseTmp, `run-${counter++}`);
-  return { s: new VectorStore({ dedupSim: opts.dedupSim ?? 0.9, stateDir: dir }), dir };
-}
-
-// --- Phase 0: data-safety invariant ---------------------------------------
-
-test("Phase 0: every added region retains a compressed-original and deletes nothing", () => {
-  const { s, dir } = store();
-  s.add({ sessionId: "sess_a", summary: "s1", regionText: "the quick brown fox jumps", tokenEstimate: 5, originalTokenEstimate: 50, timestamp: 1 });
-  s.add({ sessionId: "sess_a", summary: "s2", regionText: "a totally different region of work", tokenEstimate: 6, originalTokenEstimate: 60, timestamp: 2 });
-  const di = dataInvariantStats(dir);
-  assert.equal(di.regionsRetained, 2, "both regions retained");
-  assert.ok(di.compressedOriginalBytes > 0, "compressed-original bytes retained");
-  assert.equal(di.bytesPermanentlyDeleted, 0, "INVARIANT: nothing permanently deleted");
-});
-
-test("Phase 0: dedup collapses a duplicate but original is still retained (not deleted)", () => {
-  const { s, dir } = store();
-  const text = "identical region content that will dedup on the second add";
-  s.add({ sessionId: "sess_b", summary: "s", regionText: text, tokenEstimate: 5, originalTokenEstimate: 50, timestamp: 1 });
-  const r2 = s.add({ sessionId: "sess_b", summary: "s", regionText: text, tokenEstimate: 5, originalTokenEstimate: 50, timestamp: 2 });
-  assert.equal(r2.deduped, true, "second add deduped");
-  const di = dataInvariantStats(dir);
-  assert.equal(di.bytesPermanentlyDeleted, 0, "INVARIANT: dedup never deletes data");
-  assert.ok(di.regionsRetained >= 1, "survivor region still retained");
-});
-
-// --- Phase 1: per-tier progress callback ----------------------------------
-
-test("Phase 1: onTier fires L0→L1→L2→stored for a genuinely new region", () => {
-  const { s } = store();
-  // Seed one checkpoint so L2 has something to scan against.
-  s.add({ sessionId: "sess_c", summary: "seed", regionText: "seed region alpha", timestamp: 1 });
-  const events: Array<{ tier: string; status: string }> = [];
-  s.add({
-    sessionId: "sess_c",
-    summary: "new",
-    regionText: "a brand new region beta that is not a duplicate",
-    timestamp: 2,
-    onTier: (ev) => events.push({ tier: ev.tier, status: ev.status }),
-  });
-  const tiers = events.map((e) => e.tier);
-  assert.ok(tiers.includes("L0"), "L0 fired");
-  assert.ok(tiers.includes("L1"), "L1 fired");
-  assert.ok(tiers.includes("L2"), "L2 fired");
-  assert.equal(events.at(-1)?.tier, "new", "final event is the 'new' tier");
-  assert.equal(events.at(-1)?.status, "stored", "final status is stored");
-});
-
-test("Phase 1: onTier reports a deduped outcome and short-circuits at the matching tier", () => {
-  const { s } = store();
-  const text = "region that will exact-dedup on the second pass";
-  s.add({ sessionId: "sess_d", summary: "s", regionText: text, timestamp: 1 });
-  const events: Array<{ tier: string; status: string; detail?: string }> = [];
-  const r = s.add({
-    sessionId: "sess_d",
-    summary: "s",
-    regionText: text,
-    timestamp: 2,
-    onTier: (ev) => events.push(ev),
-  });
-  assert.equal(r.deduped, true);
-  const deduped = events.find((e) => e.status === "deduped");
-  assert.ok(deduped, "a deduped event fired");
-  assert.equal(deduped?.tier, "L0", "exact duplicate short-circuits at L0");
-  // Must NOT reach the final stored event.
-  assert.ok(!events.some((e) => e.status === "stored"), "no stored event on dedup");
-});
-
-test("Phase 1: onTier is optional (back-compat) — add() works without it", () => {
-  const { s } = store();
-  const r = s.add({ sessionId: "sess_e", summary: "s", regionText: "no callback here", timestamp: 1 });
-  assert.equal(r.deduped, false);
-});
-
-process.on("exit", () => { try { rmSync(baseTmp, { recursive: true, force: true }); } catch { /* ignore */ } });

package/src/store/phase04.test.ts

@@ -1,58 +0,0 @@
-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 { listCheckpoints, dataInvariantStats } from "./sqlite.js";
-import { decompressSmart, compressSmart } from "./compression.js";
-
-const baseTmp = mkdtempSync(join(tmpdir(), "mc-p04-"));
-
-let counter = 0;
-function store(opts: { dedupSim?: number } = {}) {
-  const dir = join(baseTmp, `run-${counter++}`);
-  return { s: new VectorStore({ dedupSim: opts.dedupSim ?? 0.9, stateDir: dir }), dir };
-}
-
-test("Phase 4: added checkpoint is listed and its compressed-original round-trips", () => {
-  const { s, dir } = store();
-  const original = "the original region text that gets compacted and must be restorable verbatim";
-  const r = s.add({ sessionId: "sess_a", summary: "s", regionText: original, tokenEstimate: 5, originalTokenEstimate: 60, timestamp: 1 });
-  const all = listCheckpoints("sess_a", dir);
-  assert.equal(all.length, 1, "one checkpoint listed");
-  const cp = all[0];
-  assert.ok(cp.compressedOriginal, "compressed-original blob present");
-  // The DR/restore path: decompressSmart must return the exact original.
-  const restored = decompressSmart(cp.compressedOriginal!).toString("utf-8");
-  assert.equal(restored, original, "restored verbatim === original");
-  assert.equal(cp.checkpointId, r.checkpoint.checkpointId);
-});
-
-test("Phase 4: findCheckpoint-by-id resolves a listed checkpoint", () => {
-  const { s, dir } = store();
-  s.add({ sessionId: "sess_b", summary: "s1", regionText: "region one text content here", tokenEstimate: 4, originalTokenEstimate: 40, timestamp: 1 });
-  const r2 = s.add({ sessionId: "sess_b", summary: "s2", regionText: "region two text content here different", tokenEstimate: 4, originalTokenEstimate: 45, timestamp: 2 });
-  const all = listCheckpoints("sess_b", dir);
-  assert.equal(all.length, 2);
-  const wanted = all.find((c) => c.checkpointId === r2.checkpoint.checkpointId)!;
-  assert.ok(wanted, "checkpoint resolved by id");
-  assert.ok(wanted.compressedOriginal, "has restorable original");
-});
-
-test("Phase 4: dataInvariantStats sanity for restore trust (0 deleted)", () => {
-  const { s, dir } = store();
-  s.add({ sessionId: "sess_c", summary: "s", regionText: "retained region body text", tokenEstimate: 5, originalTokenEstimate: 50, timestamp: 1 });
-  const di = dataInvariantStats(dir);
-  assert.equal(di.regionsRetained, 1);
-  assert.ok(di.compressedOriginalBytes > 0);
-  assert.equal(di.bytesPermanentlyDeleted, 0);
-});
-
-test("Phase 4: compressSmart/decompressSmart round-trips arbitrary text", () => {
-  const text = "x".repeat(2000);
-  const back = decompressSmart(compressSmart(Buffer.from(text, "utf-8"))).toString("utf-8");
-  assert.equal(back, text);
-});
-
-process.on("exit", () => { try { rmSync(baseTmp, { recursive: true, force: true }); } catch { /* ignore */ } });

package/src/store/sprint10.test.ts

@@ -1,214 +0,0 @@
-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, vectorList, vectorRepoStats } from "../vectorStore.js";
-import { normalize } from "../dedup/normalize.js";
-import { openBloom, closeBloom } from "./bloom.js";
-import { backfillContentHashes, isBackfillComplete } from "./backfill.js";
-import { checkSessionIntegrity, checkAllIntegrity } from "./integrity.js";
-import { openStore, closeStore, upsertCheckpoint, saveSessionState, loadSessionState } from "./sqlite.js";
-import type { StoredCheckpoint } from "../store.js";
-
-const baseTmp = mkdtempSync(join(tmpdir(), "mc-s10-"));
-
-let counter = 0;
-function store(opts: { dedupSim?: number } = {}) {
-  const dir = join(baseTmp, `run-${counter++}`);
-  return { s: new VectorStore({ dedupSim: opts.dedupSim ?? 0.9, stateDir: dir }), dir };
-}
-
-// --- L0 normalization upgrade (case/whitespace/ANSI collapse) --------------
-
-test("Sprint 10 L0: case/whitespace/ANSI variants dedup to one row", () => {
-  const { s } = store();
-  const variants = ["user reviewed the auth module and merged the PR", "  USER   REVIEWED the AUTH module and MERGED the PR ", "USER REVIEWED THE AUTH MODULE AND MERGED THE PR"];
-  let added = 0;
-  for (const v of variants) {
-    const r = s.add({ sessionId: "sess_norm", summary: "x", regionText: v, timestamp: added + 1 });
-    if (!r.deduped) added++;
-  }
-  assert.equal(vectorList(s, "sess_norm").length, 1);
-});
-
-test("normalize case-folds so Foo/foo/FOO are equal", () => {
-  assert.equal(normalize("Foo Bar"), normalize("foo bar"));
-  assert.equal(normalize("FOO BAR"), normalize("foo bar"));
-});
-
-test("normalize strips ANSI before hashing", () => {
-  assert.equal(normalize("err\x1b[31m fatal\x1b[0m"), normalize("err fatal"));
-});
-
-// --- Bloom accelerator ------------------------------------------------------
-
-test("bloom miss short-circuits the scan; hit is confirmed by query", () => {
-  const { s, dir } = store();
-  const raw = "the region text under test for bloom behavior";
-  s.add({ sessionId: "sess_bloom", summary: "x", regionText: raw, timestamp: 1 });
-  const bloom = openBloom(dir);
-  // content_hash for `raw` is present → hit path must confirm via query and dedup.
-  assert.equal(bloom.maybeHas("this-key-is-not-present"), false); // definitive miss
-  const r2 = s.add({ sessionId: "sess_bloom", summary: "x", regionText: raw, timestamp: 2 });
-  assert.equal(r2.deduped, true);
-  assert.equal(r2.reason, "contentHash");
-});
-
-test("bloom persists to disk and reloads warm", () => {
-  const dir = join(baseTmp, `run-${counter++}`);
-  const s1 = new VectorStore({ stateDir: dir });
-  s1.add({ sessionId: "sess_persist", summary: "x", regionText: "persisted region", timestamp: 1 });
-  closeBloom(dir); // evict cache so the next open reads from disk
-  const s2 = new VectorStore({ stateDir: dir });
-  const r = s2.add({ sessionId: "sess_persist", summary: "x", regionText: "persisted region", timestamp: 2 });
-  assert.equal(r.deduped, true);
-});
-
-// --- Atomic write + QA #13 timeout degrade ---------------------------------
-
-test("duplicate add is idempotent (no partial rows, single checkpoint)", () => {
-  const { s } = store();
-  const raw = "idempotent region content for atomicity check";
-  const a = s.add({ sessionId: "sess_atom", summary: "x", regionText: raw, timestamp: 1 });
-  const b = s.add({ sessionId: "sess_atom", summary: "x", regionText: raw, timestamp: 2 });
-  assert.equal(a.deduped, false);
-  assert.equal(b.deduped, true);
-  assert.equal(vectorList(s, "sess_atom").length, 1);
-});
-
-// --- Backfill orchestrator -------------------------------------------------
-
-test("backfill populates null content_hash rows and is idempotent", () => {
-  const dir = join(baseTmp, `run-${counter++}`);
-  openStore(dir);
-  // Seed two rows with null content_hash via direct upsert (simulating legacy data).
-  const cp = (id: string, summary: string): StoredCheckpoint => ({
-    checkpointId: id,
-    sessionId: "sess_bf",
-    summary,
-    keyDecisions: [],
-    nextSteps: [],
-    filesModified: [],
-    tokenEstimate: 0,
-    regionHash: "r",
-    embedding: [0, 0, 0],
-    timestamp: 1,
-  });
-  upsertCheckpoint(cp("chkpt_001", "alpha summary"), dir);
-  upsertCheckpoint(cp("chkpt_002", "beta summary"), dir);
-
-  const r1 = backfillContentHashes(dir);
-  assert.equal(r1.updated, 2);
-  assert.equal(r1.processed, 2);
-  assert.equal(isBackfillComplete(dir), true);
-
-  // Second run is a no-op (idempotent): no rows left to process.
-  const r2 = backfillContentHashes(dir);
-  assert.equal(r2.processed, 0);
-});
-
-test("backfill resolves a content_hash collision keeping the oldest row", () => {
-  const dir = join(baseTmp, `run-${counter++}`);
-  openStore(dir);
-  // Both rows share the same normalized summary → same content_hash.
-  const cp = (id: string): StoredCheckpoint => ({
-    checkpointId: id,
-    sessionId: "sess_dup",
-    summary: "identical normalized summary text",
-    keyDecisions: [],
-    nextSteps: [],
-    filesModified: [],
-    tokenEstimate: 0,
-    regionHash: "r",
-    embedding: [0, 0, 0],
-    timestamp: 1,
-  });
-  upsertCheckpoint(cp("chkpt_001"), dir);
-  upsertCheckpoint(cp("chkpt_002"), dir);
-  const r = backfillContentHashes(dir);
-  assert.equal(r.duplicatesResolved, 1);
-  assert.equal(r.updated, 1);
-});
-
-// --- Integrity checks ------------------------------------------------------
-
-test("integrity flags a tampered storedRegionHashes set", () => {
-  const dir = join(baseTmp, `run-${counter++}`);
-  const s = new VectorStore({ stateDir: dir });
-  s.add({ sessionId: "sess_int", summary: "x", regionText: "integrity region one", timestamp: 1 });
-  s.add({ sessionId: "sess_int", summary: "y", regionText: "integrity region two", timestamp: 2 });
-  const okReport = checkSessionIntegrity("sess_int", dir);
-  assert.equal(okReport.ok, true); // consistent after normal adds
-
-  // Simulate tampering: the sentinel stores a region hash the checkpoints lack.
-  const db = openStore(dir);
-  db.prepare(
-    "UPDATE session_state SET stored_region_hashes = ? WHERE session_id = ?",
-  ).run(JSON.stringify(["deadbeefcafe0000"]), "sess_int");
-  const tampered = checkSessionIntegrity("sess_int", dir);
-  assert.equal(tampered.ok, false);
-  assert.equal(tampered.regionHashMismatch, true);
-});
-
-test("integrity detects an orphan injectedCheckpointId", () => {
-  const dir = join(baseTmp, `run-${counter++}`);
-  const s = new VectorStore({ stateDir: dir });
-  s.add({ sessionId: "sess_orphan", summary: "x", regionText: "orphan region", timestamp: 1 });
-  // Manually inject a dangling id into session state (SQLite-backed).
-  const st = loadSessionState("sess_orphan", dir);
-  st.injectedCheckpointIds.push("chkpt_999");
-  saveSessionState("sess_orphan", st, dir);
-  const report = checkSessionIntegrity("sess_orphan", dir);
-  assert.equal(report.ok, false);
-  assert.deepEqual(report.orphanInjectedIds, ["chkpt_999"]);
-});
-
-test("checkAllIntegrity covers every session", () => {
-  const dir = join(baseTmp, `run-${counter++}`);
-  const s = new VectorStore({ stateDir: dir });
-  s.add({ sessionId: "sess_a", summary: "x", regionText: "a region", timestamp: 1 });
-  s.add({ sessionId: "sess_b", summary: "y", regionText: "b region", timestamp: 1 });
-  const reports = checkAllIntegrity(dir);
-  assert.equal(reports.length, 2);
-  assert.ok(reports.every((r: { ok: boolean }) => r.ok));
-});
-
-// --- schema migration (v0.4.2: original_token_estimate) -------------------
-
-test("Sprint 10 migration: pre-0.4.2 db gains original_token_estimate and repoStats works", () => {
-  const dir = join(baseTmp, `run-${counter++}`);
-  // Simulate a v0.4.1-era store: openStore() builds the full current schema,
-  // then drop the original_token_estimate column that 0.4.2 added. CREATE TABLE
-  // IF NOT EXISTS is a no-op on an existing table, which is exactly why the
-  // shipped v0.4.2 crashed at runtime on old repos ("no such column").
-  const db = openStore(dir);
-  db.exec("ALTER TABLE context_chunks DROP COLUMN original_token_estimate;");
-  closeStore(dir);
-
-  // Re-open through the real code path — must ALTER the column in, not crash.
-  const vs = new VectorStore({ dedupSim: 0.9, stateDir: dir });
-  vs.add({
-    sessionId: "sess_mig",
-    summary: "legacy region",
-    regionText: "some region text to compact",
-    tokenEstimate: 100,
-    originalTokenEstimate: 500,
-    timestamp: 1,
-  });
-  const repo = vectorRepoStats(vs);
-  // No "no such column" crash = migration succeeded; totals reflect the new col.
-  assert.equal(repo.checkpointCount, 1);
-  assert.equal(repo.originalTokens, 500, "originalTokens read from migrated column");
-  // Re-open a second time to prove idempotency (column already exists).
-  closeStore(dir);
-  const vs2 = new VectorStore({ dedupSim: 0.9, stateDir: dir });
-  assert.equal(vectorRepoStats(vs2).originalTokens, 500, "stable across re-open");
-});
-
-// --- cleanup ---------------------------------------------------------------
-
-test("Sprint 10 cleanup", () => {
-  closeStore(baseTmp);
-  rmSync(baseTmp, { recursive: true, force: true });
-});