pi-mega-compact 0.6.9 → 0.7.0

package/dist/extensions/mega-events.js

@@ -8,13 +8,13 @@
  */
 import { normalizeSessionId } from "../src/store.js";
 import { autoCompactCheck } from "../src/compact.js";
-import { estimateSessionTokens } from "../src/tokens.js";
-import { recentUserQuery, WIDGET_KEY } from "./mega-runtime.js";
-import { runCompact, doRecall, doRecallAsync, piCompactWouldNoop, runMemoryReview } from "./mega-pipeline.js";
+import { estimateSessionTokens, estimateBlockTokens } from "../src/tokens.js";
+import { recentUserQuery, WIDGET_KEY, } from "./mega-runtime.js";
+import { runCompact, doRecall, doRecallAsync, piCompactWouldNoop, runMemoryReview, } from "./mega-pipeline.js";
 import { recallMemoriesAndInline } from "../src/recall.js";
-import { driveNativeCompaction } from "./mega-compact-driver.js";
+import { driveNativeCompaction, } from "./mega-compact-driver.js";
 import { computeLiveTrimCut, liveTrimSummaryMessage } from "./mega-trim.js";
-import { pressureFromPct, memoryReviewCadence } from "./mega-config.js";
+import { pressureFromPct, memoryReviewCadence, } from "./mega-config.js";
 /**
  * DIAG accessor for the headless test harness: the most recently constructed
  * MegaRuntime, so a test that loads the compiled extension via its default
@@ -52,19 +52,30 @@ export function registerEventHandlers(pi, runtime, config) {
                 // S17: use the async variant on resume so cross-repo HNSW recall can
                 // augment when this repo's store is thin. session_start is an async-safe
                 // point (unlike the mid-turn context handler, which stays sync).
-                const r = await doRecallAsync(runtime, config, ctx, query, "resume", { crossRepo: config.crossRepoEnabled });
+                const r = await doRecallAsync(runtime, config, ctx, query, "resume", {
+                    crossRepo: config.crossRepoEnabled,
+                });
                 if (!r.empty) {
                     runtime.pendingRecallBlock = r.block;
-                    const crossLabel = r.toInject.some((h) => h.repoId) ? " (cross-repo)" : "";
+                    const crossLabel = r.toInject.some((h) => h.repoId)
+                        ? " (cross-repo)"
+                        : "";
                     runtime.setStatus(ctx, `mega-compact: recalled ${r.toInject.length} chkpt${crossLabel}`);
-                    runtime.logger.info("auto-inline", { reason: event.reason, query, injected: r.toInject.map((h) => h.checkpoint.checkpointId), crossRepo: r.toInject.some((h) => h.repoId) });
+                    runtime.logger.info("auto-inline", {
+                        reason: event.reason,
+                        query,
+                        injected: r.toInject.map((h) => h.checkpoint.checkpointId),
+                        crossRepo: r.toInject.some((h) => h.repoId),
+                    });
                 }
             }
             // S21: parallel memory recall. Same async context so we can await without
             // breaking the handler contract. Best-effort — never throws.
             try {
                 const mr = await recallMemoriesAndInline({
-                    query, stateDir: runtime.getStateDir(), limit: 5,
+                    query,
+                    stateDir: runtime.getStateDir(),
+                    limit: 5,
                     crossRepo: config.crossRepoEnabled,
                     crossRepoCosine: config.crossRepoCosine,
                 });
@@ -75,7 +86,10 @@ export function registerEventHandlers(pi, runtime, config) {
                 runtime.logger.warn("memory-recall skipped", { err: String(err) });
             }
         }
-        runtime.dashboard.event("session_start", { reason: event.reason, sessionId: runtime.rt.sessionId });
+        runtime.dashboard.event("session_start", {
+            reason: event.reason,
+            sessionId: runtime.rt.sessionId,
+        });
         runtime.snapshot(ctx);
     });
     pi.on("session_tree", async (_event, ctx) => {
@@ -89,11 +103,21 @@ export function registerEventHandlers(pi, runtime, config) {
                 const r = doRecall(runtime, config, ctx, query, "resume");
                 if (!r.empty) {
                     runtime.pendingRecallBlock = r.block;
-                    runtime.logger.info("auto-inline", { reason: "session_tree", query, injected: r.toInject.map((h) => h.checkpoint.checkpointId) });
+                    runtime.logger.info("auto-inline", {
+                        reason: "session_tree",
+                        query,
+                        injected: r.toInject.map((h) => h.checkpoint.checkpointId),
+                    });
                 }
                 // S21: parallel memory recall. Trigram embedder is sub-ms; await is fine.
                 try {
-                    const mr = await recallMemoriesAndInline({ query, stateDir: runtime.getStateDir(), limit: 5, crossRepo: config.crossRepoEnabled, crossRepoCosine: config.crossRepoCosine });
+                    const mr = await recallMemoriesAndInline({
+                        query,
+                        stateDir: runtime.getStateDir(),
+                        limit: 5,
+                        crossRepo: config.crossRepoEnabled,
+                        crossRepoCosine: config.crossRepoCosine,
+                    });
                     if (!mr.empty)
                         runtime.pendingMemoryRecallBlock = mr.block;
                 }
@@ -102,7 +126,9 @@ export function registerEventHandlers(pi, runtime, config) {
                 }
             }
         }
-        runtime.dashboard.event("session_tree", { sessionId: runtime.rt.sessionId });
+        runtime.dashboard.event("session_tree", {
+            sessionId: runtime.rt.sessionId,
+        });
         runtime.snapshot(ctx);
     });
     // ---- Auto-inline injection point: prepend staged recall to systemPrompt ----
@@ -126,7 +152,9 @@ export function registerEventHandlers(pi, runtime, config) {
     // ---- Agent tracking for real-time widget + status-line updates ---------
     pi.on("agent_start", async (_event, ctx) => {
         runtime.activeAgents++;
-        runtime.dashboard.event("agent_start", { activeAgents: runtime.activeAgents });
+        runtime.dashboard.event("agent_start", {
+            activeAgents: runtime.activeAgents,
+        });
         // Surface live agent activity on the status line (toolbar), not just the
         // above-editor widget — otherwise concurrent agents look frozen.
         runtime.setStatus(ctx, `mega-compact: ▶ ${runtime.activeAgents} agent${runtime.activeAgents === 1 ? "" : "s"}`);
@@ -134,7 +162,9 @@ export function registerEventHandlers(pi, runtime, config) {
     });
     pi.on("agent_end", async (_event, ctx) => {
         runtime.activeAgents = Math.max(0, runtime.activeAgents - 1);
-        runtime.dashboard.event("agent_end", { activeAgents: runtime.activeAgents });
+        runtime.dashboard.event("agent_end", {
+            activeAgents: runtime.activeAgents,
+        });
         if (runtime.activeAgents > 0) {
             runtime.setStatus(ctx, `mega-compact: ▶ ${runtime.activeAgents} agent${runtime.activeAgents === 1 ? "" : "s"}`);
         }
@@ -153,7 +183,7 @@ export function registerEventHandlers(pi, runtime, config) {
                 // DIAG (team-run relief): surface whether the agent is idle + over
                 // threshold at agent_end so we can see if a mid-run durable-trim trigger
                 // *should* have fired but didn't.
-                const overThreshold = (runtime.lastCtxTokens ?? 0) >= config.thresholdTokens;
+                const overThreshold = (runtime.lastCtxTokens ?? 0) >= runtime.effectiveThreshold;
                 runtime.diagAgentEndIdle++;
                 runtime.logger.info("agent-end-idle", {
                     sessionId: runtime.rt.sessionId,
@@ -163,7 +193,9 @@ export function registerEventHandlers(pi, runtime, config) {
                     ctxPct: runtime.lastCtxPercent,
                     ctxTokens: runtime.lastCtxTokens,
                     thresholdTokens: config.thresholdTokens,
-                    wouldNudge: idle && queued && now >= runtime.resumeNudgeUntil,
+                    wouldNudge: idle &&
+                        (queued || overThreshold) &&
+                        now >= runtime.resumeNudgeUntil,
                 });
                 // S16+S24: MID-RUN DURABLE TRIM. During a long team run (sub-agents),
                 // pi's native durable compaction only fires from _checkCompaction at
@@ -178,6 +210,18 @@ export function registerEventHandlers(pi, runtime, config) {
                 // pi would actually compact (piCompactWouldNoop skips the user-facing
                 // no-op throw), and debounced (one durable trim per 2s) to avoid
                 // thrashing the transcript while sub-agents keep settling.
+                //
+                // FIX "compacts but doesn't resume": the manual ctx.compact() path
+                // STOPS the agent loop (agent-session.js:1345). The old resume-nudge
+                // was gated on `queued`, so when a sub-agent settled with no
+                // *immediately* queued message, the trim fired but the nudge did not,
+                // and the (stopped) session hung. The trim still fires on
+                // `idle && overThreshold` — we intentionally do NOT add a `!queued`
+                // guard, because that would suppress mid-run relief exactly during
+                // team-run waves where queued is usually true and relief is needed
+                // most. Instead we DECOUPLE the nudge from `queued`: after a durable
+                // trim we ALWAYS nudge so the agent reliably restarts. Debounced 30s.
+                let didDurableTrim = false;
                 if (idle && overThreshold && now >= runtime.debounceUntil) {
                     if (!piCompactWouldNoop(ctx)) {
                         runtime.debounceUntil = now + 2000;
@@ -186,11 +230,18 @@ export function registerEventHandlers(pi, runtime, config) {
                             sessionId: runtime.rt.sessionId,
                             ctxTokens: runtime.lastCtxTokens,
                             thresholdTokens: config.thresholdTokens,
+                            queued,
                         });
                         ctx.compact({ customInstructions: undefined }); // guardrails-allow PREVENT-PI-004: local ctx.compact() — no network; agent settled so no in-flight abort
+                        didDurableTrim = true;
                     }
                 }
-                if (idle && queued && now >= runtime.resumeNudgeUntil) {
+                // Restart the agent after a mid-run durable trim (which stopped it), or
+                // when it settled idle with queued work. Decoupled from `queued` for the
+                // durable-trim case — see FIX note above. Debounced 30s; never blocks.
+                if (idle &&
+                    now >= runtime.resumeNudgeUntil &&
+                    (didDurableTrim || queued)) {
                     runtime.resumeNudgeUntil = now + 30_000;
                     pi.sendUserMessage("[mega-compact] continue from the compacted context above.");
                 }
@@ -255,14 +306,15 @@ export function registerEventHandlers(pi, runtime, config) {
             return;
         const messages = event.messages;
         const view = runtime.engineView(messages);
-        const currentTokens = usage?.tokens ?? estimateSessionTokens(view) ??
+        const currentTokens = usage?.tokens ??
+            estimateSessionTokens(view) ??
             Math.round((pct / 100) * (usage?.contextWindow ?? 0));
-        // FAST GATE: token-based (tier threshold), not percentage-based.
-        if (currentTokens < config.thresholdTokens) {
+        // FAST GATE: token-based (tier% of the window), not a static amount.
+        if (currentTokens < runtime.effectiveThreshold) {
             runtime.diagCtxFastGate++;
             return;
         }
-        const check = autoCompactCheck(currentTokens, config.thresholdTokens); // SERVER-STYLE CONFIRM (local)
+        const check = autoCompactCheck(currentTokens, runtime.effectiveThreshold); // SERVER-STYLE CONFIRM (local)
         if (!check.shouldCompact) {
             runtime.diagCtxNoCompact++;
             return;
@@ -277,7 +329,9 @@ export function registerEventHandlers(pi, runtime, config) {
         // Adaptive compression (Fix E): scale compression strength + keepFrom depth
         // with how close we are to the model context limit.
         const pressure = pressureFromPct(pct);
-        const ran = runCompact(pi, runtime, config, ctx, messages, { compressionPressure: pressure });
+        const ran = runCompact(pi, runtime, config, ctx, messages, {
+            compressionPressure: pressure,
+        });
         if (ran.skipped) {
             runtime.diagCtxRunSkipped++;
             return;
@@ -287,7 +341,9 @@ export function registerEventHandlers(pi, runtime, config) {
         // Read live from env (in addition to the load-time config) so the flag can be
         // toggled per-test without reloading the module; config.legacyDurableTrim is
         // the cached default. (Mirrors how piCompactWouldNoop re-reads its floor.)
-        const legacy = config.legacyDurableTrim || process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM === "true" || process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM === "1";
+        const legacy = config.legacyDurableTrim ||
+            process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM === "true" ||
+            process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM === "1";
         if (legacy) {
             if (piCompactWouldNoop(ctx))
                 return;
@@ -305,7 +361,9 @@ export function registerEventHandlers(pi, runtime, config) {
         // without reloading the module.
         try {
             const anchorEnv = process.env.MEGACOMPACT_ANCHOR_USER_MESSAGES;
-            const anchorUserMessages = (anchorEnv != null && anchorEnv !== "" && Number.isFinite(Number(anchorEnv)))
+            const anchorUserMessages = anchorEnv != null &&
+                anchorEnv !== "" &&
+                Number.isFinite(Number(anchorEnv))
                 ? Number(anchorEnv)
                 : config.anchorUserMessages;
             const cut = computeLiveTrimCut(view, {
@@ -382,7 +440,7 @@ export function registerEventHandlers(pi, runtime, config) {
             return {}; // let pi run its own native compaction
         try {
             const result = driveNativeCompaction(event, runtime, config);
-            if (result) {
+            if (result && result.compaction.summary?.trim()) {
                 runtime.diagBeforeCompactSupplied++;
                 runtime.logger.info("native-compact", {
                     sessionId: runtime.rt.sessionId,
@@ -390,8 +448,30 @@ export function registerEventHandlers(pi, runtime, config) {
                     tokensBefore: result.compaction.tokensBefore,
                     summaryTokens: result.compaction.estimatedTokensAfter,
                 });
+                nudgeResume(pi, runtime);
                 return { compaction: result.compaction };
             }
+            // FIX "compacts but doesn't resume" + "Nothing to compact" regression:
+            // when we have nothing to summarize (anchor floor protects everything →
+            // messagesToSummarize empty) or our Trident/RAPTOR summary came back
+            // EMPTY, pi's OWN compact() throws "Nothing to compact (session too
+            // small)" and leaves the session stuck with no resume context. Instead
+            // of returning {} (which makes pi run its throwing compact()), supply a
+            // fallback compaction from prep.firstKeptEntryId with a minimal resume
+            // summary. This ALWAYS injects a compact summary so the session
+            // resumes, and never surfaces the "Nothing to compact" error to the user.
+            const fb = fallbackCompaction(event);
+            if (fb) {
+                runtime.diagBeforeCompactSupplied++;
+                runtime.logger.info("native-compact-fallback", {
+                    sessionId: runtime.rt.sessionId,
+                    firstKeptEntryId: fb.compaction.firstKeptEntryId,
+                    tokensBefore: fb.compaction.tokensBefore,
+                    reason: event.reason,
+                });
+                nudgeResume(pi, runtime);
+                return { compaction: fb.compaction };
+            }
         }
         catch (err) {
             runtime.logger.error("native-compact-failed", {
@@ -399,7 +479,51 @@ export function registerEventHandlers(pi, runtime, config) {
                 error: String(err instanceof Error ? err.message : err),
             });
         }
-        // Fall back to pi's own native compaction if we can't supply one.
+        // Absolute last resort: let pi run its own (may throw "Nothing to compact").
         return {};
     });
+    /**
+     * Build a minimal fallback compaction so pi never runs its throwing compact().
+     *
+     * Used when our Trident/RAPTOR summary is empty or there is nothing to
+     * summarize (the anchor floor protects every message). We still record a
+     * resume summary + truncate from prep.firstKeptEntryId so the session always
+     * gets a compact summary and resumes. Returns undefined only if pi handed us
+     * no preparation cut point at all.
+     */
+    function fallbackCompaction(event) {
+        const prep = event.preparation;
+        if (!prep?.firstKeptEntryId)
+            return undefined;
+        // When messagesToSummarize is empty the anchor floor protects everything,
+        // so firstKeptEntryId == current first entry and the trim is a no-op — but
+        // we still record a resume summary so the session has context after compaction.
+        const tokensBefore = prep.tokensBefore ?? 0;
+        const summary = `[mega-compact] context compacted at ${tokensBefore.toLocaleString()} tokens ` +
+            `(anchor floor active). Continue from the most recent messages above.`;
+        return {
+            compaction: {
+                summary,
+                firstKeptEntryId: prep.firstKeptEntryId,
+                tokensBefore,
+                estimatedTokensAfter: estimateBlockTokens(summary),
+            },
+        };
+    }
+    /**
+     * Debounced resume-nudge: restart the agent loop after a compaction (which
+     * may have stopped it). Idempotent — one nudge per 30s, never blocks.
+     */
+    function nudgeResume(pi, runtime) {
+        try {
+            const now = Date.now();
+            if (now >= runtime.resumeNudgeUntil) {
+                runtime.resumeNudgeUntil = now + 30_000;
+                pi.sendUserMessage("[mega-compact] continue from the compacted context above.");
+            }
+        }
+        catch {
+            /* non-fatal: a failed nudge never blocks */
+        }
+    }
 }

