pi-mega-compact 0.6.3 → 0.6.5

package/dist/extensions/conflict-scan.js

@@ -12,10 +12,18 @@
  *
  * Pi-agnostic: reads package.json + greps source. No pi runtime types, so it is
  * unit-testable against a fixture node_modules tree.
+ *
+ * SCAN-SCOPE FIX (S24 follow-up): the original scanner only walked the npm
+ * `node_modules` tree, so user-level extensions installed outside npm (e.g.
+ * `pi-hermes-memory`, a data-only `MEMORY.md` + `sessions.db` memory store)
+ * were never inspected — that gap let the 5000-char file-buffer error slip
+ * through undetected. We now also scan the user-level extension dir and detect
+ * memory stores that ship with no package.json / source to grep.
  */
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
 // Marker sets. A package is flagged when its source matches a marker in a
 // category. File-grep (not AST) keeps this dependency-free and fast.
 const MARKERS = {
@@ -38,10 +46,7 @@ const MARKERS = {
         "memoryTool",
     ],
     // Tool-output shaping (compact/summarize tool results) — overlap, not a rival.
-    toolOutput: [
-        "tool_result",
-        "ToolResult",
-    ],
+    toolOutput: ["tool_result", "ToolResult"],
 };
 /** Resolve the node_modules dir that contains this package (or env override). */
 export function resolveExtensionRoot(selfDir = dirname(fileURLToPath(import.meta.url))) {
@@ -62,6 +67,41 @@ export function resolveExtensionRoot(selfDir = dirname(fileURLToPath(import.meta
     }
     return null;
 }
+/**
+ * Resolve every directory that may hold pi extensions to scan.
+ *
+ * - `MEGACOMPACT_EXT_SCAN_DIR` (if set) replaces the whole list — a single
+ *   fixture/override root for tests or custom layouts.
+ * - Otherwise: the node_modules that holds this package (classic npm layout) AND
+ *   the user-level extension dir (`~/.pi/agent`), which is where extensions
+ *   installed outside npm actually live. The original scanner only walked
+ *   node_modules, so user-level memory extensions were never flagged — that is
+ *   the gap that let the 5000-char `MEMORY.md` buffer error slip through.
+ */
+export function collectScanRoots() {
+    const override = process.env.MEGACOMPACT_EXT_SCAN_DIR;
+    if (override && override.trim() !== "")
+        return [override];
+    const roots = [];
+    const nm = resolveExtensionRoot();
+    if (nm && existsSync(nm))
+        roots.push(nm);
+    const userDir = process.env.MEGACOMPACT_EXT_USER_DIR?.trim() ||
+        join(homedir(), ".pi", "agent");
+    if (existsSync(userDir))
+        roots.push(userDir);
+    return roots;
+}
+/**
+ * True when a directory is a pi memory-store container rather than a normal code
+ * extension. `pi-hermes-memory` ships as exactly this: no package.json, no
+ * source — just `MEMORY.md` + `sessions.db`. The marker-grep path misses it,
+ * so we also detect the on-disk memory signature.
+ */
+function isMemoryStoreDir(pkgDir) {
+    return (existsSync(join(pkgDir, "sessions.db")) ||
+        existsSync(join(pkgDir, "MEMORY.md")));
+}
 /** Recursively collect source-ish files under a package, capped to avoid scans. */
 function collectFiles(root, max = 400) {
     const out = [];
@@ -131,70 +171,103 @@ function matchMarkers(pkgDir, keys) {
  * @param selfName package name to skip (defaults to this package's name).
  */
 export function detectConflicts(selfName = "pi-mega-compact") {
-    const root = resolveExtensionRoot();
+    const roots = collectScanRoots();
     const scanned = [];
     const conflicts = [];
-    if (!root || !existsSync(root))
-        return { scanned, conflicts };
-    let entries;
-    try {
-        entries = readdirSync(root);
-    }
-    catch {
-        return { scanned, conflicts };
-    }
-    for (const name of entries) {
-        const pkgDir = join(root, name);
-        if (!statSync(pkgDir).isDirectory())
-            continue;
-        const pkgJson = join(pkgDir, "package.json");
-        if (!existsSync(pkgJson))
+    for (const root of roots) {
+        if (!existsSync(root))
             continue;
-        let pkg;
+        let entries;
         try {
-            pkg = JSON.parse(readFileSync(pkgJson, "utf-8"));
+            entries = readdirSync(root);
         }
         catch {
             continue;
         }
-        const pkgName = pkg.name ?? name;
-        if (pkgName === selfName)
-            continue;
-        // Only consider packages that declare pi extensions.
-        if (!pkg.pi || !Array.isArray(pkg.pi.extensions) || pkg.pi.extensions.length === 0)
-            continue;
-        scanned.push(pkgName);
-        const memHits = matchMarkers(pkgDir, MARKERS.memory);
-        const compHits = matchMarkers(pkgDir, MARKERS.compaction);
-        const toolHits = matchMarkers(pkgDir, MARKERS.toolOutput);
-        if (compHits.length > 0) {
-            conflicts.push({
-                package: pkgName,
-                severity: "high",
-                kind: "compaction",
-                evidence: compHits,
-                recommendation: "Disabling recommended — competes with pi-mega-compact's conversation compaction.",
-            });
-            continue; // compaction is the dominant conflict; don't double-flag.
-        }
-        if (memHits.length > 0) {
-            conflicts.push({
-                package: pkgName,
-                severity: "high",
-                kind: "memory",
-                evidence: memHits,
-                recommendation: "pi-mega-compact now owns save-to-memory (/mega-memory, its own SQLite). Disable this to avoid duplicate memory stores.",
-            });
-            continue;
-        }
-        if (toolHits.length > 0) {
-            conflicts.push({
-                package: pkgName,
-                severity: "info",
-                kind: "tool-output",
-                evidence: toolHits,
-                recommendation: "Shapes tool output (summarize/compact tool results). Generally compatible; no action needed.",
-            });
+        for (const name of entries) {
+            const pkgDir = join(root, name);
+            let st;
+            try {
+                st = statSync(pkgDir);
+            }
+            catch {
+                continue;
+            }
+            if (!st.isDirectory())
+                continue;
+            // A candidate is either a real code extension (declares pi.extensions) or a
+            // data-only memory store (MEMORY.md / sessions.db at its root).
+            const pkgJson = join(pkgDir, "package.json");
+            let pkg = null;
+            if (existsSync(pkgJson)) {
+                try {
+                    pkg = JSON.parse(readFileSync(pkgJson, "utf-8"));
+                }
+                catch {
+                    pkg = null;
+                }
+            }
+            const isCodeExt = !!pkg &&
+                !!pkg.pi &&
+                Array.isArray(pkg.pi.extensions) &&
+                pkg.pi.extensions.length > 0;
+            const isMemoryStore = isMemoryStoreDir(pkgDir);
+            if (!isCodeExt && !isMemoryStore)
+                continue;
+            const pkgName = pkg?.name ?? name;
+            if (pkgName === selfName)
+                continue;
+            scanned.push(`${pkgName} (${name})`);
+            if (isCodeExt) {
+                const memHits = matchMarkers(pkgDir, MARKERS.memory);
+                const compHits = matchMarkers(pkgDir, MARKERS.compaction);
+                const toolHits = matchMarkers(pkgDir, MARKERS.toolOutput);
+                if (compHits.length > 0) {
+                    conflicts.push({
+                        package: pkgName,
+                        severity: "high",
+                        kind: "compaction",
+                        evidence: compHits,
+                        recommendation: "Disabling recommended — competes with pi-mega-compact's conversation compaction.",
+                    });
+                    continue; // compaction is the dominant conflict; don't double-flag.
+                }
+                if (memHits.length > 0) {
+                    conflicts.push({
+                        package: pkgName,
+                        severity: "high",
+                        kind: "memory",
+                        evidence: memHits,
+                        recommendation: "pi-mega-compact now owns save-to-memory (/mega-memory, its own SQLite). Disable this to avoid duplicate memory stores.",
+                    });
+                    continue;
+                }
+                if (toolHits.length > 0) {
+                    conflicts.push({
+                        package: pkgName,
+                        severity: "info",
+                        kind: "tool-output",
+                        evidence: toolHits,
+                        recommendation: "Shapes tool output (summarize/compact tool results). Generally compatible; no action needed.",
+                    });
+                }
+            }
+            // Data-only memory store: no source to grep, but the on-disk signature
+            // (sessions.db / MEMORY.md) is a conflict with our SQLite memory store.
+            if (isMemoryStore) {
+                const evidence = [];
+                if (existsSync(join(pkgDir, "sessions.db")))
+                    evidence.push("sessions.db");
+                if (existsSync(join(pkgDir, "MEMORY.md")))
+                    evidence.push("MEMORY.md");
+                conflicts.push({
+                    package: pkgName,
+                    severity: "high",
+                    kind: "memory",
+                    evidence,
+                    recommendation: "pi-mega-compact now owns save-to-memory (its own SQLite). This data-only memory store competes with it — disable to avoid a duplicate / capped memory buffer.",
+                });
+            }
         }
     }
     return { scanned, conflicts };

package/dist/extensions/dashboard-server.js

@@ -72,6 +72,7 @@ function readIndex() {
         const mapped = rows.map((r) => ({
             repoRoot: String(r.repo_root ?? ""),
             displayName: String(r.display_name ?? ""),
+            stateDir: String(r.state_dir ?? ""),
             checkpointCount: Number(r.checkpoint_count ?? 0),
             tokensSaved: Number(r.tokens_saved ?? 0),
             compressedOriginalBytes: Number(r.compressed_original_bytes ?? 0),
@@ -290,27 +291,31 @@ function dashboardHtml(tierName) {
     <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="Total size of the original conversation text dropped into compaction this session, including redundant regions skipped by dedup. This is the 'in'.">Original (dropped)</span><span class="value" id="st-in">0</span>
+      <span class="label" title="Compact summaries we are currently holding as 'memory' for this session (the 'out'). Smaller is better.">Kept (summaries)</span><span class="value" id="st-kept">0</span>
+      <span class="label" title="Conversation space freed = dropped − kept (the 'saved').">Freed (dropped − kept)</span><span class="value" id="st-freed">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 class="meter-track" style="margin-top:10px"><div class="meter-fill" id="st-compress-bar" style="width:0%"></div></div>
+    <div class="meter-sub" id="st-compress-sub">waiting for compaction…</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">Original (dropped)</span><span class="value" id="rp-in">0</span>
+      <span class="label">Kept (summaries)</span><span class="value" id="rp-kept">0</span>
+      <span class="label">Freed (dropped − kept)</span><span class="value" id="rp-freed">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 class="meter-track" style="margin-top:10px"><div class="meter-fill" id="rp-compress-bar" style="width:0%"></div></div>
+    <div class="meter-sub" id="rp-compress-sub">waiting for compaction…</div>
   </div>
   <div class="card safe">
     <h2>🛡 Data Safety</h2>
@@ -356,11 +361,11 @@ function dashboardHtml(tierName) {
   <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>Original (dropped)</b> — everything compacted away (including duplicates caught by dedup). The "in."</li>
+      <li><b>Kept (summaries)</b> — compact summaries still held as "memory" (the "out").</li>
+      <li><b>Freed</b> = dropped − kept — tokens saved so far (higher = better).</li>
+      <li><b>Compression %</b> — Freed ÷ Dropped — the headline efficiency number. Higher = more space reclaimed.</li>
+      <li><b>Storage dedup %</b> — how often new content matched something already saved, so no duplicate copy was written.</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>
@@ -431,6 +436,23 @@ function dashboardHtml(tierName) {
     <div class="summary-card"><div class="num" id="sm-saved">0</div><div class="lbl">Total Tokens Saved</div></div>
     <div class="summary-card"><div class="num" id="sm-bytes">0 B</div><div class="lbl">Compressed-Original</div></div>
   </div>
+
+  <h2 style="margin-top:24px;font-size:13px;color:#8b949e;text-transform:uppercase;letter-spacing:.5px">Savings by Model</h2>
+  <p class="legend-note" style="margin-bottom:10px">How much context &amp; cost mega-compact has reclaimed, grouped by the model you were running. Compression ratio reflects workload/content, not model quality.</p>
+  <table class="repos">
+    <thead>
+      <tr>
+        <th>Model</th><th>Provider</th>
+        <th style="text-align:right">Repos</th>
+        <th style="text-align:right">Checkpoints</th>
+        <th style="text-align:right">Tokens Saved</th>
+        <th style="text-align:right">$ Saved</th>
+        <th style="text-align:right">Last Used</th>
+      </tr>
+    </thead>
+    <tbody id="bm-rows"><tr><td colspan="7" class="repo-none">loading…</td></tr></tbody>
+  </table>
+
   <div class="updated" id="sm-updated"></div>
 </div>
 
@@ -464,10 +486,20 @@ function dashboardHtml(tierName) {
                 d.trigger.armed ? 'past fast gate — monitoring token count' : 'idle — below fast gate';
     document.getElementById('tr-state').textContent = state;
 
+    // ---- Vector Store — reconciled token accounting (same formula as widget) -
     document.getElementById('st-count').textContent = d.store.checkpointCount;
-    document.getElementById('st-tokens').textContent = d.store.totalTokenEstimate.toLocaleString();
-    document.getElementById('st-orig').textContent = (d.store.originalTokens || 0).toLocaleString();
-    document.getElementById('st-saved').textContent = (d.store.tokensSaved || 0).toLocaleString();
+    // Compression block from the snapshot (Freed = In − Out, single formula).
+    var c = d.compression || {};
+    var sess = c.session || { tokensIn:0, tokensOut:0, tokensFreed:0, compressionPct:0, dedupPct:0 };
+    var cRepo = c.repo || { tokensIn:0, tokensOut:0, tokensFreed:0, compressionPct:0, dedupPct:0 };
+    document.getElementById('st-in').textContent = sess.tokensIn.toLocaleString();
+    document.getElementById('st-kept').textContent = sess.tokensOut.toLocaleString();
+    document.getElementById('st-freed').textContent = sess.tokensFreed.toLocaleString();
+    var sp = sess.compressionPct || 0;
+    document.getElementById('st-compress-bar').style.width = Math.max(sp * 100, 0.5) + '%';
+    document.getElementById('st-compress-bar').className = 'meter-fill ' + (sp >= 0.9 ? 'meter-green' : sp >= 0.6 ? 'meter-yellow' : 'meter-red');
+    document.getElementById('st-compress-sub').textContent = (sp * 100 >= 10 ? Math.round(sp * 100) : (sp * 100).toFixed(1)) + '% tokens saved · dedup: ' + (sess.dedupPct * 100 >= 10 ? Math.round(sess.dedupPct * 100) : (sess.dedupPct * 100).toFixed(1)) + '%';
+    // ------
     document.getElementById('st-injected').textContent = d.store.injectedCount;
     document.getElementById('st-dedup').textContent = Math.round(d.store.dedupHitRate * 100) + '%';
     var sdr = d.store.storageDedupRate || 0;
@@ -475,16 +507,19 @@ function dashboardHtml(tierName) {
     document.getElementById('st-collapsed').textContent = d.store.dedupCollapsed || 0;
     document.getElementById('st-lastid').textContent = d.session.lastCheckpointId || '—';
 
-    // Repo-wide (all sessions in this repo's SQLite store).
-    var repo = d.repo || { checkpointCount: 0, totalTokenEstimate: 0, originalTokens: 0, tokensSaved: 0, sessionCount: 0, dedupCollapsed: 0, storageDedupRate: 0 };
-    document.getElementById('rp-count').textContent = repo.checkpointCount;
-    document.getElementById('rp-tokens').textContent = repo.totalTokenEstimate.toLocaleString();
-    document.getElementById('rp-orig').textContent = (repo.originalTokens || 0).toLocaleString();
-    document.getElementById('rp-saved').textContent = (repo.tokensSaved || 0).toLocaleString();
-    document.getElementById('rp-sessions').textContent = repo.sessionCount || 0;
-    document.getElementById('rp-collapsed').textContent = repo.dedupCollapsed || 0;
-    var rsdr = repo.storageDedupRate || 0;
-    document.getElementById('rp-sdedup').textContent = (rsdr * 100 >= 10 ? Math.round(rsdr * 100) : (rsdr * 100).toFixed(1)) + '%';
+    // ---- Repo (all sessions) — same compression fields, repo scope ----------
+    document.getElementById('rp-count').textContent = (d.repo && d.repo.checkpointCount || 0).toLocaleString();
+    document.getElementById('rp-in').textContent = cRepo.tokensIn.toLocaleString();
+    document.getElementById('rp-kept').textContent = cRepo.tokensOut.toLocaleString();
+    document.getElementById('rp-freed').textContent = cRepo.tokensFreed.toLocaleString();
+    document.getElementById('rp-sessions').textContent = (d.repo && d.repo.sessionCount || 0).toLocaleString();
+    document.getElementById('rp-collapsed').textContent = (d.repo && d.repo.dedupCollapsed || 0).toLocaleString();
+    var rdr = d.repo && d.repo.storageDedupRate || 0;
+    document.getElementById('rp-sdedup').textContent = (rdr * 100 >= 10 ? Math.round(rdr * 100) : (rdr * 100).toFixed(1)) + '%';
+    var rp = cRepo.compressionPct || 0;
+    document.getElementById('rp-compress-bar').style.width = Math.max(rp * 100, 0.5) + '%';
+    document.getElementById('rp-compress-bar').className = 'meter-fill ' + (rp >= 0.9 ? 'meter-green' : rp >= 0.6 ? 'meter-yellow' : 'meter-red');
+    document.getElementById('rp-compress-sub').textContent = (rp * 100 >= 10 ? Math.round(rp * 100) : (rp * 100).toFixed(1)) + '% tokens saved · dedup: ' + (cRepo.dedupPct * 100 >= 10 ? Math.round(cRepo.dedupPct * 100) : (cRepo.dedupPct * 100).toFixed(1)) + '%';
 
     // Data-safety invariant (Phase 0 — trust foundation).
     var ig = d.integrity || { regionsRetained: 0, compressedOriginalBytes: 0, duplicatesCollapsed: 0, bytesPermanentlyDeleted: 0 };
@@ -524,10 +559,11 @@ function dashboardHtml(tierName) {
     document.getElementById('md-provider').textContent = model && model.providerName ? model.providerName : (model && model.provider ? model.provider : '—');
     document.getElementById('md-input').textContent = model && model.inputRate ? '$' + (model.inputRate).toFixed(6) : '—';
     document.getElementById('md-output').textContent = model && model.outputRate ? '$' + (model.outputRate).toFixed(6) : '—';
-    if (model && model.inputRate && repo.tokensSaved > 0) {
-      var usd = (repo.tokensSaved * model.inputRate);
+    var repoSaved = cRepo.tokensFreed || 0;
+    if (model && model.inputRate && repoSaved > 0) {
+      var usd = (repoSaved * model.inputRate);
       var win = d.context.contextWindow || 0;
-      var windows = win > 0 ? (repo.tokensSaved / win).toFixed(1) : '0';
+      var windows = win > 0 ? (repoSaved / win).toFixed(1) : '0';
       document.getElementById('cost-usd').textContent = '≈ $' + usd.toFixed(4) + ' saved';
       document.getElementById('cost-windows').textContent = windows + ' context-windows extended';
     } else {
@@ -625,6 +661,49 @@ function dashboardHtml(tierName) {
     document.getElementById('cur-updated').textContent = stamp;
     document.getElementById('all-updated').textContent = stamp;
     document.getElementById('sm-updated').textContent = stamp;
+    renderByModel(repos);
+  }
+
+  // Savings-by-model aggregation for the Summary tab — groups the machine-
+  // wide repo registry by (modelName || '(unknown)') so the user can see how
+  // much context + cost mega-compact has reclaimed, broken down by which model
+  // they were running. $ Saved = Σ(tokensSaved × inputRate) per model. Sorted
+  // by tokens saved descending so the biggest-reclaim model wins the top row.
+  function renderByModel(repos) {
+    var rows = document.getElementById('bm-rows');
+    if (!rows) return;
+    if (!repos || !repos.length) {
+      rows.innerHTML = '<tr><td colspan="7" class="repo-none">No repositories registered yet.</td></tr>';
+      return;
+    }
+    var groups = {};
+    for (var i = 0; i < repos.length; i++) {
+      var r = repos[i];
+      var key = (r.modelName && String(r.modelName).trim()) || '(unknown)';
+      if (!groups[key]) groups[key] = { model: key, provider: r.providerName || r.provider || '—', repos: 0, checkpoints: 0, tokensSaved: 0, usd: 0, lastAt: 0, rates: [] };
+      var g = groups[key];
+      g.repos++;
+      g.checkpoints += (r.checkpointCount || 0);
+      g.tokensSaved += (r.tokensSaved || 0);
+      if (r.inputRate) { g.usd += (r.tokensSaved || 0) * r.inputRate; g.rates.push(r.inputRate); }
+      if (r.lastCompactedAt && r.lastCompactedAt > g.lastAt) g.lastAt = r.lastCompactedAt;
+    }
+    var arr = [];
+    for (var k in groups) { if (Object.prototype.hasOwnProperty.call(groups, k)) arr.push(groups[k]); }
+    arr.sort(function(a, b) { return b.tokensSaved - a.tokensSaved; });
+    rows.innerHTML = arr.map(function(g) {
+      var usd = g.usd > 0 ? '$' + g.usd.toFixed(4) : '—';
+      var when = g.lastAt ? new Date(g.lastAt).toLocaleString() : '—';
+      return '<tr>' +
+        '<td><span class="repo-model">' + sanitize(g.model) + '</span></td>' +
+        '<td>' + sanitize(g.provider) + '</td>' +
+        '<td class="num">' + g.repos.toLocaleString() + '</td>' +
+        '<td class="num">' + g.checkpoints.toLocaleString() + '</td>' +
+        '<td class="num">' + g.tokensSaved.toLocaleString() + '</td>' +
+        '<td class="num">' + sanitize(usd) + '</td>' +
+        '<td class="num">' + sanitize(when) + '</td>' +
+      '</tr>';
+    }).join('');
   }
 
   // Per-repo detail modal ---------------------------------------------------
@@ -757,7 +836,47 @@ export async function launchDashboardServer(stateDir) {
     // ── New server ────────────────────────────────────────────────────────────
     mkdirSync(stateDir, { recursive: true });
     let eventOffset = 0;
+    // Overlay the live current-repo snapshot (snapshot.json, rewritten every
+    // context event) onto its registry row so the All-repos / Summary views stay
+    // in sync with the live menu bar + Current-repo card in real time. The
+    // registry (index.sqlite) is only written on repo-switch (bindRepo), so
+    // without this the current repo's row freezes between switches. Read-only —
+    // no extra writes to index.sqlite. Matched by stateDir, which equals the
+    // value this server was launched with (runtime.currentStateDir).
+    function overlayCurrentRepo(idx) {
+        if (!idx || !idx.repos.length)
+            return;
+        let snap = null;
+        try {
+            snap = readSnapshot(snapshotPath);
+        }
+        catch {
+            return;
+        }
+        if (!snap || !snap.repo)
+            return;
+        const cur = idx.repos.find((r) => r.stateDir === stateDir);
+        if (!cur)
+            return;
+        const prevSaved = cur.tokensSaved;
+        const prevCp = cur.checkpointCount;
+        const prevBytes = cur.compressedOriginalBytes;
+        const comp = snap.compression?.repo;
+        const liveSaved = comp ? comp.tokensFreed : (snap.repo.tokensSaved ?? prevSaved);
+        const liveCp = snap.repo.checkpointCount ?? prevCp;
+        const liveBytes = snap.integrity?.compressedOriginalBytes ?? prevBytes;
+        cur.tokensSaved = liveSaved;
+        cur.checkpointCount = liveCp;
+        cur.compressedOriginalBytes = liveBytes;
+        if (idx.summary) {
+            idx.summary.totalTokensSaved += liveSaved - prevSaved;
+            idx.summary.totalCheckpoints += liveCp - prevCp;
+            idx.summary.totalCompressedOriginalBytes += liveBytes - prevBytes;
+        }
+        idx.updatedAt = snap.updatedAt ?? idx.updatedAt;
+    }
     const server = createServer((req, res) => {
+        // guardrails-allow PREVENT-PI-004: optional, user-triggered /dashboard localhost server (loopback-only) — CORS open for local browser access
         // CORS for local access
         res.setHeader("Access-Control-Allow-Origin", "*");
         res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
@@ -790,8 +909,11 @@ export async function launchDashboardServer(stateDir) {
         // directly from SQLite (index.sqlite). Lets one dashboard show every repo's
         // checkpoints, tokens saved, and active model. Read-only.
         if (req.url === "/api/index") {
+            const idx = readIndex();
+            if (idx)
+                overlayCurrentRepo(idx);
             res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify(readIndex() ?? { updatedAt: null, summary: null, repos: [] }));
+            res.end(JSON.stringify(idx ?? { updatedAt: null, summary: null, repos: [] }));
             return;
         }
         // /api/repos — registry list. Optional `?active=24h` filters to repos
@@ -800,8 +922,10 @@ export async function launchDashboardServer(stateDir) {
         if (req.url?.startsWith("/api/repos")) {
             const url = new URL(req.url, "http://x");
             const activeParam = url.searchParams.get("active");
-            const idx = readIndex() ?? { updatedAt: null, summary: null, repos: [] };
-            let repos = (idx.repos ?? []);
+            const idx = readIndex();
+            if (idx)
+                overlayCurrentRepo(idx);
+            let repos = idx?.repos ?? [];
             if (activeParam) {
                 const m = /^(\d+)h$/.exec(activeParam);
                 if (m) {
@@ -810,21 +934,23 @@ export async function launchDashboardServer(stateDir) {
                 }
             }
             res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ updatedAt: idx.updatedAt, repos, count: repos.length }));
+            res.end(JSON.stringify({ updatedAt: idx?.updatedAt ?? null, repos, count: repos.length }));
             return;
         }
         // /api/summary — header tiles without the full repo list (keeps payload
         // small for embed scenarios). activeRepos mirrors the /api/repos?active=24h
         // count so the dashboard can render the active badge alongside totals.
         if (req.url?.startsWith("/api/summary")) {
-            const idx = readIndex() ?? { updatedAt: null, summary: null, repos: [] };
-            const repos = (idx.repos ?? []);
+            const idx = readIndex();
+            if (idx)
+                overlayCurrentRepo(idx);
+            const repos = idx?.repos ?? [];
             const cutoffSec = Math.floor(Date.now() / 1000) - 24 * 3600;
             const activeRepos = repos.filter((r) => (r.lastSeen ?? 0) >= cutoffSec).length;
             res.writeHead(200, { "Content-Type": "application/json" });
             res.end(JSON.stringify({
-                updatedAt: idx.updatedAt,
-                summary: idx.summary,
+                updatedAt: idx?.updatedAt ?? null,
+                summary: idx?.summary ?? null,
                 activeRepos,
                 totalRepos: repos.length,
             }));

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

@@ -123,8 +123,8 @@ describe("multi-repo /api/index (S19)", () => {
         process.env.MEGACOMPACT_INDEX_DIR = indexDir;
         process.env.MEGACOMPACT_DASHBOARD_PORT = "19321"; // private base, non-colliding
         const { upsertRepoRegistry } = await import("../src/store/sqlite.js");
-        upsertRepoRegistry({ repoRoot: "/home/u/repoA", displayName: "repoA", stateDir: dir, checkpointCount: 3, tokensSaved: 1000, compressedOriginalBytes: 0 }, indexDir);
-        upsertRepoRegistry({ repoRoot: "/home/u/repoB", displayName: "repoB", stateDir: dir, checkpointCount: 5, tokensSaved: 2000, compressedOriginalBytes: 0 }, indexDir);
+        upsertRepoRegistry({ repoRoot: "/home/u/repoA", displayName: "repoA", stateDir: join(dir, "a"), checkpointCount: 3, tokensSaved: 1000, compressedOriginalBytes: 0 }, indexDir);
+        upsertRepoRegistry({ repoRoot: "/home/u/repoB", displayName: "repoB", stateDir: join(dir, "b"), checkpointCount: 5, tokensSaved: 2000, compressedOriginalBytes: 0 }, indexDir);
         const child = spawn(process.execPath, [SERVER_ENTRY, dir], { stdio: "ignore" });
         try {
             await waitFor(async () => {