pi-mega-compact 0.6.9 → 0.7.1

package/dist/extensions/mega-runtime.js

@@ -11,13 +11,14 @@
 import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { readFileSync } from "node:fs";
+import { readFileSync, appendFileSync, mkdirSync } from "node:fs";
 import { VectorStore } from "../src/vectorStore.js";
 import { toEngineMessages } from "../src/adapt.js";
 import { normalizeSessionId } from "../src/store.js";
 import { Logger } from "../src/log.js";
-import { recordModelSnapshot, latestModelSnapshot, upsertRepoRegistry, recordRepoModel } from "../src/store/sqlite.js";
-import { repoStateDir, resolveRepoRoot, pressureRatio, pressureFromPct, pressureBand } from "./mega-config.js";
+import { recordModelSnapshot, latestModelSnapshot, upsertRepoRegistry, recordRepoModel, } from "../src/store/sqlite.js";
+import { detectCrossRepoDrift } from "../src/driftDetection.js";
+import { repoStateDir, resolveRepoRoot, pressureRatio, pressureFromPct, pressureBand, effectiveThresholdTokens, } from "./mega-config.js";
 import { Dashboard } from "./mega-dashboard.js";
 export const STATUS_KEY = "mega-compact";
 export const WIDGET_KEY = "mega-compact-stats";
@@ -56,6 +57,93 @@ export const C = {
     red: "\x1b[38;5;203m", // pressure / overflow
 };
 const PULSE = ["◐", "◓", "◑", "◒"];
