pi-mega-compact 0.11.4 → 0.11.5

package/dist/extensions/mega-events.test.js

@@ -1,47 +0,0 @@
-/**
- * Tests for mega-events extension — DB-mirror event wiring.
- */
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { openStore, listCheckpointEpochs, countRawTranscript } from "../src/store/sqlite.js";
-function makeTmp() {
-    return mkdtempSync(join(tmpdir(), "mega-events-test-"));
-}
-describe("mega-events: DB-mirror integration", () => {
-    let dir;
-    beforeEach(() => {
-        dir = makeTmp();
-        // openStore creates the tables as a side effect
-        openStore(dir);
-    });
-    afterEach(() => {
-        rmSync(dir, { recursive: true, force: true });
-    });
-    it("openStore creates checkpoint_epochs and raw_transcript tables", () => {
-        const db = openStore(dir);
-        // Should not throw — tables exist
-        const epochs = listCheckpointEpochs(db);
-        assert.ok(Array.isArray(epochs));
-        const count = countRawTranscript(db);
-        assert.equal(count, 0);
-    });
-    it("DB-mirror flag defaults to false when env is unset", () => {
-        delete process.env.MEGACOMPACT_DB_MIRROR;
-        // Re-import to pick up env
-        // The extension checks env at load time, so just verify the env is absent
-        assert.equal(process.env.MEGACOMPACT_DB_MIRROR, undefined);
-    });
-    it("DB-mirror flag is enabled when env is '1'", () => {
-        process.env.MEGACOMPACT_DB_MIRROR = "1";
-        assert.equal(process.env.MEGACOMPACT_DB_MIRROR, "1");
-        delete process.env.MEGACOMPACT_DB_MIRROR;
-    });
-    it("DB-mirror flag is enabled when env is 'true'", () => {
-        process.env.MEGACOMPACT_DB_MIRROR = "true";
-        assert.equal(process.env.MEGACOMPACT_DB_MIRROR, "true");
-        delete process.env.MEGACOMPACT_DB_MIRROR;
-    });
-});

package/dist/extensions/mega-game-cmds.test.js

