pi-mega-compact 0.6.3 → 0.6.5

package/extensions/dashboard-server.ts

@@ -59,6 +59,7 @@ function getIndexDir(): string {
 interface IndexRepo {
   repoRoot: string;
   displayName: string;
+  stateDir: string;
   checkpointCount: number;
   tokensSaved: number;
   compressedOriginalBytes: number;
@@ -71,8 +72,17 @@ interface IndexRepo {
   lastSeen: number;
 }
 
+interface IndexSummary {
+  totalRepos: number;
+  totalCheckpoints: number;
+  totalTokensSaved: number;
+  totalCompressedOriginalBytes: number;
+}
+
+type IndexIndex = { updatedAt: string; summary: IndexSummary | null; repos: IndexRepo[] };
+
 /** Read the machine-wide repo registry from SQLite (read-only, single shot). */
-function readIndex(): { updatedAt: string; summary: unknown; repos: unknown[] } | null {
+function readIndex(): IndexIndex | null {
   const indexPath = join(getIndexDir(), "index.sqlite");
   if (!existsSync(indexPath)) return null;
   let db: DatabaseSync | undefined;
@@ -86,6 +96,7 @@ function readIndex(): { updatedAt: string; summary: unknown; repos: unknown[] }
     const mapped: IndexRepo[] = 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),
@@ -197,6 +208,10 @@ interface Snapshot {
     duplicatesCollapsed: number;
     bytesPermanentlyDeleted: number;
   };
+  compression: {
+    session: { tokensIn: number; tokensOut: number; tokensFreed: number; compressionPct: number; dedupPct: number };
+    repo: { tokensIn: number; tokensOut: number; tokensFreed: number; compressionPct: number; dedupPct: number };
+  };
   model?: {
     name: string;
     provider: string;
@@ -374,27 +389,31 @@ function dashboardHtml(tierName: string): string {
     <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>
@@ -440,11 +459,11 @@ function dashboardHtml(tierName: string): string {
   <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>
@@ -515,6 +534,23 @@ function dashboardHtml(tierName: string): string {
     <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>
 
@@ -548,10 +584,20 @@ function dashboardHtml(tierName: string): string {
                 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;
@@ -559,16 +605,19 @@ function dashboardHtml(tierName: string): string {
     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 };
@@ -608,10 +657,11 @@ function dashboardHtml(tierName: string): string {
     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 {
@@ -709,6 +759,49 @@ function dashboardHtml(tierName: string): string {
     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 ---------------------------------------------------
@@ -838,7 +931,40 @@ export async function launchDashboardServer(stateDir: string): Promise<{ port: n
 
   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: IndexIndex | null): void {
+    if (!idx || !idx.repos.length) return;
+    let snap: Snapshot | null = 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: IncomingMessage, res: ServerResponse) => {
+    // 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");
@@ -876,8 +1002,10 @@ export async function launchDashboardServer(stateDir: string): Promise<{ port: n
     // 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;
     }
 
@@ -887,8 +1015,9 @@ export async function launchDashboardServer(stateDir: string): Promise<{ port: n
     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 ?? []) as IndexRepo[];
+      const idx = readIndex();
+      if (idx) overlayCurrentRepo(idx);
+      let repos = idx?.repos ?? [];
       if (activeParam) {
         const m = /^(\d+)h$/.exec(activeParam);
         if (m) {
@@ -897,7 +1026,7 @@ export async function launchDashboardServer(stateDir: string): Promise<{ port: n
         }
       }
       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;
     }
 
@@ -905,14 +1034,15 @@ export async function launchDashboardServer(stateDir: string): Promise<{ port: n
     // 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 ?? []) as IndexRepo[];
+      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/extensions/mega-dashboard.ts

@@ -80,6 +80,22 @@ export interface DashboardSnapshot {
     dedupCollapsed: number;      // cumulative deduped collapses (store-wide)
     storageDedupRate: number;    // deduped / attempts, 0..1
   };
+  /**
+   * Reconciled token accounting — ONE canonical formula for both session + repo
+   * so the dashboard and widget tell the same story:
+   *   tokensIn   = original conversation dropped into compaction (incl. the
+   *                redundant regions skipped by dedup) — the "in".
+   *   tokensOut  = compact summaries currently held (stored) — the "out".
+   *   tokensFreed= tokensIn − tokensOut (the "saved").
+   *   compressionPct = tokensFreed / tokensIn (0..1) — the headline "% saved".
+   *   dedupPct   = storageDedupRate (0..1) — share of adds that collapsed.
+   * session.Freed = rt.tokensSaved (honest net freed this session, incl. deduped-away);
+   * repo.Freed   = repo.tokensSaved meta (honest net freed repo-wide).
+   */
+  compression: {
+    session: { tokensIn: number; tokensOut: number; tokensFreed: number; compressionPct: number; dedupPct: number };
+    repo: { tokensIn: number; tokensOut: number; tokensFreed: number; compressionPct: number; dedupPct: number };
+  };
   /** Phase 0 data-safety invariant (trust foundation). */
   integrity: {
     regionsRetained: number;         // checkpoints with a recoverable compressed-original

package/extensions/mega-runtime.ts

@@ -282,6 +282,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,
@@ -319,33 +338,42 @@ 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: number) => (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: number) =>
+        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
@@ -366,10 +394,11 @@ export class MegaRuntime {
       } else if (this.pulsing) {
         lines.push(`   ${pulse}${C.teal}compacting…${C.reset}`);
       }
-      // Plain-language hint so first-time users understand the widget. Always
-      // last, dimmed. "/mega-help explains these terms."
+      // Token accounting summary, always last + dimmed. Shows the total
+      // tokens dropped (in) + kept (out) for this session, then the freed
+      // (saved) tokens for both this session and all-time across the repo.
       if (lines.length < 10) {
-        lines.push(`   ${C.dim}auto-compresses old context to free space · nothing deleted · /mega-help${C.reset}`);
+        lines.push(`   ${C.dim}session ↑${fmt(sessIn)} in ↓${fmt(sessKept)} out · saved ${fmt(sessFreed)} session / ${fmt(repoFreed)} all-time${C.reset}`);
       }
       ctx.ui.setWidget(WIDGET_KEY, lines, { placement: "aboveEditor" });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "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/compact.ts

@@ -36,8 +36,13 @@ export function isChatty(text: string): boolean {
   return text.length < 40 && !/(\/|\.|\{|import |def |function )/.test(text);
 }
 
-/** Extract plausible file paths (contain '/' + an interesting extension). */
-export function extractFileCandidates(content: string): string[] {
+/** Extract plausible file paths (contain '/' + an interesting extension).
+ * Defensive against a missing/empty payload: pi's adapter can hand the engine
+ * a message whose `text`/`input`/`output` is undefined (e.g. a pure tool-call
+ * or tool-result message), and `.split` on undefined throws and takes down the
+ * whole compaction. Guard once at the source so every caller is safe. */
+export function extractFileCandidates(content: string | undefined | null): string[] {
+  if (!content) return [];
   const out: string[] = [];
   for (const raw of content.split(/\s+/)) {
     // Trim surrounding punctuation only — do NOT strip internal dots, or we

package/src/supersede.ts

@@ -12,6 +12,9 @@ import { extractFileCandidates } from "./compact.js";
 
 /** Classify a message's relationship to a file path. */
 function fileOps(msg: EngineMessage): { path: string; op: "read" | "write" }[] {
+  // msg.text may be undefined for pure tool-call/result messages; the guard
+  // lives in extractFileCandidates, but the early return short-circuits the
+  // write-detection regex too so we never classify an empty message.
   const paths = extractFileCandidates(msg.text);
   if (paths.length === 0) return [];
   const low = msg.text.toLowerCase();