pi-mega-compact 0.7.9 → 0.8.0

package/src/store/sqlite/game-scores.ts

@@ -0,0 +1,168 @@
+/**
+ * game-scores.ts — `game_scores` table accessors (S33).
+ *
+ * Per-repo leaderboard metrics for game mode. One row per recorded event
+ * (turn_end / session_compact); leaderboard() derives rankings (latest / max /
+ * SUM / COUNT DISTINCT) per repo_root. 'repos' is derived (never recorded).
+ *
+ * PREVENT-PI-004: local SQLite only, zero network.
+ * PREVENT-002: all SQL parameterized (? placeholders, no string concat of user
+ *   data). The metric is validated against a fixed allow-list before use; the
+ *   only interpolated fragments are code-controlled constants (the aggregate
+ *   selector + the optional repo_root filter clause), never external input.
+ * Pi-agnostic: no pi runtime types (mirrors game-state.ts / meta.ts).
+ */
+import { getStateDir } from "../../store.js";
+import { openStore } from "./utils.js";
+import type { SQLInputValue } from "node:sqlite";
+import { GameMetric, METRICS } from "../../game/scoring.js";
+
+// Process-local monotonic sequence appended into the low 3 digits of `ts` so
+// back-to-back inserts within the same millisecond get distinct PK values
+// (Date.now()*1000 + seq%1000). Production turns are >1ms apart, so seq is
+// almost always 0; this only disambiguates the burst case. Without it,
+// OR REPLACE would drop the earlier same-ms row and break the dedupe SUM.
+let scoreSeq = 0;
+function nextTs(): number {
+	return Date.now() * 1000 + (scoreSeq++ % 1000);
+}
+
+export type { GameMetric } from "../../game/scoring.js";
+export { METRICS } from "../../game/scoring.js";
+
+/** A single recorded game-score event (as stored). */
+export interface ScoreRow {
+	repo_root: string;
+	metric: GameMetric;
+	ts: number;
+	value: number;
+	meta?: unknown;
+}
+
+/** A leaderboard row returned by leaderboard(). */
+export interface LeaderboardRow {
+	repo_root: string;
+	value: number;
+	ts: number;
+	meta: unknown;
+}
+
+/** Options for leaderboard(): optional repo filter + result limit. */
+export interface LeaderboardOpts {
+	repoRoot?: string;
+	limit?: number;
+}
+
+/**
+ * Record one game-score event. `ts` is set to Date.now() by the store. SQL is
+ * fully parameterized (PREVENT-002); the metric is validated against the fixed
+ * allow-list. Pi-agnostic. Never throws except on a genuinely unknown metric.
+ */
+export function recordScore(
+	stateDir: string = getStateDir(),
+	args: { repo_root: string; metric: GameMetric; value: number; meta?: unknown },
+): void {
+	if (!METRICS.includes(args.metric)) {
+		throw new Error(`recordScore: unknown game metric ${String(args.metric)}`);
+	}
+	const db = openStore(stateDir);
+	db.prepare(
+		`INSERT INTO game_scores (repo_root, metric, ts, value, meta)
+		 VALUES (?, ?, ?, ?, ?)`,
+	).run(
+		args.repo_root,
+		args.metric,
+		nextTs(),
+		args.value,
+		args.meta != null ? JSON.stringify(args.meta) : null,
+	);
+}
+
+/**
+ * Read the leaderboard for a metric:
+ *   - cache/turns: latest value per repo_root, sorted desc by value.
+ *   - mega_cache: the max value (trophy) per repo_root, sorted desc.
+ *   - dedupe: SUM(value) per repo_root (cumulative collapses), sorted desc.
+ *   - repos: COUNT(DISTINCT repo_root) — derived; returns a single synthesized
+ *     row (repo_root '*') with the distinct-repo count as `value`.
+ * The metric is validated against the allow-list. Pi-agnostic.
+ */
+export function leaderboard(
+	stateDir: string = getStateDir(),
+	metric: GameMetric,
+	opts: LeaderboardOpts = {},
+): LeaderboardRow[] {
+	if (!METRICS.includes(metric)) {
+		throw new Error(`leaderboard: unknown game metric ${String(metric)}`);
+	}
+	const db = openStore(stateDir);
+	const limit = Math.max(1, opts.limit ?? 10);
+	// Code-controlled filter clauses (never external input) — safe under PREVENT-002.
+	// Two variants: the dedupe query is single-table (unqualified repo_root);
+	// the cache/turns/mega_cache query self-JOINs (must qualify as g.repo_root).
+	const repoFilterDedupe = opts.repoRoot != null ? " AND repo_root = ?" : "";
+	const repoFilter = opts.repoRoot != null ? " AND g.repo_root = ?" : "";
+	const repoParam: SQLInputValue[] = opts.repoRoot != null ? [opts.repoRoot] : [];
+
+	if (metric === "repos") {
+		const row = db
+			.prepare(`SELECT COUNT(DISTINCT repo_root) AS value FROM game_scores`)
+			.get() as { value: number };
+		return [{ repo_root: "*", value: row.value, ts: 0, meta: null }];
+	}
+
+	if (metric === "dedupe") {
+		const sql = `SELECT repo_root, SUM(value) AS value, MAX(ts) AS ts, NULL AS meta
+					 FROM game_scores
+					 WHERE metric = ?${repoFilterDedupe}
+					 GROUP BY repo_root
+					 ORDER BY value DESC
+					 LIMIT ?`;
+		const rows = db.prepare(sql).all(metric, ...repoParam, limit) as Array<{
+			repo_root: string;
+			value: number;
+			ts: number;
+			meta: string | null;
+		}>;
+		return rows.map(toLeaderboardRow);
+	}
+
+	// cache / turns / mega_cache: pick the qualifying row per repo_root (latest
+	// ts, or max value for mega_cache), then rank by value desc. The interpolated
+	// `key`/`col` fragments are derived from the validated metric — code constants,
+	// not user data (PREVENT-002 safe).
+	const key = metric === "mega_cache" ? "MAX(value)" : "MAX(ts)";
+	const col = metric === "mega_cache" ? "value" : "ts";
+	const sql = `SELECT g.repo_root, g.value AS value, g.ts AS ts, g.meta AS meta
+					 FROM game_scores g
+					 JOIN (SELECT repo_root, ${key} AS k
+							 FROM game_scores WHERE metric = ? GROUP BY repo_root) m
+						ON m.repo_root = g.repo_root AND m.k = g.${col}
+					 WHERE g.metric = ?${repoFilter}
+					 ORDER BY g.value DESC
+					 LIMIT ?`;
+	const rows = db
+		.prepare(sql)
+		.all(metric, metric, ...repoParam, limit) as Array<{
+		repo_root: string;
+		value: number;
+		ts: number;
+		meta: string | null;
+	}>;
+	return rows.map(toLeaderboardRow);
+}
+
+/** Helper: coerce a raw row (meta as JSON text) into a LeaderboardRow. */
+function toLeaderboardRow(r: {
+	repo_root: string;
+	value: number;
+	ts: number;
+	meta: string | null;
+}): LeaderboardRow {
+	return {
+		repo_root: r.repo_root,
+		value: r.value,
+		ts: r.ts,
+		meta: r.meta != null ? JSON.parse(r.meta) : null,
+	};
+}

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