@@ -1,163 +0,0 @@
-/**
- * mega-game-cmds.test.ts — /mega-game command parsing matrix (S30).
- * Uses an isolated state dir + a fake pi harness (mirrors mega-compact.test.ts).
- * Pi runtime is mocked; the src/ helpers under test are pi-agnostic.
- */
-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 { createRequire } from "node:module";
-import { closeStore, getGameState } from "../src/store/sqlite.js";
-import { THEME_IDS } from "../src/config/themes.js";
-// ESM bootstrap so `require()` works in this .test.ts (mirrors
-// mega-compact.test.ts:20-24). Needed for the dynamic `require("./mega-game-cmds.js")`
-// that wires the command against a fake pi without binding to the real pi
-// module at load time.
-const require = createRequire(import.meta.url);
-function makeHarness(stateDir, select, snapshotSpy) {
-    const commands = {};
-    const notifies = [];
-    const snapshotCalls = [];
-    const runtime = {
-        bindRepo: () => { },
-        currentStateDir: stateDir,
-        bumpGameState: () => { },
-        snapshot: () => { snapshotCalls.push(1); snapshotSpy?.(); },
-    };
-    const ctx = {
-        cwd: stateDir,
-        ui: { notify: (s) => notifies.push(s), ...(select ? { select } : {}) },
-    };
-    const fakePi = {
-        registerCommand: (name, opts) => {
-            commands[name] = opts;
-        },
-    };
-    // Import after env is set so stateDir resolves. Dynamic import keeps the
-    // test from binding to the real pi module at load time.
-    const mod = require("./mega-game-cmds.js");
-    mod.registerGameCommands(fakePi, runtime);
-    return { commands, notifies, ctx, snapshotCalls };
-}
-describe("/mega-compact-settings (S30; /mega-game alias)", () => {
-    let dir;
-    before(() => {
-        dir = mkdtempSync(join(tmpdir(), "mc-megagame-"));
-        process.env.MEGACOMPACT_STATE_DIR = dir;
-    });
-    after(() => {
-        closeStore(dir);
-        delete process.env.MEGACOMPACT_STATE_DIR;
-        rmSync(dir, { recursive: true, force: true });
-    });
-    async function run(args) {
-        const h = makeHarness(dir);
-        h.notifies.length = 0;
-        await h.commands["mega-game"].handler(args, h.ctx);
-        return h.notifies;
-    }
-    it("registers /mega-compact-settings as primary + /mega-game as alias", async () => {
-        const h = makeHarness(dir);
-        assert.ok(h.commands["mega-compact-settings"], "primary registered");
-        assert.ok(h.commands["mega-game"], "alias registered");
-    });
-    it("bare command prints current (default) state", async () => {
-        const lines = await run("");
-        assert.ok(lines.some((l) => l.includes("game mode: off")));
-        assert.ok(lines.some((l) => l.includes("transparent")));
-        assert.ok(lines.some((l) => l.includes("tui:")));
-    });
-    it("bare command opens interactive menu (select) and toggles game mode", async () => {
-        const seq = ["Turn game mode ON", "Done"];
-        let i = 0;
-        const h = makeHarness(dir, () => Promise.resolve(seq[i++] ?? undefined));
-        h.notifies.length = 0;
-        await h.commands["mega-compact-settings"].handler("", h.ctx);
-        assert.equal(getGameState().game_mode_on, true);
-        assert.ok(h.notifies.some((l) => l.includes("game mode ON")));
-        // toggle back off via the menu
-        const seq2 = ["Turn game mode OFF", "Done"];
-        let j = 0;
-        const h2 = makeHarness(dir, () => Promise.resolve(seq2[j++] ?? undefined));
-        await h2.commands["mega-compact-settings"].handler("", h2.ctx);
-        assert.equal(getGameState().game_mode_on, false);
-    });
-    it("bare command falls back to status print when select is unavailable", async () => {
-        // default harness has no select — mimics RPC/print mode
-        const lines = await run("");
-        assert.ok(lines.some((l) => l.includes("game mode: off")));
-    });
-    it("menu Theme… → picks a theme and persists", async () => {
-        const seq = ["Theme…", "retro  Retro Terminal", "Done"];
-        let i = 0;
-        const h = makeHarness(dir, () => Promise.resolve(seq[i++] ?? undefined));
-        h.notifies.length = 0;
-        await h.commands["mega-compact-settings"].handler("", h.ctx);
-        assert.equal(getGameState().theme, "retro");
-        assert.ok(h.notifies.some((l) => l.includes("theme → retro")));
-    });
-    it("menu toggle calls runtime.snapshot() so the widget refreshes live", async () => {
-        const seq = ["Turn game mode ON", "Done"];
-        let i = 0;
-        const h = makeHarness(dir, () => Promise.resolve(seq[i++] ?? undefined));
-        h.notifies.length = 0;
-        h.snapshotCalls.length = 0;
-        await h.commands["mega-compact-settings"].handler("", h.ctx);
-        assert.equal(getGameState().game_mode_on, true);
-        assert.ok(h.snapshotCalls.length >= 1, "snapshot() called so widget refreshes live");
-    });
-    it("on enables game mode and persists", async () => {
-        await run("on");
-        assert.equal(getGameState().game_mode_on, true);
-    });
-    it("off disables game mode and persists", async () => {
-        await run("on");
-        await run("off");
-        assert.equal(getGameState().game_mode_on, false);
-    });
-    it("theme <id> sets a valid theme and persists", async () => {
-        await run("theme retro");
-        assert.equal(getGameState().theme, "retro");
-        await run("theme cyan-neon");
-        assert.equal(getGameState().theme, "cyan-neon");
-    });
-    it("theme <unknown> is rejected with a usage line and does not mutate", async () => {
-        await run("theme retro");
-        const lines = await run("theme bogus");
-        assert.ok(lines.some((l) => l.includes("unknown theme")));
-        assert.equal(getGameState().theme, "retro");
-    });
-    it("theme next cycles to the next theme and wraps", async () => {
-        await run(`theme ${THEME_IDS[0]}`);
-        await run("theme next");
-        assert.equal(getGameState().theme, THEME_IDS[1]);
-        // cycle to the end then wrap
-        await run(`theme ${THEME_IDS[THEME_IDS.length - 1]}`);
-        await run("theme next");
-        assert.equal(getGameState().theme, THEME_IDS[0]);
-    });
-    it("theme (bare) lists all themes", async () => {
-        const lines = await run("theme");
-        for (const id of THEME_IDS) {
-            assert.ok(lines.some((l) => l.includes(id)), `lists ${id}`);
-        }
-    });
-    it("tui full|minimal sets display mode and persists", async () => {
-        await run("tui minimal");
-        assert.equal(getGameState().tui_display_mode, "minimal");
-        await run("tui full");
-        assert.equal(getGameState().tui_display_mode, "full");
-    });
-    it("tui <bad> prints usage and does not mutate", async () => {
-        await run("tui minimal");
-        const lines = await run("tui huge");
-        assert.ok(lines.some((l) => l.includes("usage")));
-        assert.equal(getGameState().tui_display_mode, "minimal");
-    });
-    it("unknown subcommand prints usage", async () => {
-        const lines = await run("bogus");
-        assert.ok(lines.some((l) => l.includes("usage")));
-    });
-});

