pi-mega-compact 0.7.6 → 0.7.7

package/dist/src/store/sqlite.cachehit.test.js

@@ -0,0 +1,55 @@
+/**
+ * sqlite.cachehit.test.ts — tests for the live dashboard counters
+ * (incCompactCount / getCompactCount, incRecallInjected / getRecallInjected,
+ * incCacheHitTokens / getCacheHitTokensSaved). These reuse the schemaless
+ * `meta` integer counter, so no migration is required and the same on-disk
+ * SQLite store persists the tallies across (re)opens.
+ */
+import { describe, it, beforeEach, afterEach } 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 { openStore, incCompactCount, getCompactCount, incRecallInjected, getRecallInjected, incCacheHitTokens, getCacheHitTokensSaved, } from "./sqlite.js";
+describe("live dashboard counters (meta integers)", () => {
+    let dir;
+    beforeEach(() => {
+        dir = mkdtempSync(join(tmpdir(), "cachehit-test-"));
+    });
+    afterEach(() => {
+        rmSync(dir, { recursive: true, force: true });
+    });
+    it("increments + reads compact_count and persists on reopen", () => {
+        incCompactCount(dir);
+        incCompactCount(dir);
+        assert.equal(getCompactCount(dir), 2);
+        // Ensure the store handle is (re)opened and the value is read back from disk.
+        openStore(dir);
+        assert.equal(getCompactCount(dir), 2);
+    });
+    it("accumulates recall injections + cache-hit tokens", () => {
+        incRecallInjected(3, dir);
+        incRecallInjected(2, dir);
+        assert.equal(getRecallInjected(dir), 5);
+        incCacheHitTokens(1200, dir);
+        incCacheHitTokens(800, dir);
+        assert.equal(getCacheHitTokensSaved(dir), 2000);
+    });
+    it("ignores non-positive increments (no-op)", () => {
+        incRecallInjected(0, dir);
+        incRecallInjected(-5, dir);
+        incCacheHitTokens(0, dir);
+        assert.equal(getRecallInjected(dir), 0);
+        assert.equal(getCacheHitTokensSaved(dir), 0);
+    });
+    it("persists all three counters across a fresh openStore handle", () => {
+        incCompactCount(dir);
+        incRecallInjected(4, dir);
+        incCacheHitTokens(500, dir);
+        // openStore returns the canonical (on-disk) handle; reading back proves durability.
+        openStore(dir);
+        assert.equal(getCompactCount(dir), 1);
+        assert.equal(getRecallInjected(dir), 4);
+        assert.equal(getCacheHitTokensSaved(dir), 500);
+    });
+});

package/dist/src/store/sqlite.js

@@ -594,6 +594,29 @@ export function bumpDedupStats(deduped, stateDir = getStateDir()) {
     if (deduped)
         incMeta("deduped", 1, stateDir);
 }
+// --- Live dashboard counters (schemaless meta key/value — NO migration) -----
+// These reuse the private `incMeta` atomically-incrementing integer counter so
+// all cumulative tallies live in the same `meta` table as tokens_saved etc.
+export function incCompactCount(stateDir = getStateDir()) {
+    incMeta("compact_count", 1, stateDir);
+}
+export function getCompactCount(stateDir = getStateDir()) {
+    return getMetaNumber("compact_count", stateDir);
+}
+export function incRecallInjected(n, stateDir = getStateDir()) {
+    if (n > 0)
+        incMeta("recall_injected", n, stateDir);
+}
+export function getRecallInjected(stateDir = getStateDir()) {
+    return getMetaNumber("recall_injected", stateDir);
+}
+export function incCacheHitTokens(delta, stateDir = getStateDir()) {
+    if (delta > 0)
+        incMeta("cache_hit_tokens_saved", delta, stateDir);
+}
+export function getCacheHitTokensSaved(stateDir = getStateDir()) {
+    return getMetaNumber("cache_hit_tokens_saved", stateDir);
+}
 // --- Future-feature foundation (resume sessions / daily log / lessons) -------
 // Scaffolded tables + minimal helpers so all store data lives in SQLite from
 // day one. Full UI/recall for these lands in later sprints.

package/extensions/dashboard-server.test.ts

@@ -228,6 +228,75 @@ describe("multi-repo /api/index (S19)", () => {
   });
 });
 
