pi-mega-compact 0.8.6 → 0.8.8

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

@@ -186,6 +186,7 @@ export function dashboardHtml(tierName) {
   <button class="tab" data-tab="active">Active Repos</button>
   <button class="tab" data-tab="summary">Summary</button>
   <button class="tab" data-tab="game">Game Mode</button>
+  <button class="tab" data-tab="perf">Perf</button>
 </nav>
 
 <!-- Current repo (existing single-repo view) -->
@@ -440,6 +441,18 @@ export function dashboardHtml(tierName) {
   <div id="game-empty">No scores yet — run a session with game mode on.</div>
 </div>
 
+<!-- Perf (v0.8.8) — live local instrumentation -->
+<div class="tab-panel" id="panel-perf">
+  <div class="grid">
+    <div class="card"><h2>Model latency</h2><div class="stat-grid"><span class="label">Turn p50</span><span class="value" id="pf-turn-p50">—</span><span class="label">Turn p95</span><span class="value" id="pf-turn-p95">—</span><span class="label">Provider p50</span><span class="value" id="pf-prov-p50">—</span><span class="label">Provider p95</span><span class="value" id="pf-prov-p95">—</span></div></div>
+    <div class="card"><h2>Throughput</h2><div class="stat-grid"><span class="label">TPS (avg)</span><span class="value" id="pf-tps">—</span><span class="label">Cache hit %</span><span class="value" id="pf-cache">—</span></div></div>
+    <div class="card"><h2>Process</h2><div class="stat-grid"><span class="label">RSS</span><span class="value" id="pf-rss">—</span><span class="label">Heap</span><span class="value" id="pf-heap">—</span><span class="label">CPU user/sys</span><span class="value" id="pf-cpu">—</span></div></div>
+    <div class="card"><h2>Snapshot cost</h2><div class="stat-grid"><span class="label">DB recompute p50</span><span class="value" id="pf-db-p50">—</span><span class="label">DB recompute p95</span><span class="value" id="pf-db-p95">—</span><span class="label">Disk write p50</span><span class="value" id="pf-disk">—</span></div></div>
+    <div class="card"><h2>TUI lag proxy</h2><div class="stat-grid"><span class="label">Live-trim fires</span><span class="value" id="pf-recompute">—</span><span class="label">Cache replays</span><span class="value" id="pf-replays">—</span><span class="label">Fast-gate skips</span><span class="value" id="pf-skips">—</span></div><div class="meter-sub">skip vs recompute vs replay cadence</div></div>
+  </div>
+  <div class="updated" id="perf-updated">waiting for data</div>
+</div>
+
 <script>
 (function() {
   var evBox = document.getElementById('events');
@@ -997,9 +1010,40 @@ export function dashboardHtml(tierName) {
     }).catch(function() {});
   }
 
+  // --- Perf tab (v0.8.8) — live local instrumentation ----------------------
+  var perfPollTimer = null;
+  function pollPerf() {
+    fetch('/api/perf?minutes=30').then(function(r) { return r.ok ? r.json() : null; }).then(function(d) { // guardrails-allow PREVENT-PI-004: browser-side fetch in dashboard HTML template (not Node runtime)
+      if (!d) return;
+      var el = document.getElementById('perf-updated');
+      if (el) el.textContent = d.sampleCount + ' samples \u00b7 updated ' + (d.updatedAt || '');
+      function setText(id, txt) { var e = document.getElementById(id); if (e) e.textContent = txt; }
+      function fmtMs(v) { return v == null ? '\u2014' : (v >= 100 ? Math.round(v) + 'ms' : v.toFixed(1) + 'ms'); }
+      function fmtNum(v, dec) { return v == null ? '\u2014' : (typeof v === 'number' ? v.toFixed(dec) : '\u2014'); }
+      setText('pf-turn-p50', fmtMs(d.turn_latency_ms && d.turn_latency_ms.p50));
+      setText('pf-turn-p95', fmtMs(d.turn_latency_ms && d.turn_latency_ms.p95));
+      setText('pf-prov-p50', fmtMs(d.provider_latency_ms && d.provider_latency_ms.p50));
+      setText('pf-prov-p95', fmtMs(d.provider_latency_ms && d.provider_latency_ms.p95));
+      setText('pf-tps', fmtNum(d.tps && d.tps.avg, 1));
+      setText('pf-cache', (d.cache_hit_pct && typeof d.cache_hit_pct.avg === 'number') ? fmtNum(d.cache_hit_pct.avg, 1) + '%' : '\u2014');
+      setText('pf-rss', (d.rss_mb && typeof d.rss_mb.latest === 'number') ? fmtNum(d.rss_mb.latest, 1) + ' MB' : '\u2014');
+      setText('pf-heap', (d.heap_mb && typeof d.heap_mb.latest === 'number') ? fmtNum(d.heap_mb.latest, 1) + ' MB' : '\u2014');
+      setText('pf-cpu', (d.cpu_user_ms && d.cpu_sys_ms) ? (fmtNum(d.cpu_user_ms.latest,1) + ' / ' + fmtNum(d.cpu_sys_ms.latest,1) + ' ms') : '\u2014');
+      setText('pf-db-p50', fmtMs(d.db_recompute_ms && d.db_recompute_ms.p50));
+      setText('pf-db-p95', fmtMs(d.db_recompute_ms && d.db_recompute_ms.p95));
+      setText('pf-disk', fmtMs(d.disk_write_ms && d.disk_write_ms.p50));
+      var diag = d.diag || {};
+      setText('pf-recompute', diag.liveTrimFires != null ? String(diag.liveTrimFires) : '\u2014');
+      setText('pf-replays', diag.liveTrimReplays != null ? String(diag.liveTrimReplays) : '\u2014');
+      setText('pf-skips', diag.ctxFastGate != null ? String(diag.ctxFastGate) : '\u2014');
+    }).catch(function() {});
+  }
+  function startPerfPoll() { if (perfPollTimer) return; pollPerf(); perfPollTimer = setInterval(pollPerf, 2000); }
+  function stopPerfPoll() { if (perfPollTimer) { clearInterval(perfPollTimer); perfPollTimer = null; } }
+
   // --- Tab switching ------------------------------------------------------
   var tabs = document.querySelectorAll('.tab');
-  var panels = { current: 'panel-current', all: 'panel-all', active: 'panel-active', summary: 'panel-summary', game: 'panel-game' };
+  var panels = { current: 'panel-current', all: 'panel-all', active: 'panel-active', summary: 'panel-summary', game: 'panel-game', perf: 'panel-perf' };
   for (var i = 0; i < tabs.length; i++) {
     tabs[i].addEventListener('click', function() {
       var name = this.getAttribute('data-tab');
@@ -1014,6 +1058,7 @@ export function dashboardHtml(tierName) {
       if (name === 'all' || name === 'summary') pollIndex();
       if (name === 'active') pollServers();
       if (name === 'game') { renderGameScores(); renderAchievements(); }
+      if (name === 'perf') startPerfPoll(); else stopPerfPoll();
     });
   }
 })();

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

@@ -0,0 +1,80 @@
+/**
+ * perf-server.test.ts — v0.8.8 /api/perf endpoint (GET aggregates + 405).
+ * Mirrors the server.test.ts spawn-and-fetch harness (self-contained so the
+ * dashboard HTTP-port lane stays isolated).
+ */
+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 { recordPerfSample } 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("v0.8.8 /api/perf", () => {
+    test("GET returns aggregates over recorded perf_samples", async () => {
+        const dir = freshDir("dash-perf-agg-");
+        recordPerfSample(dir, "turn_latency_ms", 100, { turnIndex: 1 });
+        recordPerfSample(dir, "turn_latency_ms", 200);
+        recordPerfSample(dir, "tps", 50);
+        recordPerfSample(dir, "rss_mb", 256);
+        await withServer("19440", dir, async (port) => {
+            const res = await fetch(`http://localhost:${port}/api/perf?minutes=30`);
+            assert.equal(res.status, 200);
+            const d = (await res.json());
+            assert.equal(d.sampleCount, 4);
+            assert.equal(d.turn_latency_ms.n, 2);
+            assert.equal(d.turn_latency_ms.p50, 100); // nearest-rank p50 of [100,200]
+            assert.equal(d.turn_latency_ms.p95, 200); // nearest-rank p95 of [100,200]
+            assert.equal(d.tps.avg, 50);
+            assert.equal(d.rss_mb.latest, 256);
+            assert.equal(d.diag, null); // no runtime wrote dashboard.json in this dir
+        });
+    });
+    test("non-GET (POST) -> 405", async () => {
+        const dir = freshDir("dash-perf-meth-");
+        await withServer("19441", dir, async (port) => {
+            const res = await fetch(`http://localhost:${port}/api/perf`, { method: "POST" });
+            assert.equal(res.status, 405);
+        });
+    });
+});

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

@@ -444,6 +444,93 @@ export async function launchDashboardServer(stateDir) {
             }
             return;
         }
