pi-mega-compact 0.11.4 → 0.11.6

package/dist/src/store/pgOpenGuard.test.js

@@ -1,74 +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(() => {
-        /* deliberately never settles — the wedge */
-    });
-    const reasons = [];
-    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 = [];
-    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 = [];
-    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 = () => { };
-    const late = new Promise((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/dist/src/store/phase01.test.js

@@ -1,81 +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 = {}) {
-    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 = [];
-    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 = [];
-    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/dist/src/store/phase04.test.js

@@ -1,54 +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 = {}) {
-    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/dist/src/store/sprint10.test.js

@@ -1,186 +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";
-const baseTmp = mkdtempSync(join(tmpdir(), "mc-s10-"));
-let counter = 0;
-function store(opts = {}) {
-    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, summary) => ({
-        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) => ({
-        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) => 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 });
-});

package/dist/src/store/sqlite/game-achievements.test.js

@@ -1,67 +0,0 @@
-/**
- * game-achievements.test.ts — S35 game_achievements table + accessors.
- * Pi-agnostic. Uses an isolated state dir (never the real user dir — G7).
- */
-import { describe, it, before, after } from "node:test";
-import assert from "node:assert/strict";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { mkdtempSync, rmSync } from "node:fs";
-import { closeStore } from "./utils.js";
-import { listAchievements, getAchievement, isUnlocked, unlockAchievement, } from "./game-achievements.js";
-describe("game-achievements (S35)", () => {
-    let dir;
-    before(() => {
-        dir = mkdtempSync(join(tmpdir(), "mc-ach-"));
-        process.env.MEGACOMPACT_STATE_DIR = dir;
-    });
-    after(() => {
-        closeStore(dir);
-        delete process.env.MEGACOMPACT_STATE_DIR;
-        rmSync(dir, { recursive: true, force: true });
-    });
-    it("seeds exactly 9 rows on first open (idempotent)", () => {
-        const rows = listAchievements(dir);
-        assert.equal(rows.length, 9);
-        // re-open: seeding is idempotent, still 9, unlocked_at still null
-        const again = listAchievements(dir);
-        assert.equal(again.length, 9);
-        assert.ok(again.every((r) => r.unlocked_at == null));
-    });
-    it("ordering: visible rows sorted by id asc; opie hidden+locked present", () => {
-        const rows = listAchievements(dir);
-        const opie = rows.find((r) => r.id === "opie_wild_ride");
-        assert.ok(opie, "opie_wild_ride present");
-        assert.equal(opie.hidden, 1);
-        assert.equal(opie.unlocked_at, null);
-        const visible = rows.filter((r) => !(r.hidden === 1 && r.unlocked_at == null));
-        const ids = visible.map((r) => r.id);
-        const sorted = [...ids].sort();
-        assert.deepEqual(ids, sorted, "visible rows ordered by id asc");
-    });
-    it("getAchievement returns a row by id, null for unknown", () => {
-        const r = getAchievement(dir, "first_compact");
-        assert.ok(r);
-        assert.equal(r.title, "First Compact");
-        assert.equal(getAchievement(dir, "nope"), null);
-    });
-    it("isUnlocked false before unlock, true after", () => {
-        assert.equal(isUnlocked(dir, "first_compact"), false);
-        assert.equal(unlockAchievement(dir, "first_compact"), true);
-        assert.equal(isUnlocked(dir, "first_compact"), true);
-    });
-    it("unlock is idempotent (second call false, unlocked_at unchanged)", () => {
-        assert.equal(unlockAchievement(dir, "turn_veteran"), true);
-        const t0 = getAchievement(dir, "turn_veteran").unlocked_at;
-        assert.equal(unlockAchievement(dir, "turn_veteran"), false);
-        assert.equal(getAchievement(dir, "turn_veteran").unlocked_at, t0);
-    });
-    it("unlockAchievement throws on unknown id", () => {
-        assert.throws(() => unlockAchievement(dir, "bogus"));
-    });
-    it("parameterizes id (no SQL injection via crafted id)", () => {
-        // The accessors bind id as a param; a hostile id is a literal lookup, never executed.
-        assert.equal(getAchievement(dir, "x'); DROP TABLE game_achievements; --"), null);
-        assert.throws(() => unlockAchievement(dir, "x'); DROP TABLE game_achievements; --"));
-    });
-});

package/dist/src/store/sqlite/game-scores.test.js