package/dist/extensions/mega-runtime/snapshot.test.js

@@ -1,127 +0,0 @@
-/**
- * snapshot.test.ts — C.4 computeMegaSnapshot tests for providerCachePct
- * and megaCacheFlare fields.
- *
- * Uses MEGACOMPACT_STATE_DIR + mkdtemp (G7). No pi runtime.
- */
-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 { computeMegaSnapshot } from "./snapshot.js";
-function baseInput(overrides = {}) {
-    return {
-        rtTokensSaved: 1000,
-        lastCtxPercent: null,
-        lastCtxTokens: 0,
-        lastCtxWindow: 0,
-        activeAgents: 0,
-        currentTurn: 0,
-        statusKey: undefined,
-        ready: false,
-        armed: false,
-        st: {
-            totalTokenEstimate: 800,
-            originalTokens: 1200,
-            storageDedupRate: 0.12,
-            checkpointCount: 3,
-            lastCheckpointId: undefined,
-            lastSummary: undefined,
-            injectedCount: 0,
-            dedupHitRate: 0.05,
-            tokensSaved: 200,
-            dedupAttempts: 40,
-            dedupCollapsed: 5,
-        },
-        repo: {
-            tokensSaved: 5000,
-            totalTokenEstimate: 4000,
-            checkpointCount: 9,
-            sessionCount: 2,
-            originalTokens: 6000,
-            dedupAttempts: 100,
-            dedupCollapsed: 30,
-            storageDedupRate: 0.3,
-        },
-        pressureBand: "low",
-        configTier: "default",
-        modelSnap: undefined,
-        lastCompactAt: null,
-        embedderName: () => "Trigram",
-        driftStatus: () => "ok",
-        getCachedGameState: () => ({
-            game_mode_on: false,
-            theme: "transparent",
-            tui_display_mode: "full",
-        }),
-        getTurnLevel: () => 1,
-        providerCachePct: 56.2,
-        megaCacheFlare: false,
-        megaCacheFlarePct: 0,
-        levelUpFlare: false,
-        achievementFlare: false,
-        achievementFlareTitles: [],
-        activeEffect: null,
-        lastActivityAt: Date.now(),
-        ticker: [],
-        lastWhy: undefined,
-        tierTrace: undefined,
-        pulsing: false,
-        ...overrides,
-    };
-}
-describe("computeMegaSnapshot (C.4)", () => {
-    let dir;
-    before(() => {
-        dir = mkdtempSync(join(tmpdir(), "mc-snap-"));
-        process.env.MEGACOMPACT_STATE_DIR = dir;
-    });
-    after(() => {
-        delete process.env.MEGACOMPACT_STATE_DIR;
-        rmSync(dir, { recursive: true, force: true });
-    });
-    // ── C.1: providerCachePct flows into cachePct ─────────────────────────
-    it("cachePct equals providerCachePct (not dedup hit rate)", () => {
-        const res = computeMegaSnapshot(baseInput({ providerCachePct: 56.2 }));
-        assert.equal(res.widgetData.cachePct, 56.2, "cachePct is providerCachePct");
-    });
-    it("cachePct is 0 when providerCachePct is 0", () => {
-        const res = computeMegaSnapshot(baseInput({ providerCachePct: 0 }));
-        assert.equal(res.widgetData.cachePct, 0, "cachePct is 0");
-    });
-    it("cachePct is independent of dedup hit rate", () => {
-        const res = computeMegaSnapshot(baseInput({
-            providerCachePct: 12.5,
-            st: {
-                totalTokenEstimate: 99999,
-                originalTokens: 99999,
-                storageDedupRate: 0.99,
-                checkpointCount: 1,
-                lastCheckpointId: undefined,
-                lastSummary: undefined,
-                injectedCount: 0,
-                dedupHitRate: 0.05,
-                tokensSaved: 200,
-                dedupAttempts: 40,
-                dedupCollapsed: 5,
-            },
-        }));
-        assert.equal(res.widgetData.cachePct, 12.5, "cachePct ignores dedup");
-    });
-    // ── megaCacheFlare fields pass through ────────────────────────────────
-    it("megaCacheFlare + megaCacheFlarePct pass through to widgetData", () => {
-        const res = computeMegaSnapshot(baseInput({ megaCacheFlare: true, megaCacheFlarePct: 287 }));
-        assert.equal(res.widgetData.megaCacheFlare, true);
-        assert.equal(res.widgetData.megaCacheFlarePct, 287);
-    });
-    it("megaCacheFlare is false by default", () => {
-        const res = computeMegaSnapshot(baseInput());
-        assert.equal(res.widgetData.megaCacheFlare, false);
-    });
-    // ── level pass-through ────────────────────────────────────────────────
-    it("level flows from getTurnLevel", () => {
-        const res = computeMegaSnapshot(baseInput({ getTurnLevel: () => 42 }));
-        assert.equal(res.curLevel, 42);
-    });
-});

