pi-mega-compact 0.11.4 → 0.11.5

package/dist/src/store/turns/sqlite-store.test.js

@@ -1,144 +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";
-// ── 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;
-    let store;
-    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
-            .db.prepare("PRAGMA journal_mode")
-            .get();
-        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 = {
-                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 = {
-            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 = {
-            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/dist/src/store/vectorIndex.test.js

@@ -1,123 +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, magnitude = 1) {
-    const v = new Array(EMBEDDING_DIM).fill(0);
-    v[idx % EMBEDDING_DIM] = magnitude;
-    return v;
-}
-function isolateIndexDir() {
-    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/dist/src/store.test.js

@@ -1,161 +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(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(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 });
-});

package/dist/src/supersede.test.js

@@ -1,36 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { findSuperseded, supersede } from "./supersede.js";
-function msg(role, text) { return { role, text }; }
-test("read superseded by later write to same path is pruned", () => {
-    const messages = [
-        msg("assistant", "read src/server.ts"),
-        msg("user", "now change it"),
-        msg("assistant", "write src/server.ts with the fix"),
-    ];
-    assert.deepEqual(findSuperseded(messages), [0]);
-});
-test("older read superseded by newer read of same path (keep latest)", () => {
-    const messages = [
-        msg("assistant", "read src/a.ts"),
-        msg("assistant", "read src/a.ts again"),
-    ];
-    assert.deepEqual(findSuperseded(messages), [0]);
-});
-test("unrelated reads are kept", () => {
-    const messages = [
-        msg("assistant", "read src/a.ts"),
-        msg("assistant", "read src/b.ts"),
-    ];
-    assert.deepEqual(findSuperseded(messages), []);
-});
-test("supersede() drops the obsolete read and preserves order", () => {
-    const messages = [
-        msg("assistant", "read src/server.ts"),
-        msg("user", "change it"),
-        msg("assistant", "write src/server.ts done"),
-    ];
-    const out = supersede(messages);
-    assert.equal(out.length, 2);
-    assert.equal(out[0].text, "change it");
-});

package/dist/src/topics/cluster.test.js

@@ -1,150 +0,0 @@
-/**
- * cluster.test.ts — S51A clustering + labeling tests. No network, temp dirs.
- * Includes the honest-boundary grep-asserts (no ollama/llm/fetch, no fabricated
- * keyword literals) required by the s47/s51 acceptance criteria.
- */
-import { test, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, readFileSync, readdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { openStore } from "../store/sqlite/utils.js";
-import { upsertCheckpoint } from "../store/sqlite/checkpoints.js";
-import { loadEmbeddings, buildTopicModel, DEFAULT_CLUSTER_CONFIG } from "./cluster.js";
-import { tfidfScores, membershipConfidence } from "./labels.js";
-let tmpDir;
-let counter = 0;
-beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "mc-topics-"));
-});
-afterEach(() => {
-    rmSync(tmpDir, { recursive: true, force: true });
-});
-function stateDir() {
-    return join(tmpDir, `run-${counter++}`);
-}
-/** Unit vector along axis `axis` (dim = total dims). */
-function axisVec(axis, dim) {
-    const v = new Array(dim).fill(0);
-    v[axis] = 1;
-    return v;
-}
-function cp(id, text, embedding, session = "sess_t") {
-    return {
-        checkpointId: id,
-        sessionId: session,
-        summary: text,
-        normalizedText: text,
-        keyDecisions: [],
-        nextSteps: [],
-        filesModified: [],
-        tokenEstimate: 0,
-        regionHash: "r",
-        embedding,
-        timestamp: 1,
-    };
-}
-/** Seed N clusters of M chunks each: cluster i sits near axis i with distinct terms. */
-function seedClusters(dir, clusters, perCluster, dim) {
-    openStore(dir);
-    const terms = ["sqlite", "wal", "checkpoint", "recovery", "backup", "replay", "fork", "merge"];
-    for (let c = 0; c < clusters; c++) {
-        for (let m = 0; m < perCluster; m++) {
-            // Near-axis vector with slight per-member jitter (stays closest to its axis).
-            const v = axisVec(c, dim).map((x, i) => x + (i === c ? 0 : (m + 1) * 1e-4 * (i + 1)));
-            const term = terms[(c * 2) % terms.length];
-            const term2 = terms[(c * 2 + 1) % terms.length];
-            upsertCheckpoint(cp(`chkpt_c${c}_${m}`, `${term} ${term2} work item ${m} details`, v), dir);
-        }
-    }
-}
-test("loadEmbeddings returns only chunks with embeddings + text", () => {
-    const dir = stateDir();
-    openStore(dir);
-    upsertCheckpoint(cp("a", "hello world", axisVec(0, 4)), dir);
-    upsertCheckpoint(cp("b", "", axisVec(1, 4)), dir); // empty text → skipped
-    upsertCheckpoint(cp("c", "no embedding here", [], "sess_t"), dir); // empty embedding → skipped
-    const chunks = loadEmbeddings(openStore(dir));
-    assert.equal(chunks.length, 1);
-    assert.equal(chunks[0].chunkId, "a");
-    assert.equal(chunks[0].text, "hello world");
-});
-test("buildTopicModel finds 3 well-separated clusters (silhouette picks k=3)", () => {
-    const dir = stateDir();
-    seedClusters(dir, 3, 6, 8); // 18 chunks, 3 tight clusters
-    const model = buildTopicModel(openStore(dir), { ...DEFAULT_CLUSTER_CONFIG, kRange: [2, 5] });
-    assert.equal(model.totalChunks, 18);
-    assert.equal(model.k, 3);
-    assert.equal(model.topics.length, 3);
-    // Every chunk assigned; assignment count == chunk count.
-    assert.equal(model.assignments.length, 18);
-    // Labels reflect the seeded discriminative terms (sqlite/wal, checkpoint/recovery, backup/replay).
-    const labels = model.topics.map((t) => t.label).join(" | ");
-    assert.ok(/sqlite|checkpoint|backup/.test(labels), `labels should carry seeded terms: ${labels}`);
-});
-test("corpus too small → single general cluster, no crash", () => {
-    const dir = stateDir();
-    openStore(dir);
-    upsertCheckpoint(cp("only", "lone chunk about sqlite", axisVec(0, 4)), dir);
-    const model = buildTopicModel(openStore(dir), DEFAULT_CLUSTER_CONFIG); // kRange[0]=3 > 1 chunk
-    assert.equal(model.k, 1);
-    assert.equal(model.topics.length, 1);
-    assert.equal(model.topics[0].memoryCount, 1);
-    assert.equal(model.silhouetteScore, null);
-});
-test("empty corpus → zero topics, no crash", () => {
-    const dir = stateDir();
-    openStore(dir);
-    const model = buildTopicModel(openStore(dir), DEFAULT_CLUSTER_CONFIG);
-    assert.equal(model.k, 0);
-    assert.equal(model.topics.length, 0);
-    assert.equal(model.assignments.length, 0);
-});
-test("tfidfScores surfaces discriminative terms, down-weights common ones", () => {
-    const mk = (text) => ({
-        chunkId: text, sessionId: "s", vec: [1], text,
-    });
-    const corpus = [
-        mk("sqlite wal sqlite pragma"),
-        mk("sqlite wal journal"),
-        mk("react component render"),
-        mk("react hooks state"),
-    ];
-    const members = corpus.slice(0, 2); // the sqlite cluster
-    const scores = tfidfScores(members, corpus);
-    const top = scores[0]?.term;
-    assert.ok(top === "sqlite" || top === "wal", `top term should be discriminative, got ${top}`);
-    // 'react' never appears in members → not scored for this cluster.
-    assert.ok(!scores.some((s) => s.term === "react"));
-});
-test("membershipConfidence maps cosine [-1,1] → [0,1]", () => {
-    assert.equal(membershipConfidence(1), 1);
-    assert.equal(membershipConfidence(-1), 0);
-    assert.equal(membershipConfidence(0), 0.5);
-});
-test("buildTopicModel is deterministic for a fixed seed", () => {
-    const dir = stateDir();
-    seedClusters(dir, 3, 5, 8);
-    const db = openStore(dir);
-    const a = buildTopicModel(db, { ...DEFAULT_CLUSTER_CONFIG, kRange: [2, 5] });
-    const b = buildTopicModel(db, { ...DEFAULT_CLUSTER_CONFIG, kRange: [2, 5] });
-    assert.equal(a.k, b.k);
-    assert.deepEqual(a.topics.map((t) => t.label).sort(), b.topics.map((t) => t.label).sort());
-});
-test("honest boundary: no LLM/Ollama/network/keyword-literals in src/topics", () => {
-    const here = dirname(fileURLToPath(import.meta.url));
-    const srcTopics = join(here, "..", "..", "..", "src", "topics"); // dist/src/topics → src/topics
-    const files = readdirSync(srcTopics).filter((f) => f.endsWith(".ts") && !f.endsWith(".test.ts"));
-    const banned = [/ollama/i, /\bllm\b/i, /\bfetch\s*\(/, /\bhybrid\b/i];
-    const fabricated = ["graphql", "docker", "stacktrace", "bottleneck", "trade-off"];
-    for (const f of files) {
-        const text = readFileSync(join(srcTopics, f), "utf8");
-        for (const re of banned) {
-            assert.ok(!re.test(text), `${f} must not contain ${re} (PREVENT-PI-004 / no-LLM boundary)`);
-        }
-        for (const word of fabricated) {
-            assert.ok(!text.toLowerCase().includes(`"${word}"`), `${f} must not hardcode fabricated taxonomy term "${word}"`);
-        }
-    }
-});