@@ -0,0 +1,89 @@
+/**
+ * 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/game-state.ts

@@ -0,0 +1,87 @@
+/**
+ * game-state.ts — `game_state` table: the global game-mode toggle state (S30).
+ *
+ * Single row (id=1) holding: game_mode_on (bool), theme (one of THEME_IDS),
+ * tui_display_mode ('full'|'minimal'). Global — one choice across all repos.
+ * Survives restarts; editable from /mega-game (TUI) or the dashboard panel
+ * (S32), both reading/writing this same row so they stay in sync.
+ *
+ * PREVENT-PI-004: local SQLite only, zero network.
+ * PREVENT-002: all SQL parameterized (@param / ? placeholders, no concat).
+ * Pi-agnostic: no pi runtime types (mirrors meta.ts / session-state.ts).
+ */
+import { DatabaseSync } from "node:sqlite";
+import { getStateDir } from "../../store.js";
+import { openStore } from "./utils.js";
+import { DEFAULT_THEME, isValidTheme } from "../../config/themes.js";
+
+/** The persisted game-mode state. `theme` is always a valid THEME_IDS member
+ *  (callers may assume the invariant; setGameState validates). */
+export interface GameState {
+  game_mode_on: boolean;
+  theme: string;
+  tui_display_mode: "full" | "minimal";
+}
+
+export const DEFAULT_GAME_STATE: GameState = {
+  game_mode_on: false,
+  theme: DEFAULT_THEME,
+  tui_display_mode: "full",
+};
+
+/** Read the global game-mode state. Returns DEFAULT_GAME_STATE if the row is
+ *  absent (fresh install) or any column is unexpectedly null/invalid — never
+ *  throws, so the widget / command can call it on every render safely. */
+export function getGameState(stateDir: string = getStateDir()): GameState {
+  const db = openStore(stateDir);
+  return getGameStateRow(db);
+}
+
+/** Read the game state from an already-open connection (used by callers that
+ *  hold a db handle, e.g. within a transaction). Same defensive fallback. */
+export function getGameStateRow(db: DatabaseSync): GameState {
+  const row = db.prepare(
+    "SELECT game_mode_on, theme, tui_display_mode FROM game_state WHERE id = 1",
+  ).get() as { game_mode_on: number; theme: string; tui_display_mode: string } | undefined;
+  if (!row) return { ...DEFAULT_GAME_STATE };
+  const mode: "full" | "minimal" =
+    row.tui_display_mode === "minimal" ? "minimal" : "full";
+  return {
+    game_mode_on: row.game_mode_on === 1,
+    theme: isValidTheme(row.theme) ? row.theme : DEFAULT_THEME,
+    tui_display_mode: mode,
+  };
+}
+
+/** A partial update to the game state (omit fields you don't want to change). */
+export type GameStatePatch = Partial<GameState>;
+
+/** Upsert the game state row, applying `patch` on top of the current values.
+ *  Validates `theme` (keeps previous on an unknown id) and `tui_display_mode`
+ *  (coerces to 'full' on anything but 'minimal'). Parameterized (PREVENT-002).
+ *  Returns the post-write state. */
+export function setGameState(patch: GameStatePatch, stateDir: string = getStateDir()): GameState {
+  const db = openStore(stateDir);
+  return setGameStateRow(db, patch);
+}
+
+/** Upsert on an already-open connection (for transactional callers). */
+export function setGameStateRow(db: DatabaseSync, patch: GameStatePatch): GameState {
+  const cur = getGameStateRow(db);
+  const next: GameState = {
+    game_mode_on: patch.game_mode_on ?? cur.game_mode_on,
+    theme: patch.theme != null && isValidTheme(patch.theme) ? patch.theme : cur.theme,
+    tui_display_mode: patch.tui_display_mode ?? cur.tui_display_mode,
+  };
+  // Single-row upsert (id=1). INSERT ... ON CONFLICT(id) DO UPDATE keeps it
+  // one row whether the table is fresh or already seeded.
+  db.prepare(
+    `INSERT INTO game_state (id, game_mode_on, theme, tui_display_mode)
+     VALUES (1, ?, ?, ?)
+     ON CONFLICT(id) DO UPDATE SET
+       game_mode_on = excluded.game_mode_on,
+       theme = excluded.theme,
+       tui_display_mode = excluded.tui_display_mode`,
+  ).run(next.game_mode_on ? 1 : 0, next.theme, next.tui_display_mode);
+  return next;
+}

