pi-mega-compact 0.7.2 → 0.7.4

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,39 +74,51 @@ 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));
+/** Wrap a string (with ANSI codes) to fit within `maxWidth` visible chars.
+ *  Splits at │ separators or whitespace when possible. */
+function wrapLine(text, maxWidth) {
+    if (maxWidth <= 0)
+        return [text];
+    const result = [];
+    let current = "";
+    let currentW = 0;
+    // Split at │ boundaries first
+    const segments = text.split("│");
+    for (let i = 0; i < segments.length; i++) {
+        const seg = (i > 0 ? "│" : "") + segments[i];
+        const segW = visibleWidth(PANEL_BG + seg.replace(/\x1b\[0m/g, PANEL_RST));
+        if (currentW + segW <= maxWidth || currentW === 0) {
+            current += seg;
+            currentW += segW;
+        }
+        else {
+            result.push(current);
+            current = seg;
+            currentW = segW;
         }
     }
-    return panelLine(line, width);
+    if (current)
+        result.push(current);
+    return result;
 }
 function panelLine(content, width) {
     const withBg = PANEL_BG + content.replace(/\x1b\[0m/g, PANEL_RST);
@@ -120,8 +132,10 @@ 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).
@@ -136,8 +150,10 @@ 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"). */
@@ -175,6 +191,7 @@ export class MegaRuntime {
         dedupAttempts: 0,
         tokensSaved: 0,
         lastCompactAt: null,
+        lastNativeCompactAt: null,
     };
     debounceUntil = 0;
     // S16: debounce for the agent_end resume nudge (avoid busy-loops).
@@ -239,6 +256,7 @@ export class MegaRuntime {
     diagBeforeCompactSupplied = 0; // session_before_compact supplied our trim
     diagAgentEndIdle = 0; // agent_end with activeAgents===0
     diagAgentEndDurable = 0; // agent_end fired ctx.compact() (mid-run durable trim)
+    diagAgentEndDurableSkipRecent = 0; // agent_end skipped ctx.compact() — compaction in last 10s (race guard)
     // Per-skip-path counters for the team-run diagnosis.
     diagCtxFastGate = 0; // returned at token fast-gate (below threshold)
     diagCtxNoCompact = 0; // autoCompactCheck().shouldCompact === false
@@ -268,7 +286,9 @@ 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
@@ -276,7 +296,9 @@ 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);
@@ -302,8 +324,14 @@ 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;
     }
@@ -314,14 +342,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
@@ -331,7 +367,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,
@@ -371,7 +407,9 @@ 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,
@@ -401,10 +439,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.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.
@@ -413,14 +473,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,
                 },
             },
@@ -445,14 +510,24 @@ 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
@@ -477,27 +552,55 @@ 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
@@ -520,31 +623,35 @@ 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 sep = ` ${C.dim}│${C.reset} `;
+        // Build one long content line — let terminal wrap it naturally
+        const content = [
+            `${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}`,
+            `${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`,
+            `${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)}`,
+        ].join(sep);
+        // Wrap to terminal width and pad each line
+        const wrapped = wrapLine(content, width - 2); // 2-char indent
         const lines = [
-            // top border
             panelBar(width, "─"),
-            // L1 — header: tier + ctx bar + pct/tokens + status + model + chk + agents/turn
-            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)
-            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)
-            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)}`,
-            ]),
+            ...wrapped.map((l) => panelLine(l, width)),
         ];
         // L4 — agents block (S27, count + status; per-agent tokens gated on P0)
         if (wd.agentsActive) {
@@ -559,7 +666,9 @@ 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) {
@@ -573,7 +682,8 @@ 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";
     }
@@ -611,6 +721,7 @@ export class MegaRuntime {
             dedupAttempts: 0,
             tokensSaved: 0,
             lastCompactAt: null,
+            lastNativeCompactAt: null,
         };
         this.statusKey = undefined;
         this.activeAgents = 0;
@@ -633,13 +744,18 @@ 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;
+            providerName =
+                ctx.modelRegistry?.getProviderDisplayName(m.provider) ?? null;
+        }
+        catch {
+            /* optional */
         }
-        catch { /* optional */ }
         const snap = {
             provider: m.provider,
             providerName,
@@ -661,14 +777,18 @@ 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,
             });
@@ -689,7 +809,8 @@ 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),
             });
         }
@@ -705,7 +826,9 @@ 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() {
@@ -715,10 +838,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}`
@@ -735,7 +861,9 @@ export class MegaRuntime {
             try {
                 this.snapshot(ctx);
             }
-            catch { /* non-fatal */ }
+            catch {
+                /* non-fatal */
+            }
         };
     }
     // Phase 3 — recall/activity ticker ring buffer.

