pi-mega-compact 0.11.2 → 0.11.4

package/extensions/mega-runtime/snapshot.test.ts

@@ -0,0 +1,139 @@
+/**
+ * snapshot.test.ts — C.4 computeMegaSnapshot tests for providerCachePct
+ * and megaCacheFlare fields.
+ *
+ * Uses MEGACOMPACT_STATE_DIR + mkdtemp (G7). No pi runtime.
+ */
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { mkdtempSync, rmSync } from "node:fs";
+import { computeMegaSnapshot, type SnapshotInput } from "./snapshot.js";
+
+function baseInput(overrides: Partial<SnapshotInput> = {}): SnapshotInput {
+	return {
+		rtTokensSaved: 1000,
+		lastCtxPercent: null,
+		lastCtxTokens: 0,
+		lastCtxWindow: 0,
+		activeAgents: 0,
+		currentTurn: 0,
+		statusKey: undefined,
+		ready: false,
+		armed: false,
+		st: {
+			totalTokenEstimate: 800,
+			originalTokens: 1200,
+			storageDedupRate: 0.12,
+			checkpointCount: 3,
+			lastCheckpointId: undefined,
+			lastSummary: undefined,
+			injectedCount: 0,
+			dedupHitRate: 0.05,
+			tokensSaved: 200,
+			dedupAttempts: 40,
+			dedupCollapsed: 5,
+		},
+		repo: {
+			tokensSaved: 5000,
+			totalTokenEstimate: 4000,
+			checkpointCount: 9,
+			sessionCount: 2,
+			originalTokens: 6000,
+			dedupAttempts: 100,
+			dedupCollapsed: 30,
+			storageDedupRate: 0.3,
+		},
+		pressureBand: "low",
+		configTier: "default",
+		modelSnap: undefined,
+		lastCompactAt: null,
+		embedderName: () => "Trigram",
+		driftStatus: () => "ok" as const,
+		getCachedGameState: () => ({
+			game_mode_on: false,
+			theme: "transparent",
+			tui_display_mode: "full",
+		}),
+		getTurnLevel: () => 1,
+		providerCachePct: 56.2,
+		megaCacheFlare: false,
+		megaCacheFlarePct: 0,
+		levelUpFlare: false,
+		achievementFlare: false,
+		achievementFlareTitles: [],
+		activeEffect: null,
+		lastActivityAt: Date.now(),
+		ticker: [],
+		lastWhy: undefined,
+		tierTrace: undefined,
+		pulsing: false,
+		...overrides,
+	};
+}
+
+describe("computeMegaSnapshot (C.4)", () => {
+	let dir: string;
+	before(() => {
+		dir = mkdtempSync(join(tmpdir(), "mc-snap-"));
+		process.env.MEGACOMPACT_STATE_DIR = dir;
+	});
+	after(() => {
+		delete process.env.MEGACOMPACT_STATE_DIR;
+		rmSync(dir, { recursive: true, force: true });
+	});
+
+	// ── C.1: providerCachePct flows into cachePct ─────────────────────────
+	it("cachePct equals providerCachePct (not dedup hit rate)", () => {
+		const res = computeMegaSnapshot(baseInput({ providerCachePct: 56.2 }));
+		assert.equal(res.widgetData.cachePct, 56.2, "cachePct is providerCachePct");
+	});
+
+	it("cachePct is 0 when providerCachePct is 0", () => {
+		const res = computeMegaSnapshot(baseInput({ providerCachePct: 0 }));
+		assert.equal(res.widgetData.cachePct, 0, "cachePct is 0");
+	});
+
+	it("cachePct is independent of dedup hit rate", () => {
+		const res = computeMegaSnapshot(
+			baseInput({
+				providerCachePct: 12.5,
+				st: {
+					totalTokenEstimate: 99999,
+					originalTokens: 99999,
+					storageDedupRate: 0.99,
+					checkpointCount: 1,
+					lastCheckpointId: undefined,
+					lastSummary: undefined,
+					injectedCount: 0,
+					dedupHitRate: 0.05,
+					tokensSaved: 200,
+					dedupAttempts: 40,
+					dedupCollapsed: 5,
+				},
+			}),
+		);
+		assert.equal(res.widgetData.cachePct, 12.5, "cachePct ignores dedup");
+	});
+
+	// ── megaCacheFlare fields pass through ────────────────────────────────
+	it("megaCacheFlare + megaCacheFlarePct pass through to widgetData", () => {
+		const res = computeMegaSnapshot(
+			baseInput({ megaCacheFlare: true, megaCacheFlarePct: 287 }),
+		);
+		assert.equal(res.widgetData.megaCacheFlare, true);
+		assert.equal(res.widgetData.megaCacheFlarePct, 287);
+	});
+
+	it("megaCacheFlare is false by default", () => {
+		const res = computeMegaSnapshot(baseInput());
+		assert.equal(res.widgetData.megaCacheFlare, false);
+	});
+
+	// ── level pass-through ────────────────────────────────────────────────
+	it("level flows from getTurnLevel", () => {
+		const res = computeMegaSnapshot(baseInput({ getTurnLevel: () => 42 }));
+		assert.equal(res.curLevel, 42);
+	});
+});