package/src/store/sqlite/schema.ts

@@ -2,6 +2,7 @@
  * schema.ts — table creation, migrations, `ensureColumn`, PRAGMA setup.
  */
 import { DatabaseSync } from "node:sqlite";
+import { ACHIEVEMENT_DEFS } from "../../game/scoring.js";
 
 const SCHEMA_VERSION = 2;
 
@@ -231,6 +232,41 @@ export function initSchema(db: DatabaseSync): void {
       first_seen_seq  INTEGER NOT NULL,
       created_at      INTEGER NOT NULL
     );
+
+    -- S30 game mode: global toggle state (single row, id=1). Holds the
+    -- game-mode on/off switch, the active visual-effect theme id, and the TUI
+    -- widget display mode. Global across all repos; written by /mega-game and
+    -- the dashboard settings strip (S32). Local SQLite (PREVENT-PI-004).
+    CREATE TABLE IF NOT EXISTS game_state (
+      id                 INTEGER PRIMARY KEY CHECK(id = 1),
+      game_mode_on       INTEGER NOT NULL DEFAULT 0,
+      theme              TEXT NOT NULL DEFAULT 'transparent',
+      tui_display_mode   TEXT NOT NULL DEFAULT 'full'
+                          CHECK(tui_display_mode IN ('full','minimal'))
+    );
+    -- S33 game mode: per-repo leaderboard metrics. One row per recorded event
+    -- (turn_end / session_compact); leaderboard() derives rankings. 'repos' is
+    -- derived (COUNT DISTINCT, never recorded). Local SQLite (PREVENT-PI-004).
+    CREATE TABLE IF NOT EXISTS game_scores (
+      repo_root TEXT NOT NULL,
+      metric    TEXT NOT NULL CHECK(metric IN ('cache','dedupe','turns','repos','mega_cache')),
+      ts        INTEGER NOT NULL,
+      value     REAL NOT NULL,
+      meta      TEXT,
+      PRIMARY KEY(repo_root, metric, ts)
+    ) WITHOUT ROWID;
+    CREATE INDEX IF NOT EXISTS idx_game_scores_metric_ts ON game_scores(metric, ts);
+
+    -- S35 game mode: achievements (9 rows, seeded idempotently on first open).
+    -- hidden=1 AND unlocked_at IS NULL => render NOTHING (no teaser). Local SQLite.
+    CREATE TABLE IF NOT EXISTS game_achievements (
+      id          TEXT PRIMARY KEY,
+      title       TEXT NOT NULL,
+      description TEXT NOT NULL,
+      hidden      INTEGER NOT NULL DEFAULT 0 CHECK(hidden IN (0,1)),
+      icon        TEXT,
+      unlocked_at INTEGER NULL
+    ) WITHOUT ROWID;
   `);
   // Idempotent column migrations. `CREATE TABLE IF NOT EXISTS` is a no-op on a
   // pre-existing table, so new columns added to context_chunks after a store was
@@ -249,6 +285,17 @@ export function initSchema(db: DatabaseSync): void {
   // S25: RAPTOR freshness-guard timestamp. Additive; old DBs have NULL → 0 →
   // treated as stale → flat fallback (safe).
   ensureColumn(db, "raptor_nodes", "built_at", "INTEGER");
+  // S35: idempotent seed of the 9 achievement rows. ON CONFLICT(id) DO
+  // NOTHING so a re-open never clobbers an already-unlocked row's
+  // unlocked_at. No user input reaches this SQL (PREVENT-002 safe).
+  const seedAch = db.prepare(
+    `INSERT INTO game_achievements (id, title, description, hidden, icon)
+     VALUES (?, ?, ?, ?, ?) ON CONFLICT(id) DO NOTHING`,
+  );
+  for (const d of ACHIEVEMENT_DEFS) {
+    seedAch.run(d.id, d.title, d.description, d.hidden ? 1 : 0, d.icon);
+  }
+
   const v = db.prepare("SELECT value FROM meta WHERE key='schema_version'").get() as
     | { value: string }
     | undefined;

package/src/store/sqlite.ts

@@ -20,3 +20,6 @@ export * from "./sqlite/raptor.js";
 export * from "./sqlite/raw-transcript.js";
 export * from "./sqlite/dedup-mirror.js";
 export * from "./sqlite/maintenance.js";
+export * from "./sqlite/game-state.js";
+export * from "./sqlite/game-scores.js";
+export * from "./sqlite/game-achievements.js";

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

@@ -1,37 +0,0 @@
-/**
- * File-reading helper functions for the dashboard server.
- */
-import { readFileSync } from "node:fs";
-export function readSnapshot(snapshotPath) {
-    try {
-        const raw = readFileSync(snapshotPath, "utf-8");
-        return JSON.parse(raw);
-    }
-    catch {
-        return {
-            version: 1,
-            updatedAt: null,
-            tier: "unknown",
-            config: { fastGatePct: 80, thresholdTokens: 100_000, anchorUserMessages: 1, preserveRecent: 2, auto: true, autoInlineK: 3 },
-            session: { id: null, state: null, persistedThisSession: false, lastCheckpointId: null, lastCompactedFrom: 0 },
-            context: { tokens: null, percent: null, contextWindow: 0 },
-            trigger: { armed: false, ready: false, currentTokens: null, thresholdTokens: 100_000, fastGatePct: 80 },
-            store: { checkpointCount: 0, totalTokenEstimate: 0, originalTokens: 0, tokensSaved: 0, injectedCount: 0, dedupHitRate: 0, storageDedupRate: 0, dedupCollapsed: 0 },
-            crew: { activeAgents: 0, currentTurn: 0 },
-            repo: { checkpointCount: 0, totalTokenEstimate: 0, originalTokens: 0, tokensSaved: 0, sessionCount: 0, dedupAttempts: 0, dedupCollapsed: 0, storageDedupRate: 0 },
-            integrity: { regionsRetained: 0, compressedOriginalBytes: 0, duplicatesCollapsed: 0, bytesPermanentlyDeleted: 0 },
-            model: undefined,
-        };
-    }
-}
-export function readFrom(path, charOffset) {
-    try {
-        const content = readFileSync(path, "utf-8");
-        if (content.length <= charOffset)
-            return { data: "", offset: charOffset };
-        return { data: content.slice(charOffset), offset: content.length };
-    }
-    catch {
-        return { data: "", offset: charOffset };
-    }
-}

package/dist/extensions/dashboard-server/html/all-repos-tab.js

@@ -1,26 +0,0 @@
-/**
- * "All repos" tab panel — machine-wide registry table (index.sqlite).
- *
- * Rows are populated by the index poller in `script.ts` (shared with the
- * in-panel table on the Current-repo tab via the same render call).
- */
-export function allReposTab() {
-    return `<!-- All repos (machine-wide registry from index.sqlite) -->
-<div class="tab-panel" id="panel-all">
-  <table class="repos">
-    <thead>
-      <tr>
-        <th>Repo</th><th>Model</th>
-        <th style="text-align:right">Checkpoints</th>
-        <th style="text-align:right">Tokens Saved</th>
-        <th style="text-align:right">Retained</th>
-        <th style="text-align:right">Last Compacted</th>
-      </tr>
-    </thead>
-    <tbody id="all-rows"><tr><td colspan="6" class="repo-none">loading…</td></tr></tbody>
-  </table>
-  <div class="updated" id="all-updated"></div>
-</div>
-
-`;
-}

package/dist/extensions/dashboard-server/html/body-open.js

@@ -1,23 +0,0 @@
-/**
- * Body opening: </head><body>, offline banner, page heading, and the tab nav.
- *
- * `tierName` is interpolated into the heading tier badge.
- * Includes the new "High Score" future-tab button (next project).
- */
-export function bodyOpen(tierName) {
-    return `</head>
-<body>
-
-<div class="offline-banner" id="offline-banner">Dashboard data unavailable — waiting for a pi session to write snapshot...</div>
-
-<h1><span>mega-compact</span><span class="tier">${tierName}</span><span class="model-pill" id="hdr-model">—</span></h1>
-
-<nav class="tabs">
-  <button class="tab active" data-tab="current">Current repo</button>
-  <button class="tab" data-tab="all">All repos</button>
-  <button class="tab" data-tab="summary">Summary</button>
-  <button class="tab future" data-tab="highscore">High Score<span class="soon">soon</span></button>
-</nav>
-
-`;
-}

package/dist/extensions/dashboard-server/html/current-repo-tab.js

@@ -1,130 +0,0 @@
-/**
- * "Current repo" tab panel — the per-repo dashboard view.
- *
- * Contains: context-window meter, trigger status, vector-store stats,
- * repo-wide stats, data-safety card, configuration, model & cost savings,
- * crew/agents, a legend, the live event stream, and the in-panel all-repos
- * table (shared rows with the All-repos tab via the index poller).
- *
- * `tierName` is interpolated into the Configuration card.
- */
-export function currentRepoTab(tierName) {
-    return `<!-- Current repo (existing single-repo view) -->
-<div class="tab-panel" id="panel-current">
-<div class="grid">
-  <div class="card">
-    <h2>Context Window</h2>
-    <div class="meter-label" id="ctx-pct">—</div>
-    <div class="meter-track"><div class="meter-fill" id="ctx-bar" style="width:0%"></div></div>
-    <div class="meter-sub" id="ctx-sub">waiting for data</div>
-  </div>
-  <div class="card">
-    <h2>Trigger Status</h2>
-    <div class="status-row"><div class="bullet" id="tr-armed"></div><span>Armed (context ≥ fast gate)</span></div>
-    <div class="status-row"><div class="bullet" id="tr-ready"></div><span>Ready (tokens ≥ threshold)</span></div>
-    <div class="state-text" id="tr-state">waiting</div>
-  </div>
-  <div class="card">
-    <h2>Vector Store</h2>
-    <div class="stat-grid">
-      <span class="label" title="A saved summary of a chunk of your conversation that was compacted to free up space.">Checkpoints</span><span class="value" id="st-count">0</span>
-      <span class="label" title="How much conversation we are currently holding as compact summaries (the 'memory' this extension keeps). Smaller is better.">Tokens Stored</span><span class="value" id="st-tokens">0</span>
-      <span class="label" title="Total size of the original conversation text before it was compacted.">Original Tokens</span><span class="value" id="st-orig">0</span>
-      <span class="label" title="How much conversation space we have freed up for you (original size minus the compact summary we kept).">Tokens Saved</span><span class="value" id="st-saved">0</span>
-      <span class="label" title="How many times old context was automatically brought back into the conversation because it was relevant to what you were doing.">Injected</span><span class="value" id="st-injected">0</span>
-      <span class="label" title="Of the times we recalled old context, how often it was actually on-topic.">Recall Relevance</span><span class="value" id="st-dedup">0%</span>
-      <span class="label" title="How often new content matched something we already had, so we skipped storing a duplicate copy. Higher = less wasted space.">Storage Dedup</span><span class="value" id="st-sdedup">0%</span>
-      <span class="label" title="How many duplicate chunks we collapsed into one instead of storing separately.">Collapsed</span><span class="value" id="st-collapsed">0</span>
-      <span class="label" title="The ID of the most recent saved checkpoint.">Last ID</span><span class="value" id="st-lastid">—</span>
-    </div>
-  </div>
-  <div class="card">
-    <h2>Repo (all sessions)</h2>
-    <div class="stat-grid">
-      <span class="label">Checkpoints</span><span class="value" id="rp-count">0</span>
-      <span class="label">Tokens Stored</span><span class="value" id="rp-tokens">0</span>
-      <span class="label">Original Tokens</span><span class="value" id="rp-orig">0</span>
-      <span class="label">Tokens Saved</span><span class="value" id="rp-saved">0</span>
-      <span class="label">Sessions</span><span class="value" id="rp-sessions">0</span>
-      <span class="label">Collapsed</span><span class="value" id="rp-collapsed">0</span>
-      <span class="label">Storage Dedup</span><span class="value" id="rp-sdedup">0%</span>
-    </div>
-  </div>
-  <div class="card safe">
-    <h2>🛡 Data Safety</h2>
-    <div class="stat-grid">
-      <span class="label">Regions Retained</span><span class="value" id="ig-retained">0</span>
-      <span class="label">Compressed-Original</span><span class="value" id="ig-bytes">0 B</span>
-      <span class="label">Dedup Duplicates</span><span class="value" id="ig-dupes">0</span>
-      <span class="label">Permanently Deleted</span><span class="value ok" id="ig-deleted">0 B</span>
-    </div>
-    <p class="safe-note">Every compacted region is kept verbatim (compressed). "Drop" = removed from the live window only. We never delete your data.</p>
-  </div>
-  <div class="card">
-    <h2>Configuration</h2>
-    <div class="conf-grid">
-      <span class="label">Tier</span><span class="value" id="cf-tier">${tierName}</span>
-      <span class="label">Threshold</span><span class="value" id="cf-threshold">—</span>
-      <span class="label">Fast Gate</span><span class="value" id="cf-gate">—</span>
-      <span class="label">Auto</span><span class="value" id="cf-auto">—</span>
-      <span class="label">Anchor</span><span class="value" id="cf-anchor">—</span>
-    </div>
-  </div>
-  <div class="card cost">
-    <h2>💰 Model &amp; Cost Savings</h2>
-    <div class="cost-usd" id="cost-usd">≈ $0.00 saved</div>
-    <div class="cost-sub" id="cost-windows">0 context-windows extended</div>
-    <div class="stat-grid" style="margin-top:12px">
-      <span class="label" title="The model pi is currently using — its pricing drives the cost figure.">Model</span><span class="value" id="md-name">—</span>
-      <span class="label" title="The provider serving the model.">Provider</span><span class="value" id="md-provider">—</span>
-      <span class="label" title="USD per input token, from the model's pricing.">Input Rate</span><span class="value" id="md-input">—</span>
-      <span class="label" title="USD per output token, from the model's pricing.">Output Rate</span><span class="value" id="md-output">—</span>
-    </div>
-  </div>
-  <div class="card">
-    <h2>Crew / Agents</h2>
-    <div class="stat-grid">
-      <span class="label">Active Agents</span><span class="value" id="cr-agents">0</span>
-      <span class="label">Current Turn</span><span class="value" id="cr-turn">0</span>
-      <span class="label">Status</span><span class="value" id="cr-status">idle</span>
-    </div>
-  </div>
-  <div class="card legend">
-    <h2>What these numbers mean</h2>
-    <ul class="legend-list">
-      <li><b>Tokens saved</b> — conversation space this extension has freed up for you (it compacted old text into short summaries).</li>
-      <li><b>Tokens stored</b> — how much "memory" (compact summaries) the extension is currently holding for this repo.</li>
-      <li><b>Injected</b> — times old context was automatically pasted back in because it was relevant to your current task.</li>
-      <li><b>Recall relevance</b> — of those, how often the recalled context was actually on-topic.</li>
-      <li><b>Storage dedup</b> — how often new content matched something already saved, so a duplicate copy was skipped (saves space).</li>
-      <li><b>Data safety</b> — every compacted region is kept verbatim (compressed). Nothing is permanently deleted; you can restore any of it.</li>
-    </ul>
-    <p class="legend-note">Hover any label above for a quick explanation.</p>
-  </div>
-</div>
-
-<div class="events">
-  <h2>Event Stream</h2>
-  <div class="events-wrap" id="events"><div class="empty">connecting…</div></div>
-</div>
-
-<h2 style="margin-top:24px;font-size:13px;color:#8b949e;text-transform:uppercase;letter-spacing:.5px">All Repositories</h2>
-<table class="repos">
-  <thead>
-    <tr>
-      <th>Repo</th><th>Model</th>
-      <th style="text-align:right">Checkpoints</th>
-      <th style="text-align:right">Tokens Saved</th>
-      <th style="text-align:right">Retained</th>
-      <th style="text-align:right">Last Compacted</th>
-    </tr>
-  </thead>
-  <tbody id="cur-rows"><tr><td colspan="6" class="repo-none">loading…</td></tr></tbody>
-</table>
-<div class="updated" id="cur-updated"></div>
-
-<div class="updated" id="updated"></div>
-</div><!-- /panel-current -->
-
-`;
-}

package/dist/extensions/dashboard-server/html/head-open.js

@@ -1,16 +0,0 @@
-/**
- * Document opening: DOCTYPE, <html>, <head> opening + meta/title.
- *
- * Styles are injected between this fragment and `bodyOpen()` by the
- * `dashboardHtml` composer in `../html-template.ts`.
- */
-export function headOpen() {
-    return `<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>mega-compact dashboard</title>
-`;
-    // trailing \n preserves the original blank-line separation to <style> in the composer
-}