pi-mega-compact 0.11.4 → 0.11.6

package/extensions/mega-events.test.ts

@@ -1,55 +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(): string {
-  return mkdtempSync(join(tmpdir(), "mega-events-test-"));
-}
-
-describe("mega-events: DB-mirror integration", () => {
-  let dir: string;
-
-  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/extensions/mega-game-cmds.test.ts

@@ -1,197 +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);
-
-type Cmd = { description?: string; handler: (args: string, ctx: any) => Promise<void> };
-
-type Harness = {
-  commands: Record<string, Cmd>;
-  notifies: string[];
-  ctx: any;
-  snapshotCalls: number[];
-};
-
-function makeHarness(
-  stateDir: string,
-  select?: (title: string, options: string[]) => Promise<string | undefined>,
-  snapshotSpy?: () => void,
-): Harness {
-  const commands: Record<string, Cmd> = {};
-  const notifies: string[] = [];
-  const snapshotCalls: number[] = [];
-  const runtime = {
-    bindRepo: () => {},
-    currentStateDir: stateDir,
-    bumpGameState: () => {},
-    snapshot: () => { snapshotCalls.push(1); snapshotSpy?.(); },
-  };
-  const ctx = {
-    cwd: stateDir,
-    ui: { notify: (s: string) => notifies.push(s), ...(select ? { select } : {}) },
-  };
-  const fakePi = {
-    registerCommand: (name: string, opts: Cmd) => {
-      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") as {
-    registerGameCommands: (pi: unknown, runtime: unknown) => void;
-  };
-  mod.registerGameCommands(fakePi, runtime);
-  return { commands, notifies, ctx, snapshotCalls };
-}
-
-describe("/mega-compact-settings (S30; /mega-game alias)", () => {
-  let dir: string;
-  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: string): Promise<string[]> {
-    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/extensions/mega-runtime/snapshot.test.ts

@@ -1,139 +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, type SnapshotInput } from "./snapshot.js";
-
-function baseInput(overrides: Partial<SnapshotInput> = {}): SnapshotInput {
-	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" as const,
-		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: string;
-	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/extensions/mega-runtime/state.test.ts

@@ -1,262 +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") as {
-	MegaRuntime: new (config: any) => any;
-};
-
-/** Minimal MegaConfig — enough fields for the constructor; the snapshot path
- *  isn't exercised here, only getCachedGameState/bumpGameState. */
-function minimalConfig(stateDir: string): any {
-	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(): string {
-	return mkdtempSync(join(tmpdir(), "mc-state-"));
-}
-
-describe("MegaRuntime setEffect lifecycle (v0.8.3)", () => {
-	const dirs: string[] = [];
-	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: string[] = [];
-  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: string[] = [];
-	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 { /* */ }
-	});
-});