+        // /api/perf — v0.8.8 Perf dashboard tab. GET returns rolling-window
+        // aggregates over perf_samples: per-kind p50/p95 (turn/provider latency,
+        // tps avg, db recompute, disk write), latest rss/heap, cpu user/sys delta,
+        // cache hit %, plus the diag recompute/skip/replay counts (read from
+        // dashboard.json snapshot if available). The dashboard server is a detached
+        // child with no MegaRuntime ref, so it reads perf_samples via a require()'d
+        // sqlite helper (same pattern as /api/game-scores). Unknown/invalid params
+        // are clamped (never throw). Non-GET -> 405. PREVENT-PI-004: loopback.
+        if (req.url?.startsWith("/api/perf")) {
+            const pfReq = createRequire(import.meta.url);
+            const { readPerfSamples } = pfReq("../../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)
+                let minutes = Number(url.searchParams.get("minutes") ?? "30");
+                if (!Number.isFinite(minutes) || minutes <= 0)
+                    minutes = 30;
+                minutes = Math.min(minutes, 1440); // cap at 24h
+                const sinceTs = Date.now() - minutes * 60_000;
+                const rows = readPerfSamples(stateDir, sinceTs); // guardrails-allow PREVENT-PI-004: local SQLite read (loopback dashboard)
+                const byKind = new Map();
+                for (const r of rows) {
+                    let arr = byKind.get(r.kind);
+                    if (!arr) {
+                        arr = [];
+                        byKind.set(r.kind, arr);
+                    }
+                    arr.push(r.value);
+                }
+                // Nearest-rank percentile (ceil(p/100*n)-1, clamped). Code-controlled,
+                // never user input (PREVENT-002 safe).
+                function pct(arr, p) {
+                    if (!arr.length)
+                        return 0;
+                    const s = [...arr].sort((a, b) => a - b);
+                    const idx = Math.min(s.length - 1, Math.max(0, Math.ceil((p / 100) * s.length) - 1));
+                    return s[idx];
+                }
+                function avg(arr) {
+                    if (!arr.length)
+                        return 0;
+                    return arr.reduce((a, b) => a + b, 0) / arr.length;
+                }
+                // rows are ASC by ts, so the last pushed value is the most recent.
+                function latest(arr) {
+                    return arr.length ? arr[arr.length - 1] : 0;
+                }
+                const get = (k) => byKind.get(k) ?? [];
+                // diag counters live in the runtime-written dashboard.json (the server is
+                // a detached child with no MegaRuntime ref). Read defensively — absent
+                // until the first snapshot() write (PREVENT-001: assign before access).
+                let diag = null;
+                try {
+                    const raw = readFileSync(snapshotPath, "utf-8");
+                    const parsed = JSON.parse(raw);
+                    if (parsed && typeof parsed === "object" && parsed.diag)
+                        diag = parsed.diag;
+                }
+                catch { /* dashboard.json not written yet */ }
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({
+                    updatedAt: new Date().toISOString(),
+                    windowMinutes: minutes,
+                    sampleCount: rows.length,
+                    turn_latency_ms: { p50: pct(get("turn_latency_ms"), 50), p95: pct(get("turn_latency_ms"), 95), n: get("turn_latency_ms").length },
+                    provider_latency_ms: { p50: pct(get("provider_latency_ms"), 50), p95: pct(get("provider_latency_ms"), 95), n: get("provider_latency_ms").length },
+                    tps: { avg: avg(get("tps")), n: get("tps").length },
+                    cache_hit_pct: { avg: avg(get("cache_hit_pct")), latest: latest(get("cache_hit_pct")), n: get("cache_hit_pct").length },
+                    db_recompute_ms: { p50: pct(get("db_recompute_ms"), 50), p95: pct(get("db_recompute_ms"), 95), n: get("db_recompute_ms").length },
+                    disk_write_ms: { p50: pct(get("disk_write_ms"), 50), p95: pct(get("disk_write_ms"), 95), n: get("disk_write_ms").length },
+                    rss_mb: { latest: latest(get("rss_mb")), n: get("rss_mb").length },
+                    heap_mb: { latest: latest(get("heap_mb")), n: get("heap_mb").length },
+                    cpu_user_ms: { latest: latest(get("cpu_user_ms")), n: get("cpu_user_ms").length },
+                    cpu_sys_ms: { latest: latest(get("cpu_sys_ms")), n: get("cpu_sys_ms").length },
+                    diag,
+                }));
+            }
+            catch (e) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "perf_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

