pi-mega-compact 0.7.9 → 0.8.1

package/extensions/dashboard-server/server.test.ts

@@ -0,0 +1,131 @@
+/**
+ * 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: () => boolean | Promise<boolean>, timeoutMs = 6000): Promise<void> {
+  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: string): string {
+  return mkdtempSync(join(tmpdir(), prefix));
+}
+
+async function withServer<T>(
+  port: string,
+  dir: string,
+  fn: (port: number) => Promise<T>,
+): Promise<T> {
+  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()) as Array<{ repo_root: string; value: number; ts: number }>;
+      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())) as unknown[];
+      assert.equal(all.length, 3);
+      const capped = (await fetch(`http://localhost:${port}/api/game-scores?metric=cache&limit=2`).then((r) => r.json())) as unknown[];
+      assert.equal(capped.length, 2);
+      const zero = (await fetch(`http://localhost:${port}/api/game-scores?metric=cache&limit=0`).then((r) => r.json())) as unknown[];
+      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()) as Array<{ id: string; title: string; hidden: number; unlocked_at: number | null }>;
+      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/extensions/dashboard-server/server.ts

@@ -14,6 +14,7 @@ import { readSnapshot, readFrom } from "./snapshot.js";
 import { dashboardHtml } from "./html.js";
 import { ACTIVE_WINDOW_SEC } from "./types.js";
 import type { IndexIndex, Snapshot, LiveSnapshot } from "./types.js";
+import type { GameMetric } from "../../src/game/scoring.js";
 
 export async function launchDashboardServer(stateDir: string): Promise<{ port: number; url: string }> {
   // Our own package version — exposed at /api/version so the launcher can
@@ -21,10 +22,16 @@ export async function launchDashboardServer(stateDir: string): Promise<{ port: n
   // upgrade instead of reuse it.
   let SERVER_VERSION = "0.0.0";
   try {
-    // dashboard-server.js lives at <pkg>/dist/extensions/, so package.json is
-    // two levels up. Guard each candidate so a dev-checkout layout still works.
+    // Since v0.7.9 (8821ef3) dashboard-server.js lives at
+    // <pkg>/dist/extensions/dashboard-server/, so package.json is THREE levels
+    // up. Keep the two- and one-level-up candidates as fallbacks for flatter
+    // dev-checkout layouts. Guard each candidate so a missing file is skipped.
     const here = dirname(fileURLToPath(import.meta.url));
-    const candidates = [join(here, "..", "..", "package.json"), join(here, "..", "package.json")];
+    const candidates = [
+      join(here, "..", "..", "..", "package.json"),
+      join(here, "..", "..", "package.json"),
+      join(here, "..", "package.json"),
+    ];
     for (const p of candidates) {
       if (!existsSync(p)) continue;
       const pkg = JSON.parse(readFileSync(p, "utf-8"));
@@ -115,7 +122,7 @@ export async function launchDashboardServer(stateDir: string): Promise<{ port: n
     // 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") {
@@ -285,6 +292,152 @@ export async function launchDashboardServer(stateDir: string): Promise<{ port: n
       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") as typeof import("../../src/store/sqlite.js");
+      const { isValidTheme } = gsReq("../../src/config/themes.js") as typeof import("../../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: Buffer) => { // guardrails-allow PREVENT-PI-004: loopback dashboard request body (local)
+          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: Record<string, unknown> = {};
+          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: { game_mode_on?: boolean; theme?: string; tui_display_mode?: "full" | "minimal" } = {};
+        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") as typeof import("../../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 as readonly string[]).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 as GameMetric; // 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") as typeof import("../../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/extensions/dashboard-server-s32.test.ts

@@ -0,0 +1,195 @@
+/**
+ * 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: () => boolean | Promise<boolean>, timeoutMs = 6000): Promise<void> {
+  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: string): string {
+  return mkdtempSync(join(tmpdir(), prefix));
+}
+
+async function withServer<T>(
+  port: string,
+  dir: string,
+  fn: (port: number) => Promise<T>,
+): Promise<T> {
+  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())) as {
+        game_mode_on: boolean; theme: string; tui_display_mode: string;
+      };
+      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()) as { theme: string };
+      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()) as { error: string };
+      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()) as { tui_display_mode: string };
+      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()) as { game_mode_on: boolean };
+      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/extensions/mega-compact.ts

@@ -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-compact-settings (+ /mega-game alias) toggle + theme + TUI display mode
  *   - mega-dashboard-cmds.ts  localhost dashboard server lifecycle commands
  *   - mega-events.ts        pi lifecycle event handlers
  *
@@ -33,6 +34,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: ExtensionAPI) {
   const config = loadConfig();
@@ -42,4 +44,5 @@ export default function (pi: ExtensionAPI) {
   registerDashboardCommands(pi, runtime);
   registerConflictCommands(pi, runtime);
   registerDbCommands(pi, runtime);
+  registerGameCommands(pi, runtime);
 }

package/extensions/mega-events/agent-handlers.ts

@@ -14,6 +14,10 @@ import {
 	memoryReviewCadence,
 	type MegaConfig,
 } 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(
@@ -176,6 +180,50 @@ export function registerAgentHandlers(
 		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/extensions/mega-events/compact-handlers.ts

@@ -19,6 +19,9 @@ import {
 import { estimateBlockTokens } from "../../src/tokens.js";
 import { type MegaRuntime } from "../mega-runtime.js";
 import type { MegaConfig } from "../mega-config.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().
@@ -160,5 +163,30 @@ export function registerCompactHandlers(
 				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 */
+			}
 		});
 }

package/extensions/mega-events/context-handler.ts

@@ -83,14 +83,16 @@ export function registerContextHandler(
 	// Legacy: MEGACOMPACT_LEGACY_DURABLE_TRIM=true restores the v0.4.28 ctx.compact
 	// path (kept one release as rollback).
 	pi.on("context", async (event: ContextEvent, ctx: ExtensionContext) => {
-		if (!config.auto) return;
 		const usage = ctx.getContextUsage();
 		const pct = usage?.percent;
-		// Always track context for the dashboard, even if we return early below.
+		// Always track context for the dashboard/widget, even when auto is off.
+		// (v0.8 regression: !config.auto gate sat above this, leaving ctx stats
+		// null -> widget '?% / ?/?' when auto disabled. Track first, THEN gate.)
 		runtime.lastCtxTokens = usage?.tokens ?? null;
 		runtime.lastCtxPercent = pct ?? null;
 		runtime.lastCtxWindow = usage?.contextWindow ?? 0;
 		runtime.snapshot(ctx);
+		if (!config.auto) return;
 
 		const messages = event.messages;
 		const view = runtime.engineView(messages);