pi-mega-compact 0.11.3 → 0.11.5

package/src/store/turns/migrations.test.ts

@@ -1,161 +0,0 @@
-/**
- * migrations.test.ts — S49B main-db → turns.db migration tests.
- *
- * Seeds a legacy main sqlite.db (with S48-era turn tables + session_state
- * conversation pointers), then opens the turns store and asserts rows moved,
- * legacy dropped, and the move is idempotent + flag-gated. No network.
- */
-
-import { test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { DatabaseSync } from "node:sqlite";
-import { openTurnStore, closeTurnStore } from "./connection.js";
-import { TurnsConfig } from "../../config/turns.js";
-
-let tmpDir: string;
-let counter = 0;
-
-beforeEach(() => {
-	tmpDir = mkdtempSync(join(tmpdir(), "mc-migrate-"));
-});
-
-afterEach(() => {
-	rmSync(tmpDir, { recursive: true, force: true });
-});
-
-function stateDir(): string {
-	return join(tmpDir, `run-${counter++}`);
-}
-
-/** Seed a legacy main db with S48-era turn tables + a conversation pointer. */
-function seedLegacyMainDb(dir: string): void {
-	mkdirSync(dir, { recursive: true });
-	const db = new DatabaseSync(join(dir, "sqlite.db"));
-	db.exec(`
-    CREATE TABLE turns (
-      id INTEGER PRIMARY KEY AUTOINCREMENT, conversation_id TEXT NOT NULL,
-      session_id TEXT NOT NULL, turn_index INTEGER NOT NULL, role TEXT,
-      started_at INTEGER NOT NULL, ended_at INTEGER, ctx_tokens INTEGER,
-      ctx_percent REAL, pressure_band TEXT, model_id TEXT, epoch_id TEXT,
-      UNIQUE(session_id, turn_index)
-    );
-    CREATE TABLE turn_recall (
-      id INTEGER PRIMARY KEY AUTOINCREMENT, turn_id INTEGER NOT NULL,
-      checkpoint_id TEXT NOT NULL, score REAL NOT NULL, source TEXT NOT NULL,
-      raptor_level INTEGER, UNIQUE(turn_id, checkpoint_id)
-    );
-    CREATE TABLE conversation_branches (
-      conversation_id TEXT PRIMARY KEY, parent_conversation_id TEXT NOT NULL,
-      fork_turn_id INTEGER NOT NULL, created_at INTEGER NOT NULL
-    );
-    CREATE TABLE session_state (
-      session_id TEXT PRIMARY KEY, injected_checkpoint_ids TEXT,
-      stored_region_hashes TEXT, conversation_id TEXT, last_turn_id INTEGER
-    );
-    INSERT INTO turns (conversation_id, session_id, turn_index, started_at, ended_at, ctx_tokens)
-      VALUES ('conv_leg', 'sess_leg', 0, 100, 200, 500);
-    INSERT INTO turn_recall (turn_id, checkpoint_id, score, source)
-      VALUES (1, 'cp_leg', 0.6, 'flat');
-    INSERT INTO conversation_branches (conversation_id, parent_conversation_id, fork_turn_id, created_at)
-      VALUES ('conv_child', 'conv_leg', 1, 300);
-    INSERT INTO session_state (session_id, conversation_id) VALUES ('sess_leg', 'conv_leg');
-  `);
-	db.close();
-}
-
-function tableExists(db: DatabaseSync, name: string): boolean {
-	return (
-		db
-			.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?")
-			.get(name) !== undefined
-	);
-}
-
-test("fresh dir (no main db) → no-op, marks migrated", () => {
-	const dir = stateDir();
-	const db = openTurnStore(dir);
-	// openTurnStore ran the migration hook; with no sqlite.db it should just mark.
-	const row = db
-		.prepare("SELECT value FROM turns_meta WHERE key='migrated_from_main'")
-		.get() as { value: string } | undefined;
-	assert.equal(row?.value, "1");
-	closeTurnStore(dir);
-});
-
-test("legacy rows moved, legacy tables dropped, conversation pointer migrated", () => {
-	const dir = stateDir();
-	seedLegacyMainDb(dir);
-	const db = openTurnStore(dir); // triggers migration
-
-	// Rows present in turns.db.
-	const turns = db.prepare("SELECT * FROM turns").all() as Array<
-		Record<string, unknown>
-	>;
-	assert.equal(turns.length, 1);
-	assert.equal(turns[0].conversation_id, "conv_leg");
-	const recall = db.prepare("SELECT * FROM turn_recall").all() as Array<
-		Record<string, unknown>
-	>;
-	assert.equal(recall.length, 1);
-	assert.equal(recall[0].checkpoint_id, "cp_leg");
-	const branches = db
-		.prepare("SELECT * FROM conversation_forks")
-		.all() as Array<Record<string, unknown>>;
-	assert.equal(branches.length, 1);
-	assert.equal(branches[0].parent_conversation_id, "conv_leg");
-	assert.equal(branches[0].child_conversation_id, "conv_child");
-	assert.equal(branches[0].fork_turn_index, 1);
-	// Conversation pointer migrated to session_conversations (session_id → conversation_id).
-	const ptr = db
-		.prepare(
-			"SELECT conversation_id FROM session_conversations WHERE session_id='sess_leg'",
-		)
-		.get() as { conversation_id: string } | undefined;
-	assert.equal(ptr?.conversation_id, "conv_leg");
-
-	closeTurnStore(dir);
-
-	// Legacy tables dropped from the main db.
-	const main = new DatabaseSync(join(dir, "sqlite.db"));
-	assert.ok(!tableExists(main, "turns"));
-	assert.ok(!tableExists(main, "turn_recall"));
-	assert.ok(!tableExists(main, "conversation_branches"));
-	assert.ok(tableExists(main, "session_state")); // left intact
-	main.close();
-});
-
-test("idempotent: re-open does not re-copy or re-drop", () => {
-	const dir = stateDir();
-	seedLegacyMainDb(dir);
-	openTurnStore(dir);
-	closeTurnStore(dir);
-	// Second open — marker set, should be a no-op even though main db now lacks turn tables.
-	const db = openTurnStore(dir);
-	const turns = db.prepare("SELECT * FROM turns").all() as Array<
-		Record<string, unknown>
-	>;
-	assert.equal(turns.length, 1); // still exactly the migrated row, not duplicated
-	closeTurnStore(dir);
-});
-
-test("flag OFF → legacy tables untouched, no marker write from hook", () => {
-	const dir = stateDir();
-	seedLegacyMainDb(dir);
-	const original = TurnsConfig.TURNS_DB_ENABLED;
-	TurnsConfig.TURNS_DB_ENABLED = false;
-	try {
-		const db = openTurnStore(dir);
-		closeTurnStore(dir);
-		void db;
-	} finally {
-		TurnsConfig.TURNS_DB_ENABLED = original;
-	}
-	// Main db turn tables must be intact (migration hook was gated off).
-	const main = new DatabaseSync(join(dir, "sqlite.db"));
-	assert.ok(tableExists(main, "turns"));
-	assert.ok(tableExists(main, "conversation_branches"));
-	main.close();
-});

package/src/store/turns/sqlite-store.test.ts

@@ -1,161 +0,0 @@
-/**
- * sqlite-store.test.ts — SqliteTurnStore compliance + SQLite-specific tests.
- *
- * Compliance: shared suite run in-memory (fast).
- * SQLite-specific: file-backed tests verifying:
- *   - Separate turns.db (not sqlite.db)
- *   - WAL mode active
- *   - Connection caching (same path → same connection)
- *   - dbSizeBytes reports file size
- *   - File persistence across store instances
- */
-
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { existsSync, statSync, rmSync, mkdtempSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { SqliteTurnStore } from "./sqlite-store.js";
-import { runComplianceSuite } from "./contract-compliance.test.js";
-import { closeAllTurnDbs } from "./connection.js";
-import type { TurnEntry } from "./types.js";
-
-// ── Compliance suite (in-memory, fast) ──────────────────────────
-
-runComplianceSuite(
-	"SqliteTurnStore",
-	(options) => new SqliteTurnStore(options),
-	{ stateDir: join(tmpdir(), "turns-compliance-sqlite"), inMemory: true },
-);
-
-// ── SQLite-specific file-backed tests ───────────────────────────
-
-describe("SqliteTurnStore — file-backed", () => {
-	let stateDir: string;
-	let store: SqliteTurnStore;
-
-	beforeEach(() => {
-		closeAllTurnDbs(); // clear any cached connections
-		stateDir = mkdtempSync(join(tmpdir(), "turns-file-"));
-		store = new SqliteTurnStore({ stateDir });
-	});
-
-	afterEach(() => {
-		try {
-			store.close();
-		} catch {
-			// best-effort
-		}
-		closeAllTurnDbs();
-		try {
-			rmSync(stateDir, { recursive: true, force: true });
-		} catch {
-			// best-effort
-		}
-	});
-
-	it("creates turns.db separate from sqlite.db", () => {
-		const turnsDbPath = join(stateDir, "turns.db");
-		assert.ok(existsSync(turnsDbPath), "turns.db should exist");
-
-		// sqlite.db should NOT be created by the turns store
-		const sqliteDbPath = join(stateDir, "sqlite.db");
-		assert.ok(!existsSync(sqliteDbPath), "sqlite.db should NOT be created");
-	});
-
-	it("uses WAL journal mode", () => {
-		const row = (store as unknown as { db: { prepare: (s: string) => { get: () => unknown } } })
-			.db.prepare("PRAGMA journal_mode")
-			.get() as { journal_mode: string };
-		assert.equal(row.journal_mode, "wal");
-	});
-
-	it("caches connections for the same path", () => {
-		// Creating a second store with the same stateDir should reuse
-		// the cached connection (not create a new file lock conflict)
-		const store2 = new SqliteTurnStore({ stateDir });
-		try {
-			// Both should be able to write without locking errors
-			const entry: TurnEntry = {
-				conversationId: "conv_cache",
-				sessionId: "sess_cache",
-				turnIndex: 0,
-				role: "assistant",
-				endedAt: Date.now(),
-			};
-			store.asWriter().appendTurn(entry);
-			store2.asWriter().appendTurn({
-				...entry,
-				turnIndex: 1,
-			});
-
-			assert.equal(store.asReader().countTurns("conv_cache"), 2);
-		} finally {
-			store2.close();
-		}
-	});
-
-	it("reports dbSizeBytes for file-backed store", () => {
-		const entry: TurnEntry = {
-			conversationId: "conv_size",
-			sessionId: "sess_size",
-			turnIndex: 0,
-			role: "assistant",
-			endedAt: Date.now(),
-		};
-		store.asWriter().appendTurn(entry);
-
-		// prune returns a PruneReport with freedBytes; we can also
-		// verify the file exists and has content
-		const turnsDbPath = join(stateDir, "turns.db");
-		const size = statSync(turnsDbPath).size;
-		assert.ok(size > 0, "turns.db should have non-zero size after writes");
-	});
-
-	it("persists data across store instances", () => {
-		const entry: TurnEntry = {
-			conversationId: "conv_persist",
-			sessionId: "sess_persist",
-			turnIndex: 0,
-			role: "assistant",
-			endedAt: Date.now(),
-			model: "test-model",
-		};
-		store.asWriter().appendTurn(entry);
-		store.close();
-		closeAllTurnDbs();
-
-		// Re-open the same stateDir
-		const store2 = new SqliteTurnStore({ stateDir });
-		try {
-			const turns = store2.asReader().query({ conversationId: "conv_persist" });
-			assert.equal(turns.length, 1);
-			assert.equal(turns[0].model, "test-model");
-		} finally {
-			store2.close();
-			closeAllTurnDbs();
-		}
-	});
-
-	it("supports custom dbPath", () => {
-		const customPath = join(stateDir, "custom-turns.db");
-		const customStore = new SqliteTurnStore({
-			stateDir,
-			dbPath: customPath,
-		});
-		try {
-			assert.ok(existsSync(customPath), "custom db path should be created");
-			customStore.asWriter().appendTurn({
-				conversationId: "conv_custom",
-				sessionId: "sess_custom",
-				turnIndex: 0,
-				role: "user",
-				endedAt: Date.now(),
-			});
-			assert.equal(customStore.asReader().countTurns("conv_custom"), 1);
-		} finally {
-			customStore.close();
-			closeAllTurnDbs();
-		}
-	});
-});

package/src/store/vectorIndex.test.ts

@@ -1,140 +0,0 @@
-/**
- * vectorIndex.test.ts — Slice 2 async PGlite/HNSW vector index.
- *
- * Proves: cross-repo nearest-neighbor recall, repoId scoping, the dimension
- * guard (non-512 vectors skipped, never corrupt the index), and graceful
- * degradation when the index is disabled (kill-switch) — all without touching
- * the synchronous node:sqlite store.
- *
- * The index is a WASM Postgres (PGlite) — fully local, zero network
- * (PREVENT-PI-004). Each test isolates state via MEGACOMPACT_VECTOR_INDEX_DIR.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-  EMBEDDING_DIM,
-  initVectorIndex,
-  upsertEmbedding,
-  searchAsync,
-  closeVectorIndex,
-  isVectorIndexDisabled,
-} from "./vectorIndex.js";
-
-/** A 512-dim unit-ish vector with a single spike at `idx` (deterministic NN). */
-function spikeVec(idx: number, magnitude = 1): number[] {
-  const v = new Array<number>(EMBEDDING_DIM).fill(0);
-  v[idx % EMBEDDING_DIM] = magnitude;
-  return v;
-}
-
-function isolateIndexDir(): string {
-  const dir = mkdtempSync(join(tmpdir(), "mc-vecidx-"));
-  process.env.MEGACOMPACT_VECTOR_INDEX_DIR = dir;
-  return dir;
-}
-
-test("cross-repo HNSW nearest-neighbor recall across repos + repoId scoping", async () => {
-  delete process.env.MEGACOMPACT_PGLITE_DISABLED;
-  const dir = isolateIndexDir();
-  try {
-    await closeVectorIndex(); // ensure a fresh singleton for this dir
-    const pg = await initVectorIndex();
-    assert.ok(pg, "index should initialize (PGlite WASM available)");
-
-    // repoA: two checkpoints; repoB: one checkpoint. Distinct spike directions.
-    await upsertEmbedding("/repoA/.pi/mega-compact", "sessA", "chkpt_001", spikeVec(0));
-    await upsertEmbedding("/repoA/.pi/mega-compact", "sessA", "chkpt_002", spikeVec(5));
-    await upsertEmbedding("/repoB/.pi/mega-compact", "sessB", "chkpt_001", spikeVec(0));
-
-    // Cross-repo query near spike(0): nearest are the two spike(0) rows, one per repo.
-    const cross = await searchAsync(spikeVec(0), { k: 2 });
-    assert.equal(cross.length, 2, "cross-repo returns two nearest");
-    const repos = new Set(cross.map((h) => h.repoId));
-    assert.ok(repos.has("/repoA/.pi/mega-compact"), "hit from repoA");
-    assert.ok(repos.has("/repoB/.pi/mega-compact"), "hit from repoB");
-    assert.ok(cross[0].score > 0.99, "top hit is near-identical (cosine ~1)");
-
-    // Scoped to repoA only: excludes repoB even though repoB has an identical vec.
-    const scoped = await searchAsync(spikeVec(0), { k: 5, repoId: "/repoA/.pi/mega-compact" });
-    assert.ok(scoped.length >= 1, "scoped returns repoA hits");
-    assert.ok(
-      scoped.every((h) => h.repoId === "/repoA/.pi/mega-compact"),
-      "repoId filter excludes other repos",
-    );
-  } finally {
-    await closeVectorIndex();
-    rmSync(dir, { recursive: true, force: true });
-    delete process.env.MEGACOMPACT_VECTOR_INDEX_DIR;
-  }
-});
-
-test("dimension guard: non-512 vectors are skipped, never corrupt the index", async () => {
-  delete process.env.MEGACOMPACT_PGLITE_DISABLED;
-  const dir = isolateIndexDir();
-  try {
-    await closeVectorIndex();
-    await initVectorIndex();
-    // Wrong-dimension vector (BYO embedder mismatch) must be silently skipped.
-    await upsertEmbedding("/repoC/.pi/mega-compact", "sessC", "chkpt_001", [1, 2, 3]);
-    const hits = await searchAsync(spikeVec(0), { k: 5 });
-    assert.equal(hits.length, 0, "no rows stored for a mismatched-dim vector");
-
-    // A correct-dim vector still stores fine afterward (index not corrupted).
-    await upsertEmbedding("/repoC/.pi/mega-compact", "sessC", "chkpt_002", spikeVec(3));
-    const ok = await searchAsync(spikeVec(3), { k: 1 });
-    assert.equal(ok.length, 1, "valid vector stored after a skipped one");
-    assert.equal(ok[0].checkpointId, "chkpt_002");
-  } finally {
-    await closeVectorIndex();
-    rmSync(dir, { recursive: true, force: true });
-    delete process.env.MEGACOMPACT_VECTOR_INDEX_DIR;
-  }
-});
-
-test("corrupt-dir self-heal: torn PGlite dir is deleted + retried, never crashes", async () => {
-  delete process.env.MEGACOMPACT_PGLITE_DISABLED;
-  const dir = isolateIndexDir();
-  try {
-    await closeVectorIndex();
-    // Tear the dir: garbage bytes where PGlite expects its data/ files.
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, "data"), Buffer.from([0xde, 0xad, 0xbe, 0xef, 0xde, 0xad]));
-    // openPgLite(retryOnCorrupt=true) deletes + retries; if that still fails it
-    // disables gracefully. Either path must NOT throw.
-    const pg = await initVectorIndex();
-    assert.ok(pg, "index self-healed after corruption ");
-    // And the index works after heal: upsert + search round-trip.
-    await upsertEmbedding("/repoE/.pi/mega-compact", "sessE", "chkpt_001", spikeVec(7));
-    const hits = await searchAsync(spikeVec(7), { k: 1 });
-    assert.equal(hits.length, 1, "search works on the healed index");
-    assert.equal(hits[0].checkpointId, "chkpt_001");
-  } finally {
-    await closeVectorIndex();
-    rmSync(dir, { recursive: true, force: true });
-    delete process.env.MEGACOMPACT_VECTOR_INDEX_DIR;
-  }
-});
-
-test("kill-switch: MEGACOMPACT_PGLITE_DISABLED disables the index gracefully", async () => {
-  const dir = isolateIndexDir();
-  process.env.MEGACOMPACT_PGLITE_DISABLED = "true";
-  try {
-    await closeVectorIndex();
-    assert.equal(isVectorIndexDisabled(), true, "kill-switch reported disabled");
-    const pg = await initVectorIndex();
-    assert.equal(pg, undefined, "init returns undefined when disabled");
-    // Upsert + search are no-ops that never throw and return empty.
-    await upsertEmbedding("/repoD/.pi/mega-compact", "sessD", "chkpt_001", spikeVec(0));
-    const hits = await searchAsync(spikeVec(0), { k: 3 });
-    assert.deepEqual(hits, [], "search returns [] when disabled");
-  } finally {
-    delete process.env.MEGACOMPACT_PGLITE_DISABLED;
-    await closeVectorIndex();
-    rmSync(dir, { recursive: true, force: true });
-    delete process.env.MEGACOMPACT_VECTOR_INDEX_DIR;
-  }
-});

