pi-mega-compact 0.7.1 → 0.7.2

package/dist/extensions/mega-pipeline.js

@@ -8,13 +8,13 @@
  */
 import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
 import { compactSession } from "../src/engine.js";
-import { recallAndInline, recallAndInlineAsync, formatRecallBlock, } from "../src/recall.js";
+import { recallAndInline, recallAndInlineAsync, formatRecallBlock } from "../src/recall.js";
 import { normalizeSessionId } from "../src/store.js";
 import { estimateBlockTokens } from "../src/tokens.js";
 import { touchSession, logDaily } from "../src/store/sqlite.js";
 import { consolidateMemories } from "../src/memory.js";
-import { C, MARKER_TYPE } from "./mega-runtime.js";
-import { resolveRepoRoot, preserveRecentForPressure, } from "./mega-config.js";
+import { C, MARKER_TYPE, } from "./mega-runtime.js";
+import { resolveRepoRoot, preserveRecentForPressure } from "./mega-config.js";
 import { runRaptor } from "../src/dedup/raptor/index.js";
 import { loadDedupConfig } from "../src/config/dedup.js";
 import { upsertEmbedding as indexUpsertEmbedding } from "../src/store/vectorIndex.js";
@@ -110,17 +110,13 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
     // Grow the rolling "saved" goal so the progress bar always has a fresh
     // denominator (we don't want it pinned at 100% once we pass an old target).
     if (runtime.rt.tokensSaved > runtime.savedGoal)
-        runtime.savedGoal =
-            Math.ceil((runtime.rt.tokensSaved * 1.25) / 10_000) * 10_000;
+        runtime.savedGoal = Math.ceil((runtime.rt.tokensSaved * 1.25) / 10_000) * 10_000;
     // Live toolbar activity: what file/region just got compacted or deduped.
     // Rendered via the rotating ticker line (see snapshot); the ring buffer is
     // cycled one-per-repaint so the single line scrolls through recent files.
     const files = result.filesModified ?? [];
     const fileLabel = files.length
-        ? files
-            .map((f) => f.split("/").pop() ?? f)
-            .slice(0, 2)
-            .join(", ")
+        ? files.map((f) => f.split("/").pop() ?? f).slice(0, 2).join(", ")
         : result.regionHash.slice(0, 8);
     runtime.lastActivityAt = Date.now();
     // Explain-why line: surfaced while fresh. Pulls the dedup reason (which for
@@ -172,10 +168,7 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
     // waiting for the next turn-cadence tick. Uses the shared runMemoryReview
     // helper (fire-and-forget; doCompact is sync). Best-effort + non-fatal. Only
     // fires above the `high` band so low-pressure compactions don't pay the cost.