package/dist/extensions/mega-cache-replay.test.js

@@ -0,0 +1,189 @@
+/**
+ * mega-cache-replay.test.ts — locks the v0.8.7 cache-stability fix.
+ *
+ * Two tests (reuses the mega-teamrun.test.ts harness shape: mock pi + the REAL
+ * compiled extension at extensions/mega-compact.js):
+ *  a. REPLAY: drive >=2 gated context events past the debounce within ONE epoch
+ *     (same lastCheckpointId) and assert diagLiveTrimReplays > 0 AND the returned
+ *     messages array is byte-identical (deepEqual) across replays (stable prefix).
+ *  b. DEDUP-ON-DIFFERENT-CHECKPOINT: after a fresh trim, simulate a re-compact
+ *     (context grew on the token basis) that DEDUPS onto a DIFFERENT existing
+ *     checkpoint id (L0 contentHash match against an OLDER checkpoint, so
+ *     result.checkpointId != rt.lastCheckpointId), then assert the NEXT gated
+ *     event STILL replays (diagLiveTrimReplays increments) — i.e. the cache key
+ *     trimCache.checkpointId === rt.lastCheckpointId holds. This is the P2 gap the
+ *     v0.8.6 audit found: keying on the dedup-volatile result.checkpointId
+ *     disabled replay for the rest of the epoch after such a dedup fire.
+ *
+ * MEGACOMPACT_PGLITE_DISABLED keeps the run fast (no WASM index init).
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createRequire } from "node:module";
+import { closeVectorIndex } from "../src/store/vectorIndex.js";
+const require = createRequire(import.meta.url);
+const baseTmp = mkdtempSync(join(tmpdir(), "mc-cache-"));
+process.env.MEGACOMPACT_INDEX_DIR = join(baseTmp, "index");
+process.env.MEGACOMPACT_PGLITE_DISABLED = "true"; // fast: skip WASM index
+let counter = 0;
+function harness() {
+    const stateDir = join(baseTmp, `run-${counter++}`);
+    process.env.MEGACOMPACT_STATE_DIR = stateDir;
+    process.env.MEGACOMPACT_DEBUG = "true";
+    process.env.MEGACOMPACT_THRESHOLD_TOKENS = "50";
+    process.env.MEGACOMPACT_FAST_GATE_PCT = "1";
+    process.env.MEGACOMPACT_ANCHOR_USER_MESSAGES = "1";
+    process.env.MEGACOMPACT_DURABLE_TRIM_FLOOR = "0";
+    process.env.MEGACOMPACT_MEMORY_AUTO_REVIEW = "false";
+    process.env.MEGACOMPACT_RAPTOR_ENABLED = "false";
+    // Disable the FUZZY dedup tiers (L1 MinHash/LSH + L2 cosine) so the DEDUP test
+    // is controlled by L0 contentHash only: setB (different vocabulary) then
+    // creates a genuinely NEW checkpoint instead of fuzzy-matching setA's, and
+    // setA-re-again still L0-contentHash-dedups onto the first setA checkpoint.
+    // The TrigramEmbedder otherwise matches on shared structural trigrams
+    // ("— step N" / "Edit"), collapsing setB onto setA. Harmless for the REPLAY
+    // test (pure replay, no dedup reliance).
+    process.env.MEGACOMPACT_L1_ENABLED = "false";
+    process.env.MEGACOMPACT_L2_ENABLED = "false";
+    delete process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM;
+    // Mutable context-usage so tests can drive re-compact on the TOKEN basis by
+    // raising `tokens` while keeping `percent` null (→ token gate + token
+    // grewEnough path in context-handler.ts). The REPLAY test keeps percent=100 so
+    // the percent-basis grewEnough (>=10) never trips (no re-compact → pure replay).
+    const usage = { tokens: 200000, contextWindow: 200000, percent: 100 };
+    const handlers = {};
+    const compactCalls = [];
+    function msg(role, text, toolName) {
+        if (role === "assistant" && toolName) {
+            return { role: "assistant", content: [{ type: "toolCall", name: toolName, id: "c1", arguments: {} }], api: "anthropic-messages", provider: "anthropic", model: "m", usage: { inputTokens: 1, outputTokens: 1, cacheReadTokens: 0, cacheWriteTokens: 0 }, stopReason: "tool_use", timestamp: 0 };
+        }
+        if (role === "toolResult" && toolName) {
+            return { role: "toolResult", content: [{ type: "text", text }], toolCallId: "c1", toolName, isError: false, timestamp: 0 };
+        }
+        return { role: "user", content: text, timestamp: 0 };
+    }
+    // Build a session of `n` tool-call triples tagged `tag`. Set A and B differ in
+    // content (so B never dedups against A) but A === A reproduces the same
+    // regionText → same L0 contentHash → dedup onto the first A checkpoint.
+    function buildSession(tag, n) {
+        const s = [];
+        for (let i = 0; i < n; i++) {
+            s.push(msg("user", `[${tag}] we decided to use approach ${i} for module ${i}`));
+            s.push(msg("assistant", `[${tag}] edited module ${i}`, "Edit"));
+            s.push(msg("toolResult", `[${tag}] edited module ${i}`, "Edit"));
+        }
+        return s;
+    }
+    const toEntry = (m, i) => ({ type: "message", id: `e${i}`, parentId: null, timestamp: String(i), message: m });
+    const sessionManager = {
+        getSessionId: () => "sess_cache_001",
+        getEntries: () => buildSession("A", 14).map(toEntry),
+        getBranch: () => buildSession("A", 14).map(toEntry),
+    };
+    function makeCtx(over = {}) {
+        return {
+            ui: { setStatus: () => { }, notify: () => { }, select: () => { }, confirm: async () => true, input: async () => "", setWidget: () => { } },
+            mode: "tui", hasUI: true, cwd: stateDir, sessionManager,
+            modelRegistry: {}, model: undefined, isIdle: () => true, isProjectTrusted: () => true,
+            signal: undefined, abort: () => { }, hasPendingMessages: () => false, shutdown: () => { },
+            getContextUsage: () => ({ ...usage }),
+            compact: (opts) => { compactCalls.push(opts); return undefined; },
+            getSystemPrompt: () => "system base",
+            ...over,
+        };
+    }
+    const pi = {
+        on: (ev, h) => { handlers[ev] = h; },
+        registerCommand: () => { }, registerTool: () => { }, registerShortcut: () => { },
+        registerFlag: () => { }, getFlag: () => undefined, registerMessageRenderer: () => { },
+        registerEntryRenderer: () => { }, sendMessage: () => { }, sendUserMessage: () => { },
+        appendEntry: () => { }, setSessionName: () => { }, getSessionName: () => undefined,
+        setLabel: () => { }, exec: async () => ({ stdout: "", stderr: "", code: 0 }),
+        getActiveTools: () => [], getAllTools: () => [], setActiveTools: () => { },
+        getCommands: () => [], setModel: async () => false, getThinkingLevel: () => "off",
+        setThinkingLevel: () => { },
+    };
+    const mod = require("./mega-compact.js");
+    mod.default(pi);
+    const { lastRuntime } = require("./mega-events.js");
+    const fire = (ev, event, ctx) => handlers[ev](event, ctx);
+    return {
+        stateDir, handlers, compactCalls, fire, ctx: makeCtx, usage, buildSession,
+        runtime: lastRuntime, // MegaRuntime with diag* counters + rt + trimCache
+        // Bypass the 2s debounce so each fire proceeds without real waiting.
+        clearDebounce: () => { if (lastRuntime)
+            lastRuntime.debounceUntil = 0; },
+    };
+}
+test("REPLAY: >=2 gated context events within one epoch replay verbatim (byte-identical)", async () => {
+    const h = harness();
+    const ctx = h.ctx();
+    const session = h.buildSession("A", 14);
+    // Fire 3 gated context events; clearDebounce between so each passes the gate.
+    // percent stays 100 → percent-basis grewEnough (>=10) never trips → pure replay.
+    h.clearDebounce();
+    const r1 = await h.fire("context", { type: "context", messages: session }, ctx);
+    h.clearDebounce();
+    const r2 = await h.fire("context", { type: "context", messages: session }, ctx);
+    h.clearDebounce();
+    const r3 = await h.fire("context", { type: "context", messages: session }, ctx);
+    const rt = h.runtime;
+    assert.ok(rt.diagLiveTrimFires >= 1, "fresh trim fired on first event");
+    assert.ok(rt.diagLiveTrimReplays >= 2, `replay fired >=2 (got ${rt.diagLiveTrimReplays})`);
+    // byte-identical (stable KV-cache prefix) across replays
+    assert.deepEqual(r2?.messages, r3?.messages, "replay messages byte-identical across replays");
+    // replay matches the fresh-trim view (shallow-copy preserves content)
+    assert.deepEqual(r1?.messages, r2?.messages, "replay matches fresh-trim view (stable prefix)");
+});
+test("DEDUP: re-compact that dedups onto a DIFFERENT checkpoint still replays next (P2 fix)", async () => {
+    const h = harness();
+    // Token-basis growth path: percent null → token gate + token grewEnough
+    // (currentTokens - trimCache.ctxTokens >= effectiveThreshold * 0.5 = 25).
+    h.usage.percent = null;
+    h.usage.tokens = 200000;
+    const ctx = h.ctx();
+    const setA = h.buildSession("A", 14);
+    const setB = h.buildSession("B", 14); // different content, same length
+    const rt = h.runtime;
+    // 1) Fresh trim on setA → genuinely new checkpoint cp_A. lastCheckpointId = cp_A.
+    h.clearDebounce();
+    await h.fire("context", { type: "context", messages: setA }, ctx);
+    const cpA = rt.rt.lastCheckpointId;
+    assert.ok(cpA, "cp_A created on fresh trim");
+    assert.equal(rt.diagLiveTrimFires, 1, "first fire was a fresh trim");
+    // 2) Re-compact on setB (grew tokens) → genuinely new checkpoint cp_B (not deduped).
+    h.usage.tokens = 200100; // grew 100 >= 25
+    h.clearDebounce();
+    await h.fire("context", { type: "context", messages: setB }, ctx);
+    const cpB = rt.rt.lastCheckpointId;
+    assert.notEqual(cpB, cpA, "cp_B is a different, genuinely new checkpoint");
+    assert.equal(rt.rt.dedupSkips, 0, "setB did not dedup (different vocabulary, fuzzy tiers off)");
+    // 3) Re-compact on setA AGAIN (grew tokens) → L0 contentHash dedup onto cp_A.
+    //    result.checkpointId = cp_A (!= lastCheckpointId cp_B); lastCheckpointId is
+    //    NOT updated on a dedup (compact.ts:100-104), so it stays cp_B. With the
+    //    fix, trimCache.checkpointId is keyed on lastCheckpointId (cp_B), NOT the
+    //    dedup-volatile result.checkpointId (cp_A).
+    h.usage.tokens = 200200; // grew 100 >= 25
+    h.clearDebounce();
+    await h.fire("context", { type: "context", messages: setA }, ctx);
+    assert.equal(rt.rt.lastCheckpointId, cpB, "dedup did NOT bump lastCheckpointId (still cp_B)");
+    assert.ok(rt.rt.dedupSkips >= 1, "setA re-compact deduped onto an existing checkpoint");
+    // The P2 invariant: the cache key must equal the stable epoch signal.
+    assert.equal(rt.trimCache?.checkpointId, rt.rt.lastCheckpointId, "trimCache.checkpointId keyed on lastCheckpointId (P2 fix), not dedup-volatile result.checkpointId");
+    // 4) Next gated event (no growth) MUST replay instead of re-running runCompact.
+    //    Without the fix, trimCache.checkpointId (cp_A) != lastCheckpointId (cp_B)
+    //    → the replay condition is false → runCompact re-runs every fire → the
+    //    thrash silently persists in that path (the audit's finding).
+    const replaysBefore = rt.diagLiveTrimReplays;
+    h.usage.tokens = 200200; // no growth → replay
+    h.clearDebounce();
+    await h.fire("context", { type: "context", messages: setA }, ctx);
+    assert.ok(rt.diagLiveTrimReplays > replaysBefore, `replay fired after dedup-onto-different-checkpoint (got ${rt.diagLiveTrimReplays}, was ${replaysBefore})`);
+});
+test("cleanup", async () => {
+    await closeVectorIndex();
+    rmSync(baseTmp, { recursive: true, force: true });
+});

package/dist/extensions/mega-dashboard.js

@@ -23,9 +23,18 @@ export class Dashboard {
         this.snapshotPath = join(stateDir, "dashboard.json");
         this.eventsPath = join(stateDir, "events.log");
     }
+    /** v0.8.8: duration (ms) of the last dashboard.json write — read by
+     *  MegaRuntime.snapshot() to record a `disk_write_ms` perf sample without
+     *  wrapping the giant snapshot object literal at the call site. */
+    _lastWriteMs = 0;
+    get lastWriteMs() {
+        return this._lastWriteMs;
+    }
     /** Write a full state snapshot (atomically replaces previous). */
     snapshot(data) {
+        const t = performance.now();
         writeFileSync(this.snapshotPath, JSON.stringify(data, null, 2) + "\n");
+        this._lastWriteMs = performance.now() - t;
     }
     /** Append a timestamped JSONL event line. */
     event(type, data) {

package/dist/extensions/mega-events/context-handler.js

@@ -146,7 +146,9 @@ export function registerContextHandler(pi, runtime, config) {
                 runtime.diagLiveTrimFires++; // trim view returned this call (replay counts as a fire)
                 runtime.diagLiveTrimReplays++;
                 runtime.snapshot(ctx);
-                return { messages: [runtime.trimCache.summaryAgentMsg, ...recent] };
+                // v0.8.7: shallow-copy the cached summary so pi's transformContext can't
+                // mutate the shared reference across replays (audit P3).
+                return { messages: [{ ...runtime.trimCache.summaryAgentMsg }, ...recent] };
             }
             // else: context grew enough → fall through to re-compact (cache is stale)
         }
