pi-mega-compact 0.7.9 → 0.8.0

package/dist/extensions/dashboard-server/server.js

@@ -123,7 +123,7 @@ export async function launchDashboardServer(stateDir) {
         // guardrails-allow PREVENT-PI-004: optional, user-triggered /dashboard localhost server (loopback-only) — CORS open for local browser access
         // CORS for local access
         res.setHeader("Access-Control-Allow-Origin", "*");
-        res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+        res.setHeader("Access-Control-Allow-Methods", "GET, PUT, OPTIONS");
         res.setHeader("Access-Control-Allow-Headers", "Content-Type");
         if (req.method === "OPTIONS") {
             res.writeHead(204);
@@ -301,6 +301,166 @@ export async function launchDashboardServer(stateDir) {
             });
             return;
         }
+        // /api/game-state — S32 game-mode settings (game_mode_on / theme /
+        // tui_display_mode). GET returns the current row; PUT applies a partial
+        // patch (validated) and returns the post-write row. The dashboard server is
+        // a detached child with no MegaRuntime ref, so it reads/writes the
+        // game_state SQLite row directly; the in-process MegaRuntime picks up the
+        // change via its fs.watch cache-eviction watcher. PREVENT-PI-004: loopback.
+        if (req.url?.startsWith("/api/game-state")) {
+            const gsReq = createRequire(import.meta.url);
+            const { getGameState, setGameState } = gsReq("../../src/store/sqlite.js");
+            const { isValidTheme } = gsReq("../../src/config/themes.js");
+            if (req.method === "GET") {
+                try {
+                    const gs = getGameState(stateDir); // guardrails-allow PREVENT-PI-004: local SQLite read (loopback dashboard)
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify(gs));
+                }
+                catch (e) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "game_state_unavailable", detail: String(e) }));
+                }
+                return;
+            }
+            if (req.method === "PUT") {
+                // Read + parse the JSON body (capped — the patch is tiny). The handler
+                // is sync, so drain the stream via data/end listeners then continue.
+                let body = "";
+                let tooBig = false;
+                req.on("data", (chunk) => {
+                    if (body.length > 65536) {
+                        tooBig = true;
+                        return;
+                    }
+                    body += chunk.toString();
+                });
+                req.on("end", () => {
+                    if (tooBig) {
+                        res.writeHead(413, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "body_too_large" }));
+                        return;
+                    }
+                    let patch = {};
+                    try {
+                        patch = body ? JSON.parse(body) : {};
+                    }
+                    catch {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "invalid_json" }));
+                        return;
+                    }
+                    // Reject valid-but-non-object JSON (null/[]/42) — dereferencing
+                    // patch.game_mode_on would throw an unhandled TypeError inside this
+                    // 'end' listener and crash the detached server (audit P1: loopback DoS).
+                    if (typeof patch !== "object" || patch === null || Array.isArray(patch)) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "invalid_patch_object" }));
+                        return;
+                    }
+                    // Validate the patch fields (unknown keys ignored; invalid values -> 400).
+                    const clean = {};
+                    let bad = false;
+                    if (patch.game_mode_on != null) {
+                        if (typeof patch.game_mode_on !== "boolean")
+                            bad = true;
+                        else
+                            clean.game_mode_on = patch.game_mode_on;
+                    }
+                    if (patch.theme != null) {
+                        if (typeof patch.theme !== "string" || !isValidTheme(patch.theme))
+                            bad = true;
+                        else
+                            clean.theme = patch.theme;
+                    }
+                    if (patch.tui_display_mode != null) {
+                        if (patch.tui_display_mode !== "full" && patch.tui_display_mode !== "minimal")
+                            bad = true;
+                        else
+                            clean.tui_display_mode = patch.tui_display_mode;
+                    }
+                    if (bad) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "invalid_patch" }));
+                        return;
+                    }
+                    try {
+                        const gs = setGameState(clean, stateDir); // guardrails-allow PREVENT-PI-004: local SQLite write (loopback dashboard)
+                        res.writeHead(200, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify(gs));
+                    }
+                    catch (e) {
+                        res.writeHead(500, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "game_state_write_failed", detail: String(e) }));
+                    }
+                });
+                return;
+            }
+            // Any other method on /api/game-state → 405.
+            res.writeHead(405, { "Content-Type": "application/json" }); // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+            res.end(JSON.stringify({ error: "method_not_allowed" }));
+            return;
+        }
+        // /api/game-scores — S34 high-score leaderboards. GET returns the leaderboard
+        // for a metric (?metric=<m>&limit=<n>). `metric` is validated against the
+        // METRICS allow-list from src/game/scoring (re-exported via the sqlite barrel);
+        // default limit 10, clamped to [1,100]. The dashboard server is a detached
+        // child with no MegaRuntime ref, so it reads the game_scores SQLite table
+        // directly. Unknown metric -> 400, non-GET -> 405. PREVENT-PI-004: loopback.
+        if (req.url?.startsWith("/api/game-scores")) {
+            const gsReq = createRequire(import.meta.url);
+            const { leaderboard, METRICS } = gsReq("../../src/store/sqlite.js");
+            if (req.method !== "GET") {
+                res.writeHead(405, { "Content-Type": "application/json" }); // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+                res.end(JSON.stringify({ error: "method_not_allowed" }));
+                return;
+            }
+            try {
+                const url = new URL(req.url, "http://x"); // guardrails-allow PREVENT-PI-004: localhost dashboard URL base (loopback-only)
+                const metricParam = url.searchParams.get("metric") ?? "cache";
+                if (!METRICS.includes(metricParam)) {
+                    res.writeHead(400, { "Content-Type": "application/json" }); // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+                    res.end(JSON.stringify({ error: "unknown_metric", metric: metricParam }));
+                    return;
+                }
+                const metric = metricParam; // validated against METRICS above
+                let limit = Number(url.searchParams.get("limit") ?? "10");
+                if (!Number.isFinite(limit) || limit <= 0)
+                    limit = 10;
+                limit = Math.min(Math.max(limit, 1), 100); // clamp to [1,100]
+                const rows = leaderboard(stateDir, metric, { limit }); // guardrails-allow PREVENT-PI-004: local SQLite read (loopback dashboard)
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(rows));
+            }
+            catch (e) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "game_scores_unavailable", detail: String(e) }));
+            }
+            return;
+        }
+        // /api/achievements — S35 achievement tiles. GET returns the 9 seeded rows
+        // {id,title,description,icon,hidden,unlocked_at}. The dashboard server is a
+        // detached child with no MegaRuntime ref, so it reads game_achievements via
+        // listAchievements(stateDir) directly. Non-GET -> 405. PREVENT-PI-004: loopback.
+        if (req.url?.startsWith("/api/achievements")) {
+            const achReq = createRequire(import.meta.url);
+            const { listAchievements } = achReq("../../src/store/sqlite.js");
+            if (req.method !== "GET") {
+                res.writeHead(405, { "Content-Type": "application/json" }); // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+                res.end(JSON.stringify({ error: "method_not_allowed" }));
+                return;
+            }
+            try {
+                const rows = listAchievements(stateDir); // guardrails-allow PREVENT-PI-004: local SQLite read (loopback dashboard)
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(rows));
+            }
+            catch (e) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "achievements_unavailable", detail: String(e) }));
+            }
+            return;
+        }
         // Fallback — serve the dashboard
         const tier = readSnapshot(snapshotPath).tier;
         res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });

package/dist/extensions/dashboard-server/server.test.js

@@ -0,0 +1,120 @@
+/**
+ * server.test.ts — S34 /api/game-scores endpoint (GET leaderboard, metric
+ * validation, method + limit handling). Mirrors the S32 /api/game-state
+ * spawn-and-fetch harness.
+ */
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+import { recordScore } from "../../src/store/sqlite.js";
+const SERVER_ENTRY = new URL("./server.js", import.meta.url).pathname;
+function waitFor(cond, timeoutMs = 6000) {
+    const start = Date.now();
+    return new Promise((resolve, reject) => {
+        const tick = async () => {
+            if (await cond())
+                return resolve();
+            if (Date.now() - start > timeoutMs)
+                return reject(new Error("timeout"));
+            setTimeout(tick, 50);
+        };
+        tick();
+    });
+}
+function freshDir(prefix) {
+    return mkdtempSync(join(tmpdir(), prefix));
+}
+async function withServer(port, dir, fn) {
+    process.env.MEGACOMPACT_DASHBOARD_PORT = port;
+    const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
+    try {
+        await waitFor(async () => {
+            try {
+                const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
+                const res = await fetch(`http://localhost:${raw.port}/api/version`);
+                return res.ok;
+            }
+            catch {
+                return false;
+            }
+        });
+        const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
+        return await fn(raw.port);
+    }
+    finally {
+        child.kill("SIGTERM");
+        delete process.env.MEGACOMPACT_DASHBOARD_PORT;
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+describe("S34 /api/game-scores", () => {
+    test("GET ?metric=cache returns recorded rows as JSON array", async () => {
+        const dir = freshDir("dash-gs-cache-");
+        recordScore(dir, { repo_root: "/repo/a", metric: "cache", value: 42 });
+        await withServer("19430", dir, async (port) => {
+            const res = await fetch(`http://localhost:${port}/api/game-scores?metric=cache`);
+            assert.equal(res.status, 200);
+            const rows = (await res.json());
+            assert.ok(Array.isArray(rows));
+            assert.equal(rows.length, 1);
+            assert.equal(rows[0].repo_root, "/repo/a");
+            assert.equal(rows[0].value, 42);
+            assert.ok(typeof rows[0].ts === "number");
+        });
+    });
+    test("unknown metric -> 400", async () => {
+        const dir = freshDir("dash-gs-bad-");
+        await withServer("19431", dir, async (port) => {
+            const res = await fetch(`http://localhost:${port}/api/game-scores?metric=bogus`);
+            assert.equal(res.status, 400);
+        });
+    });
+    test("non-GET (POST) -> 405", async () => {
+        const dir = freshDir("dash-gs-meth-");
+        await withServer("19432", dir, async (port) => {
+            const res = await fetch(`http://localhost:${port}/api/game-scores`, { method: "POST" });
+            assert.equal(res.status, 405);
+        });
+    });
+    test("limit clamp: 3 rows -> default 10 returns 3, limit=2 caps to 2, limit<=0 clamps to >=1", async () => {
+        const dir = freshDir("dash-gs-lim-");
+        recordScore(dir, { repo_root: "/repo/a", metric: "cache", value: 1 });
+        recordScore(dir, { repo_root: "/repo/b", metric: "cache", value: 2 });
+        recordScore(dir, { repo_root: "/repo/c", metric: "cache", value: 3 });
+        await withServer("19433", dir, async (port) => {
+            const all = (await fetch(`http://localhost:${port}/api/game-scores?metric=cache`).then((r) => r.json()));
+            assert.equal(all.length, 3);
+            const capped = (await fetch(`http://localhost:${port}/api/game-scores?metric=cache&limit=2`).then((r) => r.json()));
+            assert.equal(capped.length, 2);
+            const zero = (await fetch(`http://localhost:${port}/api/game-scores?metric=cache&limit=0`).then((r) => r.json()));
+            assert.ok(zero.length >= 1, "limit<=0 clamps to >=1 row");
+        });
+    });
+});
+describe("S35 /api/achievements", () => {
+    test("GET returns the 9 seeded achievement rows", async () => {
+        const dir = freshDir("dash-ach-");
+        await withServer("19434", dir, async (port) => {
+            const res = await fetch(`http://localhost:${port}/api/achievements`);
+            assert.equal(res.status, 200);
+            const rows = (await res.json());
+            assert.ok(Array.isArray(rows));
+            assert.equal(rows.length, 9);
+            const opie = rows.find((r) => r.id === "opie_wild_ride");
+            assert.ok(opie, "opie_wild_ride seeded");
+            assert.equal(opie.hidden, 1);
+            assert.equal(opie.unlocked_at, null);
+            assert.equal(rows.find((r) => r.id === "first_compact").title, "First Compact");
+        });
+    });
+    test("non-GET (POST) -> 405", async () => {
+        const dir = freshDir("dash-ach-meth-");
+        await withServer("19435", dir, async (port) => {
+            const res = await fetch(`http://localhost:${port}/api/achievements`, { method: "POST" });
+            assert.equal(res.status, 405);
+        });
+    });
+});

package/dist/extensions/dashboard-server-s32.test.js

@@ -0,0 +1,181 @@
+/**
+ * dashboard-server.test.ts — S32 game-state API + settings strip tests.
+ *
+ * GET/PUT /api/game-state round-trips the game_state SQLite row through the
+ * real server subprocess (spawn + waitFor + fetch), and the HTML template
+ * carries the data-theme attribute + settings strip + theme CSS-var blocks.
+ */
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+import { dashboardHtml } from "./dashboard-server/html.js";
+import { setGameState, getGameState } from "../src/store/sqlite.js";
+const SERVER_ENTRY = new URL("./dashboard-server.js", import.meta.url).pathname;
+function waitFor(cond, timeoutMs = 6000) {
+    const start = Date.now();
+    return new Promise((resolve, reject) => {
+        const tick = async () => {
+            if (await cond())
+                return resolve();
+            if (Date.now() - start > timeoutMs)
+                return reject(new Error("timeout"));
+            setTimeout(tick, 50);
+        };
+        tick();
+    });
+}
+function freshDir(prefix) {
+    return mkdtempSync(join(tmpdir(), prefix));
+}
+async function withServer(port, dir, fn) {
+    process.env.MEGACOMPACT_DASHBOARD_PORT = port;
+    const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
+    try {
+        await waitFor(async () => {
+            try {
+                const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
+                const res = await fetch(`http://localhost:${raw.port}/api/version`);
+                return res.ok;
+            }
+            catch {
+                return false;
+            }
+        });
+        const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
+        return await fn(raw.port);
+    }
+    finally {
+        child.kill("SIGTERM");
+        delete process.env.MEGACOMPACT_DASHBOARD_PORT;
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+describe("S32 /api/game-state", () => {
+    test("GET returns the current game_state row (seeded via setGameState)", async () => {
+        const dir = freshDir("dash-gs-get-");
+        setGameState({ game_mode_on: true, theme: "retro", tui_display_mode: "minimal" }, dir);
+        await withServer("19330", dir, async (port) => {
+            const gs = (await fetch(`http://localhost:${port}/api/game-state`).then((r) => r.json()));
+            assert.equal(gs.game_mode_on, true);
+            assert.equal(gs.theme, "retro");
+            assert.equal(gs.tui_display_mode, "minimal");
+        });
+    });
+    test("PUT {theme:'retro'} -> 200 and getGameState(dir).theme === 'retro'", async () => {
+        const dir = freshDir("dash-gs-theme-");
+        await withServer("19331", dir, async (port) => {
+            const res = await fetch(`http://localhost:${port}/api/game-state`, {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ theme: "retro" }),
+            });
+            assert.equal(res.status, 200);
+            const body = (await res.json());
+            assert.equal(body.theme, "retro");
+            // And the authoritative DB read reflects the write.
+            assert.equal(getGameState(dir).theme, "retro");
+        });
+    });
+    test("PUT invalid theme 'bogus' -> 400 and row unchanged", async () => {
+        const dir = freshDir("dash-gs-invalid-");
+        setGameState({ theme: "orange-bold" }, dir);
+        const before = getGameState(dir).theme;
+        await withServer("19332", dir, async (port) => {
+            const res = await fetch(`http://localhost:${port}/api/game-state`, {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ theme: "bogus" }),
+            });
+            assert.equal(res.status, 400);
+        });
+        assert.equal(getGameState(dir).theme, before, "row unchanged after invalid PUT");
+    });
+    test("PUT body 'null' (valid-but-non-object JSON) -> 400, server stays up (audit P1)", async () => {
+        const dir = freshDir("dash-gs-nullobj-");
+        setGameState({ theme: "amber-mono" }, dir);
+        const before = getGameState(dir).theme;
+        await withServer("19335", dir, async (port) => {
+            // A valid-JSON-but-non-object body must NOT crash the detached server
+            // (audit P1: unhandled TypeError on patch.game_mode_on deref).
+            const res = await fetch(`http://localhost:${port}/api/game-state`, {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(null),
+            });
+            assert.equal(res.status, 400, "non-object JSON -> 400, not a crash");
+            const body = (await res.json());
+            assert.equal(body.error, "invalid_patch_object");
+            // Server must still be up — a follow-up GET must succeed.
+            const follow = await fetch(`http://localhost:${port}/api/game-state`);
+            assert.equal(follow.status, 200, "server survived the non-object PUT");
+        });
+        assert.equal(getGameState(dir).theme, before, "row unchanged after non-object PUT");
+    });
+    test("PUT body '[]' (array) -> 400, server stays up", async () => {
+        const dir = freshDir("dash-gs-arr-");
+        await withServer("19336", dir, async (port) => {
+            const res = await fetch(`http://localhost:${port}/api/game-state`, {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify([]),
+            });
+            assert.equal(res.status, 400);
+            const follow = await fetch(`http://localhost:${port}/api/game-state`);
+            assert.equal(follow.status, 200, "server survived the array PUT");
+        });
+    });
+    test("PUT {tui_display_mode:'minimal'} round-trips", async () => {
+        const dir = freshDir("dash-gs-tui-");
+        await withServer("19333", dir, async (port) => {
+            const res = await fetch(`http://localhost:${port}/api/game-state`, {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ tui_display_mode: "minimal" }),
+            });
+            assert.equal(res.status, 200);
+            const body = (await res.json());
+            assert.equal(body.tui_display_mode, "minimal");
+            assert.equal(getGameState(dir).tui_display_mode, "minimal");
+        });
+    });
+    test("PUT {game_mode_on:true} round-trips", async () => {
+        const dir = freshDir("dash-gs-mode-");
+        await withServer("19334", dir, async (port) => {
+            const res = await fetch(`http://localhost:${port}/api/game-state`, {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ game_mode_on: true }),
+            });
+            assert.equal(res.status, 200);
+            const body = (await res.json());
+            assert.equal(body.game_mode_on, true);
+            assert.equal(getGameState(dir).game_mode_on, true);
+        });
+    });
+});
+describe("S32 dashboard HTML skin", () => {
+    test("carries data-theme on <html> + settings strip + theme CSS-var blocks", () => {
+        const html = dashboardHtml("custom");
+        // default transparent theme attribute on <html>
+        assert.match(html, /<html lang="en" data-theme="transparent">/);
+        // settings strip with the three controls
+        assert.match(html, /<div class="settings-strip">/);
+        assert.match(html, /id="set-game-mode"/);
+        assert.match(html, /id="set-theme"/);
+        assert.match(html, /id="set-tui-mode"/);
+        // all 6 theme ids appear as :root[data-theme="<id>"] override blocks
+        for (const id of ["transparent", "retro", "orange-bold", "cyan-neon", "amber-mono", "grayscale"]) {
+            assert.ok(html.includes(`:root[data-theme="${id}"]{`), `${id} data-theme block present`);
+        }
+        // core CSS vars defined in the base :root
+        assert.match(html, /--bg: #0d1117;/);
+        assert.match(html, /--fg: #c9d1d9;/);
+        assert.match(html, /--accent: #3fb950;/);
+        assert.match(html, /--mega: #f0883e;/);
+        // body uses the themed var (not a hardcoded hex)
+        assert.match(html, /body\s*\{[^}]*background: var\(--bg\)/);
+    });
+});

package/dist/extensions/mega-compact.js

@@ -18,6 +18,7 @@
  *   - mega-runtime.ts       shared live state (MegaRuntime) + widget + model capture
  *   - mega-pipeline.ts      runCompact (Trident+persist) + doRecall (Layer 5)
  *   - mega-commands.ts      data/inspection slash commands
+ *   - mega-game-cmds.ts     /mega-game toggle + theme + TUI display mode
  *   - mega-dashboard-cmds.ts  localhost dashboard server lifecycle commands
  *   - mega-events.ts        pi lifecycle event handlers
  *
@@ -31,6 +32,7 @@ import { registerCommands } from "./mega-commands.js";
 import { registerDashboardCommands } from "./mega-dashboard-cmds.js";
 import { registerConflictCommands } from "./mega-conflict-cmds.js";
 import { registerDbCommands } from "./mega-db-cmds.js";
+import { registerGameCommands } from "./mega-game-cmds.js";
 export default function (pi) {
     const config = loadConfig();
     const runtime = new MegaRuntime(config);
@@ -39,4 +41,5 @@ export default function (pi) {
     registerDashboardCommands(pi, runtime);
     registerConflictCommands(pi, runtime);
     registerDbCommands(pi, runtime);
+    registerGameCommands(pi, runtime);
 }

package/dist/extensions/mega-events/agent-handlers.js

@@ -1,5 +1,9 @@
 import { piCompactWouldNoop, runMemoryReview, } from "../mega-pipeline.js";
 import { memoryReviewCadence, } from "../mega-config.js";
+import { recordScore } from "../../src/store/sqlite.js";
+import { evaluateAndUnlockAchievements } from "../../src/store/sqlite/game-achievements.js";
+import { isMegaCache } from "../../src/game/scoring.js";
+import { resolveRepoRoot } from "../mega-config.js";
 /** Register agent/turn tracking event handlers. */
 export function registerAgentHandlers(pi, runtime, config) {
     // ---- Agent tracking for real-time widget + status-line updates ---------
@@ -143,6 +147,51 @@ export function registerAgentHandlers(pi, runtime, config) {
     pi.on("turn_end", async (event, ctx) => {
         runtime.dashboard.event("turn_end", { turnIndex: event.turnIndex });
         runtime.snapshot(ctx);
+        // S33: game-mode scoring — record turns + cache metrics per repo, and arm
+        // the MEGA CACHE flare (oopsie gag) when the real dedup hit rate exceeds
+        // 100%. Gated behind game_mode_on (no scoring when off). Best-effort +
+        // non-fatal: a scoring failure must never break the agent loop (G6).
+        try {
+            if (runtime.getCachedGameState().game_mode_on) {
+                const repo = resolveRepoRoot(ctx.cwd) ?? runtime.currentStateDir;
+                const st = runtime.store.stats(runtime.rt.sessionId);
+                const cachePct = st.dedupHitRate * 100;
+                const modelId = runtime.currentModel?.modelId ?? "unknown";
+                recordScore(runtime.currentStateDir, {
+                    repo_root: repo,
+                    metric: "turns",
+                    value: runtime.currentTurn,
+                    meta: { modelId, turnIndex: event.turnIndex },
+                });
+                recordScore(runtime.currentStateDir, {
+                    repo_root: repo,
+                    metric: "cache",
+                    value: cachePct,
+                    meta: {
+                        hits: st.dedupCollapsed + runtime.rt.recallInjections,
+                        lookups: st.checkpointCount,
+                    },
+                });
+                // MEGA CACHE: the real ratio >1 (dedupHitRate>1) → trophy row + flare.
+                if (isMegaCache(cachePct)) {
+                    recordScore(runtime.currentStateDir, {
+                        repo_root: repo,
+                        metric: "mega_cache",
+                        value: cachePct,
+                        meta: { peakPct: cachePct, firstSeenTs: Date.now() },
+                    });
+                    runtime.armMegaCacheFlare(cachePct);
+                }
+                // S35: evaluate achievements after scoring; arm a one-time flare for
+                // the newly-unlocked ones (consumed by snapshot() → widget toast).
+                const newTitles = evaluateAndUnlockAchievements(runtime.currentStateDir);
+                if (newTitles.length)
+                    runtime.armAchievementFlare(newTitles);
+            }
+        }
+        catch {
+            /* non-fatal: scoring must never break the agent loop */
+        }
         // S20+S24: auto-review the conversation and persist durable memories. The
         // review cadence scales with pressure (memoryReviewCadence): as context
         // fills, the conversation is reviewed more often so memories keep pace with

package/dist/extensions/mega-events/compact-handlers.js

@@ -1,5 +1,8 @@
 import { driveNativeCompaction, } from "../mega-compact-driver.js";
 import { estimateBlockTokens } from "../../src/tokens.js";
+import { recordScore, getDedupStats } from "../../src/store/sqlite.js";
+import { evaluateAndUnlockAchievements } from "../../src/store/sqlite/game-achievements.js";
+import { resolveRepoRoot } from "../mega-config.js";
 /**
  * Build a minimal fallback compaction so pi never runs its throwing compact().
  *
@@ -129,5 +132,31 @@ export function registerCompactHandlers(pi, runtime, config) {
             sessionId: runtime.rt.sessionId,
             at: runtime.rt.lastCompactAt,
         });
+        // S33: game-mode dedupe scoring — record the DELTA of cumulative dedup
+        // collapses since the last compact (leaderboard SUMs the deltas). Gated
+        // behind game_mode_on (no scoring when off). Best-effort + non-fatal (G6).
+        try {
+            if (runtime.getCachedGameState().game_mode_on) {
+                const ds = getDedupStats(runtime.currentStateDir);
+                const delta = ds.deduped - runtime.lastDedupCollapsed;
+                runtime.lastDedupCollapsed = ds.deduped;
+                if (delta > 0) {
+                    const repo = resolveRepoRoot(_ctx.cwd) ?? runtime.currentStateDir;
+                    recordScore(runtime.currentStateDir, {
+                        repo_root: repo,
+                        metric: "dedupe",
+                        value: delta,
+                        meta: { compactCount: runtime.rt.compactCount },
+                    });
+                }
+            }
+            // S35: evaluate achievements after scoring; arm the one-time flare.
+            const newTitles = evaluateAndUnlockAchievements(runtime.currentStateDir);
+            if (newTitles.length)
+                runtime.armAchievementFlare(newTitles);
+        }
+        catch {
+            /* non-fatal: scoring must never break compaction */
+        }
     });
 }