-    if (!result.deduped &&
-        config.memoryAutoReview &&
-        runtime.pressureBand !== "low" &&
-        runtime.pressureBand !== "medium") {
+    if (!result.deduped && config.memoryAutoReview && runtime.pressureBand !== "low" && runtime.pressureBand !== "medium") {
         void runMemoryReview(runtime, view, "pressure");
     }
     // Sentinel marker: a non-LLM bookkeeping entry so subsequent triggers can
@@ -203,9 +196,7 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
                 // S25: stamp the tree with the newest checkpoint epoch so the
                 // freshness guard in raptorSearchHits can reject stale trees after a
                 // later compaction adds newer checkpoints.
-                const builtAt = all.length > 0
-                    ? Math.max(...all.map((c) => c.timestamp))
-                    : Date.now();
+                const builtAt = all.length > 0 ? Math.max(...all.map((c) => c.timestamp)) : Date.now();
                 runRaptor(leaves, {
                     stateDir: runtime.currentStateDir,
                     sessionId: sid,
@@ -323,8 +314,7 @@ export function piCompactWouldNoop(ctx) {
                 if (m.role !== "toolResult")
                     isCut = true;
                 const c = m.content;
-                const text = typeof c === "string"
-                    ? c
+                const text = typeof c === "string" ? c
                     : Array.isArray(c)
                         ? c.map((b) => b?.text ?? "").join(" ")
                         : "";
@@ -377,22 +367,12 @@ export function doRecall(runtime, config, ctx, query, source) {
         liveWindow,
         dedupSim: config.dedupSim,
     }, runtime.store);
-    runtime.dashboard.event("recall", {
-        source,
-        query: query.slice(0, 120),
-        injected: result.toInject.length,
-        empty: result.empty,
-    });
+    runtime.dashboard.event("recall", { source, query: query.slice(0, 120), injected: result.toInject.length, empty: result.empty });
     if (!result.empty && result.toInject.length > 0) {
         const top = result.toInject[0];
         const scorePct = Math.round((top.score ?? 0) * 100);
         const files = top.checkpoint.filesModified ?? [];
-        const label = files.length
-            ? files
-                .map((f) => f.split("/").pop() ?? f)
-                .slice(0, 2)
-                .join(", ")
-            : top.checkpoint.checkpointId;
+        const label = files.length ? files.map((f) => f.split("/").pop() ?? f).slice(0, 2).join(", ") : top.checkpoint.checkpointId;
         runtime.pushTicker(`${C.amber}↩${C.reset} recalled ${top.checkpoint.checkpointId} · ${scorePct}% · ${label}`);
         runtime.lastWhy = `why: recalled@${scorePct}% (${result.toInject.length} chkpt)`;
     }
@@ -415,15 +395,9 @@ export async function doRecallAsync(runtime, config, ctx, query, source, opts =
     const liveWindow = config.windowDedupe ? extractLiveWindow(ctx) : undefined;
     // Sync same-repo first (fast, never blocks).
     const sameRepo = recallAndInline({
-        sessionId: sid,
-        query,
-        limit: config.autoInlineK,
-        source,
-        skipInjected: true,
-        recallMaxTokens: config.recallMaxTokens,
-        windowDedupe: config.windowDedupe,
-        liveWindow,
-        dedupSim: config.dedupSim,
+        sessionId: sid, query, limit: config.autoInlineK, source, skipInjected: true,
+        recallMaxTokens: config.recallMaxTokens, windowDedupe: config.windowDedupe,
+        liveWindow, dedupSim: config.dedupSim,
     }, runtime.store);
     if (!config.crossRepoEnabled || !opts.crossRepo)
         return sameRepo;
@@ -432,22 +406,13 @@ export async function doRecallAsync(runtime, config, ctx, query, source, opts =
     // Augment: cross-repo HNSW (async) with the stricter floor. Non-fatal.
     try {
         const x = await recallAndInlineAsync({
-            sessionId: sid,
-            query,
-            limit: config.autoInlineK,
-            source,
-            skipInjected: true,
-            recallMaxTokens: config.recallMaxTokens,
-            windowDedupe: config.windowDedupe,
-            liveWindow,
-            dedupSim: config.crossRepoCosine,
-            crossRepo: true,
+            sessionId: sid, query, limit: config.autoInlineK, source, skipInjected: true,
+            recallMaxTokens: config.recallMaxTokens, windowDedupe: config.windowDedupe,
+            liveWindow, dedupSim: config.crossRepoCosine, crossRepo: true,
             globalIndexDir: process.env.MEGACOMPACT_INDEX_DIR,
         }, runtime.store);
         runtime.dashboard.event("recall-crossrepo", {
-            source,
-            query: query.slice(0, 120),
-            injected: x.toInject.length,
+            source, query: query.slice(0, 120), injected: x.toInject.length,
             sourceRepos: x.toInject.map((h) => h.repoId).filter(Boolean),
         });
         // Merge, dedup by checkpointId, respect the same token cap by reformatting.

package/dist/extensions/mega-runtime.js

@@ -16,9 +16,9 @@ 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 { 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 { 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";
@@ -74,25 +74,40 @@ function visibleWidth(s) {
     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));
+        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 spreadGroups(width, groups, indent = 0) {
+    if (groups.length === 0)
+        return panelLine('', width);
+    // Calculate visible width of each group
+    const groupWidths = groups.map(g => visibleWidth(PANEL_BG + g.replace(/\x1b\[0m/g, PANEL_RST)));
+    const totalContent = groupWidths.reduce((a, b) => a + b, 0);
+    const separator = ` ${C.dim}│${C.reset} `;
+    const sepWidth = visibleWidth(PANEL_BG + separator.replace(/\x1b\[0m/g, PANEL_RST));
+    const totalSep = sepWidth * (groups.length - 1);
+    const available = width - indent - totalContent - totalSep;
+    const gapSize = groups.length > 1 ? Math.max(1, Math.floor(available / (groups.length - 1))) : 0;
+    const extra = groups.length > 1 ? available - gapSize * (groups.length - 1) : 0;
+    let line = ' '.repeat(indent);
+    for (let i = 0; i < groups.length; i++) {
+        line += groups[i];
+        if (i < groups.length - 1) {
+            const gap = gapSize + (i < extra ? 1 : 0);
+            line += separator + ' '.repeat(Math.max(0, gap));
+        }
+    }
+    return panelLine(line, width);
+}
 function panelLine(content, width) {
     const withBg = PANEL_BG + content.replace(/\x1b\[0m/g, PANEL_RST);
     const pad = Math.max(0, width - visibleWidth(withBg));
@@ -105,10 +120,8 @@ function panelBar(width, ch = "─") {
 /** 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`
+    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).
@@ -123,10 +136,8 @@ function ramp(pct, w = 12) {
     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;
+        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"). */
@@ -257,9 +268,7 @@ export class MegaRuntime {
      * 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) {
+        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
@@ -267,9 +276,7 @@ export class MegaRuntime {
             // 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) {
+        if (this.lastCtxTokens != null && this.lastCtxTokens > 0 && this.config.thresholdTokens > 0) {
             return pressureRatio(this.lastCtxTokens, this.config.thresholdTokens);
         }
         return pressureFromPct(this.lastCtxPercent);
@@ -295,14 +302,8 @@ export class MegaRuntime {
     }
     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;
     }
@@ -313,22 +314,14 @@ 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
@@ -338,7 +331,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,
@@ -378,9 +371,7 @@ export class MegaRuntime {
         // 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 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,
@@ -410,32 +401,10 @@ 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.effectiveThreshold,
-                fastGatePct: this.config.fastGatePct,
-                tierPct: this.config.tierPct,
-                effectiveThresholdPct,
-            },
+            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.
@@ -444,19 +413,14 @@ 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,
                 },
             },
@@ -481,24 +445,14 @@ export class MegaRuntime {
         // Live stats widget above the editor
         if (ctx) {
             // ── 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}%`
-                : "?%";
+            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.
             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 (decimal for sub-10%).
             const storageRate = st.storageDedupRate; // 0..1
@@ -523,55 +477,27 @@ export class MegaRuntime {
             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;
+            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;
+            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;
+                : (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,
+                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,
+                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
@@ -594,24 +520,31 @@ export class MegaRuntime {
     buildWidgetLines(width) {
         const wd = this.widgetData;
         if (!wd) {
-            return [
-                panelBar(width, "─"),
-                panelLine(" mega-compact: warming up…", width),
-                panelBar(width, "─"),
-            ];
+            return [panelBar(width, "─"), panelLine(" mega-compact: warming up…", width), panelBar(width, "─")];
         }
-        const pulse = wd.pulsing
-            ? `${C.cyan}${PULSE[Math.floor(Date.now() / 250) % PULSE.length]}${C.reset} `
-            : "";
+        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),
+            spreadGroups(width, [
+                `${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}`,
+            ]),
             // 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),
+            spreadGroups(width, [
+                `${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`,
+            ]),
             // 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),
+            spreadGroups(width, [
+                `${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)}`,
+            ]),
         ];
         // L4 — agents block (S27, count + status; per-agent tokens gated on P0)
         if (wd.agentsActive) {
@@ -626,9 +559,7 @@ export class MegaRuntime {
             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}`
-                : "";
+            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) {
@@ -642,8 +573,7 @@ export class MegaRuntime {
     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"
+        return process.env.MEGACOMPACT_MINILM === "true" || process.env.MEGACOMPACT_MINILM === "1"
             ? "MiniLM"
             : "Trigram";
     }
@@ -703,18 +633,13 @@ export class MegaRuntime {
             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;
-        }
-        catch {
-            /* optional */
+            providerName = ctx.modelRegistry?.getProviderDisplayName(m.provider) ?? null;
         }
+        catch { /* optional */ }
         const snap = {
             provider: m.provider,
             providerName,
@@ -736,18 +661,14 @@ export class MegaRuntime {
         try {
             recordModelSnapshot(repo, snap, this.currentStateDir);
             this.appendEvent("captureModel:recorded", {
-                repo,
-                modelId: snap.modelId,
-                provider: snap.provider,
-                inputRate: snap.inputRate,
-                outputRate: snap.outputRate,
+                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,
+                repo, modelId: snap.modelId,
                 error: e instanceof Error ? e.message : String(e),
                 stack: e instanceof Error ? e.stack : undefined,
             });
@@ -768,8 +689,7 @@ export class MegaRuntime {
         }
         catch (e) {
             this.appendEvent("captureModel:index-record-failed", {
-                repo,
-                modelId: snap.modelId,
+                repo, modelId: snap.modelId,
                 error: e instanceof Error ? e.message : String(e),
             });
         }
@@ -785,9 +705,7 @@ export class MegaRuntime {
             mkdirSync(this.currentStateDir, { recursive: true });
             appendFileSync(join(this.currentStateDir, "events.log"), JSON.stringify({ ts: Date.now(), event, ...fields }) + "\n");
         }
-        catch {
-            /* non-fatal */
-        }
+        catch { /* non-fatal */ }
     }
     /** S21: state dir of the currently bound repo (where memories live). */
     getStateDir() {
@@ -797,13 +715,10 @@ 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}`
@@ -820,9 +735,7 @@ export class MegaRuntime {
             try {
                 this.snapshot(ctx);
             }
-            catch {
-                /* non-fatal */
-            }
+            catch { /* non-fatal */ }
         };
     }
     // Phase 3 — recall/activity ticker ring buffer.