+describe("multi-repo /api/servers (active cache-hit stats)", () => {
+  test("returns active repos with live dashboard.json cache-hit/compaction stats", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "dash-servers-"));
+    const indexDir = mkdtempSync(join(tmpdir(), "index-servers-"));
+    process.env.MEGACOMPACT_INDEX_DIR = indexDir;
+    process.env.MEGACOMPACT_DASHBOARD_PORT = "19323";
+
+    const { upsertRepoRegistry } = await import("../src/store/sqlite.js");
+
+    const activeState = mkdtempSync(join(tmpdir(), "srv-active-"));
+    writeFileSync(join(activeState, "dashboard.json"), JSON.stringify({
+      updatedAt: new Date().toISOString(),
+      tier: "high",
+      context: { tokens: 5000, percent: 0.42, contextWindow: 12000 },
+      session: { id: "s1", state: "idle" },
+      cacheHits: { session: 3, total: 7, sessionTokensSaved: 1200, totalTokensSaved: 9000 },
+      compacts: { session: 2, total: 5 },
+      timeSaved: { compact: { sessionSec: 1.5, totalSec: 4 }, cacheHit: { sessionSec: 0.6, totalSec: 4.5 } },
+    }, null, 2));
+    upsertRepoRegistry(
+      { repoRoot: "/home/u/active", displayName: "active", stateDir: activeState, checkpointCount: 4, tokensSaved: 9000, compressedOriginalBytes: 0, lastSeen: Math.floor(Date.now() / 1000), modelName: "gpt-4o", providerName: "OpenAI" },
+      indexDir,
+    );
+
+    const staleState = mkdtempSync(join(tmpdir(), "srv-stale-"));
+    writeFileSync(join(staleState, "dashboard.json"), JSON.stringify({ updatedAt: new Date().toISOString(), tier: "low" }, null, 2));
+    const longAgo = Math.floor(Date.now() / 1000) - 7 * 86_400;
+    upsertRepoRegistry(
+      { repoRoot: "/home/u/stale", displayName: "stale", stateDir: staleState, checkpointCount: 1, tokensSaved: 100, compressedOriginalBytes: 0, lastSeen: longAgo },
+      indexDir,
+    );
+
+    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"));
+      const body = (await fetch(`http://localhost:${raw.port}/api/servers`).then((r) => r.json())) as {
+        updatedAt: string;
+        servers: Array<Record<string, unknown>>;
+      };
+      assert.equal(body.servers.length, 1, "only the active repo is returned");
+      const s = body.servers[0];
+      assert.equal(s.displayName, "active");
+      assert.equal(s.tier, "high");
+      assert.equal(s.model, "gpt-4o");
+      assert.equal(s.provider, "OpenAI");
+      assert.equal(s.contextPct, 0.42);
+      assert.equal(s.state, "idle");
+      assert.deepEqual(s.cacheHits, { session: 3, total: 7, sessionTokensSaved: 1200, totalTokensSaved: 9000 });
+      assert.deepEqual(s.compacts, { session: 2, total: 5 });
+      const ts = s.timeSaved as { compact: { sessionSec: number; totalSec: number }; cacheHit: { sessionSec: number; totalSec: number } };
+      assert.equal(ts.compact.sessionSec, 1.5);
+      assert.equal(ts.cacheHit.sessionSec, 0.6);
+    } finally {
+      child.kill("SIGTERM");
+      delete process.env.MEGACOMPACT_INDEX_DIR;
+      delete process.env.MEGACOMPACT_DASHBOARD_PORT;
+      rmSync(dir, { recursive: true, force: true });
+      rmSync(indexDir, { recursive: true, force: true });
+    }
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Lifecycle integration — launch the compiled server as a real subprocess
 // (the same way the /dashboard command spawns it) and assert the two failure

package/extensions/dashboard-server.ts