package/dist/src/mirror/dedup.js

@@ -0,0 +1,44 @@
+/**
+ * dedup.ts — S27 Task 6: Fork snapshot → compress/dedupe pipeline.
+ *
+ * After the served window is handed to pi, asynchronously:
+ * 1. Read raw_transcript rows [0..cut_index] for the epoch
+ * 2. For each row, compute content_hash (reuse digest from dedup/)
+ * 3. INSERT OR IGNORE INTO dedup_mirror (stores bytes once per unique hash)
+ * 4. Update raw_transcript.content_ref to point to dedup_mirror
+ * 5. Increment dedup_mirror.ref_count for existing hashes
+ *
+ * Pi-agnostic: no pi runtime imports (src/ invariant).
+ */
+import { upsertDedupMirror, updateRawTranscriptRef, listRawTranscriptRange, getDedupRatio, } from "../store/sqlite.js";
+import { computeContentDigest } from "../dedup/digest.js";
+/**
+ * Deduplicate raw transcript rows for a session range.
+ * Fire-and-forget: errors are logged, not thrown.
+ *
+ * @returns Number of rows deduplicated, or -1 on error.
+ */
+export function dedupTranscript(db, sessionId, fromSeq, toSeq) {
+    try {
+        const rows = listRawTranscriptRange(db, sessionId, fromSeq, toSeq);
+        let deduped = 0;
+        for (const row of rows) {
+            const contentHash = computeContentDigest(row.contentBytes).contentHash;
+            const isNew = upsertDedupMirror(db, contentHash, row.contentBytes, row.seq);
+            updateRawTranscriptRef(db, sessionId, row.seq, contentHash);
+            if (!isNew) {
+                deduped++;
+            }
+        }
+        return deduped;
+    }
+    catch (err) {
+        // Fire-and-forget: log but don't throw
+        console.error("[mega-compact] dedupTranscript failed:", err);
+        return -1;
+    }
+}
+/**
+ * Get dedup ratio for a session.
+ */
+export { getDedupRatio };

package/dist/src/mirror/epoch.js

@@ -0,0 +1,36 @@
+/**
+ * epoch.ts — deterministic epoch-id derivation for the S27 DB-mirror.
+ *
+ * The epoch id MUST be a pure function of the checkpoint it decorates so that
+ * replaying / refreshing the same compaction yields the SAME epoch id (idempotent
+ * appends + ON CONFLICT refresh). No Date.now / uuid / crypto — this is the
+ * only source of randomness-free epoch naming in the mirror stack.
+ *
+ * - epochIdFor(cp)  → "epoch:" + cp   (human-traceable back to its checkpoint)
+ * - epochNonceFor(cp) → FNV-1a 32-bit hash (cheap, well-distributed nonce)
+ *
+ * Pi-agnostic: no pi runtime imports (src/ invariant).
+ */
+/**
+ * FNV-1a 32-bit nonce for a checkpoint id. Deterministic and RNG-free:
+ * h = 0x811c9dc5; for each char: h ^= codePoint; h = Math.imul(h, 0x01000193);
+ * return h >>> 0 (unsigned).
+ */
+export function epochNonceFor(checkpointId) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < checkpointId.length; i++) {
+        const cp = checkpointId.codePointAt(i);
+        if (cp === undefined)
+            continue;
+        h ^= cp;
+        h = Math.imul(h, 0x01000193);
+    }
+    return h >>> 0;
+}
+/**
+ * Deterministic epoch id: "epoch:" + checkpointId. Trivially traceable back to
+ * the source checkpoint, and stable under replay (refresh-safe upserts).
+ */
+export function epochIdFor(checkpointId) {
+    return "epoch:" + checkpointId;
+}