@@ -1,106 +0,0 @@
-/**
- * game-scores.test.ts — S33 game_scores table round-trip + leaderboard ordering.
- * Pi-agnostic. Uses an isolated state dir (never the real user dir — G7).
- */
-import { describe, it, before, after } from "node:test";
-import assert from "node:assert/strict";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { mkdtempSync, rmSync } from "node:fs";
-import { closeStore } from "./utils.js";
-import { recordScore, leaderboard, METRICS, } from "./game-scores.js";
-describe("game-scores (S33)", () => {
-    let dir;
-    before(() => {
-        dir = mkdtempSync(join(tmpdir(), "mc-gamescores-"));
-        process.env.MEGACOMPACT_STATE_DIR = dir;
-    });
-    after(() => {
-        closeStore(dir);
-        delete process.env.MEGACOMPACT_STATE_DIR;
-        rmSync(dir, { recursive: true, force: true });
-    });
-    it("records + reads back a cache score with parsed meta", () => {
-        recordScore(dir, {
-            repo_root: "/repo/a",
-            metric: "cache",
-            value: 42,
-            meta: { hits: 7, lookups: 10 },
-        });
-        const rows = leaderboard(dir, "cache", { repoRoot: "/repo/a" });
-        assert.equal(rows.length, 1);
-        assert.equal(rows[0].repo_root, "/repo/a");
-        assert.equal(rows[0].value, 42);
-        assert.deepEqual(rows[0].meta, { hits: 7, lookups: 10 });
-    });
-    it("cache leaderboard ranks by latest value per repo, descending", () => {
-        recordScore(dir, { repo_root: "/repo/a", metric: "cache", value: 10 });
-        recordScore(dir, { repo_root: "/repo/a", metric: "cache", value: 99 }); // latest wins
-        recordScore(dir, { repo_root: "/repo/b", metric: "cache", value: 50 });
-        recordScore(dir, { repo_root: "/repo/c", metric: "cache", value: 75 });
-        const rows = leaderboard(dir, "cache"); // all repos, default limit 10
-        assert.equal(rows.length, 3);
-        assert.deepEqual(rows.map((r) => [r.repo_root, r.value]), [["/repo/a", 99], ["/repo/c", 75], ["/repo/b", 50]]);
-        const a = rows.find((r) => r.repo_root === "/repo/a");
-        assert.equal(a.value, 99); // not the older 10
-    });
-    it("turns leaderboard uses the latest value per repo", () => {
-        recordScore(dir, { repo_root: "/repo/a", metric: "turns", value: 3 });
-        recordScore(dir, { repo_root: "/repo/a", metric: "turns", value: 8 });
-        const rows = leaderboard(dir, "turns", { repoRoot: "/repo/a" });
-        assert.equal(rows.length, 1);
-        assert.equal(rows[0].value, 8);
-    });
-    it("dedupe leaderboard sums collapses per repo, descending", () => {
-        recordScore(dir, { repo_root: "/repo/a", metric: "dedupe", value: 2 });
-        recordScore(dir, { repo_root: "/repo/a", metric: "dedupe", value: 3 });
-        recordScore(dir, { repo_root: "/repo/b", metric: "dedupe", value: 10 });
-        const rows = leaderboard(dir, "dedupe");
-        assert.equal(rows.length, 2);
-        assert.deepEqual(rows.map((r) => [r.repo_root, r.value]), [["/repo/b", 10], ["/repo/a", 5]]);
-    });
-    it("mega_cache leaderboard returns the max trophy per repo", () => {
-        recordScore(dir, {
-            repo_root: "/repo/a",
-            metric: "mega_cache",
-            value: 120,
-            meta: { peakPct: 120 },
-        });
-        recordScore(dir, {
-            repo_root: "/repo/a",
-            metric: "mega_cache",
-            value: 150,
-            meta: { peakPct: 150 },
-        });
-        const rows = leaderboard(dir, "mega_cache", { repoRoot: "/repo/a" });
-        assert.equal(rows.length, 1);
-        assert.equal(rows[0].value, 150);
-        assert.deepEqual(rows[0].meta, { peakPct: 150 });
-    });
-    it("repos leaderboard is the derived COUNT(DISTINCT repo_root)", () => {
-        recordScore(dir, { repo_root: "/repo/a", metric: "cache", value: 1 });
-        recordScore(dir, { repo_root: "/repo/b", metric: "cache", value: 1 });
-        recordScore(dir, { repo_root: "/repo/c", metric: "cache", value: 1 });
-        const rows = leaderboard(dir, "repos");
-        assert.equal(rows.length, 1);
-        assert.equal(rows[0].value, 3);
-    });
-    it("parameterizes repo_root (no SQL injection via repo path)", () => {
-        const evil = "x'); DROP TABLE game_scores; --";
-        recordScore(dir, { repo_root: evil, metric: "cache", value: 5 });
-        const rows = leaderboard(dir, "cache", { repoRoot: evil });
-        assert.equal(rows.length, 1);
-        assert.equal(rows[0].repo_root, evil);
-        // the table is intact: a normal insert still works
-        recordScore(dir, { repo_root: "/repo/z", metric: "cache", value: 1 });
-        assert.equal(leaderboard(dir, "cache", { repoRoot: "/repo/z" }).length, 1);
-    });
-    it("rejects an unknown metric", () => {
-        const bad = "bogus";
-        assert.throws(() => recordScore(dir, { repo_root: "/r", metric: bad, value: 1 }));
-        assert.throws(() => leaderboard(dir, bad));
-    });
-    it("METRICS allow-list matches the schema CHECK set", () => {
-        assert.deepEqual([...METRICS].sort(), ["cache", "dedupe", "mega_cache", "repos", "turns"]);
-    });
-});