package/dist/extensions/mega-runtime/state.test.js

@@ -1,266 +0,0 @@
-/**
- * state.test.ts — S31 MegaRuntime game-state cache round-trip.
- *
- * getCachedGameState() lazily reads the game_state row; bumpGameState()
- * evicts so the next read re-queries. Uses MEGACOMPACT_STATE_DIR + mkdtemp
- * (G7). A minimal MegaRuntime is constructed directly (no pi runtime).
- */
-import { describe, it, 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 { createRequire } from "node:module";
-import { execSync } from "node:child_process";
-import { closeStore, getGameState, setGameState } from "../../src/store/sqlite.js";
-import { DEFAULT_GAME_STATE } from "../../src/store/sqlite/game-state.js";
-const require = createRequire(import.meta.url);
-// Require the compiled JS (build output) so ESM import of pi-tui etc. resolves.
-const { MegaRuntime } = require("./state.js");
-/** Minimal MegaConfig — enough fields for the constructor; the snapshot path
- *  isn't exercised here, only getCachedGameState/bumpGameState. */
-function minimalConfig(stateDir) {
-    return {
-        tier: "custom",
-        tierPct: null,
-        thresholdTokens: 100_000,
-        stateDir,
-        fastGatePct: 70,
-        anchorUserMessages: 3,
-        preserveRecent: 4,
-        preserveRecentMin: 2,
-        auto: false,
-        autoInline: false,
-        autoContinueLengthStop: false,
-        autoPctTrigger: null,
-        dedupSim: 0.9,
-        raptorEnabled: false,
-        legacyDurableTrim: false,
-        dbMirror: false,
-        crossRepoEnabled: false,
-        crossRepoCosine: 0.9,
-        memoryAutoReview: false,
-        memoryReviewInterval: 10,
-        recallMaxTokens: 1500,
-        windowDedupe: false,
-        debug: false,
-    };
-}
-/** Fresh isolated state dir per test — the game_state row is global and
- *  persists across cases in a shared dir, so each case gets its own mkdtemp to
- *  avoid cross-test contamination. */
-function freshDir() {
-    return mkdtempSync(join(tmpdir(), "mc-state-"));
-}
-describe("MegaRuntime setEffect lifecycle (v0.8.3)", () => {
-    const dirs = [];
-    after(() => {
-        for (const d of dirs) {
-            try {
-                closeStore(d);
-            }
-            catch { /* */ }
-        }
-        delete process.env.MEGACOMPACT_STATE_DIR;
-        for (const d of dirs)
-            rmSync(d, { recursive: true, force: true });
-    });
-    it("activeEffect starts null and setEffect arms it with startedAt ~now", () => {
-        const dir = freshDir();
-        dirs.push(dir);
-        process.env.MEGACOMPACT_STATE_DIR = dir;
-        const rt = new MegaRuntime(minimalConfig(dir));
-        assert.equal(rt.activeEffect, null, "idle on construction");
-        const before = Date.now();
-        rt.setEffect("pulse", "accent", 2000);
-        const after = Date.now();
-        assert.equal(rt.activeEffect.type, "pulse");
-        assert.equal(rt.activeEffect.role, "accent");
-        assert.equal(rt.activeEffect.durationMs, 2000);
-        assert.ok(rt.activeEffect.startedAt >= before && rt.activeEffect.startedAt <= after, "startedAt within the call window");
-    });
-    it("setEffect replaces an in-flight effect (last call wins)", () => {
-        const dir = freshDir();
-        dirs.push(dir);
-        process.env.MEGACOMPACT_STATE_DIR = dir;
-        const rt = new MegaRuntime(minimalConfig(dir));
-        rt.setEffect("pulse", "accent", 2000);
-        const first = rt.activeEffect;
-        rt.setEffect("flash", "mega", 1200);
-        assert.notEqual(rt.activeEffect, first, "a fresh object replaced the prior");
-        assert.equal(rt.activeEffect.type, "flash");
-        assert.equal(rt.activeEffect.role, "mega");
-        assert.equal(rt.activeEffect.durationMs, 1200);
-    });
-    it("a backdated effect is recognized as expired by the snapshot predicate", () => {
-        const dir = freshDir();
-        dirs.push(dir);
-        process.env.MEGACOMPACT_STATE_DIR = dir;
-        const rt = new MegaRuntime(minimalConfig(dir));
-        rt.setEffect("pulse", "accent", 2000);
-        // Backdate startedAt past the duration window (no snapshot/ctx needed —
-        // this mirrors the exact predicate snapshot() runs after the flare consume).
-        rt.activeEffect.startedAt = Date.now() - 3000;
-        const expired = !!rt.activeEffect &&
-            Date.now() - rt.activeEffect.startedAt >= rt.activeEffect.durationMs;
-        assert.ok(expired, "backdated effect satisfies the expiry predicate");
-        // Clearing mirrors the snapshot() bookkeeping branch:
-        if (expired)
-            rt.activeEffect = null;
-        assert.equal(rt.activeEffect, null, "cleared once expired");
-    });
-});
-describe("MegaRuntime pushTicker dedupe (P1)", () => {
-    const dirs = [];
-    after(() => {
-        for (const d of dirs) {
-            try {
-                closeStore(d);
-            }
-            catch { /* */ }
-        }
-        delete process.env.MEGACOMPACT_STATE_DIR;
-        for (const d of dirs)
-            rmSync(d, { recursive: true, force: true });
-    });
-    it("pushTicker skips consecutive identical entries (keeps ring at capacity for variety)", () => {
-        const dir = freshDir();
-        dirs.push(dir);
-        process.env.MEGACOMPACT_STATE_DIR = dir;
-        const rt = new MegaRuntime(minimalConfig(dir));
-        rt.pushTicker("compact");
-        rt.pushTicker("compact"); // dedup — skipped
-        rt.pushTicker("compact"); // dedup — skipped
-        rt.pushTicker("recall");
-        assert.equal(rt.ticker.length, 2, "only 2 unique entries kept");
-        assert.equal(rt.ticker[0].text, "compact");
-        assert.equal(rt.ticker[1].text, "recall");
-    });
-    it("pushTicker keeps distinct entries and respects TICKER_MAX", () => {
-        const dir = freshDir();
-        dirs.push(dir);
-        process.env.MEGACOMPACT_STATE_DIR = dir;
-        const rt = new MegaRuntime(minimalConfig(dir));
-        for (let i = 0; i < rt.TICKER_MAX + 3; i++)
-            rt.pushTicker(`t${i}`);
-        assert.equal(rt.ticker.length, rt.TICKER_MAX, "capped at TICKER_MAX");
-        assert.equal(rt.ticker[rt.TICKER_MAX - 1].text, `t${rt.TICKER_MAX + 2}`);
-    });
-});
-describe("MegaRuntime game-state cache (S31)", () => {
-    const dirs = [];
-    after(() => {
-        for (const d of dirs) {
-            try {
-                closeStore(d);
-            }
-            catch { /* */ }
-        }
-        delete process.env.MEGACOMPACT_STATE_DIR;
-        for (const d of dirs)
-            rmSync(d, { recursive: true, force: true });
-    });
-    it("getCachedGameState returns defaults on a fresh install", () => {
-        const dir = freshDir();
-        dirs.push(dir);
-        process.env.MEGACOMPACT_STATE_DIR = dir;
-        const rt = new MegaRuntime(minimalConfig(dir));
-        const gs = rt.getCachedGameState();
-        assert.deepEqual(gs, { ...DEFAULT_GAME_STATE });
-    });
-    it("getCachedGameState memoizes (same ref across calls)", () => {
-        const dir = freshDir();
-        dirs.push(dir);
-        process.env.MEGACOMPACT_STATE_DIR = dir;
-        const rt = new MegaRuntime(minimalConfig(dir));
-        const a = rt.getCachedGameState();
-        const b = rt.getCachedGameState();
-        assert.equal(a, b, "memoized — same object ref");
-    });
-    it("bumpGameState evicts so the next read reflects a setGameState write", () => {
-        const dir = freshDir();
-        dirs.push(dir);
-        process.env.MEGACOMPACT_STATE_DIR = dir;
-        const rt = new MegaRuntime(minimalConfig(dir));
-        const before = rt.getCachedGameState();
-        assert.equal(before.game_mode_on, false);
-        // Write out-of-band (as /mega-game would).
-        setGameState({ game_mode_on: true, theme: "retro", tui_display_mode: "minimal" }, dir);
-        // Without bump, the stale memo is returned.
-        const stale = rt.getCachedGameState();
-        assert.equal(stale.game_mode_on, false, "stale cache before bump");
-        // After bump, the next read re-queries and reflects the write.
-        rt.bumpGameState();
-        const fresh = rt.getCachedGameState();
-        assert.equal(fresh.game_mode_on, true);
-        assert.equal(fresh.theme, "retro");
-        assert.equal(fresh.tui_display_mode, "minimal");
-        // And matches the authoritative getGameState read.
-        assert.deepEqual(fresh, getGameState(dir));
-    });
-    it("bumpGameState is idempotent (safe to call when cache is empty)", () => {
-        const dir = freshDir();
-        dirs.push(dir);
-        process.env.MEGACOMPACT_STATE_DIR = dir;
-        const rt = new MegaRuntime(minimalConfig(dir));
-        rt.bumpGameState(); // no cached state yet — must not throw
-        const gs = rt.getCachedGameState();
-        assert.deepEqual(gs, { ...DEFAULT_GAME_STATE });
-    });
-    it("bindRepo evicts cachedGameState so a repo switch reflects the new repo's game_state", () => {
-        // Two fresh git repos A and B simulate a real repo switch. Each holds its
-        // own per-repo state dir at <root>/.pi/mega-compact (what repoStateDir
-        // returns for a git cwd), and each holds its own game_state row, so a repo
-        // switch (bindRepo) must evict the cached memo or the widget shows A's
-        // theme/mode/toggle after moving to B. Uses MEGACOMPACT_STATE_DIR + mkdtemp
-        // + closeStore (G7); the global state dir stays separate.
-        const globalDir = freshDir();
-        dirs.push(globalDir);
-        const repoA = freshDir();
-        dirs.push(repoA);
-        const repoB = freshDir();
-        dirs.push(repoB);
-        const stateA = join(repoA, ".pi", "mega-compact");
-        const stateB = join(repoB, ".pi", "mega-compact");
-        // Make A and B real git roots so resolveRepoRoot(cwd) returns the root and
-        // repoStateDir produces <root>/.pi/mega-compact (the per-repo store).
-        execSync("git init -q", { cwd: repoA });
-        execSync("git init -q", { cwd: repoB });
-        // Seed A and B with distinct game_state rows in their per-repo dirs.
-        setGameState({ game_mode_on: true, theme: "retro", tui_display_mode: "minimal" }, stateA);
-        setGameState({ game_mode_on: false, theme: "cyan-neon", tui_display_mode: "full" }, stateB);
-        // Construct the runtime against the GLOBAL dir (the non-git fallback so a
-        // real bindRepo switch occurs once we point it at a git root).
-        process.env.MEGACOMPACT_STATE_DIR = globalDir;
-        const rt = new MegaRuntime(minimalConfig(globalDir));
-        // Point the runtime at repo A and prime the cache.
-        rt.bindRepo(repoA);
-        assert.equal(rt.currentStateDir, stateA, "bindRepo(A) switched to A's per-repo dir");
-        const a = rt.getCachedGameState();
-        assert.equal(a.game_mode_on, true, "A: game_mode_on primed");
-        assert.equal(a.theme, "retro", "A: theme primed");
-        assert.equal(a.tui_display_mode, "minimal", "A: tui_display_mode primed");
-        // Switch to repo B: bindRepo must evict cachedGameState so the next read
-        // re-queries B's row instead of returning A's stale memo.
-        rt.bindRepo(repoB);
-        assert.equal(rt.currentStateDir, stateB, "bindRepo(B) switched to B's per-repo dir");
-        const b = rt.getCachedGameState();
-        assert.equal(b.game_mode_on, false, "B: game_mode_on after switch (not A's stale true)");
-        assert.equal(b.theme, "cyan-neon", "B: theme after switch (not A's stale retro)");
-        assert.equal(b.tui_display_mode, "full", "B: tui_display_mode after switch (not A's stale minimal)");
-        assert.deepEqual(b, getGameState(stateB), "B matches authoritative getGameState read");
-        // Cleanup the per-repo DB handles.
-        try {
-            closeStore(globalDir);
-        }
-        catch { /* */ }
-        try {
-            closeStore(stateA);
-        }
-        catch { /* */ }
-        try {
-            closeStore(stateB);
-        }
-        catch { /* */ }
-    });
-});