package/extensions/mega-runtime/snapshot.ts

@@ -81,6 +81,9 @@ export interface SnapshotInput {
 	// Model snapshot (pre-fetched)
 	modelSnap: ModelSnapshot | undefined;
 
+	// Provider prompt cache hit rate (lifetime avg, required — callers compute once).
+	providerCachePct: number;
+
 	// Game-mode state (callers that need real-time values pass lambdas)
 	getCachedGameState: () => GameState;
 	getTurnLevel: () => number;
@@ -150,8 +153,7 @@ export function computeMegaSnapshot(p: SnapshotInput): SnapshotResult {
 	const ctxPct = p.lastCtxPercent != null ? p.lastCtxPercent / 100 : 0;
 
 	// ── model + provider (S26 capture) for the header ─────────────────────
-	const modelName =
-		p.modelSnap?.modelName ?? p.modelSnap?.modelId ?? "?";
+	const modelName = p.modelSnap?.modelName ?? p.modelSnap?.modelId ?? "?";
 	const modelStr = p.modelSnap?.provider
 		? `${modelName}·${p.modelSnap.provider}`
 		: modelName;
@@ -177,7 +179,7 @@ export function computeMegaSnapshot(p: SnapshotInput): SnapshotResult {
 	// ── S31: game-mode state ──────────────────────────────────────────────
 	const gs = p.getCachedGameState();
 	const curLevel = p.getTurnLevel();
-	const cachePct = st.dedupHitRate * 100;
+	const cachePct = p.providerCachePct;
 
 	const widgetData: WidgetData = {
 		version: ownVersion(),
@@ -227,4 +229,4 @@ export function computeMegaSnapshot(p: SnapshotInput): SnapshotResult {
 	};
 
 	return { widgetData, curLevel };
-}
+}

package/extensions/mega-runtime/widget.test.ts

@@ -99,6 +99,8 @@ describe("buildWidgetLines (S31)", () => {
 							level: 1,
 							cachePct,
 							megaCacheFlare: flare,
+							// C.3: flare gate reads megaCacheFlarePct, not cachePct
+							...(flare ? { megaCacheFlarePct: cachePct } : {}),
 						});
 						const lines = buildWidgetLines(wd, WIDTH, 0);
 						const body = contentLines(lines);
@@ -161,123 +163,306 @@ describe("buildWidgetLines (S31)", () => {
 	}
 });
 
-
 describe("buildWidgetLines ambient border effect (v0.8.3)", () => {
-  const effBase = (overrides: Partial<WidgetData> = {}): WidgetData => baseWd({
-    theme: DEFAULT_THEME, tuiMode: "full", gameMode: true, level: 1, cachePct: 42, ...overrides,
-  });
-  const isBorder = (l: string): boolean => l.includes("─");
+	const effBase = (overrides: Partial<WidgetData> = {}): WidgetData =>
+		baseWd({
+			theme: DEFAULT_THEME,
+			tuiMode: "full",
+			gameMode: true,
+			level: 1,
+			cachePct: 42,
+			...overrides,
+		});
+	const isBorder = (l: string): boolean => l.includes("─");
+
+	it("activeEffect (pulse, mid-window) -> border lines carry a 256-color fg SGR", () => {
+		const ae = {
+			type: "pulse" as const,
+			role: "accent" as const,
+			startedAt: Date.now() - 250,
+			durationMs: 2000,
+		};
+		const lines = buildWidgetLines(effBase({ activeEffect: ae }), WIDTH, 0);
+		const borders = lines.filter(isBorder);
+		assert.ok(borders.length >= 2, "has top + bottom borders");
+		for (const b of borders) {
+			assert.ok(
+				b.includes("\x1b[38;5;"),
+				`border carries 256-color fg: ${JSON.stringify(b)}`,
+			);
+		}
+	});
+
+	it("activeEffect null -> plain borders, no 38;5 fg SGR on border lines", () => {
+		const lines = buildWidgetLines(effBase({ activeEffect: null }), WIDTH, 0);
+		const borders = lines.filter(isBorder);
+		for (const b of borders) {
+			assert.ok(
+				!b.includes("\x1b[38;5;"),
+				`no effect SGR on plain border: ${JSON.stringify(b)}`,
+			);
+		}
+	});
+
+	it("expired activeEffect -> plain borders (per-frame expiry enforced)", () => {
+		const ae = {
+			type: "pulse" as const,
+			role: "accent" as const,
+			startedAt: Date.now() - 5000,
+			durationMs: 1000,
+		};
+		const lines = buildWidgetLines(effBase({ activeEffect: ae }), WIDTH, 0);
+		const borders = lines.filter(isBorder);
+		for (const b of borders) {
+			assert.ok(
+				!b.includes("\x1b[38;5;"),
+				`expired effect -> plain border: ${JSON.stringify(b)}`,
+			);
+		}
+	});
+
+	it("activeEffect border lines are width-safe (pulse, minimal + full)", () => {
+		for (const tuiMode of ["minimal", "full"] as const) {
+			const ae = {
+				type: "pulse" as const,
+				role: "mega" as const,
+				startedAt: Date.now() - 100,
+				durationMs: 2000,
+			};
+			const lines = buildWidgetLines(
+				effBase({ activeEffect: ae, tuiMode }),
+				60,
+				0,
+			);
+			for (const l of lines)
+				assert.ok(
+					visibleWidth(l) <= 60,
+					`width safe (${tuiMode}): ${visibleWidth(l)}`,
+				);
+		}
+	});
 
-  it("activeEffect (pulse, mid-window) -> border lines carry a 256-color fg SGR", () => {
-    const ae = { type: "pulse" as const, role: "accent" as const, startedAt: Date.now() - 250, durationMs: 2000 };
-    const lines = buildWidgetLines(effBase({ activeEffect: ae }), WIDTH, 0);
-    const borders = lines.filter(isBorder);
-    assert.ok(borders.length >= 2, "has top + bottom borders");
-    for (const b of borders) {
-      assert.ok(b.includes("\x1b[38;5;"), `border carries 256-color fg: ${JSON.stringify(b)}`);
-    }
-  });
+	it("flash effect mid-window border carries the full base index SGR", () => {
+		// Force an 'on' phase of the 120ms alternate by starting just now.
+		const ae = {
+			type: "flash" as const,
+			role: "red" as const,
+			startedAt: Date.now(),
+			durationMs: 1200,
+		};
+		const lines = buildWidgetLines(effBase({ activeEffect: ae }), WIDTH, 0);
+		const borders = lines.filter(isBorder);
+		assert.ok(
+			borders.some((b) => b.includes("\x1b[38;5;203m")),
+			`flash-on phase uses red base 203`,
+		);
+	});
+});
 
-  it("activeEffect null -> plain borders, no 38;5 fg SGR on border lines", () => {
-    const lines = buildWidgetLines(effBase({ activeEffect: null }), WIDTH, 0);
-    const borders = lines.filter(isBorder);
-    for (const b of borders) {
-      assert.ok(!b.includes("\x1b[38;5;"), `no effect SGR on plain border: ${JSON.stringify(b)}`);
-    }
-  });
+describe("buildWidgetLines C.3 flare gate regression", () => {
+	const flareBase = (overrides: Partial<WidgetData> = {}): WidgetData =>
+		baseWd({
+			theme: DEFAULT_THEME,
+			tuiMode: "full",
+			gameMode: true,
+			level: 1,
+			cachePct: 42,
+			...overrides,
+		});
 
-  it("expired activeEffect -> plain borders (per-frame expiry enforced)", () => {
-    const ae = { type: "pulse" as const, role: "accent" as const, startedAt: Date.now() - 5000, durationMs: 1000 };
-    const lines = buildWidgetLines(effBase({ activeEffect: ae }), WIDTH, 0);
-    const borders = lines.filter(isBorder);
-    for (const b of borders) {
-      assert.ok(!b.includes("\x1b[38;5;"), `expired effect -> plain border: ${JSON.stringify(b)}`);
-    }
-  });
+	it("flare fires when megaCacheFlarePct >= 100 even when cachePct < 100", () => {
+		// Regression: the old code read (wd.cachePct ?? 0) >= 100, so when
+		// cachePct was 56 (provider hit rate) the flare silently broke.
+		const lines = buildWidgetLines(
+			flareBase({
+				cachePct: 56,
+				megaCacheFlare: true,
+				megaCacheFlarePct: 287,
+			}),
+			WIDTH,
+			0,
+		);
+		assert.ok(
+			lines.join("\n").includes("MEGA CACHE"),
+			"flare fires from megaCacheFlarePct",
+		);
+	});
 
-  it("activeEffect border lines are width-safe (pulse, minimal + full)", () => {
-    for (const tuiMode of ["minimal", "full"] as const) {
-      const ae = { type: "pulse" as const, role: "mega" as const, startedAt: Date.now() - 100, durationMs: 2000 };
-      const lines = buildWidgetLines(effBase({ activeEffect: ae, tuiMode }), 60, 0);
-      for (const l of lines) assert.ok(visibleWidth(l) <= 60, `width safe (${tuiMode}): ${visibleWidth(l)}`);
-    }
-  });
+	it("flare suppressed when megaCacheFlarePct < 100 even when cachePct >= 100", () => {
+		// Symmetric regression: high cachePct should NOT alone trigger flare.
+		const lines = buildWidgetLines(
+			flareBase({
+				cachePct: 150,
+				megaCacheFlare: true,
+				megaCacheFlarePct: 42,
+			}),
+			WIDTH,
+			0,
+		);
+		assert.ok(
+			!lines.join("\n").includes("MEGA CACHE"),
+			"no flare when megaCacheFlarePct below threshold",
+		);
+	});
 
-  it("flash effect mid-window border carries the full base index SGR", () => {
-    // Force an 'on' phase of the 120ms alternate by starting just now.
-    const ae = { type: "flash" as const, role: "red" as const, startedAt: Date.now(), durationMs: 1200 };
-    const lines = buildWidgetLines(effBase({ activeEffect: ae }), WIDTH, 0);
-    const borders = lines.filter(isBorder);
-    assert.ok(borders.some((b) => b.includes("\x1b[38;5;203m")), `flash-on phase uses red base 203`);
-  });
+	it("flare suppressed when megaCacheFlarePct is missing (undefined)", () => {
+		const lines = buildWidgetLines(
+			flareBase({
+				cachePct: 150,
+				megaCacheFlare: true,
+			}),
+			WIDTH,
+			0,
+		);
+		assert.ok(
+			!lines.join("\n").includes("MEGA CACHE"),
+			"no flare without megaCacheFlarePct",
+		);
+	});
 });
 
 describe("buildWidgetLines footer stability (P1 — no 250ms rotation)", () => {
-  // P1: the L5 ticker branch used to re-pick the head text every 250ms via
-  // `step = floor(Date.now()/250)`, flipping the footer line on a 250·N ms
-  // cycle. After the fix it pins to the most-recent entry, so two renders of
-  // the SAME WidgetData at t and t+500ms (well past one rotation slot) must
-  // produce byte-identical footer lines. Proves the metronome is gone.
-  const stabBase = (overrides: Partial<WidgetData> = {}): WidgetData => baseWd({
-    theme: DEFAULT_THEME, tuiMode: "full", gameMode: false, level: 1, cachePct: 42, ...overrides,
-  });
+	// P1: the L5 ticker branch used to re-pick the head text every 250ms via
+	// `step = floor(Date.now()/250)`, flipping the footer line on a 250·N ms
+	// cycle. After the fix it pins to the most-recent entry, so two renders of
+	// the SAME WidgetData at t and t+500ms (well past one rotation slot) must
+	// produce byte-identical footer lines. Proves the metronome is gone.
+	const stabBase = (overrides: Partial<WidgetData> = {}): WidgetData =>
+		baseWd({
+			theme: DEFAULT_THEME,
+			tuiMode: "full",
+			gameMode: false,
+			level: 1,
+			cachePct: 42,
+			...overrides,
+		});
 
-  it("ticker footer is byte-identical across simulated frames 500ms apart", () => {
-    const wd = stabBase({
-      ticker: [
-        { text: "first", at: 1000 },
-        { text: "second", at: 2000 },
-        { text: "third", at: 3000 },
-      ],
-      lastWhy: "because",
-    });
-    const realNow = Date.now;
-    try {
-      Date.now = () => 1_000_000; // t
-      const a = buildWidgetLines(wd, WIDTH, 0);
-      Date.now = () => 1_000_500; // t+500ms (would have rotated twice under the old code)
-      const b = buildWidgetLines(wd, WIDTH, 0);
-      assert.deepEqual(a, b, "footer byte-identical across 500ms with no state change");
-      // And the pinned head is the most-recent entry (third), not a rotation:
-      assert.ok(a.some((l) => l.includes("third")), "shows most-recent ticker entry");
-      assert.ok(a.some((l) => l.includes("(+2 more)")), "(+N more) suffix preserved");
-      assert.ok(a.some((l) => l.includes("because")), "lastWhy preserved");
-    } finally {
-      Date.now = realNow;
-    }
-  });
+	it("ticker footer is byte-identical across simulated frames 500ms apart", () => {
+		const wd = stabBase({
+			ticker: [
+				{ text: "first", at: 1000 },
+				{ text: "second", at: 2000 },
+				{ text: "third", at: 3000 },
+			],
+			lastWhy: "because",
+		});
+		const realNow = Date.now;
+		try {
+			Date.now = () => 1_000_000; // t
+			const a = buildWidgetLines(wd, WIDTH, 0);
+			Date.now = () => 1_000_500; // t+500ms (would have rotated twice under the old code)
+			const b = buildWidgetLines(wd, WIDTH, 0);
+			assert.deepEqual(
+				a,
+				b,
+				"footer byte-identical across 500ms with no state change",
+			);
+			// And the pinned head is the most-recent entry (third), not a rotation:
+			assert.ok(
+				a.some((l) => l.includes("third")),
+				"shows most-recent ticker entry",
+			);
+			assert.ok(
+				a.some((l) => l.includes("(+2 more)")),
+				"(+N more) suffix preserved",
+			);
+			assert.ok(
+				a.some((l) => l.includes("because")),
+				"lastWhy preserved",
+			);
+		} finally {
+			Date.now = realNow;
+		}
+	});
 
-  it("footer still flips when the ticker actually changes (new pushTicker)", () => {
-    const realNow = Date.now;
-    try {
-      Date.now = () => 1_000_000;
-      const before = buildWidgetLines(stabBase({ ticker: [{ text: "a", at: 1 }] }), WIDTH, 0);
-      const after = buildWidgetLines(stabBase({ ticker: [{ text: "a", at: 1 }, { text: "b", at: 2 }] }), WIDTH, 0);
-      assert.notDeepEqual(before, after, "footer changes when ticker grows");
-    } finally {
-      Date.now = realNow;
-    }
-  });
+	it("footer still flips when the ticker actually changes (new pushTicker)", () => {
+		const realNow = Date.now;
+		try {
+			Date.now = () => 1_000_000;
+			const before = buildWidgetLines(
+				stabBase({ ticker: [{ text: "a", at: 1 }] }),
+				WIDTH,
+				0,
+			);
+			const after = buildWidgetLines(
+				stabBase({
+					ticker: [
+						{ text: "a", at: 1 },
+						{ text: "b", at: 2 },
+					],
+				}),
+				WIDTH,
+				0,
+			);
+			assert.notDeepEqual(before, after, "footer changes when ticker grows");
+		} finally {
+			Date.now = realNow;
+		}
+	});
 });
 
 describe("buildWidgetLines achievement flare (S35)", () => {
-  const achBase = (overrides: Partial<WidgetData> = {}): WidgetData => baseWd({
-    theme: DEFAULT_THEME, tuiMode: "full", gameMode: true, level: 1, cachePct: 42, ...overrides,
-  });
-  it("achievementFlare + titles -> renders the unlock toast line", () => {
-    const lines = buildWidgetLines(achBase({ achievementFlare: true, achievementFlareTitles: ["First Compact"] }), WIDTH, 0);
-    assert.ok(lines.some((l) => l.includes("Achievement unlocked: First Compact")), "toast line present");
-  });
-  it("achievementFlare off -> no toast line", () => {
-    const lines = buildWidgetLines(achBase({ achievementFlare: false, achievementFlareTitles: ["First Compact"] }), WIDTH, 0);
-    assert.ok(!lines.some((l) => l.includes("Achievement unlocked")), "no toast when flare off");
-  });
-  it("gameMode off -> no toast even if flare set", () => {
-    const lines = buildWidgetLines(achBase({ gameMode: false, achievementFlare: true, achievementFlareTitles: ["X"] }), WIDTH, 0);
-    assert.ok(!lines.some((l) => l.includes("Achievement unlocked")), "no toast when game off");
-  });
-  it("achievement toast is width-safe", () => {
-    const lines = buildWidgetLines(achBase({ achievementFlare: true, achievementFlareTitles: ["First Compact", "Turn Veteran"] }), 60, 0);
-    for (const l of lines) assert.ok(visibleWidth(l) <= 60, "width safe");
-  });
+	const achBase = (overrides: Partial<WidgetData> = {}): WidgetData =>
+		baseWd({
+			theme: DEFAULT_THEME,
+			tuiMode: "full",
+			gameMode: true,
+			level: 1,
+			cachePct: 42,
+			...overrides,
+		});
+	it("achievementFlare + titles -> renders the unlock toast line", () => {
+		const lines = buildWidgetLines(
+			achBase({
+				achievementFlare: true,
+				achievementFlareTitles: ["First Compact"],
+			}),
+			WIDTH,
+			0,
+		);
+		assert.ok(
+			lines.some((l) => l.includes("Achievement unlocked: First Compact")),
+			"toast line present",
+		);
+	});
+	it("achievementFlare off -> no toast line", () => {
+		const lines = buildWidgetLines(
+			achBase({
+				achievementFlare: false,
+				achievementFlareTitles: ["First Compact"],
+			}),
+			WIDTH,
+			0,
+		);
+		assert.ok(
+			!lines.some((l) => l.includes("Achievement unlocked")),
+			"no toast when flare off",
+		);
+	});
+	it("gameMode off -> no toast even if flare set", () => {
+		const lines = buildWidgetLines(
+			achBase({
+				gameMode: false,
+				achievementFlare: true,
+				achievementFlareTitles: ["X"],
+			}),
+			WIDTH,
+			0,
+		);
+		assert.ok(
+			!lines.some((l) => l.includes("Achievement unlocked")),
+			"no toast when game off",
+		);
+	});
+	it("achievement toast is width-safe", () => {
+		const lines = buildWidgetLines(
+			achBase({
+				achievementFlare: true,
+				achievementFlareTitles: ["First Compact", "Turn Veteran"],
+			}),
+			60,
+			0,
+		);
+		for (const l of lines) assert.ok(visibleWidth(l) <= 60, "width safe");
+	});
 });

package/extensions/mega-runtime/widget.ts

@@ -33,7 +33,22 @@ export {
 } from "./widget-ansi.js";
 export type { TickerEntry, WidgetData } from "./widget-types.js";
 
-import { C, PULSE, DEFAULT_PANEL_BG, panelBgFor, themeAnsi, sgrReset, wrapLine, panelLine, panelBar, effectBorderSgr, effectBar, fmtTokens, ramp, sinceCompactStr } from "./widget-ansi.js";
+import {
+	C,
+	PULSE,
+	DEFAULT_PANEL_BG,
+	panelBgFor,
+	themeAnsi,
+	sgrReset,
+	wrapLine,
+	panelLine,
+	panelBar,
+	effectBorderSgr,
+	effectBar,
+	fmtTokens,
+	ramp,
+	sinceCompactStr,
+} from "./widget-ansi.js";
 import type { WidgetData } from "./widget-types.js";
 
 // ── buildWidgetLines ───────────────────────────────────────────────────────
@@ -70,13 +85,13 @@ export function buildWidgetLines(
 	// width guard + theme bg apply identically to the full panel. Level is shown
 	// only when game mode is on (otherwise just the cache %).
 	if (wd.tuiMode === "minimal") {
-		const lvl = wd.gameMode ? wd.level ?? 1 : undefined;
+		const lvl = wd.gameMode ? (wd.level ?? 1) : undefined;
 		const cachePct = wd.cachePct ?? 0;
 		const cacheStr = `${Math.round(cachePct * 10) / 10}%`;
 		const accent = themeAnsi(wd.theme, "accent");
 		const mega = themeAnsi(wd.theme, "mega");
 		const megaFlare =
-			wd.gameMode && wd.megaCacheFlare && cachePct >= 100
+			wd.gameMode && wd.megaCacheFlare && (wd.megaCacheFlarePct ?? 0) >= 100
 				? ` ${mega}MEGA CACHE${sgrReset(mega)}`
 				: "";
 		const body =
@@ -100,7 +115,7 @@ export function buildWidgetLines(
 		? `${themeAnsi(wd.theme, "accent")}${wd.gameMode && wd.levelUpFlare ? "\x1b[5m" : ""}LVL ${wd.level ?? 1}${wd.gameMode && wd.levelUpFlare ? "\x1b[0m" : ""}${sgrReset(themeAnsi(wd.theme, "accent"))} `
 		: "";
 	const megaFlareSuffix =
-		wd.gameMode && wd.megaCacheFlare && (wd.cachePct ?? 0) >= 100
+		wd.gameMode && wd.megaCacheFlare && (wd.megaCacheFlarePct ?? 0) >= 100
 			? `${sep}${themeAnsi(wd.theme, "mega")}MEGA CACHE! (oops, you cached so hard the dedup caught fire)${sgrReset(themeAnsi(wd.theme, "mega"))}`
 			: "";
 	// Build one long content line — let terminal wrap it naturally
@@ -157,13 +172,21 @@ export function buildWidgetLines(
 			),
 		);
 	} else if (wd.pulsing) {
-		lines.push(panelLine(`   ${pulse}${C.teal}compacting…${C.reset}`, width, panelBg));
+		lines.push(
+			panelLine(`   ${pulse}${C.teal}compacting…${C.reset}`, width, panelBg),
+		);
 	}
 	// S35: achievement-unlock toast (one-line, accent) -- fires for one render cycle.
 	if (wd.gameMode && wd.achievementFlare && wd.achievementFlareTitles?.length) {
 		const accentSgr = themeAnsi(wd.theme, "accent");
 		const titlesStr = wd.achievementFlareTitles.join(", ");
-		lines.push(panelLine(`   ${accentSgr}🏆 Achievement unlocked: ${titlesStr}${sgrReset(accentSgr)}`, width, panelBg));
+		lines.push(
+			panelLine(
+				`   ${accentSgr}🏆 Achievement unlocked: ${titlesStr}${sgrReset(accentSgr)}`,
+				width,
+				panelBg,
+			),
+		);
 	}
 	// bottom border
 	lines.push(effectBar(panelBar(width, "─", panelBg), borderSgr));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.11.2",
+  "version": "0.11.4",
   "description": "Layered, local, vector-backed context compressor for pi — supersede/collapse/cluster compaction with deduped inline recall.",
   "type": "module",
   "license": "BSD-3-Clause",