package/dist/src/store/sqlite/game-state.test.js

@@ -1,76 +0,0 @@
-/**
- * game-state.test.ts — S30 game_state table round-trip + validation.
- * Pi-agnostic. Uses an isolated state dir (never the real user dir — G7).
- */
-import { describe, it, before, after } from "node:test";
-import assert from "node:assert/strict";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { mkdtempSync, rmSync } from "node:fs";
-import { closeStore } from "./utils.js";
-import { getGameState, setGameState, DEFAULT_GAME_STATE, } from "./game-state.js";
-describe("game-state (S30)", () => {
-    let dir;
-    before(() => {
-        dir = mkdtempSync(join(tmpdir(), "mc-gamestate-"));
-        process.env.MEGACOMPACT_STATE_DIR = dir;
-    });
-    after(() => {
-        closeStore(dir);
-        delete process.env.MEGACOMPACT_STATE_DIR;
-        rmSync(dir, { recursive: true, force: true });
-    });
-    it("returns DEFAULT_GAME_STATE on a fresh store", () => {
-        const s = getGameState();
-        assert.deepEqual(s, { ...DEFAULT_GAME_STATE });
-        assert.equal(s.game_mode_on, false);
-        assert.equal(s.theme, "transparent");
-        assert.equal(s.tui_display_mode, "full");
-    });
-    it("round-trips game_mode_on", () => {
-        setGameState({ game_mode_on: true });
-        assert.equal(getGameState().game_mode_on, true);
-        setGameState({ game_mode_on: false });
-        assert.equal(getGameState().game_mode_on, false);
-    });
-    it("round-trips a valid theme", () => {
-        setGameState({ theme: "retro" });
-        assert.equal(getGameState().theme, "retro");
-        setGameState({ theme: "cyan-neon" });
-        assert.equal(getGameState().theme, "cyan-neon");
-    });
-    it("rejects an unknown theme (keeps previous)", () => {
-        setGameState({ theme: "orange-bold" });
-        setGameState({ theme: "does-not-exist" });
-        assert.equal(getGameState().theme, "orange-bold");
-    });
-    it("round-trips tui_display_mode full|minimal", () => {
-        setGameState({ tui_display_mode: "minimal" });
-        assert.equal(getGameState().tui_display_mode, "minimal");
-        setGameState({ tui_display_mode: "full" });
-        assert.equal(getGameState().tui_display_mode, "full");
-    });
-    it("persists across a reopen (survives restart)", () => {
-        setGameState({ game_mode_on: true, theme: "amber-mono", tui_display_mode: "minimal" });
-        // evict + reopen the store to prove it hit disk
-        closeStore(dir);
-        const s = getGameState();
-        assert.equal(s.game_mode_on, true);
-        assert.equal(s.theme, "amber-mono");
-        assert.equal(s.tui_display_mode, "minimal");
-    });
-    it("setGameState is a partial merge (untouched fields preserved)", () => {
-        setGameState({ game_mode_on: true, theme: "grayscale", tui_display_mode: "minimal" });
-        const s = setGameState({ game_mode_on: false });
-        assert.equal(s.game_mode_on, false);
-        assert.equal(s.theme, "grayscale");
-        assert.equal(s.tui_display_mode, "minimal");
-    });
-    it("stays a single row (no duplicate id=1)", () => {
-        setGameState({ game_mode_on: true });
-        setGameState({ game_mode_on: false });
-        setGameState({ theme: "retro" });
-        const s = getGameState();
-        assert.ok(s); // single state, last-write-wins
-    });
-});