pi-mega-compact 0.11.3 → 0.11.5

package/src/store/sqlite/game-achievements.test.ts

@@ -1,80 +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: string;
-	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/src/store/sqlite/game-scores.test.ts

@@ -1,132 +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,
-	type GameMetric,
-} from "./game-scores.js";
-
-describe("game-scores (S33)", () => {
-	let dir: string;
-	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" as unknown as GameMetric;
-		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/src/store/sqlite/game-state.test.ts

@@ -1,89 +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: string;
-  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" as string });
-    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
-  });
-});

package/src/store/sqlite/global-index.test.ts

@@ -1,222 +0,0 @@
-/**
- * global-index.test.ts — S39 session heartbeats + token_samples round-trip.
- *
- * Verifies recordSessionHeartbeat + appendTokenSample + readActiveSessions +
- * readSessionTimeseries + pruneStaleSessions + pruneTokenSamples +
- * clearSessionHeartbeat, with particular focus on the Step 5 events.log
- * session_sample JSONL line shape (the SSE real-time push wire format).
- *
- * Pi-agnostic. Uses an isolated mock index dir (never the real user
- * `~/.mega-compact-index/` — guardrail G7). PREVENT-PI-004 (zero network):
- * every operation is local SQLite + local FS append.
- */
-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, readFileSync, existsSync } from "node:fs";
-
-import {
-	recordSessionHeartbeat,
-	appendTokenSample,
-	readActiveSessions,
-	readSessionTimeseries,
-	pruneStaleSessions,
-	pruneTokenSamples,
-	clearSessionHeartbeat,
-	closeIndexStore,
-} from "./global-index.js";
-
-describe("global-index session time-series (S39)", () => {
-	let indexDir: string;
-	let eventsLogPath: string;
-
-	before(() => {
-		indexDir = mkdtempSync(join(tmpdir(), "mc-global-idx-"));
-		eventsLogPath = join(indexDir, "events.log");
-	});
-
-	after(() => {
-		closeIndexStore();
-		rmSync(indexDir, { recursive: true, force: true });
-	});
-
-	it("recordSessionHeartbeat + readActiveSessions: heartbeat row appears", () => {
-		recordSessionHeartbeat(
-			12_345,
-			"sess-abc-1",
-			"/home/u/repos/proj-a",
-			"/home/u/.pi/state-a",
-			200_000,
-			indexDir,
-		);
-		const sessions = readActiveSessions(indexDir);
-		assert.equal(sessions.length, 1);
-		const s = sessions[0];
-		assert.equal(s.pid, 12_345);
-		assert.equal(s.sessionId, "sess-abc-1");
-		assert.equal(s.repoRoot, "/home/u/repos/proj-a");
-		assert.equal(s.stateDir, "/home/u/.pi/state-a");
-		assert.equal(s.ctxWindow, 200_000);
-		assert.ok(s.lastSeen > 0);
-		// No token sample yet → tokens/percent are null.
-		assert.equal(s.tokens, null);
-		assert.equal(s.percent, null);
-	});
-
-	it("appendTokenSample writes a token_samples row + a session_sample JSONL line", () => {
-		appendTokenSample(
-			"sess-abc-1",
-			"/home/u/repos/proj-a",
-			42_000,
-			21.5,
-			200_000,
-			eventsLogPath,
-			indexDir,
-		);
-		// The token_samples row should now be the latest sample for this session.
-		const sessions = readActiveSessions(indexDir);
-		const s = sessions.find((x) => x.sessionId === "sess-abc-1");
-		assert.ok(s, "session must still appear in readActiveSessions");
-		assert.equal(s!.tokens, 42_000);
-		assert.equal(s!.percent, 21.5);
-
-		// The events.log JSONL line should exist and match the wire format
-		// described by the SseSessionSample contract: an object with `ts`
-		// (ISO 8601 string), `type: 'session_sample'`, and the payload fields.
-		assert.ok(existsSync(eventsLogPath), "events.log should exist");
-		const lines = readFileSync(eventsLogPath, "utf-8")
-			.trim()
-			.split("\n")
-			.filter(Boolean);
-		assert.equal(lines.length, 1, "exactly one JSONL line expected");
-		const parsed = JSON.parse(lines[0]) as Record<string, unknown>;
-		assert.equal(parsed["type"], "session_sample");
-		assert.equal(parsed["sessionId"], "sess-abc-1");
-		assert.equal(parsed["tokens"], 42_000);
-		assert.equal(parsed["percent"], 21.5);
-		// Step 5 contract mirroring: `ts` is an ISO 8601 string (matches every
-		// other SseEvent variant's `ts: string` and the DashboardEmitter
-		// events.log pattern), NOT a numeric ms value.
-		assert.equal(
-			typeof parsed["ts"],
-			"string",
-			"ts must be an ISO 8601 string (matches other SseEvent variants)",
-		);
-		// Must be ISO-parseable (NaN if invalid → typeof won't be number).
-		const tsMs = Date.parse(parsed["ts"] as string);
-		assert.ok(
-			Number.isFinite(tsMs),
-			"ts must be a valid ISO 8601 timestamp",
-		);
-		// And recent (within the last 5s).
-		assert.ok(
-			Math.abs(Date.now() - tsMs) < 5_000,
-			"ts must be within ~5s of now",
-		);
-	});
-
-	it("readSessionTimeseries returns per-session series + totals in chronological order", () => {
-		// Two sessions, two samples each — fully within the rolling window.
-		// sess-xyz-9 needs its own heartbeat row so readActiveSessions can later
-		// surface it (heartbeats are the primary key, not the samples).
-		recordSessionHeartbeat(
-			67_890,
-			"sess-xyz-9",
-			"/home/u/repos/proj-b",
-			"/home/u/.pi/state-b",
-			200_000,
-			indexDir,
-		);
-		appendTokenSample(
-			"sess-abc-1",
-			"/home/u/repos/proj-a",
-			50_000,
-			25,
-			200_000,
-			null, // no events.log line for this assertion
-			indexDir,
-		);
-		appendTokenSample(
-			"sess-xyz-9",
-			"/home/u/repos/proj-b",
-			10_000,
-			5,
-			200_000,
-			null,
-			indexDir,
-		);
-		appendTokenSample(
-			"sess-xyz-9",
-			"/home/u/repos/proj-b",
-			30_000,
-			15,
-			200_000,
-			null,
-			indexDir,
-		);
-		const since = Date.now() - 60_000;
-		const result = readSessionTimeseries(since, indexDir);
-
-		const seriesIds = result.series.map((s) => s.sessionId).sort();
-		assert.deepEqual(seriesIds, ["sess-abc-1", "sess-xyz-9"]);
-
-		const xyz = result.series.find((s) => s.sessionId === "sess-xyz-9");
-		assert.ok(xyz, "sess-xyz-9 series must exist");
-		assert.equal(xyz!.data.length, 2);
-		assert.equal(xyz!.data[0].tokens, 10_000);
-		assert.equal(xyz!.data[1].tokens, 30_000);
-		// Stable hash-based color from the SESSION_COLORS palette.
-		assert.match(xyz!.color, /^#[0-9a-f]{6}$/i);
-
-		// Totals: each timestamp summed across sessions.
-		assert.ok(result.totals.length >= 2);
-		for (const t of result.totals) {
-			assert.ok(typeof t.ts === "number" && t.ts > 0);
-			assert.ok(typeof t.tokens === "number" && t.tokens >= 0);
-		}
-		// Totals are sorted ascending by ts.
-		for (let i = 1; i < result.totals.length; i++) {
-			assert.ok(
-				result.totals[i].ts >= result.totals[i - 1].ts,
-				"totals must be chronologically ascending",
-			);
-		}
-	});
-
-	it("pruneStaleSessions clears heartbeats older than the cutoff (and only those)", () => {
-		// At this point we have 2 sessions; both are fresh (lastSeen ≈ now).
-		const beforeCount = readActiveSessions(indexDir).length;
-		assert.equal(beforeCount, 2);
-
-		// With a 0 ms cutoff, both are stale → pruned.
-		const pruned = pruneStaleSessions(0, indexDir);
-		assert.equal(pruned, 2, "both heartbeats should be pruned");
-		assert.equal(readActiveSessions(indexDir).length, 0);
-	});
-
-	it("pruneTokenSamples clears token_samples older than the cutoff", () => {
-		// Re-seed two samples; the previously-written ones were for two
-		// sessions (sess-abc-1 + sess-xyz-9). The prunedStaleSessions call
-		// above left token_samples untouched (separate table).
-		const sinceBefore = Date.now() - 60_000;
-		const before = readSessionTimeseries(sinceBefore, indexDir);
-		const beforeCount = before.series.reduce((n, s) => n + s.data.length, 0);
-		assert.ok(beforeCount >= 3, "expected to find the seeded samples");
-
-		const npurged = pruneTokenSamples(0, indexDir);
-		assert.ok(npurged >= 3, "should have pruned the seeded samples");
-
-		const after = readSessionTimeseries(sinceBefore, indexDir);
-		const afterCount = after.series.reduce((n, s) => n + s.data.length, 0);
-		assert.equal(afterCount, 0, "no samples should remain after pruning");
-	});
-
-	it("clearSessionHeartbeat is a no-op on missing rows (never throws)", () => {
-		const before = readActiveSessions(indexDir).length;
-		assert.doesNotThrow(() =>
-			clearSessionHeartbeat(99_999, "nonexistent-session", indexDir),
-		);
-		assert.equal(readActiveSessions(indexDir).length, before);
-	});
-});

package/src/store/sqlite/mechanical-fix.test.ts

@@ -1,162 +0,0 @@
-/**
- * mechanical-fix.test.ts — focused unit tests for the SQLite-side mechanical-fix
- * batch: safeJson (utils.ts), storeStats numeric MAX + dedup_status filter
- * (stats.ts), addTokensSaved CAST AS REAL (meta.ts), evictMemoryLru named
- * @param bindings (memories.ts). Pi-agnostic; uses isolated state dirs (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 { safeJson, closeStore } from "./utils.js";
-import { storeStats } from "./stats.js";
-import { upsertCheckpoint, setDedupStatus } from "./checkpoints.js";
-import { addTokensSaved, getTokensSaved } from "./meta.js";
-import { addMemory, listMemories } from "./memories.js";
-import type { StoredCheckpoint } from "../../store.js";
-
-function makeCp(id: string, sessionId: string): StoredCheckpoint {
-  return {
-    checkpointId: id,
-    sessionId,
-    summary: `summary-${id}`,
-    keyDecisions: [],
-    nextSteps: [],
-    filesModified: [],
-    tokenEstimate: 100,
-    regionHash: `hash-${id}`,
-    embedding: [],
-    timestamp: Date.now(),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// safeJson (utils.ts)
-// ---------------------------------------------------------------------------
-
-describe("mechanical-fix: safeJson (utils.ts)", () => {
-  it("returns fallback on null, undefined, empty, and corrupt JSON", () => {
-    assert.deepEqual(safeJson<string[]>(null, []), []);
-    assert.deepEqual(safeJson<string[]>(undefined, []), []);
-    assert.deepEqual(safeJson<string[]>("", []), []);
-    assert.deepEqual(safeJson<string[]>("not json", ["fb"]), ["fb"]);
-    assert.deepEqual(safeJson<string[]>('["a","b"]', []), ["a", "b"]);
-    assert.equal(safeJson<number>(null, 42), 42);
-    assert.deepEqual(safeJson<Record<string, number>>('{"k":1}', {}), { k: 1 });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// storeStats (stats.ts) — numeric MAX(id) + dedup_status filter
-// ---------------------------------------------------------------------------
-
-describe("mechanical-fix: storeStats (stats.ts)", () => {
-  let dir: string;
-  before(() => {
-    dir = mkdtempSync(join(tmpdir(), "mc-mech-stats-"));
-    process.env.MEGACOMPACT_STATE_DIR = dir;
-  });
-  after(() => {
-    closeStore(dir);
-    delete process.env.MEGACOMPACT_STATE_DIR;
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  it("returns numerically-max checkpoint id (not lexicographic) for 100+ checkpoints", () => {
-    const sid = "sess_stats";
-    // Insert chkpt_001..chkpt_100 (100 checkpoints) + chkpt_999 + chkpt_1000.
-    // Numeric max = 1000 → "chkpt_1000"; lexicographic max would be "chkpt_999"
-    // (because '9' > '1' at position 6 when comparing 8 vs 9-char strings).
-    for (let i = 1; i <= 100; i++) {
-      upsertCheckpoint(makeCp(`chkpt_${String(i).padStart(3, "0")}`, sid), dir);
-    }
-    upsertCheckpoint(makeCp("chkpt_999", sid), dir);
-    upsertCheckpoint(makeCp("chkpt_1000", sid), dir);
-
-    const s = storeStats(sid, dir);
-    assert.equal(s.checkpointCount, 102);
-    assert.equal(s.lastCheckpointId, "chkpt_1000");
-    assert.equal(s.lastSummary, "summary-chkpt_1000");
-  });
-
-  it("excludes dedup_status='removed' rows from counts", () => {
-    const sid = "sess_dedup";
-    upsertCheckpoint(makeCp("chkpt_001", sid), dir);
-    upsertCheckpoint(makeCp("chkpt_002", sid), dir);
-    setDedupStatus("chkpt_001", sid, "removed", dir);
-    const s = storeStats(sid, dir);
-    assert.equal(s.checkpointCount, 1);
-    assert.equal(s.lastCheckpointId, "chkpt_002");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// addTokensSaved (meta.ts) — CAST AS REAL preserves fractional values
-// ---------------------------------------------------------------------------
-
-describe("mechanical-fix: addTokensSaved (meta.ts)", () => {
-  let dir: string;
-  before(() => {
-    dir = mkdtempSync(join(tmpdir(), "mc-mech-meta-"));
-    process.env.MEGACOMPACT_STATE_DIR = dir;
-  });
-  after(() => {
-    closeStore(dir);
-    delete process.env.MEGACOMPACT_STATE_DIR;
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  it("preserves fractional values (CAST AS REAL, not INTEGER)", () => {
-    addTokensSaved(10.5, dir);
-    assert.equal(getTokensSaved(dir), 10.5);
-    addTokensSaved(10.5, dir);
-    // With INTEGER: CAST("10.5" AS INTEGER)=10, 10+10.5=20.5.
-    // With REAL: CAST("10.5" AS REAL)=10.5, 10.5+10.5=21.
-    assert.equal(getTokensSaved(dir), 21);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// evictMemoryLru (memories.ts) — named @param bindings
-// ---------------------------------------------------------------------------
-
-describe("mechanical-fix: evictMemoryLru (memories.ts)", () => {
-  let dir: string;
-  before(() => {
-    dir = mkdtempSync(join(tmpdir(), "mc-mech-mem-"));
-    process.env.MEGACOMPACT_STATE_DIR = dir;
-    process.env.MEGACOMPACT_MEMORY_MAX_ROWS = "3";
-  });
-  after(() => {
-    closeStore(dir);
-    delete process.env.MEGACOMPACT_STATE_DIR;
-    delete process.env.MEGACOMPACT_MEMORY_MAX_ROWS;
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  it("evicts oldest rows past cap (repo-scoped, @repo named binding)", () => {
-    const repo = "test-repo";
-    for (let i = 0; i < 5; i++) {
-      addMemory({ content: `memory-${i}` }, repo, dir);
-    }
-    const memories = listMemories(repo, 100, dir);
-    assert.equal(memories.length, 3);
-    // Oldest two (memory-0, memory-1) evicted; memory-2, 3, 4 survive.
-    const contents = memories.map((m) => m.content).sort();
-    assert.deepEqual(contents, ["memory-2", "memory-3", "memory-4"]);
-  });
-
-  it("handles null-repo scope (repo IS NULL branch, @over only)", () => {
-    for (let i = 0; i < 4; i++) {
-      addMemory({ content: `nullmem-${i}` }, null, dir);
-    }
-    // listMemories(null, ...) returns ALL rows (no repo filter); narrow to
-    // null-repo rows to verify the IS NULL eviction branch in isolation.
-    const nullMemories = listMemories(null, 100, dir).filter((m) => m.repo === null);
-    assert.equal(nullMemories.length, 3);
-    // Oldest (nullmem-0) evicted.
-    const contents = nullMemories.map((m) => m.content).sort();
-    assert.deepEqual(contents, ["nullmem-1", "nullmem-2", "nullmem-3"]);
-  });
-});