+// ── Full-width widget panel helpers ────────────────────────────────────────
+// pi's above-editor widget renderer (a Container of Text lines) does NOT pass
+// a terminal width to setWidget(), so lines render left-aligned by default. To
+// make the widget read as a full-width status panel we pad each line to the
+// real terminal width with a background fill. NOTE: C.reset is a FULL SGR
+// reset, so we re-apply the panel bg after every reset to keep the background
+// continuous under colored text (and under pi's own trailing reset).
+const PANEL_BG = "\x1b[48;5;236m"; // dark slate panel background
+const PANEL_RST = "\x1b[0m" + PANEL_BG; // reset fg but retain panel bg
+/** Visible cell width of a string, ignoring ANSI SGR/OSC escapes. */
+function visibleWidth(s) {
+    const stripped = s
+        .replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "")
+        .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "");
+    let w = 0;
+    for (const ch of stripped) {
+        const cp = ch.codePointAt(0) ?? 0;
+        const wide = cp >= 0x1100 &&
+            (cp <= 0x115f ||
+                (cp >= 0x2e80 && cp <= 0x303e) ||
+                (cp >= 0x3041 && cp <= 0x33ff) ||
+                (cp >= 0x3400 && cp <= 0x4dbf) ||
+                (cp >= 0x4e00 && cp <= 0x9fff) ||
+                (cp >= 0xa000 && cp <= 0xa4cf) ||
+                (cp >= 0xac00 && cp <= 0xd7a3) ||
+                (cp >= 0xf900 && cp <= 0xfaff) ||
+                (cp >= 0xfe30 && cp <= 0xfe4f) ||
+                (cp >= 0xff00 && cp <= 0xff60) ||
+                (cp >= 0xffe0 && cp <= 0xffe6) ||
+                (cp >= 0x1f300 && cp <= 0x1faff) ||
+                (cp >= 0x20000 && cp <= 0x3fffd));
+        w += wide ? 2 : 1;
+    }
+    return w;
+}
+/** Pad a content string (with ANSI colors) to `width` cells using panel bg. */
+function panelLine(content, width) {
+    const withBg = PANEL_BG + content.replace(/\x1b\[0m/g, PANEL_RST);
+    const pad = Math.max(0, width - visibleWidth(withBg));
+    return withBg + " ".repeat(pad) + "\x1b[0m";
+}
+/** A full-width hairline bar (top/bottom border of the panel). */
+function panelBar(width, ch = "─") {
+    return PANEL_BG + ch.repeat(Math.max(0, width)) + "\x1b[0m";
+}
+/** Token-count formatter: M at/above 1e6, k at/above 1e3, raw below.
+ *  5,472,700 → "5.5mil", 24,100 → "24.1k", 142 → "142". */
+function fmtTokens(x) {
+    return x >= 1_000_000
+        ? `${(x / 1_000_000).toFixed(1)}mil`
+        : x >= 1000
+            ? `${(x / 1000).toFixed(1)}k`
+            : `${Math.round(x)}`;
+}
+/** Retro gradient bar — `w` cells shaded by fill position (green→amber→red).
+ *  Used for CONTEXT fill where low=green (room) and high=red (near the limit). */
+function ramp(pct, w = 12) {
+    const cells = ["▏", "▎", "▍", "▌", "▋", "▊", "▉", "█"];
+    const scaled = Math.max(0, Math.min(w, pct * w));
+    const full = Math.floor(scaled);
+    const frac = scaled - full;
+    const fracCell = frac > 0 ? cells[Math.round(frac * (cells.length - 1))] : "";
+    let out = "";
+    for (let i = 0; i < full; i++)
+        out += (i / w < 0.6 ? C.green : i / w < 0.85 ? C.amber : C.red) + "█";
+    if (fracCell)
+        out +=
+            (full / w < 0.6 ? C.green : full / w < 0.85 ? C.amber : C.red) + fracCell;
+    out +=
+        C.dim + "░".repeat(Math.max(0, w - full - (fracCell ? 1 : 0))) + C.reset;
+    return out;
+}
+/** Human "time since" string from a millisecond delta (or null → "never"). */
+function sinceCompactStr(ms) {
+    if (ms == null)
+        return "never";
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${s}s ago`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m ago`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h ago`;
+    return `${Math.floor(h / 24)}d ago`;
+}
 export class MegaRuntime {
     config;
     // Store/dashboard/logger are rebound per-repo by bindRepo() so each git repo
@@ -75,6 +163,7 @@ export class MegaRuntime {
         dedupSkips: 0,
         dedupAttempts: 0,
         tokensSaved: 0,
+        lastCompactAt: null,
     };
     debounceUntil = 0;
     // S16: debounce for the agent_end resume nudge (avoid busy-loops).
@@ -121,6 +210,11 @@ export class MegaRuntime {
     lastCtxTokens = null;
     lastCtxPercent = null;
     lastCtxWindow = 0;
+    // Latest computed widget payload (recomputed per snapshot, rendered per frame).
+    widgetData = null;
+    // Cached cross-repo drift status (recomputed at most every 30s — it opens the
+    // machine-wide registry DB, so we don't want to do it on every render frame).
+    driftCache = null;
     /**
      * DIAG counters for the "team run doesn't relieve context" investigation.
      * Plain integers, incremented at the three compaction decision points. They
@@ -142,27 +236,73 @@ export class MegaRuntime {
     diagCtxCutNull = 0; // computeLiveTrimCut returned null (anchor/boundary)
     diagCtxThrown = 0; // live-trim try threw (caught)
     /**
-     * Live 0–1 pressure: how full the context window is relative to the compaction
-     * threshold. Computed from the most recent context event the runtime already
-     * tracks (token count when available — the direct signal — otherwise the usage
-     * percentage). This is the single "how full" number every subsystem reads; the
-     * toolbar/dashboard tier label is `pressureBand` over this, so it climbs
-     * low→mega as context rises (S24). Always finite + in [0,1].
+     * S26 capture instrumentation: the "model_snapshots empty → $0.00 cost card"
+     * bug was invisible because captureModel swallowed the DB write in a silent
+     * `catch {}`. These always-updated counters (zero cost) let a headless test or
+     * a live capture tell whether captureModel ran and whether the snapshot landed.
+     */
+    diagCaptureModelCalls = 0; // captureModel entered with a populated ctx.model
+    diagCaptureModelFails = 0; // recordModelSnapshot threw → model_snapshots stays empty
+    /**
+     * Live 0–1 pressure — how full the context window is relative to the
+     * compaction threshold.
+     *
+     * RECONCILE (BACKLOG dual-basis flicker): when the model context window is
+     * known we base pressure consistently on the *percentage* basis
+     * (`lastCtxPercent / (tierPct*100)`). This keeps the band stable whether the
+     * latest context event carried a token count or only a percentage, so the
+     * threshold comparison doesn't jump when a token-count event arrives vs a
+     * percent-only event. We only fall back to the token-count basis
+     * (`config.thresholdTokens`) when the window is unknown (e.g. before the first
+     * context event, or a `custom` tier with no tierPct). Always finite + in [0,1].
      */
     get pressure() {
-        if (this.lastCtxTokens != null && this.lastCtxTokens > 0 && this.config.thresholdTokens > 0) {
+        if (this.lastCtxWindow > 0 &&
+            this.config.tierPct != null &&
+            this.lastCtxPercent != null) {
+            // pressureFromPct(x) = x/100, and x = lastCtxPercent/tierPct, so this is
+            // exactly the intended lastCtxPercent/(tierPct*100) 0–1 ratio: at the
+            // fire point (lastCtxPercent == tierPct*100) pressure == 1.0, matching the
+            // token-based pressureRatio(currentTokens, effectiveThreshold) reading so
+            // the band doesn't jump when a token-count vs percent-only event arrives.
+            return pressureFromPct(this.lastCtxPercent / this.config.tierPct);
+        }
+        if (this.lastCtxTokens != null &&
+            this.lastCtxTokens > 0 &&
+            this.config.thresholdTokens > 0) {
             return pressureRatio(this.lastCtxTokens, this.config.thresholdTokens);
         }
         return pressureFromPct(this.lastCtxPercent);
     }
+    /**
+     * The live compaction FIRE POINT in tokens: the effective threshold scaled by
+     * the current model context window (`tierPct * window`) when known, else the
+     * boot fallback `config.thresholdTokens`. This is what the FAST GATE /
+     * `autoCompactCheck` / agent_end durable-trigger compare against, so
+     * compaction fires at tier% of the window for ANY model size (200k or 1M),
+     * always below pi's native auto-compaction (~80% of window).
+     */
+    get effectiveThreshold() {
+        return effectiveThresholdTokens({
+            tierPct: this.config.tierPct,
+            fallbackThreshold: this.config.thresholdTokens,
+            window: this.lastCtxWindow,
+        });
+    }
     /** Live discrete pressure band (low/medium/high/ultra/mega) over `pressure`. */
     get pressureBand() {
         return pressureBand(this.pressure);
     }
     constructor(config) {
         this.config = config;
-        this.store = new VectorStore({ dedupSim: config.dedupSim, stateDir: config.stateDir });
-        this.logger = new Logger({ enabled: config.debug, path: join(config.stateDir, "mega-compact.log") });
+        this.store = new VectorStore({
+            dedupSim: config.dedupSim,
+            stateDir: config.stateDir,
+        });
+        this.logger = new Logger({
+            enabled: config.debug,
+            path: join(config.stateDir, "mega-compact.log"),
+        });
         this.dashboard = new Dashboard(config.stateDir);
         this.currentStateDir = config.stateDir;
     }
@@ -173,14 +313,22 @@ export class MegaRuntime {
      * and events are fully isolated. Falls back to the global default outside git.
      */
     bindRepo(cwd) {
-        const dir = cwd ? repoStateDir(cwd, this.config.stateDir) : this.config.stateDir;
-        const key = cwd ? resolveRepoRoot(cwd) ?? dir : dir;
+        const dir = cwd
+            ? repoStateDir(cwd, this.config.stateDir)
+            : this.config.stateDir;
+        const key = cwd ? (resolveRepoRoot(cwd) ?? dir) : dir;
         if (key === this.activeRepoRoot)
             return dir;
         this.activeRepoRoot = key;
         this.currentStateDir = dir;
-        this.store = new VectorStore({ dedupSim: this.config.dedupSim, stateDir: dir });
-        this.logger = new Logger({ enabled: this.config.debug, path: join(dir, "mega-compact.log") });
+        this.store = new VectorStore({
+            dedupSim: this.config.dedupSim,
+            stateDir: dir,
+        });
+        this.logger = new Logger({
+            enabled: this.config.debug,
+            path: join(dir, "mega-compact.log"),
+        });
         this.dashboard = new Dashboard(dir);
         // Aggregate this repo into the machine-wide index so the multi-repo
         // dashboard (Summary / All-repos tabs) can show it alongside every other
@@ -190,7 +338,7 @@ export class MegaRuntime {
         try {
             const repo = this.store.repoStats();
             const di = this.store.dataInvariant();
-            const root = key !== dir ? key : resolveRepoRoot(cwd ?? dir) ?? dir;
+            const root = key !== dir ? key : (resolveRepoRoot(cwd ?? dir) ?? dir);
             upsertRepoRegistry({
                 repoRoot: root,
                 displayName: root.split(/[\\/]/).filter(Boolean).pop() ?? root,
@@ -224,8 +372,16 @@ export class MegaRuntime {
                 outputRate: modelSnap.outputRate,
             }
             : undefined;
-        const armed = this.lastCtxPercent != null && this.lastCtxPercent >= this.config.fastGatePct;
-        const ready = armed && (this.lastCtxTokens ?? 0) >= this.config.thresholdTokens;
+        // effectiveThresholdPct: the live fire point as a % of the window (null for
+        // `custom`, which has no tierPct). Used by armed/ready + the dashboard.
+        const effectiveThresholdPct = this.config.tierPct != null ? this.config.tierPct * 100 : null;
+        // armed lights at/above the REAL fire point: max(effectiveThresholdPct,
+        // fastGatePct). fastGatePct already equals tierPct*100 by default, but a
+        // MEGACOMPACT_FAST_GATE_PCT override can raise it, so we take the max.
+        const armed = this.lastCtxPercent != null &&
+            this.lastCtxPercent >=
+                Math.max(effectiveThresholdPct ?? 0, this.config.fastGatePct);
+        const ready = armed && (this.lastCtxTokens ?? 0) >= this.effectiveThreshold;
         this.dashboard.snapshot({
             version: 1,
             updatedAt: new Date().toISOString(),
@@ -236,7 +392,9 @@ export class MegaRuntime {
             pressure: this.pressure,
             config: {
                 fastGatePct: this.config.fastGatePct,
-                thresholdTokens: this.config.thresholdTokens,
+                thresholdTokens: this.effectiveThreshold,
+                tierPct: this.config.tierPct,
+                effectiveThresholdPct,
                 anchorUserMessages: this.config.anchorUserMessages,
                 preserveRecent: this.config.preserveRecent,
                 auto: this.config.auto,
@@ -252,10 +410,32 @@ export class MegaRuntime {
                 dedupSkips: this.rt.dedupSkips,
                 dedupAttempts: this.rt.dedupAttempts,
             },
-            context: { tokens: this.lastCtxTokens, percent: this.lastCtxPercent, contextWindow: this.lastCtxWindow },
-            trigger: { armed, ready, currentTokens: this.lastCtxTokens, thresholdTokens: this.config.thresholdTokens, fastGatePct: this.config.fastGatePct },
+            context: {
+                tokens: this.lastCtxTokens,
+                percent: this.lastCtxPercent,
+                contextWindow: this.lastCtxWindow,
+            },
+            trigger: {
+                armed,
+                ready,
+                currentTokens: this.lastCtxTokens,
+                thresholdTokens: this.effectiveThreshold,
+                fastGatePct: this.config.fastGatePct,
+                tierPct: this.config.tierPct,
+                effectiveThresholdPct,
+            },
             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 },
+            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.
@@ -264,14 +444,19 @@ export class MegaRuntime {
                     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,
+                    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,
+                    compressionPct: repo.tokensSaved + repo.totalTokenEstimate > 0
+                        ? repo.tokensSaved / (repo.tokensSaved + repo.totalTokenEstimate)
+                        : 0,
                     dedupPct: repo.storageDedupRate,
                 },
             },
@@ -295,102 +480,188 @@ export class MegaRuntime {
         });
         // Live stats widget above the editor
         if (ctx) {
-            const tokStr = this.lastCtxTokens != null ? `${Math.round(this.lastCtxTokens / 1000)}k` : "?";
-            const maxStr = this.lastCtxWindow > 0 ? `${Math.round(this.lastCtxWindow / 1000)}k` : "?";
-            const pctStr = this.lastCtxPercent != null ? `${Math.round(this.lastCtxPercent * 10) / 10}%` : "?%";
+            // ── gather widget data (computed per snapshot, rendered per frame) ────
+            const tokStr = this.lastCtxTokens != null
+                ? `${Math.round(this.lastCtxTokens / 1000)}k`
+                : "?";
+            const maxStr = this.lastCtxWindow > 0
+                ? `${Math.round(this.lastCtxWindow / 1000)}k`
+                : "?";
+            const pctStr = this.lastCtxPercent != null
+                ? `${Math.round(this.lastCtxPercent * 10) / 10}%`
+                : "?%";
             // S24: the tier label is the LIVE pressure band (low/medium/high/ultra/
-            // mega), not the static env preset. It climbs as context fills, so the
-            // user can see the system react. The base preset is shown as a dim suffix.
+            // mega), not the static env preset. It climbs as context fills.
             const liveBand = this.pressureBand;
             const tierLabel = `${C.bold}${liveBand}${C.reset}${C.gray}·${this.config.tier}${C.reset}`;
-            const triggerLabel = ready ? `${C.green}● ready${C.reset}` : armed ? `${C.amber}◐ armed${C.reset}` : `${C.gray}○ idle${C.reset}`;
+            const triggerLabel = ready
+                ? `${C.green}● ready${C.reset}`
+                : armed
+                    ? `${C.amber}◐ armed${C.reset}`
+                    : `${C.gray}○ idle${C.reset}`;
             // Storage dedup rate is cumulative (store-wide, per-repo) and survives
-            // session resets. Always show a number: 0% before any compaction, a
-            // decimal for sub-10% rates so small-but-real dedup isn't rounded away.
+            // session resets. Always show a number (decimal for sub-10%).
             const storageRate = st.storageDedupRate; // 0..1
             const dedupStr = storageRate * 100 >= 10
                 ? `${Math.round(storageRate * 100)}%`
                 : `${(storageRate * 100).toFixed(1)}%`;
-            // 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)}mil`
-                : x >= 1000 ? `${(x / 1000).toFixed(1)}k`
-                    : `${Math.round(x)}`;
-            const agentStr = this.activeAgents > 0 ? ` │ 🤖 ${this.activeAgents} agent${this.activeAgents === 1 ? "" : "s"}` : "";
+            // Agents view: count + status (S27 per-agent tokens are gated on P0).
+            const agentLabel = this.activeAgents > 0
+                ? `🤖 ${this.activeAgents} agent${this.activeAgents === 1 ? "" : "s"}`
+                : `${C.dim}🤖 idle${C.reset}`;
+            const agentStr = ` │ ${agentLabel}`;
             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) ---------------------------
+            // Reconciled in/out view (session + repo) — ONE canonical formula.
             const sessIn = this.rt.tokensSaved + st.totalTokenEstimate;
             const sessKept = st.totalTokenEstimate;
-            const sessFreed = this.rt.tokensSaved;
-            const sessPct = sessIn > 0 ? sessFreed / sessIn : 0;
+            const sessPct = sessIn > 0 ? this.rt.tokensSaved / sessIn : 0;
             const repoIn = repo.tokensSaved + repo.totalTokenEstimate;
             const repoKept = repo.totalTokenEstimate;
-            const repoFreed = repo.tokensSaved;
-            const repoPct = repoIn > 0 ? repoFreed / repoIn : 0;
-            // Retro gradient bar — `w` cells, each shaded by fill position so it
-            // reads as a smooth green→amber→red ramp. Used for CONTEXT fill where
-            // low=green (room to spare) and high=red (near the limit) — the only
-            // live-moving metric worth a bar. Savings ratios saturate near 100% and
-            // are shown as explanatory numbers instead (see L2).
-            const ramp = (pct, w = 12) => {
-                const cells = ["▏", "▎", "▍", "▌", "▋", "▊", "▉", "█"];
-                const scaled = Math.max(0, Math.min(w, pct * w));
-                const full = Math.floor(scaled);
-                const frac = scaled - full;
-                const fracCell = frac > 0 ? cells[Math.round(frac * (cells.length - 1))] : "";
-                let out = "";
-                for (let i = 0; i < full; i++)
-                    out += (i / w < 0.6 ? C.green : i / w < 0.85 ? C.amber : C.red) + "█";
-                if (fracCell)
-                    out += (full / w < 0.6 ? C.green : full / w < 0.85 ? C.amber : C.red) + fracCell;
-                out += C.dim + "░".repeat(Math.max(0, w - full - (fracCell ? 1 : 0))) + C.reset;
-                return out;
-            };
-            const ctxPct = this.lastCtxPercent != null ? this.lastCtxPercent / 100 : 0;
+            const repoPct = repoIn > 0 ? repo.tokensSaved / repoIn : 0;
             const sTxt = (sessPct * 100).toFixed(sessPct * 100 >= 10 ? 0 : 1);
             const rTxt = (repoPct * 100).toFixed(repoPct * 100 >= 10 ? 0 : 1);
-            const lines = [
-                // L1 — header: tier + ctx-fill bar (20-cell, green=room→red=full) +
-                // tokens + status glyph + checkpoints + agents/turn. Widened to use the
-                // terminal width; the context bar is the only live-moving bar.
-                ` ${C.amber}⚡ ${tierLabel}${C.reset} v${C.bold}${ownVersion()}${C.reset} ${ramp(ctxPct, 20)} ${C.bold}${pctStr}${C.reset} ${tokStr}/${maxStr} │ ${triggerLabel} │ ${st.checkpointCount} chk${agentStr}${turnStr}`,
-                // L2 — savings EXPLAINED, not bar'd. The freed/(freed+kept) ratio
-                // saturates near 100% once cumulative freed dwarfs live kept (4.8mil
-                // freed vs 612 kept), so a bar is visually useless. Instead show the
-                // compaction story: "in→kept (X% freed)" reads as "compacted N tokens
-                // down to M, freeing X%". Plus repo-wide chk/session counts.
-                `   ${C.magenta}dup ${dedupStr}${C.reset} │ ${C.gray}sess${C.reset} ${fmt(sessIn)}→${fmt(sessKept)} kept ${C.green}(${sTxt}% freed)${C.reset} · ${C.gray}all-time${C.reset} ${fmt(repoIn)}→${fmt(repoKept)} kept ${C.blue}(${rTxt}% freed)${C.reset} │ ${repo.checkpointCount} chk/${repo.sessionCount} sess`,
+            const ctxPct = this.lastCtxPercent != null ? this.lastCtxPercent / 100 : 0;
+            // Model + provider (S26 capture) for the header.
+            const modelName = modelSnap?.modelName ?? modelSnap?.modelId ?? "?";
+            const modelStr = modelSnap?.provider
+                ? `${modelName}·${modelSnap.provider}`
+                : modelName;
+            // Since-last-compact (ms; null until first compaction this session).
+            const sinceCompact = this.rt.lastCompactAt != null
+                ? Date.now() - this.rt.lastCompactAt
+                : null;
+            // Memory store: embedder + compression ratio (original / stored).
+            const embedderName = this.embedderName();
+            const compRatio = st.originalTokens > 0 && st.totalTokenEstimate > 0
+                ? st.originalTokens / st.totalTokenEstimate
+                : st.originalTokens > 0
+                    ? 1
+                    : 0;
+            const compStr = compRatio >= 1 ? `${compRatio.toFixed(1)}x` : "—";
+            // Cross-repo drift status (cached, read-only).
+            const driftStatus = this.driftStatus();
+            const agentsActive = this.activeAgents > 0;
+            this.widgetData = {
+                version: ownVersion(),
+                tierLabel,
+                triggerLabel,
+                pctStr,
+                tokStr,
+                maxStr,
+                ctxPct,
+                chk: st.checkpointCount,
+                agentStr,
+                turnStr,
+                dedupStr,
+                sessIn,
+                sessKept,
+                sTxt,
+                repoIn,
+                repoKept,
+                rTxt,
+                repoChk: repo.checkpointCount,
+                repoSess: repo.sessionCount,
+                modelStr,
+                sinceCompact,
+                embedderName,
+                compStr,
+                driftStatus,
+                agentsActive,
+                fresh: Date.now() - this.lastActivityAt < 4000,
+                ticker: this.ticker,
+                lastWhy: this.lastWhy,
+                tierTrace: this.tierTrace,
+                pulsing: this.pulsing,
+            };
+            // Auto-fit: register a factory so pi re-renders the panel at the REAL
+            // terminal width every frame (tui.columns), instead of guessing with
+            // process.stdout.columns. buildWidgetLines reads this.widgetData live.
+            this.renderWidget(ctx);
+        }
+    }
+    /** Register the above-editor widget as a width-aware factory so pi re-renders
+     *  it at the REAL terminal width every frame (auto-fit wide/narrow). The
+     *  factory returns a minimal Component whose render() reads this.widgetData.
+     */
+    renderWidget(ctx) {
+        ctx.ui.setWidget(WIDGET_KEY, (_tui, _theme) => ({
+            render: (width) => this.buildWidgetLines(width > 0 ? width : 200),
+            invalidate: () => { },
+        }), { placement: "aboveEditor" });
+    }
+    /** Build the full-width panel lines from the latest snapshot. Cheap: reads
+     *  only this.widgetData + a couple of live counters; no DB/IO. */
+    buildWidgetLines(width) {
+        const wd = this.widgetData;
+        if (!wd) {
+            return [
+                panelBar(width, "─"),
+                panelLine(" mega-compact: warming up…", width),
+                panelBar(width, "─"),
             ];
-            // Live "now processing" line + why + recent deduped/compacted events,
-            // collapsed to ONE rotating line (fresh only). The ticker ring buffer
-            // (≤5 most-recent events) is cycled one-per-repaint so the line scrolls
-            // through recent files in real time while activity fires. We rotate on a
-            // 250ms step (same cadence as the pulse), using an event counter as the
-            // deterministic phase so consecutive repaints advance the visible entry.
-            const fresh = Date.now() - this.lastActivityAt < 4000;
-            if (this.tierTrace && fresh) {
-                lines.push(`   ${pulse}${this.tierTrace}`);
-            }
-            else if (this.ticker.length > 0) {
-                const step = Math.floor(Date.now() / 250);
-                const idx = this.ticker.length - 1 - (step % this.ticker.length);
-                const head = this.ticker[idx].text;
-                const why = this.lastWhy ? ` ${C.gray}· ${this.lastWhy}${C.reset}` : "";
-                const more = this.ticker.length > 1 ? ` ${C.dim}(+${this.ticker.length - 1} more)${C.reset}` : "";
-                lines.push(`   ${fresh ? C.teal : C.dim}${head}${why}${more}${C.reset}`);
-            }
-            else if (this.pulsing) {
-                lines.push(`   ${pulse}${C.teal}compacting…${C.reset}`);
-            }
-            // (Accounting folded into L2's "in→kept (X% freed)" framing — freed =
-            //  in − kept is implied, and the saturated-ratio bars are gone.)
-            ctx.ui.setWidget(WIDGET_KEY, lines, { placement: "aboveEditor" });
         }
+        const pulse = wd.pulsing
+            ? `${C.cyan}${PULSE[Math.floor(Date.now() / 250) % PULSE.length]}${C.reset} `
+            : "";
+        const lines = [
+            // top border
+            panelBar(width, "─"),
+            // L1 — header: tier + ctx bar + pct/tokens + status + model + chk + agents/turn
+            panelLine(` ${C.amber}⚡ ${wd.tierLabel}${C.reset} v${C.bold}${wd.version}${C.reset} ${ramp(wd.ctxPct, 20)} ${C.bold}${wd.pctStr}${C.reset} ${wd.tokStr}/${wd.maxStr} │ ${wd.triggerLabel} │ ${C.cyan}${wd.modelStr}${C.reset} │ ${wd.chk} chk${wd.agentStr}${wd.turnStr}`, width),
+            // L2 — savings reconciled (session + all-time)
+            panelLine(`   ${C.magenta}dup ${wd.dedupStr}${C.reset} │ ${C.gray}sess${C.reset} ${fmtTokens(wd.sessIn)}→${fmtTokens(wd.sessKept)} kept ${C.green}(${wd.sTxt}% freed)${C.reset} · ${C.gray}all-time${C.reset} ${fmtTokens(wd.repoIn)}→${fmtTokens(wd.repoKept)} kept ${C.blue}(${wd.rTxt}% freed)${C.reset} │ ${wd.repoChk} chk/${wd.repoSess} sess`, width),
+            // L3 — memory store + compression + drift + since-compact (NEW)
+            panelLine(`   ${C.gray}mem${C.reset} ${wd.embedderName} · ${wd.chk} chunks · ${C.blue}comp ${wd.compStr}${C.reset} │ ${C.gray}drift${C.reset} ${wd.driftStatus === "ok" ? C.green : C.amber}${wd.driftStatus}${C.reset} │ ${C.gray}compact${C.reset} ${sinceCompactStr(wd.sinceCompact)}`, width),
+        ];
+        // L4 — agents block (S27, count + status; per-agent tokens gated on P0)
+        if (wd.agentsActive) {
+            lines.push(panelLine(`   ${C.cyan}🤖 ${this.activeAgents} active${wd.turnStr}${C.reset}`, width));
+        }
+        // L5 — live ticker / activity (♻ deduped … why, or tier trace, or pulsing)
+        if (wd.tierTrace && wd.fresh) {
+            lines.push(panelLine(`   ${pulse}${wd.tierTrace}`, width));
+        }
+        else if (wd.ticker.length > 0) {
+            const step = Math.floor(Date.now() / 250);
+            const idx = wd.ticker.length - 1 - (step % wd.ticker.length);
+            const head = wd.ticker[idx].text;
+            const why = wd.lastWhy ? ` ${C.gray}· ${wd.lastWhy}${C.reset}` : "";
+            const more = wd.ticker.length > 1
+                ? ` ${C.dim}(+${wd.ticker.length - 1} more)${C.reset}`
+                : "";
+            lines.push(panelLine(`   ${wd.fresh ? C.teal : C.dim}${head}${why}${more}${C.reset}`, width));
+        }
+        else if (wd.pulsing) {
+            lines.push(panelLine(`   ${pulse}${C.teal}compacting…${C.reset}`, width));
+        }
+        // bottom border
+        lines.push(panelBar(width, "─"));
+        return lines;
+    }
+    /** Active embedder name for the memory-store line (Trigram default / MiniLM). */
+    embedderName() {
+        // MINILM_EMBEDDER flag lives in src/config/dedup.ts; read the same env var
+        // the embedder factory uses so the label matches what's actually running.
+        return process.env.MEGACOMPACT_MINILM === "true" ||
+            process.env.MEGACOMPACT_MINILM === "1"
+            ? "MiniLM"
+            : "Trigram";
+    }
+    /** Cross-repo drift status (ok | warn), cached for 30s (opens the registry DB). */
+    driftStatus() {
+        const now = Date.now();
+        if (this.driftCache && now - this.driftCache.at < 30_000)
+            return this.driftCache.status;
+        let status = "ok";
+        try {
+            const report = detectCrossRepoDrift();
+            status = report.totals.warn > 0 ? "warn" : "ok";
+        }
+        catch {
+            status = "ok";
+        }
+        this.driftCache = { at: now, status };
+        return status;
     }
     setStatus(ctx, text) {
         this.statusKey = text;
@@ -409,6 +680,7 @@ export class MegaRuntime {
             dedupSkips: 0,
             dedupAttempts: 0,
             tokensSaved: 0,
+            lastCompactAt: null,
         };
         this.statusKey = undefined;
         this.activeAgents = 0;
@@ -427,15 +699,22 @@ export class MegaRuntime {
      */
     captureModel(ctx) {
         const m = ctx.model;
-        if (!m)
+        if (!m) {
+            this.appendEvent("captureModel:no-model", { cwd: ctx.cwd });
             return;
-        if (this.currentModel && this.currentModel.modelId === m.id && this.currentModel.provider === m.provider)
+        }
+        if (this.currentModel &&
+            this.currentModel.modelId === m.id &&
+            this.currentModel.provider === m.provider)
             return;
         let providerName = null;
         try {
-            providerName = ctx.modelRegistry?.getProviderDisplayName(m.provider) ?? null;
+            providerName =
+                ctx.modelRegistry?.getProviderDisplayName(m.provider) ?? null;
+        }
+        catch {
+            /* optional */
         }
-        catch { /* optional */ }
         const snap = {
             provider: m.provider,
             providerName,
@@ -448,9 +727,32 @@ export class MegaRuntime {
             reasoning: !!m.reasoning,
         };
         this.currentModel = { ...snap, capturedAt: Date.now() };
+        this.diagCaptureModelCalls++;
+        const repo = resolveRepoRoot(ctx.cwd) ?? this.currentStateDir;
+        // S26: previously a single silent `catch {}` hid every capture failure, so
+        // model_snapshots stayed empty and the cost card read $0.00 with zero signal.
+        // Split per-write + append to events.log (always-on, dashboard live-streams
+        // it) + bump a DIAG counter so a live capture surfaces the root cause.
         try {
-            const repo = resolveRepoRoot(ctx.cwd) ?? this.currentStateDir;
             recordModelSnapshot(repo, snap, this.currentStateDir);
+            this.appendEvent("captureModel:recorded", {
+                repo,
+                modelId: snap.modelId,
+                provider: snap.provider,
+                inputRate: snap.inputRate,
+                outputRate: snap.outputRate,
+            });
+        }
+        catch (e) {
+            this.diagCaptureModelFails++;
+            this.appendEvent("captureModel:record-failed", {
+                repo,
+                modelId: snap.modelId,
+                error: e instanceof Error ? e.message : String(e),
+                stack: e instanceof Error ? e.stack : undefined,
+            });
+        }
+        try {
             // Denormalize the active model into the machine-wide index so the
             // All-repos dashboard table can show provider/model per repo without
             // opening every repo's DB. Best-effort + non-fatal.
@@ -464,7 +766,28 @@ export class MegaRuntime {
                 displayName: repo.split(/[\\/]/).filter(Boolean).pop() ?? repo,
             });
         }
-        catch { /* non-fatal: cost estimation degrades to model-in-memory only */ }
+        catch (e) {
+            this.appendEvent("captureModel:index-record-failed", {
+                repo,
+                modelId: snap.modelId,
+                error: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }
+    /**
+     * Append a structured line to the repo's events.log — the always-on
+     * diagnostics sink the dashboard live-streams. Unlike this.logger (gated by
+     * config.debug), this fires in production, so capture failures surface during
+     * a real capture even with debugging off. Best-effort + non-fatal.
+     */
+    appendEvent(event, fields) {
+        try {
+            mkdirSync(this.currentStateDir, { recursive: true });
+            appendFileSync(join(this.currentStateDir, "events.log"), JSON.stringify({ ts: Date.now(), event, ...fields }) + "\n");
+        }
+        catch {
+            /* non-fatal */
+        }
     }
     /** S21: state dir of the currently bound repo (where memories live). */
     getStateDir() {
@@ -474,10 +797,13 @@ export class MegaRuntime {
     makeTierCallback(ctx) {
         const order = ["L0", "L1", "L2", "new"];
         const seen = new Map();
-        const glyph = (status) => status === "deduped" ? `${C.green}✓${C.reset}` :
-            status === "passed" ? `${C.dim}○${C.reset}` :
-                status === "scanning" ? `${C.amber}…${C.reset}` :
-                    `${C.cyan}●${C.reset}`;
+        const glyph = (status) => status === "deduped"
+            ? `${C.green}✓${C.reset}`
+            : status === "passed"
+                ? `${C.dim}○${C.reset}`
+                : status === "scanning"
+                    ? `${C.amber}…${C.reset}`
+                    : `${C.cyan}●${C.reset}`;
         return (ev) => {
             const label = ev.tier === "new"
                 ? `${C.cyan}stored${C.reset}`
@@ -494,7 +820,9 @@ export class MegaRuntime {
             try {
                 this.snapshot(ctx);
             }
-            catch { /* non-fatal */ }
+            catch {
+                /* non-fatal */
+            }
         };
     }
     // Phase 3 — recall/activity ticker ring buffer.