@@ -262,7 +264,20 @@ export function registerContextHandler(pi, runtime, config) {
             // replay it verbatim (stabilizing the KV-cache prefix) instead of
             // regenerating a fresh summary + sentinel every fire.
             runtime.trimCache = {
-                checkpointId: ran.result.checkpointId ?? `epoch-${runtime.rt.lastCompactAt ?? Date.now()}`,
+                // v0.8.7: key the replay cache on the STABLE epoch signal
+                // (rt.lastCheckpointId) instead of ran.result.checkpointId, which is
+                // dedup-volatile: on a re-compact that dedups onto a DIFFERENT existing
+                // checkpoint, result.checkpointId is the matched id (engine.ts:188) while
+                // lastCheckpointId is only updated on a genuinely new checkpoint
+                // (compact.ts:100-104). Keying on result.checkpointId would make
+                // trimCache.checkpointId != rt.lastCheckpointId forever after that
+                // dedup fire, disabling replay for the rest of the epoch (the
+                // alternating cache-miss that 0.8.6 meant to fix). Prefer the stable
+                // signal; fall back to result.checkpointId then the epoch timestamp
+                // only for the no-checkpoint edge case.
+                checkpointId: runtime.rt.lastCheckpointId ??
+                    ran.result.checkpointId ??
+                    `epoch-${runtime.rt.lastCompactAt ?? Date.now()}`,
                 cut,
                 summaryAgentMsg,
                 ctxPct: pct ?? null,

package/dist/extensions/mega-events/perf-handler.js

@@ -0,0 +1,71 @@
+import { recordPerfSample } from "../../src/store/sqlite.js";
+/** Narrow a turn_end message to its usage block when it is an assistant msg. */
+function usageOf(msg) {
+    if (msg.role !== "assistant" || !msg.usage)
+        return null;
+    return msg.usage;
+}
+/** Register perf instrumentation handlers + start the 5s cpu/mem interval. */
+export function registerPerfHandler(pi, runtime) {
+    // turn_start: record the wall-clock start of the turn. Using Date.now() (not
+    // event.timestamp) so the turn_end duration is on ONE clock — mixing pi's
+    // timestamp with Date.now() would skew the delta. Also (re)arms the cpu/mem
+    // interval so a new session after a dispose() resumes sampling on its first
+    // turn (the interval is cleared in runtime.dispose()).
+    pi.on("turn_start", async () => {
+        try {
+            runtime.perfTurnStart = Date.now();
+            runtime.ensurePerfInterval();
+        }
+        catch {
+            /* non-fatal */
+        }
+    });
+    // turn_end: compute turn latency + TPS + cache hit % from the assistant
+    // message's usage block. One perf_samples row per metric per turn.
+    pi.on("turn_end", async (event) => {
+        try {
+            if (runtime.perfTurnStart > 0) {
+                const durMs = Date.now() - runtime.perfTurnStart;
+                recordPerfSample(runtime.currentStateDir, "turn_latency_ms", durMs, {
+                    turnIndex: event.turnIndex,
+                });
+                const u = usageOf(event.message);
+                if (u) {
+                    const durSec = Math.max(durMs / 1000, 0.001);
+                    recordPerfSample(runtime.currentStateDir, "tps", u.output / durSec, { outputTokens: u.output });
+                    const denom = u.cacheRead + u.input + u.cacheWrite;
+                    const hitPct = denom > 0 ? (u.cacheRead / denom) * 100 : 0;
+                    recordPerfSample(runtime.currentStateDir, "cache_hit_pct", hitPct, { input: u.input, cacheRead: u.cacheRead, cacheWrite: u.cacheWrite });
+                }
+            }
+        }
+        catch {
+            /* non-fatal: instrumentation must never break the agent loop */
+        }
+    });
+    // before_provider_request -> after_provider_response: raw round-trip latency
+    // to the model endpoint (HTTP status carried on the response event).
+    pi.on("before_provider_request", async () => {
+        try {
+            runtime.perfProviderStart = Date.now();
+        }
+        catch {
+            /* non-fatal */
+        }
+    });
+    pi.on("after_provider_response", async (event) => {
+        try {
+            if (runtime.perfProviderStart > 0) {
+                const lat = Date.now() - runtime.perfProviderStart;
+                recordPerfSample(runtime.currentStateDir, "provider_latency_ms", lat, { status: event.status });
+            }
+        }
+        catch {
+            /* non-fatal */
+        }
+    });
+    // Start the 5s cpu/mem sampling interval (one per MegaRuntime; cleared in
+    // runtime.dispose()). Idempotent — safe to call again after a dispose().
+    runtime.ensurePerfInterval();
+}

package/dist/extensions/mega-events/register.js

@@ -2,6 +2,7 @@ import { registerSessionHandlers } from "./session-handlers.js";
 import { registerAgentHandlers } from "./agent-handlers.js";
 import { registerContextHandler } from "./context-handler.js";
 import { registerCompactHandlers } from "./compact-handlers.js";
+import { registerPerfHandler } from "./perf-handler.js";
 /**
  * DIAG accessor for the headless test harness: the most recently constructed
  * MegaRuntime, so a test that loads the compiled extension via its default
@@ -18,4 +19,5 @@ export function registerEventHandlers(pi, runtime, config) {
     registerAgentHandlers(pi, runtime, config);
     registerContextHandler(pi, runtime, config);
     registerCompactHandlers(pi, runtime, config);
+    registerPerfHandler(pi, runtime);
 }

package/dist/extensions/mega-events.js

@@ -15,3 +15,4 @@ export * from "./mega-events/session-handlers.js";
 export * from "./mega-events/agent-handlers.js";
 export * from "./mega-events/context-handler.js";
 export * from "./mega-events/compact-handlers.js";
+export * from "./mega-events/perf-handler.js";