package/dist/extensions/mega-runtime.js

@@ -11,13 +11,13 @@
 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 { 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 +56,44 @@ 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";
+}
 export class MegaRuntime {
     config;
     // Store/dashboard/logger are rebound per-repo by bindRepo() so each git repo
@@ -142,19 +180,55 @@ 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.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);
@@ -224,8 +298,14 @@ 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 +316,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,
@@ -253,7 +335,7 @@ export class MegaRuntime {
                 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 },
+            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 },
             // Reconciled token accounting (single canonical formula, session + repo).
@@ -319,7 +401,14 @@ export class MegaRuntime {
             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: ALWAYS show the agent line so status is visible even when
+            // idle (previously hidden at 0). 🤖 N agents when active, dimmed 🤖 idle
+            // when none — this is the restored "agents view" (count + status). Real
+            // per-agent/sub-agent token usage is scoped in Sprint 27.
+            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} ` : "";
@@ -354,27 +443,28 @@ export class MegaRuntime {
             const ctxPct = this.lastCtxPercent != null ? this.lastCtxPercent / 100 : 0;
             const sTxt = (sessPct * 100).toFixed(sessPct * 100 >= 10 ? 0 : 1);
             const rTxt = (repoPct * 100).toFixed(repoPct * 100 >= 10 ? 0 : 1);
+            // Full-width panel: read the real terminal width and pad each line with a
+            // panel background so the above-editor widget reads as a full-width status
+            // bar. pi's widget renderer does not pass width to setWidget(), so we pad
+            // ourselves. Falls back to 200 cols when stdout.columns is unavailable.
+            const W = process.stdout?.columns ?? 200;
             const lines = [
+                // top border — full-width hairline
+                panelBar(W, "─"),
                 // 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}`,