package/src/store.test.ts

@@ -1,191 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { gzipSync } from "node:zlib";
-import {
-  compressSmart,
-  decompressSmart,
-  readGzJson,
-  writeGzJson,
-  normalizeSessionId,
-  nextCheckpointId,
-} from "./store.js";
-
-const baseTmp = mkdtempSync(join(tmpdir(), "mc-store-"));
-let counter = 0;
-function tmpDir() {
-  return join(baseTmp, `d-${counter++}`);
-}
-
-// ---------------------------------------------------------------------------
-// compressSmart / decompressSmart
-// ---------------------------------------------------------------------------
-
-test("compressSmart: tiny payload (<512B) uses RAW tier", () => {
-  const data = Buffer.from(JSON.stringify({ hello: "world" }));
-  assert.ok(data.length < 512);
-  const compressed = compressSmart(data);
-  // Versioned header: 0xEC 0x01 [version=1] [tier=0x00 RAW]; payload after byte 4.
-  assert.equal(compressed[0], 0xec, "magic hi");
-  assert.equal(compressed[1], 0x01, "magic lo / version marker");
-  assert.equal(compressed[2], 0x01, "format version 1");
-  assert.equal(compressed[3], 0x00, "tag RAW");
-  // Payload after the 4-byte header should be identical to original
-  assert.deepEqual(compressed.subarray(4), data);
-});
-
-test("compressSmart: medium payload (4KB–32KB) uses GZIP-6 tier", () => {
-  // ~8KB of repetitive text
-  const data = Buffer.from("the quick brown fox jumps over the lazy dog. ".repeat(180));
-  assert.ok(data.length >= 4096 && data.length < 32768);
-  const compressed = compressSmart(data);
-  // Versioned header + tier tag 0x02 (GZIP-6) at byte 3.
-  assert.equal(compressed[0], 0xec);
-  assert.equal(compressed[3], 0x02, "tag GZIP-6");
-  // Compressed should be smaller
-  assert.ok(compressed.length < data.length, "compressed smaller than raw");
-});
-
-test("compressSmart: large payload (>32KB) uses BROTLI tier", () => {
-  // ~40KB of repetitive text
-  const data = Buffer.from("this is a long summary of a coding session. ".repeat(900));
-  assert.ok(data.length >= 32768);
-  const compressed = compressSmart(data);
-  // Versioned header + tier tag 0x05 (BROTLI_4) at byte 3.
-  assert.equal(compressed[0], 0xec);
-  assert.equal(compressed[3], 0x05, "tag BROTLI_4");
-  // Compressed should be smaller
-  assert.ok(compressed.length < data.length, "brotli compressed smaller than raw");
-});
-
-test("compressSmart: small payload (512B–4KB) uses GZIP-1 tier", () => {
-  // ~1.5KB
-  const data = Buffer.from("a moderately sized summary with some repetition. ".repeat(30));
-  assert.ok(data.length >= 512 && data.length < 4096);
-  const compressed = compressSmart(data);
-  assert.equal(compressed[0], 0xec);
-  assert.equal(compressed[3], 0x01, "tag GZIP-1");
-});
-
-test("decompressSmart roundtrips all tiers", () => {
-  const sizes = [
-    { label: "tiny",   gen: () => Buffer.from("small") },
-    { label: "small",  gen: () => Buffer.from("x".repeat(600)) },
-    { label: "medium", gen: () => Buffer.from("y".repeat(8000)) },
-    { label: "large",  gen: () => Buffer.from("z".repeat(40000)) },
-  ];
-  for (const { label, gen } of sizes) {
-    const original = gen();
-    const compressed = compressSmart(original);
-    const decompressed = decompressSmart(compressed);
-    assert.deepEqual(decompressed, original, `roundtrip failed for ${label} (${original.length}B)`);
-  }
-});
-
-test("decompressSmart handles legacy untagged gzip files (backward compat)", () => {
-  const data = Buffer.from(JSON.stringify({ legacy: true }));
-  const legacyGzip = gzipSync(data); // no tag byte, starts with 0x1f
-  assert.equal(legacyGzip[0], 0x1f, "gzip magic byte present");
-  const result = decompressSmart(legacyGzip);
-  assert.deepEqual(JSON.parse(result.toString()), { legacy: true });
-});
-
-test("readGzJson / writeGzJson roundtrip with smart compression", () => {
-  const dir = tmpDir();
-  const path = join(dir, "test.json.gz");
-  const data = [{ id: "a", value: 42 }, { id: "b", value: 99 }];
-  writeGzJson(path, data);
-  const loaded = readGzJson<typeof data>(path, []);
-  assert.deepEqual(loaded, data);
-});
-
-test("readGzJson reads legacy gzip files written by old code", () => {
-  const dir = tmpDir();
-  const path = join(dir, "legacy.json.gz");
-  const data = { old: true };
-  // Simulate old writeGzJson (plain gzip, no tag)
-  mkdirSync(join(path, ".."), { recursive: true });
-  const buf = gzipSync(Buffer.from(JSON.stringify(data), "utf-8"));
-  writeFileSync(path, buf);
-
-  const loaded = readGzJson<typeof data>(path, { old: false });
-  assert.deepEqual(loaded, { old: true });
-});
-
-test("compression tier: GZIP-1 and GZIP-6 tiers produce valid, smaller output", () => {
-  // GZIP-1 tier (~600B input, 512B–4KB band)
-  const small = compressSmart(Buffer.from("compress me ".repeat(200)));
-  assert.equal(small[0], 0xec, "versioned magic");
-  assert.equal(small[3], 0x01, "GZIP-1 tag for small input");
-  assert.ok(small.length < 600, "GZIP-1 output smaller than input");
-  assert.deepEqual(decompressSmart(small), Buffer.from("compress me ".repeat(200)));
-
-  // GZIP-6 tier (~8KB input, 4KB–32KB band)
-  const big = compressSmart(Buffer.from("compress me ".repeat(1800)));
-  assert.equal(big[0], 0xec, "versioned magic");
-  assert.equal(big[3], 0x02, "GZIP-6 tag for medium input");
-  assert.ok(big.length < Buffer.from("compress me ".repeat(1800)).length, "GZIP-6 output smaller than input");
-  assert.deepEqual(decompressSmart(big), Buffer.from("compress me ".repeat(1800)));
-});
-
-test("Fix E: pressure escalates gzip tier strength (sync, no zstd)", () => {
-  const small = Buffer.from("compress me ".repeat(200)); // 512B–4KB band
-  const medium = Buffer.from("compress me ".repeat(1800)); // 4KB–32KB band
-
-  // Low pressure → cheap levels (gzip-1 / gzip-6).
-  const lowSmall = compressSmart(small, 0);
-  const lowMedium = compressSmart(medium, 0);
-  assert.equal(lowSmall[3], 0x01, "small tier tag");
-  assert.equal(lowMedium[3], 0x02, "medium tier tag");
-  assert.ok(decompressSmart(lowSmall).equals(small), "low-pressure small roundtrips");
-  assert.ok(decompressSmart(lowMedium).equals(medium), "low-pressure medium roundtrips");
-
-  // High pressure → stronger levels (gzip-9 / gzip-9); tag unchanged, output
-  // must still decode to the exact original (versioned header preserved).
-  const highSmall = compressSmart(small, 1);
-  const highMedium = compressSmart(medium, 1);
-  assert.equal(highSmall[3], 0x01, "tag unchanged under pressure");
-  assert.equal(highMedium[3], 0x02, "tag unchanged under pressure");
-  assert.ok(decompressSmart(highSmall).equals(small), "high-pressure small roundtrips");
-  assert.ok(decompressSmart(highMedium).equals(medium), "high-pressure medium roundtrips");
-});
-
-// ---------------------------------------------------------------------------
-// normalizeSessionId
-// ---------------------------------------------------------------------------
-
-test("normalizeSessionId adds sess_ prefix when missing", () => {
-  assert.equal(normalizeSessionId("abc"), "sess_abc");
-  assert.equal(normalizeSessionId("sess_abc"), "sess_abc");
-});
-
-// ---------------------------------------------------------------------------
-// nextCheckpointId
-// ---------------------------------------------------------------------------
-
-test("nextCheckpointId returns chkpt_001 for new session", () => {
-  const dir = tmpDir();
-  assert.equal(nextCheckpointId("sess_nci1", dir), "chkpt_001");
-});
-
-test("nextCheckpointId increments highest existing id", () => {
-  const dir = tmpDir();
-  const sid = "sess_nci2";
-  // Write a checkpoints file with two entries to simulate existing state
-  const fakeCheckpoints = [
-    { checkpointId: "chkpt_001", sessionId: "sess_nci2", summary: "a", keyDecisions: [], nextSteps: [], filesModified: [], tokenEstimate: 100, regionHash: "h1", embedding: [], timestamp: 1 },
-    { checkpointId: "chkpt_003", sessionId: "sess_nci2", summary: "b", keyDecisions: [], nextSteps: [], filesModified: [], tokenEstimate: 100, regionHash: "h2", embedding: [], timestamp: 2 },
-  ];
-  writeGzJson(join(dir, "sess_nci2.checkpoints.json.gz"), fakeCheckpoints);
-  assert.equal(nextCheckpointId(sid, dir), "chkpt_004");
-});
-
-// ---------------------------------------------------------------------------
-// cleanup
-// ---------------------------------------------------------------------------
-
-test("cleanup", () => {
-  rmSync(baseTmp, { recursive: true, force: true });
-});