@@ -46,6 +46,8 @@ function log(...parts: unknown[]): void {
 // concurrent writer's WAL never blocks the request). All registry data lives in
 // SQLite (the project's one-store invariant) — there is no JSON mirror. Same
 // index-dir resolution as src/store/sqlite.ts getIndexDir().
+const ACTIVE_WINDOW_SEC = 1800;
+
 function getIndexDir(): string {
   const override = process.env.MEGACOMPACT_INDEX_DIR;
   if (override && override.trim() !== "") return override;
@@ -266,6 +268,20 @@ interface Snapshot {
     duplicatesCollapsed: number;
     bytesPermanentlyDeleted: number;
   };
+  cacheHits: {
+    session: number;
+    total: number;
+    sessionTokensSaved: number;
+    totalTokensSaved: number;
+  };
+  compacts: {
+    session: number;
+    total: number;
+  };
+  timeSaved: {
+    compact: { sessionSec: number; totalSec: number };
+    cacheHit: { sessionSec: number; totalSec: number };
+  };
   compression: {
     session: { tokensIn: number; tokensOut: number; tokensFreed: number; compressionPct: number; dedupPct: number };
     repo: { tokensIn: number; tokensOut: number; tokensFreed: number; compressionPct: number; dedupPct: number };
@@ -283,6 +299,8 @@ interface Snapshot {
 // Helpers
 // ---------------------------------------------------------------------------
 
+interface LiveSnapshot { tier?: string; updatedAt?: string | null; context?: { tokens?: number | null; percent?: number | null; contextWindow?: number }; session?: { id?: string; state?: string }; cacheHits?: { session: number; total: number; sessionTokensSaved: number; totalTokensSaved: number }; compacts?: { session: number; total: number }; timeSaved?: { compact: { sessionSec: number; totalSec: number }; cacheHit: { sessionSec: number; totalSec: number } }; }
+
 function readSnapshot(snapshotPath: string) {
   try {
     const raw = readFileSync(snapshotPath, "utf-8");
@@ -302,6 +320,9 @@ function readSnapshot(snapshotPath: string) {
       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 },
+      cacheHits: { session: 0, total: 0, sessionTokensSaved: 0, totalTokensSaved: 0 },
+      compacts: { session: 0, total: 0 },
+      timeSaved: { compact: { sessionSec: 0, totalSec: 0 }, cacheHit: { sessionSec: 0, totalSec: 0 } },
       compression: { session: { tokensIn: 0, tokensOut: 0, tokensFreed: 0, compressionPct: 0, dedupPct: 0 }, repo: { tokensIn: 0, tokensOut: 0, tokensFreed: 0, compressionPct: 0, dedupPct: 0 } },
       model: undefined,
     } as Snapshot;
@@ -426,6 +447,7 @@ function dashboardHtml(tierName: string): string {
 <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="active">Active Repos</button>
   <button class="tab" data-tab="summary">Summary</button>
 </nav>
 
@@ -527,6 +549,26 @@ function dashboardHtml(tierName: string): string {
     </ul>
     <p class="legend-note">Hover any label above for a quick explanation.</p>
   </div>
+  <div class="card">
+    <h2>💾 Cache Hits &amp; Compactions</h2>
+    <div class="stat-grid">
+      <span class="label">Cache Hits (session)</span><span class="value" id="ch-session">0</span>
+      <span class="label">Cache Hits (total)</span><span class="value" id="ch-total">0</span>
+      <span class="label">Tokens Saved (session)</span><span class="value" id="ch-tok-session">0</span>
+      <span class="label">Tokens Saved (total)</span><span class="value" id="ch-tok-total">0</span>
+      <span class="label">Compactions (session)</span><span class="value" id="cp-session">0</span>
+      <span class="label">Compactions (total)</span><span class="value" id="cp-total">0</span>
+    </div>
+  </div>
+  <div class="card">
+    <h2>⏱ Time Saved (est.)</h2>
+    <div class="stat-grid">
+      <span class="label">Compact (session)</span><span class="value" id="ts-compact-session">0</span>
+      <span class="label">Compact (total)</span><span class="value" id="ts-compact-total">0</span>
+      <span class="label">Cache Hit (session)</span><span class="value" id="ts-cache-session">0</span>
+      <span class="label">Cache Hit (total)</span><span class="value" id="ts-cache-total">0</span>
+    </div>
+  </div>
 </div>
 
 <div class="events">
@@ -552,6 +594,28 @@ function dashboardHtml(tierName: string): string {
 <div class="updated" id="updated"></div>
 </div><!-- /panel-current -->
 
+<!-- Active repos (live cache-hit / compaction stats across machines) -->
+<div class="tab-panel" id="panel-active">
+  <div class="card">
+    <h2>Active Repos — Live Cache Hits &amp; Compactions</h2>
+    <p class="legend-note">Repos seen within the last 30 minutes, with their per-repo cache-hit, compaction, and time-saved (est.) totals pulled live from each repo's dashboard.json.</p>
+    <table class="repos">
+      <thead>
+        <tr>
+          <th>Repo</th><th>Model</th><th>Tier</th>
+          <th style="text-align:right">Context %</th><th>State</th>
+          <th style="text-align:right">Compactions (s/t)</th>
+          <th style="text-align:right">Cache Hits (s/t)</th>
+          <th style="text-align:right">Compact s/t (s)</th>
+          <th style="text-align:right">CacheHit s/t (s)</th>
+        </tr>
+      </thead>
+      <tbody id="active-rows"><tr><td colspan="9" class="repo-none">loading…</td></tr></tbody>
+    </table>
+    <div class="updated" id="active-updated"></div>
+  </div>
+</div>
+
 <!-- Per-repo detail modal -->
 <div class="repo-detail" id="repo-detail">
   <div class="repo-detail-box">
@@ -746,6 +810,21 @@ function dashboardHtml(tierName: string): string {
       document.getElementById('cost-windows').textContent = '0 context-windows extended';
     }
 
+    // --- Cache hits & compactions (live counters) ---------------------------
+    var ch = d.cacheHits || { session: 0, total: 0, sessionTokensSaved: 0, totalTokensSaved: 0 };
+    var cp = d.compacts || { session: 0, total: 0 };
+    var ts = d.timeSaved || { compact: { sessionSec: 0, totalSec: 0 }, cacheHit: { sessionSec: 0, totalSec: 0 } };
+    document.getElementById('ch-session').textContent = (ch.session || 0).toLocaleString();
+    document.getElementById('ch-total').textContent = (ch.total || 0).toLocaleString();
+    document.getElementById('ch-tok-session').textContent = (ch.sessionTokensSaved || 0).toLocaleString();
+    document.getElementById('ch-tok-total').textContent = (ch.totalTokensSaved || 0).toLocaleString();
+    document.getElementById('cp-session').textContent = (cp.session || 0).toLocaleString();
+    document.getElementById('cp-total').textContent = (cp.total || 0).toLocaleString();
+    document.getElementById('ts-compact-session').textContent = fmtSec(ts.compact.sessionSec);
+    document.getElementById('ts-compact-total').textContent = fmtSec(ts.compact.totalSec);
+    document.getElementById('ts-cache-session').textContent = fmtSec(ts.cacheHit.sessionSec);
+    document.getElementById('ts-cache-total').textContent = fmtSec(ts.cacheHit.totalSec);
+
     document.getElementById('updated').textContent = 'Updated ' + new Date(d.updatedAt).toLocaleTimeString();
   }
 
@@ -951,9 +1030,51 @@ function dashboardHtml(tierName: string): string {
   pollIndex();
   setInterval(pollIndex, 5000);
 
+  // --- Active repos (live cache-hit / compaction stats) ---------------------
+  function fmtSec(s) {
+    s = s || 0;
+    if (s >= 3600) return (s / 3600).toFixed(1) + 'h';
+    if (s >= 60) return Math.round(s / 60) + 'm';
+    if (s >= 1) return s.toFixed(1) + 's';
+    return Math.round(s * 1000) + 'ms';
+  }
+  function renderActiveRepos(d) {
+    d = d || { updatedAt: null, servers: [] };
+    var servers = d.servers || [];
+    var rowsEl = document.getElementById('active-rows');
+    if (!rowsEl) return;
+    if (!servers.length) {
+      rowsEl.innerHTML = '<tr><td colspan="9" class="repo-none">No active repositories.</td></tr>';
+    } else {
+      rowsEl.innerHTML = servers.map(function(r) {
+        var ch = r.cacheHits || { session: 0, total: 0, sessionTokensSaved: 0, totalTokensSaved: 0 };
+        var cp = r.compacts || { session: 0, total: 0 };
+        var ts = r.timeSaved || { compact: { sessionSec: 0, totalSec: 0 }, cacheHit: { sessionSec: 0, totalSec: 0 } };
+        return '<tr>' +
+          '<td title="' + sanitize(r.repoRoot) + '">' + sanitize(r.displayName || r.repoRoot) + '</td>' +
+          '<td>' + sanitize(r.model || '—') + '</td>' +
+          '<td>' + sanitize(r.tier || '—') + '</td>' +
+          '<td class="num">' + (r.contextPct != null ? Math.round(r.contextPct * 100) + '%' : '—') + '</td>' +
+          '<td>' + sanitize(r.state || '—') + '</td>' +
+          '<td class="num">' + (cp.session || 0) + ' / ' + (cp.total || 0) + '</td>' +
+          '<td class="num">' + (ch.session || 0) + ' / ' + (ch.total || 0) + '</td>' +
+          '<td class="num">' + fmtSec(ts.compact.sessionSec) + ' / ' + fmtSec(ts.compact.totalSec) + '</td>' +
+          '<td class="num">' + fmtSec(ts.cacheHit.sessionSec) + ' / ' + fmtSec(ts.cacheHit.totalSec) + '</td>' +
+        '</tr>';
+      }).join('');
+    }
+    var upd = document.getElementById('active-updated');
+    if (upd) upd.textContent = d.updatedAt ? 'Updated ' + new Date(d.updatedAt).toLocaleTimeString() : '';
+  }
+  function pollServers() {
+    fetch('/api/servers').then(function(r) { return r.json(); }).then(renderActiveRepos).catch(function() {});
+  }
+  pollServers();
+  setInterval(pollServers, 5000);
+
   // --- Tab switching ------------------------------------------------------
   var tabs = document.querySelectorAll('.tab');
-  var panels = { current: 'panel-current', all: 'panel-all', summary: 'panel-summary' };
+  var panels = { current: 'panel-current', all: 'panel-all', active: 'panel-active', summary: 'panel-summary' };
   for (var i = 0; i < tabs.length; i++) {
     tabs[i].addEventListener('click', function() {
       var name = this.getAttribute('data-tab');
@@ -966,6 +1087,7 @@ function dashboardHtml(tierName: string): string {
         }
       }
       if (name === 'all' || name === 'summary') pollIndex();
+      if (name === 'active') pollServers();
     });
   }
 })();
@@ -1170,6 +1292,24 @@ export async function launchDashboardServer(stateDir: string): Promise<{ port: n
       return;
     }
 
+    if (req.url === "/api/servers") {
+      try {
+        const idx = readIndex();
+        const nowSec = Math.floor(Date.now() / 1000);
+        const servers = (idx?.repos ?? []).filter((r) => (r.lastSeen ?? 0) >= nowSec - ACTIVE_WINDOW_SEC).map((r) => {
+          const out: Record<string, unknown> = { repoRoot: r.repoRoot, displayName: r.displayName, model: r.modelName, provider: r.providerName, lastSeen: r.lastSeen, lastCompactedAt: r.lastCompactedAt };
+          try { const p = join(r.stateDir, "dashboard.json"); if (existsSync(p)) { const snap = JSON.parse(readFileSync(p, "utf-8")) as LiveSnapshot; out.tier = snap.tier ?? null; out.contextPct = (snap.context && snap.context.percent != null) ? snap.context.percent : null; out.state = (snap.session && snap.session.state) || null; out.cacheHits = snap.cacheHits ?? null; out.compacts = snap.compacts ?? null; out.timeSaved = snap.timeSaved ?? null; out.updatedAt = snap.updatedAt ?? null; } } catch { /* best-effort */ }
+          return out;
+        }).sort((a, b) => (b.lastSeen as number) - (a.lastSeen as number));
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ updatedAt: new Date().toISOString(), servers }));
+      } catch {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "servers_unavailable" }));
+      }
+      return;
+    }
+
     if (req.url === "/api/events") {
       res.writeHead(200, {
         "Content-Type": "text/event-stream",

package/extensions/mega-dashboard.ts

@@ -114,6 +114,23 @@ export interface DashboardSnapshot {
     duplicatesCollapsed: number;     // dedup duplicates (original kept on survivor)
     bytesPermanentlyDeleted: number; // ALWAYS 0 — the invariant
   };
+  /** Cache-hit / recall-injection counters (live session + store-wide totals). */
+  cacheHits: {
+    session: number;            // dedup skips + recall injections this session
+    total: number;              // store-wide deduped collapses + recall injections
+    sessionTokensSaved: number; // tokens saved via cache hits this session
+    totalTokensSaved: number;   // store-wide tokens saved via cache hits
+  };
+  /** Compaction counters (live session + store-wide cumulative). */
+  compacts: {
+    session: number;            // compactions performed this session
+    total: number;              // store-wide cumulative compaction count
+  };
+  /** Estimated wall-clock time saved (rough tokens/sec heuristic). */
+  timeSaved: {
+    compact: { sessionSec: number; totalSec: number };
+    cacheHit: { sessionSec: number; totalSec: number };
+  };
   /** Active model/provider (captured live) — shown on the current-repo card. */
   model?: {
     name: string;          // Model.name or Model.id

package/extensions/mega-pipeline.ts

@@ -15,7 +15,7 @@ import type { EngineMessage } from "../src/types.js";
 import { recallAndInline, recallAndInlineAsync, formatRecallBlock, type RecallInjectResult } from "../src/recall.js";
 import { normalizeSessionId } from "../src/store.js";
 import { estimateBlockTokens } from "../src/tokens.js";
-import { touchSession, logDaily } from "../src/store/sqlite.js";
+import { touchSession, logDaily, incCompactCount, incRecallInjected, incCacheHitTokens } from "../src/store/sqlite.js";
 import { consolidateMemories } from "../src/memory.js";
 import {
   type MegaRuntime,
@@ -146,6 +146,9 @@ function doCompact(
     ? result.originalTokenEstimate
     : Math.max(0, result.originalTokenEstimate - result.tokenEstimate);
   runtime.rt.tokensSaved += saved;
+  runtime.rt.compactCount += 1;
+  incCompactCount(runtime.currentStateDir);
+  if (result.deduped) { runtime.rt.cacheHitTokens += saved; incCacheHitTokens(saved, runtime.currentStateDir); }
   runtime.rt.lastCompactAt = Date.now();
   if (result.deduped) runtime.rt.dedupSkips++;
   // Grow the rolling "saved" goal so the progress bar always has a fresh
@@ -435,6 +438,13 @@ export function doRecall(
     runtime.pushTicker(`${C.amber}↩${C.reset} recalled ${top.checkpoint.checkpointId} · ${scorePct}% · ${label}`);
     runtime.lastWhy = `why: recalled@${scorePct}% (${result.toInject.length} chkpt)`;
   }
+  if (result.toInject.length > 0) {
+    let sumTokens = 0; for (const h of result.toInject) sumTokens += h.checkpoint.tokenEstimate;
+    runtime.rt.recallInjections += result.toInject.length;
+    runtime.rt.cacheHitTokens += sumTokens;
+    incRecallInjected(result.toInject.length, runtime.currentStateDir);
+    incCacheHitTokens(sumTokens, runtime.currentStateDir);
+  }
   return result;
 }
 
@@ -493,6 +503,13 @@ export async function doRecallAsync(
       if (!seen.has(h.checkpoint.checkpointId)) { merged.push(h); seen.add(h.checkpoint.checkpointId); }
     }
     const block = merged.length ? formatRecallBlock(merged) : "";
+    if (merged.length > 0) {
+      let sumTokens = 0; for (const h of merged) sumTokens += h.checkpoint.tokenEstimate;
+      runtime.rt.recallInjections += merged.length;
+      runtime.rt.cacheHitTokens += sumTokens;
+      incRecallInjected(merged.length, runtime.currentStateDir);
+      incCacheHitTokens(sumTokens, runtime.currentStateDir);
+    }
     return {
       toInject: merged,
       report: merged.map((h) => `  • ${h.checkpoint.checkpointId}${h.repoId ? ` (from ${h.repoId.split("/").filter(Boolean).pop()})` : ""}`),

package/extensions/mega-runtime.ts

@@ -24,6 +24,10 @@ import {
 	latestModelSnapshot,
 	upsertRepoRegistry,
 	recordRepoModel,
+	getDedupStats,
+	getCompactCount,
+	getRecallInjected,
+	getCacheHitTokensSaved,
 	type ModelSnapshot,
 } from "../src/store/sqlite.js";
 import { detectCrossRepoDrift } from "../src/driftDetection.js";
@@ -73,6 +77,10 @@ interface SessionRuntime {
 	tokensSaved: number; // this session-instance only: reset on session_start
 	lastCompactAt: number | null; // wall-clock ms of the last compaction this session
 	lastNativeCompactAt: number | null; // COMPACT-DEDUP FIX: wall-clock ms of the last NATIVE pi compaction (session_compact event) — used by the agent_end/legacy race guard to skip a redundant ctx.compact() that would throw "Already compacted".
+	// S25: live dashboard counters (reset on session_start, mirrored to SQLite).
+	compactCount: number; // compactions performed this session-instance
+	recallInjections: number; // recall blocks injected this session-instance
+	cacheHitTokens: number; // tokens saved via cache hits (dedup + recall) this session
 }
 
 /** ANSI palette for the toolbar. The pi TUI's Text component preserves ANSI
@@ -94,6 +102,11 @@ export const C = {
 
 const PULSE = ["◐", "◓", "◑", "◒"];
 
+// Rough tokens-processed-per-second heuristic for the dashboard's "time saved"
+// estimate. Throughput varies by model/hardware; this is order-of-magnitude so
+// the dashboard can show a human-readable figure, not a precise measurement.
+const TOKENS_PER_SEC_ESTIMATE = 2000;
+
 // ── Full-width widget panel helpers ────────────────────────────────────────
 // pi's above-editor widget renderer (a Container of Text lines) does NOT pass
 // a terminal width to setWidget(), so lines render left-aligned by default. To
@@ -274,6 +287,9 @@ export class MegaRuntime {
 		tokensSaved: 0,
 		lastCompactAt: null,
 		lastNativeCompactAt: null,
+		compactCount: 0,
+		recallInjections: 0,
+		cacheHitTokens: 0,
 	};
 	debounceUntil = 0;
 	// S16: debounce for the agent_end resume nudge (avoid busy-loops).
@@ -485,6 +501,12 @@ export class MegaRuntime {
 		const st = this.store.stats(this.rt.sessionId);
 		const repo = this.store.repoStats();
 		const di = this.store.dataInvariant();
+		// Live + store-wide cache-hit / compaction counters for the dashboard.
+		const ds = getDedupStats(this.currentStateDir);
+		const cacheHitsTotal = ds.deduped + getRecallInjected(this.currentStateDir);
+		const cacheHitsTotalTokens = getCacheHitTokensSaved(this.currentStateDir);
+		const cacheHitsSession = this.rt.dedupSkips + this.rt.recallInjections;
+		const sec = (tok: number) => (tok || 0) / TOKENS_PER_SEC_ESTIMATE;
 		// Active model/provider for the current-repo card + the multi-repo table.
 		const modelSnap = latestModelSnapshot(this.currentStateDir);
 		const model = modelSnap
@@ -604,6 +626,20 @@ export class MegaRuntime {
 				duplicatesCollapsed: di.duplicatesCollapsed,
 				bytesPermanentlyDeleted: di.bytesPermanentlyDeleted,
 			},
+			cacheHits: {
+				session: cacheHitsSession,
+				total: cacheHitsTotal,
+				sessionTokensSaved: this.rt.cacheHitTokens,
+				totalTokensSaved: cacheHitsTotalTokens,
+			},
+			compacts: {
+				session: this.rt.compactCount,
+				total: getCompactCount(this.currentStateDir),
+			},
+			timeSaved: {
+				compact: { sessionSec: sec(this.rt.tokensSaved), totalSec: sec(this.store.repoStats().tokensSaved) },
+				cacheHit: { sessionSec: sec(this.rt.cacheHitTokens), totalSec: sec(cacheHitsTotalTokens) },
+			},
 			model,
 		} as DashboardSnapshot);
 
@@ -849,7 +885,10 @@ export class MegaRuntime {
 			tokensSaved: 0,
 			lastCompactAt: null,
 			lastNativeCompactAt: null,
-		};
+			compactCount: 0,
+			recallInjections: 0,
+			cacheHitTokens: 0,
+	};
 		this.statusKey = undefined;
 		this.activeAgents = 0;
 		this.currentTurn = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "description": "Layered, local, vector-backed context compressor for pi — supersede/collapse/cluster compaction with deduped inline recall.",
   "type": "module",
   "license": "BSD-2-Clause",

package/src/store/sqlite.cachehit.test.ts

@@ -0,0 +1,68 @@
+/**
+ * sqlite.cachehit.test.ts — tests for the live dashboard counters
+ * (incCompactCount / getCompactCount, incRecallInjected / getRecallInjected,
+ * incCacheHitTokens / getCacheHitTokensSaved). These reuse the schemaless
+ * `meta` integer counter, so no migration is required and the same on-disk
+ * SQLite store persists the tallies across (re)opens.
+ */
+import { describe, it, beforeEach, afterEach } 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 {
+	openStore,
+	incCompactCount,
+	getCompactCount,
+	incRecallInjected,
+	getRecallInjected,
+	incCacheHitTokens,
+	getCacheHitTokensSaved,
+} from "./sqlite.js";
+
+describe("live dashboard counters (meta integers)", () => {
+	let dir: string;
+	beforeEach(() => {
+		dir = mkdtempSync(join(tmpdir(), "cachehit-test-"));
+	});
+	afterEach(() => {
+		rmSync(dir, { recursive: true, force: true });
+	});
+
+	it("increments + reads compact_count and persists on reopen", () => {
+		incCompactCount(dir);
+		incCompactCount(dir);
+		assert.equal(getCompactCount(dir), 2);
+		// Ensure the store handle is (re)opened and the value is read back from disk.
+		openStore(dir);
+		assert.equal(getCompactCount(dir), 2);
+	});
+
+	it("accumulates recall injections + cache-hit tokens", () => {
+		incRecallInjected(3, dir);
+		incRecallInjected(2, dir);
+		assert.equal(getRecallInjected(dir), 5);
+		incCacheHitTokens(1200, dir);
+		incCacheHitTokens(800, dir);
+		assert.equal(getCacheHitTokensSaved(dir), 2000);
+	});
+
+	it("ignores non-positive increments (no-op)", () => {
+		incRecallInjected(0, dir);
+		incRecallInjected(-5, dir);
+		incCacheHitTokens(0, dir);
+		assert.equal(getRecallInjected(dir), 0);
+		assert.equal(getCacheHitTokensSaved(dir), 0);
+	});
+
+	it("persists all three counters across a fresh openStore handle", () => {
+		incCompactCount(dir);
+		incRecallInjected(4, dir);
+		incCacheHitTokens(500, dir);
+		// openStore returns the canonical (on-disk) handle; reading back proves durability.
+		openStore(dir);
+		assert.equal(getCompactCount(dir), 1);
+		assert.equal(getRecallInjected(dir), 4);
+		assert.equal(getCacheHitTokensSaved(dir), 500);
+	});
+});

package/src/store/sqlite.ts

@@ -704,6 +704,34 @@ export function bumpDedupStats(deduped: boolean, stateDir: string = getStateDir(
   if (deduped) incMeta("deduped", 1, stateDir);
 }
 
+// --- Live dashboard counters (schemaless meta key/value — NO migration) -----
+// These reuse the private `incMeta` atomically-incrementing integer counter so
+// all cumulative tallies live in the same `meta` table as tokens_saved etc.
+
+export function incCompactCount(stateDir: string = getStateDir()): void {
+  incMeta("compact_count", 1, stateDir);
+}
+
+export function getCompactCount(stateDir: string = getStateDir()): number {
+  return getMetaNumber("compact_count", stateDir);
+}
+
+export function incRecallInjected(n: number, stateDir: string = getStateDir()): void {
+  if (n > 0) incMeta("recall_injected", n, stateDir);
+}
+
+export function getRecallInjected(stateDir: string = getStateDir()): number {
+  return getMetaNumber("recall_injected", stateDir);
+}
+
+export function incCacheHitTokens(delta: number, stateDir: string = getStateDir()): void {
+  if (delta > 0) incMeta("cache_hit_tokens_saved", delta, stateDir);
+}
+
+export function getCacheHitTokensSaved(stateDir: string = getStateDir()): number {
+  return getMetaNumber("cache_hit_tokens_saved", stateDir);
+}
+
 // --- Future-feature foundation (resume sessions / daily log / lessons) -------
 // Scaffolded tables + minimal helpers so all store data lives in SQLite from
 // day one. Full UI/recall for these lands in later sprints.