+                // tokens + status glyph + checkpoints + agents/turn. The context bar is
+                // the only live-moving bar; the whole block is padded to full width.
+                panelLine(` ${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}`, W),
                 // 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`,
+                // saturates near 100% once cumulative freed dwarfs live kept, so a bar
+                // is visually useless; show the compaction story instead.
+                panelLine(`   ${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`, W),
             ];
             // 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.
+            // collapsed to ONE rotating line (fresh only); padded to full width.
             const fresh = Date.now() - this.lastActivityAt < 4000;
             if (this.tierTrace && fresh) {
-                lines.push(`   ${pulse}${this.tierTrace}`);
+                lines.push(panelLine(`   ${pulse}${this.tierTrace}`, W));
             }
             else if (this.ticker.length > 0) {
                 const step = Math.floor(Date.now() / 250);
@@ -382,11 +472,13 @@ export class MegaRuntime {
                 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}`);
+                lines.push(panelLine(`   ${fresh ? C.teal : C.dim}${head}${why}${more}${C.reset}`, W));
             }
             else if (this.pulsing) {
-                lines.push(`   ${pulse}${C.teal}compacting…${C.reset}`);
+                lines.push(panelLine(`   ${pulse}${C.teal}compacting…${C.reset}`, W));
             }
+            // bottom border — full-width hairline closes the panel
+            lines.push(panelBar(W, "─"));
             // (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" });
@@ -427,8 +519,10 @@ 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)
             return;
         let providerName = null;
@@ -448,9 +542,28 @@ 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 +577,25 @@ 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() {