pi-mega-compact 0.6.2 → 0.6.4

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>
@@ -464,10 +469,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 +490,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 +542,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 {
@@ -757,7 +776,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 +849,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 +862,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 +874,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 () => {

package/dist/extensions/mega-runtime.js

@@ -255,6 +255,25 @@ export class MegaRuntime {
             trigger: { armed, ready, currentTokens: this.lastCtxTokens, thresholdTokens: this.config.thresholdTokens, fastGatePct: this.config.fastGatePct },
             crew: { activeAgents: this.activeAgents, currentTurn: this.currentTurn },
             store: { checkpointCount: st.checkpointCount, totalTokenEstimate: st.totalTokenEstimate, originalTokens: st.originalTokens, tokensSaved: this.rt.tokensSaved, injectedCount: st.injectedCount, dedupHitRate: st.dedupHitRate, storageDedupRate: st.storageDedupRate, dedupAttempts: st.dedupAttempts, dedupCollapsed: st.dedupCollapsed },
+            // Reconciled token accounting (single canonical formula, session + repo).
+            // Freed = In − Out; In = Freed + Out. session.Freed = rt.tokensSaved (incl.
+            // deduped-away originals); repo.Freed = repo.tokensSaved meta counter.
+            compression: {
+                session: {
+                    tokensIn: this.rt.tokensSaved + st.totalTokenEstimate,
+                    tokensOut: st.totalTokenEstimate,
+                    tokensFreed: this.rt.tokensSaved,
+                    compressionPct: (this.rt.tokensSaved + st.totalTokenEstimate) > 0 ? this.rt.tokensSaved / (this.rt.tokensSaved + st.totalTokenEstimate) : 0,
+                    dedupPct: st.storageDedupRate,
+                },
+                repo: {
+                    tokensIn: repo.tokensSaved + repo.totalTokenEstimate,
+                    tokensOut: repo.totalTokenEstimate,
+                    tokensFreed: repo.tokensSaved,
+                    compressionPct: (repo.tokensSaved + repo.totalTokenEstimate) > 0 ? repo.tokensSaved / (repo.tokensSaved + repo.totalTokenEstimate) : 0,
+                    dedupPct: repo.storageDedupRate,
+                },
+            },
             repo: {
                 checkpointCount: repo.checkpointCount,
                 totalTokenEstimate: repo.totalTokenEstimate,
@@ -291,33 +310,41 @@ export class MegaRuntime {
             const dedupStr = storageRate * 100 >= 10
                 ? `${Math.round(storageRate * 100)}%`
                 : `${(storageRate * 100).toFixed(1)}%`;
-            // saved = tokens removed from context (cumulative original − stored).
-            // Show BOTH this-session (rt.tokensSaved) and repo-wide-total
-            // (repo.tokensSaved) so the user sees per-session progress vs the running
-            // repo total. "used" = stored checkpoint tokens (repo.totalTokenEstimate
-            // vs st.totalTokenEstimate). Use "k" only at/above 1000 so small-but-real
-            // numbers stay visible (previously Math.round(x/1000) zeroed <1000).
-            const fmt = (x) => (x >= 1000 ? `${(x / 1000).toFixed(1)}k` : `${x}`);
-            const savedStr = `${C.green}${fmt(this.rt.tokensSaved)} sess${C.reset} / ${C.blue}${fmt(repo.tokensSaved)} repo${C.reset}`;
-            const usedStr = `${C.cyan}${fmt(st.totalTokenEstimate)} sess${C.reset} / ${C.blue}${fmt(repo.totalTokenEstimate)} repo${C.reset}`;
+            // Reconciled token accounting — ONE canonical formula for session + repo,
+            // matching the dashboard so the two never disagree. unit format: M at/above
+            // 1e6, k at/above 1e3, raw below — so 5,472,700 → "5.5M", 24,100 → "24.1k",
+            // 142 → "142". Dropped (in) = Freed + Kept; Freed = rt.tokensSaved (session)
+            // / repo.tokensSaved meta (repo); Kept = totalTokenEstimate (stored).
+            const fmt = (x) => x >= 1_000_000 ? `${(x / 1_000_000).toFixed(1)}M`
+                : x >= 1000 ? `${(x / 1000).toFixed(1)}k`
+                    : `${Math.round(x)}`;
             const agentStr = this.activeAgents > 0 ? ` │ 🤖 ${this.activeAgents} agent${this.activeAgents === 1 ? "" : "s"}` : "";
             const turnStr = this.currentTurn > 0 ? ` │ turn ${this.currentTurn}` : "";
             // Phase 3 — pulsing status glyph while a compaction is in flight.
             const pulse = this.pulsing ? `${C.cyan}${PULSE[Math.floor(Date.now() / 250) % PULSE.length]}${C.reset} ` : "";
+            // --- reconciled in/out view (session + repo) ---------------------------
+            const sessIn = this.rt.tokensSaved + st.totalTokenEstimate;
+            const sessKept = st.totalTokenEstimate;
+            const sessFreed = this.rt.tokensSaved;
+            const sessPct = sessIn > 0 ? sessFreed / sessIn : 0;
+            const repoIn = repo.tokensSaved + repo.totalTokenEstimate;
+            const repoKept = repo.totalTokenEstimate;
+            const repoFreed = repo.tokensSaved;
+            const repoPct = repoIn > 0 ? repoFreed / repoIn : 0;
             const lines = [
                 ` ${C.amber}⚡ ${tierLabel}${C.reset} v${C.bold}${ownVersion()}${C.reset} │ ${tokStr}/${maxStr} tokens (${C.bold}${pctStr}${C.reset}) │ ${st.checkpointCount} saved${agentStr}${turnStr}`,
-                `   ${triggerLabel} │ ${C.magenta}repeat-skipped: ${dedupStr}${C.reset} │ ${C.gray}memory held:${C.reset} ${usedStr} │ ${C.gray}space freed:${C.reset} ${savedStr}`,
+                `   ${triggerLabel} │ ${C.magenta}repeat-skipped: ${dedupStr}${C.reset}`,
+                `   ${C.gray}dropped ${fmt(sessIn)} → kept ${fmt(sessKept)} sess / ${fmt(repoKept)} repo · freed ${fmt(sessFreed)} sess / ${fmt(repoFreed)} repo${C.reset}`,
             ];
-            // Phase 3 — compact progress bar: session tokens saved toward the rolling goal.
-            if (this.rt.tokensSaved > 0) {
-                const goal = Math.max(this.savedGoal, 1);
-                const pct = Math.min(100, Math.round((this.rt.tokensSaved / goal) * 100));
-                const filled = Math.round((pct / 100) * 10);
-                const bar = "▓".repeat(filled) + "░".repeat(10 - filled);
-                // Session tokens saved, with the repo-wide total held alongside so the
-                // bar reads "saved X of goal" and the right side shows saved vs total.
-                const totalHeld = st.totalTokenEstimate > 0 ? st.totalTokenEstimate : repo.totalTokenEstimate;
-                lines.push(`   ${C.green}saved ${fmt(this.rt.tokensSaved)} ${bar}${C.reset} ${pct}% of ${fmt(goal)} ${C.gray}│${C.reset} ${C.blue}${fmt(this.rt.tokensSaved)}${C.reset}/${C.blue}${fmt(totalHeld)}${C.reset} tok held`);
+            // Compression meter — the single headline "% tokens saved" (Freed / In),
+            // same formula as the dashboard. Higher = better, so it reads green.
+            {
+                const w = 10;
+                const filled = Math.max(0, Math.min(w, Math.round(sessPct * w)));
+                const cbar = C.green + "▓".repeat(filled) + C.dim + "░".repeat(w - filled) + C.reset;
+                const sTxt = (sessPct * 100).toFixed(sessPct * 100 >= 10 ? 0 : 1);
+                const rTxt = (repoPct * 100).toFixed(repoPct * 100 >= 10 ? 0 : 1);
+                lines.push(`   ${cbar} ${sTxt}% tokens saved (sess) · ${rTxt}% repo${C.reset}`);
             }
             // Live "now processing" line + why + recent deduped/compacted events,
             // collapsed to ONE rotating line (fresh only). The ticker ring buffer

package/dist/src/store/memoryIndex.js

@@ -22,17 +22,15 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { mkdirSync, rmSync, existsSync } from "node:fs";
-// PGlite + pgvector are script-free WASM (no native build) → survive pi's
-// install-script block. Imported lazily so a missing/broken package degrades
-// gracefully instead of crashing module load.
-import { PGlite } from "@electric-sql/pglite";
-import { vector } from "@electric-sql/pglite-pgvector";
 /** Vector dimension produced by the default TrigramEmbedder (src/embedder.ts). */
 export const MEMORY_INDEX_DIM = 512;
 let db;
 let initPromise;
 let disabled = false;
 let warned = false;
+/** Lazily-loaded PGlite module + pgvector extension (see loadPgLite). */
+let pgliteMod;
+let pgliteLoadFailed = false;
 function indexDir() {
     const override = process.env.MEGACOMPACT_INDEX_DIR;
     if (override && override.trim() !== "")
@@ -77,17 +75,44 @@ export function initMemoryIndex() {
     initPromise = openPgLite(/* retryOnCorrupt */ true);
     return initPromise;
 }
+/**
+ * Lazily load the PGlite module + pgvector extension via dynamic import. Caches
+ * success and permanent failure. Returns undefined (once, then forever) when the
+ * package is missing/broken so callers fall back to the same-repo scan. Never throws.
+ */
+async function loadPgLite() {
+    if (pgliteMod)
+        return pgliteMod;
+    if (pgliteLoadFailed)
+        return undefined;
+    try {
+        const [pglitePkg, pgvectorPkg] = await Promise.all([
+            import("@electric-sql/pglite"),
+            import("@electric-sql/pglite-pgvector"),
+        ]);
+        pgliteMod = { PGlite: pglitePkg.PGlite, vector: pgvectorPkg.vector };
+        return pgliteMod;
+    }
+    catch (err) {
+        pgliteLoadFailed = true;
+        logWarn(`package unavailable: ${err instanceof Error ? err.message : String(err)}`);
+        return undefined;
+    }
+}
 /**
  * Open + schema-init PGlite. When `retryOnCorrupt` is true, a WASM-level abort
  * (typically from a corrupted/torn data dir) triggers a delete + one retry.
  */
 async function openPgLite(retryOnCorrupt) {
     try {
+        const mod = await loadPgLite();
+        if (!mod)
+            return undefined;
         const dir = indexDir();
         mkdirSync(dir, { recursive: true });
-        const pg = await new PGlite({
+        const pg = await new mod.PGlite({
             dataDir: dir,
-            extensions: { vector },
+            extensions: { vector: mod.vector },
         });
         await pg.exec("CREATE EXTENSION IF NOT EXISTS vector;");
         await pg.exec(`

package/dist/src/store/vectorIndex.js

@@ -18,17 +18,15 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { mkdirSync, rmSync, existsSync } from "node:fs";
-// PGlite + pgvector are script-free WASM (no native build) → survive pi's
-// install-script block. Imported lazily so a missing/broken package degrades
-// gracefully instead of crashing module load.
-import { PGlite } from "@electric-sql/pglite";
-import { vector } from "@electric-sql/pglite-pgvector";
 /** Vector dimension produced by the default TrigramEmbedder (src/embedder.ts). */
 export const EMBEDDING_DIM = 512;
 let db;
 let initPromise;
 let disabled = false;
 let warned = false;
+/** Lazily-loaded PGlite module + pgvector extension (see loadPgLite). */
+let pgliteMod;
+let pgliteLoadFailed = false;
 function indexDir() {
     const override = process.env.MEGACOMPACT_VECTOR_INDEX_DIR;
     if (override && override.trim() !== "")
@@ -73,6 +71,30 @@ export function initVectorIndex() {
     initPromise = openPgLite(/* retryOnCorrupt */ true);
     return initPromise;
 }
+/**
+ * Lazily load the PGlite module + pgvector extension via dynamic import. Caches
+ * success and permanent failure. Returns undefined (once, then forever) when the
+ * package is missing/broken so callers fall back to the sync scan. Never throws.
+ */
+async function loadPgLite() {
+    if (pgliteMod)
+        return pgliteMod;
+    if (pgliteLoadFailed)
+        return undefined;
+    try {
+        const [pglitePkg, pgvectorPkg] = await Promise.all([
+            import("@electric-sql/pglite"),
+            import("@electric-sql/pglite-pgvector"),
+        ]);
+        pgliteMod = { PGlite: pglitePkg.PGlite, vector: pgvectorPkg.vector };
+        return pgliteMod;
+    }
+    catch (err) {
+        pgliteLoadFailed = true;
+        logWarn(`package unavailable: ${err instanceof Error ? err.message : String(err)}`);
+        return undefined;
+    }
+}
 /**
  * Open + schema-init PGlite. When `retryOnCorrupt` is true, a WASM-level
  * abort (typically from a corrupted/torn data dir) triggers a delete + one
@@ -80,11 +102,14 @@ export function initVectorIndex() {
  */
 async function openPgLite(retryOnCorrupt) {
     try {
+        const mod = await loadPgLite();
+        if (!mod)
+            return undefined;
         const dir = indexDir();
         mkdirSync(dir, { recursive: true });
-        const pg = await new PGlite({
+        const pg = await new mod.PGlite({
             dataDir: dir,
-            extensions: { vector },
+            extensions: { vector: mod.vector },
         });
         await pg.exec("CREATE EXTENSION IF NOT EXISTS vector;");
         await pg.exec(`

package/extensions/conflict-scan.test.ts

@@ -0,0 +1,129 @@
+/**
+ * conflict-scan.test.ts — unit tests for the extension-conflict scanner.
+ *
+ * Fixture trees are written under a temp dir and scanned via
+ * MEGACOMPACT_EXT_SCAN_DIR (which makes collectScanRoots() return that
+ * single root). This covers the S24 follow-up fix:
+ *
+ *   1. node_modules-style code extensions (package.json + pi.extensions) are
+ *      still detected by source-marker grep (regression).
+ *   2. USER-LEVEL extensions installed outside npm (e.g. pi-hermes-memory)
+ *      now get scanned too — previously only `node_modules` was walked, so a
+ *      data-only memory store (MEMORY.md + sessions.db, no package.json)
+ *      was never flagged (the 5000-char file-buffer error slipped through).
+ *   3. The data-only memory-store signature is detected even with no source.
+ *   4. pi-mega-compact (selfName) is always skipped.
+ */
+
+import { test, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { detectConflicts, collectScanRoots } from "./conflict-scan.js";
+
+const base = mkdtempSync(join(tmpdir(), "mc-scan-"));
+let n = 0;
+
+/** Make a fixture root containing one or more fake extensions, return its path. */
+function fixture(build: (root: string) => void): string {
+	const root = join(base, `case-${n++}`);
+	mkdirSync(root, { recursive: true });
+	build(root);
+	return root;
+}
+
+after(() => {
+	rmSync(base, { recursive: true, force: true });
+});
+
+test("scans a user-level, data-only memory store (no package.json)", () => {
+	const root = fixture((r) => {
+		const ext = join(r, "pi-hermes-memory");
+		mkdirSync(ext, { recursive: true });
+		// No package.json, no source — just pi's memory-store signature.
+		writeFileSync(join(ext, "MEMORY.md"), "# memory\n");
+		writeFileSync(join(ext, "sessions.db"), "");
+	});
+	process.env.MEGACOMPACT_EXT_SCAN_DIR = root;
+	try {
+		const { conflicts } = detectConflicts();
+		assert.ok(conflicts.length >= 1, "expected a memory conflict");
+		const hit = conflicts.find((c) => c.kind === "memory");
+		assert.ok(hit, "expected a memory-kind conflict");
+		assert.equal(hit!.severity, "high");
+		assert.ok(
+			hit!.evidence.includes("MEMORY.md") ||
+				hit!.evidence.includes("sessions.db"),
+			"evidence should name the on-disk memory signature",
+		);
+	} finally {
+		delete process.env.MEGACOMPACT_EXT_SCAN_DIR;
+	}
+});
+
+test("still detects a code extension by source marker (regression)", () => {
+	const root = fixture((r) => {
+		// A code extension is a DIRECT child of the scan root (mirrors the
+		// node_modules layout: packages live one level under the root).
+		const ext = join(r, "some-memory-ext");
+		mkdirSync(ext, { recursive: true });
+		writeFileSync(
+			join(ext, "package.json"),
+			JSON.stringify({ name: "some-memory-ext", pi: { extensions: ["x.ts"] } }),
+		);
+		writeFileSync(join(ext, "index.ts"), "export const MEMORY_TOOL = true;");
+	});
+	process.env.MEGACOMPACT_EXT_SCAN_DIR = root;
+	try {
+		const { conflicts } = detectConflicts();
+		const hit = conflicts.find((c) => c.package === "some-memory-ext");
+		assert.ok(hit, "expected some-memory-ext to be flagged");
+		assert.equal(hit!.kind, "memory");
+	} finally {
+		delete process.env.MEGACOMPACT_EXT_SCAN_DIR;
+	}
+});
+
+test("skips pi-mega-compact (selfName) and non-extension dirs", () => {
+	const root = fixture((r) => {
+		// selfName dir with a memory signature — must be ignored.
+		const me = join(r, "node_modules", "pi-mega-compact");
+		mkdirSync(me, { recursive: true });
+		writeFileSync(join(me, "sessions.db"), "");
+		// unrelated dir with no pi.extensions and no memory signature.
+		mkdirSync(join(r, "node_modules", "totally-fine"), { recursive: true });
+	});
+	process.env.MEGACOMPACT_EXT_SCAN_DIR = root;
+	try {
+		const { scanned, conflicts } = detectConflicts();
+		assert.equal(conflicts.length, 0, "no conflicts expected");
+		assert.ok(
+			!scanned.some((s) => s.includes("pi-mega-compact")),
+			"selfName should not appear in scanned",
+		);
+	} finally {
+		delete process.env.MEGACOMPACT_EXT_SCAN_DIR;
+	}
+});
+
+test("collectScanRoots honors MEGACOMPACT_EXT_SCAN_DIR override", () => {
+	const root = fixture(() => {});
+	process.env.MEGACOMPACT_EXT_SCAN_DIR = root;
+	try {
+		const roots = collectScanRoots();
+		assert.deepEqual(roots, [root], "override replaces the whole root list");
+	} finally {
+		delete process.env.MEGACOMPACT_EXT_SCAN_DIR;
+	}
+});
+
+test("collectScanRoots falls back to node_modules + user dir when no override", () => {
+	delete process.env.MEGACOMPACT_EXT_SCAN_DIR;
+	delete process.env.MEGACOMPACT_EXT_USER_DIR;
+	// No override set and this test file lives under extensions/, so node_modules
+	// resolution walks up from here; the user dir (~/.pi/agent) may or may
+	// not exist in CI. We only assert the call returns a non-throwing array.
+	const roots = collectScanRoots();
+	assert.ok(Array.isArray(roots), "collectScanRoots must return an array");
+});