pi-mega-compact 0.8.4 → 0.8.6

package/dist/extensions/mega-compact.js

@@ -42,4 +42,13 @@ export default function (pi) {
     registerConflictCommands(pi, runtime);
     registerDbCommands(pi, runtime);
     registerGameCommands(pi, runtime);
+    // v0.8.5 (audit P3): release the fs.watch game-state watcher handle on
+    // session teardown so it doesn't linger across reloads. pi exposes no
+    // extension-unload event (the factory return value is ignored and there is no
+    // "shutdown" event on the ExtensionAPI), so dispose() is wired to the
+    // session_shutdown lifecycle event — the closest valid teardown signal.
+    // dispose() is idempotent, and the next snapshot() re-opens the watcher
+    // lazily via bindRepo() → ensureGameStateWatcher(), so there is no permanent
+    // leak and no per-session fd accumulation.
+    pi.on("session_shutdown", () => runtime.dispose());
 }

package/dist/extensions/mega-events/compact-handlers.js

@@ -128,6 +128,7 @@ export function registerCompactHandlers(pi, runtime, config) {
     pi.on("session_compact", async (_event, _ctx) => {
         runtime.rt.lastNativeCompactAt = Date.now();
         runtime.rt.lastCompactAt = Date.now();
+        runtime.trimCache = null; // v0.8.6: durable truncation changes the transcript — never replay the stale cached cut (PREVENT-PI-001/002)
         runtime.logger.info("session-compacted", {
             sessionId: runtime.rt.sessionId,
             at: runtime.rt.lastCompactAt,

package/dist/extensions/mega-events/context-handler.js

@@ -122,6 +122,34 @@ export function registerContextHandler(pi, runtime, config) {
             return;
         }
         runtime.debounceUntil = now + 2000;
+        // v0.8.6 cache-stability: replay the cached trim view when still in the
+        // same compaction epoch AND context hasn't grown enough to warrant a
+        // re-compact. This stabilizes the provider KV-cache prefix (the summary +
+        // cut are reused verbatim) instead of regenerating a fresh summary +
+        // sentinel every fire, which invalidated the prefix on every other turn
+        // (the alternating cache-miss regression). Re-compact only when context
+        // grew >=10% of the window (percent basis) or >=50% of the effective
+        // threshold (token basis, when percent is unavailable). The cached `cut`
+        // is only valid while the transcript grows within the epoch — it is
+        // cleared on session_compact (durable truncation) + resetRuntime, so we
+        // never replay a stale cut into a truncated transcript (PREVENT-PI-001/002).
+        const RECOMPACT_PCT_DELTA = 10;
+        if (runtime.trimCache &&
+            runtime.trimCache.checkpointId === runtime.rt.lastCheckpointId &&
+            runtime.trimCache.cut <= messages.length) {
+            const grewEnough = pct != null && runtime.trimCache.ctxPct != null
+                ? pct - runtime.trimCache.ctxPct >= RECOMPACT_PCT_DELTA
+                : currentTokens - (runtime.trimCache.ctxTokens ?? 0) >=
+                    runtime.effectiveThreshold * 0.5;
+            if (!grewEnough) {
+                const recent = messages.slice(runtime.trimCache.cut); // guardrails-allow PREVENT-PI-002: cached `cut` was sanitized once by computeLiveTrimCut (src/boundary.ts) and replayed verbatim; the transcript only grows within an epoch (cache is cleared on durable truncation), so the preserved run still starts on a toolPair-safe index.
+                runtime.diagLiveTrimFires++; // trim view returned this call (replay counts as a fire)
+                runtime.diagLiveTrimReplays++;
+                runtime.snapshot(ctx);
+                return { messages: [runtime.trimCache.summaryAgentMsg, ...recent] };
+            }
+            // else: context grew enough → fall through to re-compact (cache is stale)
+        }
         // Adaptive compression (Fix E): scale compression strength + keepFrom depth
         // with how close we are to the model context limit. Null-safe: when the
         // token-fallback path ran (pct unavailable) use the token-basis pressure
@@ -224,9 +252,22 @@ export function registerContextHandler(pi, runtime, config) {
             const summaryAgentMsg = {
                 role: "user",
                 content: summaryMsg.text,
-                timestamp: Date.now(),
+                // v0.8.6: stable timestamp across the epoch (NOT Date.now()) so the
+                // summary message bytes — and thus the KV-cache prefix — don't drift
+                // on every replay within the same compaction epoch.
+                timestamp: runtime.rt.lastCompactAt ?? Date.now(),
             };
             const recent = messages.slice(cut); // guardrails-allow PREVENT-PI-002: `cut` is the pre-sanitized `compactedFrom` produced by src/boundary.ts computeDropRange, so the preserved run begins on a toolPair-safe index.
+            // v0.8.6: cache the trim view so subsequent gated calls in this epoch
+            // replay it verbatim (stabilizing the KV-cache prefix) instead of
+            // regenerating a fresh summary + sentinel every fire.
+            runtime.trimCache = {
+                checkpointId: ran.result.checkpointId ?? `epoch-${runtime.rt.lastCompactAt ?? Date.now()}`,
+                cut,
+                summaryAgentMsg,
+                ctxPct: pct ?? null,
+                ctxTokens: currentTokens,
+            };
             runtime.snapshot(ctx);
             // DIAG (team-run relief): confirm the live trim actually fires + how big
             // the window still is. The return is non-durable (per-LLM-call only), so

package/dist/extensions/mega-pipeline/compact.js

@@ -152,12 +152,19 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
     }
     // Sentinel marker: a non-LLM bookkeeping entry so subsequent triggers can
     // skip re-vectorizing an already-compacted region (zero token cost).
-    pi.appendEntry(MARKER_TYPE, {
-        checkpointId: result.checkpointId,
-        regionHash: result.regionHash,
-        tokenEstimate: result.tokenEstimate,
-        deduped: result.deduped,
-    });
+    // v0.8.6: gate on !result.deduped so the marker ONLY lands when a genuinely
+    // new checkpoint was created. Without this, every dedup re-fire appended a
+    // fresh sentinel to the real transcript, bloating it and perturbing the
+    // provider KV-cache prefix (the alternating cache-miss regression). Matches
+    // the RAPTOR + vector-index blocks above, which are already !deduped-gated.
+    if (!result.deduped) {
+        pi.appendEntry(MARKER_TYPE, {
+            checkpointId: result.checkpointId,
+            regionHash: result.regionHash,
+            tokenEstimate: result.tokenEstimate,
+            deduped: result.deduped,
+        });
+    }
     // Fix D: refresh the RAPTOR tree for this session so live recall (search) can
     // serve high-level summaries. Best-effort + non-fatal: never block compaction.
     // Budget-guarded (RAPTOR_BUDGET_MS) so it can't hang a large session.

package/dist/extensions/mega-runtime/state.js

@@ -50,6 +50,14 @@ export class MegaRuntime {
         cacheHitTokens: 0,
         lengthStopPending: false,
     };
+    // v0.8.6 cache-stability: the cached live-trim view for the current
+    // compaction epoch. Set after a fresh runCompact + computeLiveTrimCut, and
+    // replayed verbatim on subsequent gated context events in the SAME epoch
+    // (same checkpointId) so the provider KV-cache prefix stays stable instead
+    // of being invalidated by a freshly regenerated summary + sentinel every
+    // fire. Invalidated on session restart (resetRuntime) and on any native
+    // durable compaction (session_compact) that truncates the transcript.
+    trimCache = null;
     debounceUntil = 0;
     // S16: debounce for the agent_end resume nudge (avoid busy-loops).
     resumeNudgeUntil = 0;
@@ -119,6 +127,17 @@ export class MegaRuntime {
     lastCtxWindow = 0;
     // Latest computed widget payload (recomputed per snapshot, rendered per frame).
     widgetData = null;
+    // v0.8.5: material-change signature from the last full snapshot() body. When
+    // the next snapshot()'s signature matches, the expensive recompute (6 sync
+    // SQLite opens) + writeFileSync(dashboard.json) are skipped — only the
+    // (already-registered) widget factory is refreshed. Kills the per-event
+    // main-thread block during typing/idle streaming with no material change.
+    lastSnapshotSig = null;
+    // v0.8.5: bumped whenever the cached game-state memo is evicted (bumpGameState
+    // for in-process /mega-game writes, the fs.watch callback for cross-process
+    // dashboard-server writes, and bindRepo on repo switch) so the snapshot gate
+    // invalidates and the widget re-reads theme/mode after the change.
+    gameStateBump = 0;
     // Cached cross-repo drift status (recomputed at most every 30s — it opens the
     // machine-wide registry DB, so we don't want to do it on every render frame).
     driftCache = null;
@@ -148,6 +167,7 @@ export class MegaRuntime {
      * updated and cost nothing).
      */
     diagLiveTrimFires = 0; // context handler returned a trimmed view
+    diagLiveTrimReplays = 0; // v0.8.6: trim view returned via cached replay (skipped re-compact)
     diagBeforeCompactFires = 0; // session_before_compact handler entered
     diagBeforeCompactSupplied = 0; // session_before_compact supplied our trim
     diagAgentEndIdle = 0; // agent_end with activeAgents===0
@@ -253,6 +273,7 @@ export class MegaRuntime {
         // stateDir), so evict the memo on every repo switch; the next widget render
         // re-queries lazily via getCachedGameState().
         this.cachedGameState = undefined;
+        this.gameStateBump++;
         // S32: re-target the fs.watch cache-eviction watcher at the NEW stateDir's
         // sqlite.db so cross-process writes (dashboard server) still evict the memo.
         this.ensureGameStateWatcher();
@@ -293,6 +314,21 @@ export class MegaRuntime {
     snapshot(ctx) {
         if (ctx)
             this.bindRepo(ctx.cwd);
+        // v0.8.5: gate the expensive body (6 sync SQLite opens +
+        // writeFileSync(dashboard.json)) behind a cheap material-change signature.
+        // During typing / idle / no-compaction streaming, the 'context' event
+        // fires repeatedly with NO material change — skip the recompute + write and
+        // just re-register the (live) widget factory, which reads the cached
+        // widgetData every frame. This removes the per-event main-thread block
+        // WITHOUT changing write timing, so tests that read dashboard.json
+        // synchronously after a compaction still see it written (compaction changes
+        // compactCount/tokensSaved → the signature changes → the full recompute +
+        // write runs).
+        const sig = this.materialSig();
+        if (ctx && this.widgetData && this.lastSnapshotSig === sig) {
+            this.renderWidget(ctx);
+            return;
+        }
         const st = this.store.stats(this.rt.sessionId);
         const repo = this.store.repoStats();
         const di = this.store.dataInvariant();
@@ -596,6 +632,9 @@ export class MegaRuntime {
             // process.stdout.columns. buildWidgetLines reads this.widgetData live.
             this.renderWidget(ctx);
         }
+        // v0.8.5: record the material-change signature computed at the top so the
+        // next snapshot() can skip this whole body when nothing material changed.
+        this.lastSnapshotSig = sig;
     }
     /** Register the above-editor widget as a width-aware factory so pi re-renders
      *  it at the REAL terminal width every frame (auto-fit wide/narrow). The
@@ -607,6 +646,34 @@ export class MegaRuntime {
             invalidate: () => { },
         }), { placement: "aboveEditor" });
     }
+    /** v0.8.5: cheap material-change signature over live runtime fields (no
+     *  SQLite). Two snapshots with the same signature produce identical
+     *  dashboard.json + widgetData, so the 6 synchronous SQLite opens + the
+     *  writeFileSync(dashboard.json) can be skipped. Built from in-memory state
+     *  only; gameStateBump covers cross-process game_state edits (fs.watch) +
+     *  in-process /mega-game writes (bumpGameState) + repo switches (bindRepo).
+     *  The transient flare flags are included so a one-shot flare forces the
+     *  recompute that renders (then clears) it for exactly one cycle. */
+    materialSig() {
+        const rt = this.rt;
+        const ae = this.activeEffect;
+        return JSON.stringify([
+            this.lastCtxTokens, this.lastCtxPercent, this.lastCtxWindow,
+            this.activeAgents, this.currentTurn,
+            rt.compactCount, rt.tokensSaved, rt.dedupSkips, rt.dedupAttempts,
+            rt.recallInjections, rt.cacheHitTokens, rt.persistedThisSession,
+            rt.lastCheckpointId ?? null, rt.lastCompactedFrom, rt.lastCompactedTokens,
+            this.statusKey ?? null,
+            this.currentModel?.modelId ?? null, this.currentModel?.provider ?? null,
+            ae ? `${ae.type}:${ae.role}:${ae.startedAt}` : null,
+            this.gameStateBump,
+            this.megaCacheFlare, this.megaCacheFlarePct,
+            this.levelUpFlare, this.achievementFlare,
+            this.achievementFlareTitles.join("|"),
+            this.tierTrace ?? null, this.lastWhy ?? null, this.pulsing,
+            this.ticker.length,
+        ]);
+    }
     /** Active embedder name for the memory-store line (Trigram default / MiniLM). */
     embedderName() {
         // MINILM_EMBEDDER flag lives in src/config/dedup.ts; read the same env var
@@ -656,6 +723,7 @@ export class MegaRuntime {
             cacheHitTokens: 0,
             lengthStopPending: false,
         };
+        this.trimCache = null; // v0.8.6: never replay a stale trim into a new session
         this.statusKey = undefined;
         this.activeAgents = 0;
         this.currentTurn = 0;
@@ -803,6 +871,7 @@ export class MegaRuntime {
             this.gameStateWatcher = watch(this.currentStateDir, (_eventType, filename) => {
                 if (typeof filename === "string" && filename.startsWith("sqlite.db")) {
                     this.cachedGameState = undefined;
+                    this.gameStateBump++;
                 }
             });
             this.gameStateWatchDir = this.currentStateDir;
@@ -849,6 +918,7 @@ export class MegaRuntime {
      *  the panel picks up theme/mode/toggle changes live. */
     bumpGameState() {
         this.cachedGameState = undefined;
+        this.gameStateBump++;
     }
     /** S33: player level for game mode — floor(log2(turns+1))+1 (gentle).
      *  Defensive: non-finite/negative collapses to 1 (never NaN). */

package/extensions/mega-compact.ts

@@ -45,4 +45,13 @@ export default function (pi: ExtensionAPI) {
   registerConflictCommands(pi, runtime);
   registerDbCommands(pi, runtime);
   registerGameCommands(pi, runtime);
+  // v0.8.5 (audit P3): release the fs.watch game-state watcher handle on
+  // session teardown so it doesn't linger across reloads. pi exposes no
+  // extension-unload event (the factory return value is ignored and there is no
+  // "shutdown" event on the ExtensionAPI), so dispose() is wired to the
+  // session_shutdown lifecycle event — the closest valid teardown signal.
+  // dispose() is idempotent, and the next snapshot() re-opens the watcher
+  // lazily via bindRepo() → ensureGameStateWatcher(), so there is no permanent
+  // leak and no per-session fd accumulation.
+  pi.on("session_shutdown", () => runtime.dispose());
 }

package/extensions/mega-events/compact-handlers.ts

@@ -159,6 +159,7 @@ export function registerCompactHandlers(
 		pi.on("session_compact", async (_event: SessionCompactEvent, _ctx: ExtensionContext) => {
 			runtime.rt.lastNativeCompactAt = Date.now();
 			runtime.rt.lastCompactAt = Date.now();
+			runtime.trimCache = null; // v0.8.6: durable truncation changes the transcript — never replay the stale cached cut (PREVENT-PI-001/002)
 			runtime.logger.info("session-compacted", {
 				sessionId: runtime.rt.sessionId,
 				at: runtime.rt.lastCompactAt,

package/extensions/mega-events/context-handler.ts

@@ -157,6 +157,38 @@ export function registerContextHandler(
 		}
 		runtime.debounceUntil = now + 2000;
 
+		// v0.8.6 cache-stability: replay the cached trim view when still in the
+		// same compaction epoch AND context hasn't grown enough to warrant a
+		// re-compact. This stabilizes the provider KV-cache prefix (the summary +
+		// cut are reused verbatim) instead of regenerating a fresh summary +
+		// sentinel every fire, which invalidated the prefix on every other turn
+		// (the alternating cache-miss regression). Re-compact only when context
+		// grew >=10% of the window (percent basis) or >=50% of the effective
+		// threshold (token basis, when percent is unavailable). The cached `cut`
+		// is only valid while the transcript grows within the epoch — it is
+		// cleared on session_compact (durable truncation) + resetRuntime, so we
+		// never replay a stale cut into a truncated transcript (PREVENT-PI-001/002).
+		const RECOMPACT_PCT_DELTA = 10;
+		if (
+			runtime.trimCache &&
+			runtime.trimCache.checkpointId === runtime.rt.lastCheckpointId &&
+			runtime.trimCache.cut <= messages.length
+		) {
+			const grewEnough =
+				pct != null && runtime.trimCache.ctxPct != null
+					? pct - runtime.trimCache.ctxPct >= RECOMPACT_PCT_DELTA
+					: currentTokens - (runtime.trimCache.ctxTokens ?? 0) >=
+							runtime.effectiveThreshold * 0.5;
+			if (!grewEnough) {
+				const recent = messages.slice(runtime.trimCache.cut); // guardrails-allow PREVENT-PI-002: cached `cut` was sanitized once by computeLiveTrimCut (src/boundary.ts) and replayed verbatim; the transcript only grows within an epoch (cache is cleared on durable truncation), so the preserved run still starts on a toolPair-safe index.
+				runtime.diagLiveTrimFires++; // trim view returned this call (replay counts as a fire)
+				runtime.diagLiveTrimReplays++;
+				runtime.snapshot(ctx);
+				return { messages: [runtime.trimCache.summaryAgentMsg, ...recent] };
+			}
+			// else: context grew enough → fall through to re-compact (cache is stale)
+		}
+
 		// Adaptive compression (Fix E): scale compression strength + keepFrom depth
 		// with how close we are to the model context limit. Null-safe: when the
 		// token-fallback path ran (pct unavailable) use the token-basis pressure
@@ -266,9 +298,22 @@ export function registerContextHandler(
 			const summaryAgentMsg = {
 				role: "user" as const,
 				content: summaryMsg.text,
-				timestamp: Date.now(),
+				// v0.8.6: stable timestamp across the epoch (NOT Date.now()) so the
+				// summary message bytes — and thus the KV-cache prefix — don't drift
+				// on every replay within the same compaction epoch.
+				timestamp: runtime.rt.lastCompactAt ?? Date.now(),
 			} as unknown as AgentMessage;
 			const recent = messages.slice(cut); // guardrails-allow PREVENT-PI-002: `cut` is the pre-sanitized `compactedFrom` produced by src/boundary.ts computeDropRange, so the preserved run begins on a toolPair-safe index.
+			// v0.8.6: cache the trim view so subsequent gated calls in this epoch
+			// replay it verbatim (stabilizing the KV-cache prefix) instead of
+			// regenerating a fresh summary + sentinel every fire.
+			runtime.trimCache = {
+				checkpointId: ran.result.checkpointId ?? `epoch-${runtime.rt.lastCompactAt ?? Date.now()}`,
+				cut,
+				summaryAgentMsg,
+				ctxPct: pct ?? null,
+				ctxTokens: currentTokens,
+			};
 			runtime.snapshot(ctx);
 			// DIAG (team-run relief): confirm the live trim actually fires + how big
 			// the window still is. The return is non-durable (per-LLM-call only), so

package/extensions/mega-pipeline/compact.ts

@@ -192,12 +192,19 @@ function doCompact(
 
   // Sentinel marker: a non-LLM bookkeeping entry so subsequent triggers can
   // skip re-vectorizing an already-compacted region (zero token cost).
-  pi.appendEntry(MARKER_TYPE, {
-    checkpointId: result.checkpointId,
-    regionHash: result.regionHash,
-    tokenEstimate: result.tokenEstimate,
-    deduped: result.deduped,
-  });
+  // v0.8.6: gate on !result.deduped so the marker ONLY lands when a genuinely
+  // new checkpoint was created. Without this, every dedup re-fire appended a
+  // fresh sentinel to the real transcript, bloating it and perturbing the
+  // provider KV-cache prefix (the alternating cache-miss regression). Matches
+  // the RAPTOR + vector-index blocks above, which are already !deduped-gated.
+  if (!result.deduped) {
+    pi.appendEntry(MARKER_TYPE, {
+      checkpointId: result.checkpointId,
+      regionHash: result.regionHash,
+      tokenEstimate: result.tokenEstimate,
+      deduped: result.deduped,
+    });
+  }
 
   // Fix D: refresh the RAPTOR tree for this session so live recall (search) can
   // serve high-level summaries. Best-effort + non-fatal: never block compaction.

package/extensions/mega-runtime/state.ts

@@ -87,6 +87,20 @@ export class MegaRuntime {
 		cacheHitTokens: 0,
 		lengthStopPending: false,
 	};
+	// v0.8.6 cache-stability: the cached live-trim view for the current
+	// compaction epoch. Set after a fresh runCompact + computeLiveTrimCut, and
+	// replayed verbatim on subsequent gated context events in the SAME epoch
+	// (same checkpointId) so the provider KV-cache prefix stays stable instead
+	// of being invalidated by a freshly regenerated summary + sentinel every
+	// fire. Invalidated on session restart (resetRuntime) and on any native
+	// durable compaction (session_compact) that truncates the transcript.
+	trimCache: {
+		checkpointId: string;
+		cut: number;
+		summaryAgentMsg: AgentMessage;
+		ctxPct: number | null;
+		ctxTokens: number | null;
+	} | null = null;
 	debounceUntil = 0;
 	// S16: debounce for the agent_end resume nudge (avoid busy-loops).
 	resumeNudgeUntil = 0;
@@ -158,6 +172,17 @@ export class MegaRuntime {
 
 	// Latest computed widget payload (recomputed per snapshot, rendered per frame).
 	widgetData: WidgetData | null = null;
+	// v0.8.5: material-change signature from the last full snapshot() body. When
+	// the next snapshot()'s signature matches, the expensive recompute (6 sync
+	// SQLite opens) + writeFileSync(dashboard.json) are skipped — only the
+	// (already-registered) widget factory is refreshed. Kills the per-event
+	// main-thread block during typing/idle streaming with no material change.
+	private lastSnapshotSig: string | null = null;
+	// v0.8.5: bumped whenever the cached game-state memo is evicted (bumpGameState
+	// for in-process /mega-game writes, the fs.watch callback for cross-process
+	// dashboard-server writes, and bindRepo on repo switch) so the snapshot gate
+	// invalidates and the widget re-reads theme/mode after the change.
+	private gameStateBump = 0;
 	// Cached cross-repo drift status (recomputed at most every 30s — it opens the
 	// machine-wide registry DB, so we don't want to do it on every render frame).
 	private driftCache: { at: number; status: "ok" | "warn" } | null = null;
@@ -188,6 +213,7 @@ export class MegaRuntime {
 	 * updated and cost nothing).
 	 */
 	diagLiveTrimFires = 0; // context handler returned a trimmed view
+	diagLiveTrimReplays = 0; // v0.8.6: trim view returned via cached replay (skipped re-compact)
 	diagBeforeCompactFires = 0; // session_before_compact handler entered
 	diagBeforeCompactSupplied = 0; // session_before_compact supplied our trim
 	diagAgentEndIdle = 0; // agent_end with activeAgents===0
@@ -303,6 +329,7 @@ export class MegaRuntime {
 		// stateDir), so evict the memo on every repo switch; the next widget render
 		// re-queries lazily via getCachedGameState().
 		this.cachedGameState = undefined;
+		this.gameStateBump++;
 		// S32: re-target the fs.watch cache-eviction watcher at the NEW stateDir's
 		// sqlite.db so cross-process writes (dashboard server) still evict the memo.
 		this.ensureGameStateWatcher();
@@ -343,6 +370,21 @@ export class MegaRuntime {
 	/** Collect live state and write it to disk (+ paint the above-editor widget). */
 	snapshot(ctx?: ExtensionContext): void {
 		if (ctx) this.bindRepo(ctx.cwd);
+		// v0.8.5: gate the expensive body (6 sync SQLite opens +
+		// writeFileSync(dashboard.json)) behind a cheap material-change signature.
+		// During typing / idle / no-compaction streaming, the 'context' event
+		// fires repeatedly with NO material change — skip the recompute + write and
+		// just re-register the (live) widget factory, which reads the cached
+		// widgetData every frame. This removes the per-event main-thread block
+		// WITHOUT changing write timing, so tests that read dashboard.json
+		// synchronously after a compaction still see it written (compaction changes
+		// compactCount/tokensSaved → the signature changes → the full recompute +
+		// write runs).
+		const sig = this.materialSig();
+		if (ctx && this.widgetData && this.lastSnapshotSig === sig) {
+			this.renderWidget(ctx);
+			return;
+		}
 		const st = this.store.stats(this.rt.sessionId);
 		const repo = this.store.repoStats();
 		const di = this.store.dataInvariant();
@@ -664,6 +706,9 @@ export class MegaRuntime {
 			// process.stdout.columns. buildWidgetLines reads this.widgetData live.
 			this.renderWidget(ctx);
 		}
+		// v0.8.5: record the material-change signature computed at the top so the
+		// next snapshot() can skip this whole body when nothing material changed.
+		this.lastSnapshotSig = sig;
 	}
 
 	/** Register the above-editor widget as a width-aware factory so pi re-renders
@@ -686,6 +731,35 @@ export class MegaRuntime {
 		);
 	}
 
+	/** v0.8.5: cheap material-change signature over live runtime fields (no
+	 *  SQLite). Two snapshots with the same signature produce identical
+	 *  dashboard.json + widgetData, so the 6 synchronous SQLite opens + the
+	 *  writeFileSync(dashboard.json) can be skipped. Built from in-memory state
+	 *  only; gameStateBump covers cross-process game_state edits (fs.watch) +
+	 *  in-process /mega-game writes (bumpGameState) + repo switches (bindRepo).
+	 *  The transient flare flags are included so a one-shot flare forces the
+	 *  recompute that renders (then clears) it for exactly one cycle. */
+	private materialSig(): string {
+		const rt = this.rt;
+		const ae = this.activeEffect;
+		return JSON.stringify([
+			this.lastCtxTokens, this.lastCtxPercent, this.lastCtxWindow,
+			this.activeAgents, this.currentTurn,
+			rt.compactCount, rt.tokensSaved, rt.dedupSkips, rt.dedupAttempts,
+			rt.recallInjections, rt.cacheHitTokens, rt.persistedThisSession,
+			rt.lastCheckpointId ?? null, rt.lastCompactedFrom, rt.lastCompactedTokens,
+			this.statusKey ?? null,
+			this.currentModel?.modelId ?? null, this.currentModel?.provider ?? null,
+			ae ? `${ae.type}:${ae.role}:${ae.startedAt}` : null,
+			this.gameStateBump,
+			this.megaCacheFlare, this.megaCacheFlarePct,
+			this.levelUpFlare, this.achievementFlare,
+			this.achievementFlareTitles.join("|"),
+			this.tierTrace ?? null, this.lastWhy ?? null, this.pulsing,
+			this.ticker.length,
+		]);
+	}
+
 	/** Active embedder name for the memory-store line (Trigram default / MiniLM). */
 	private embedderName(): string {
 		// MINILM_EMBEDDER flag lives in src/config/dedup.ts; read the same env var
@@ -736,6 +810,7 @@ export class MegaRuntime {
 			cacheHitTokens: 0,
 			lengthStopPending: false,
 	};
+		this.trimCache = null; // v0.8.6: never replay a stale trim into a new session
 		this.statusKey = undefined;
 		this.activeAgents = 0;
 		this.currentTurn = 0;
@@ -887,6 +962,7 @@ export class MegaRuntime {
 				(_eventType, filename) => {
 					if (typeof filename === "string" && filename.startsWith("sqlite.db")) {
 						this.cachedGameState = undefined;
+						this.gameStateBump++;
 					}
 				},
 			);
@@ -932,6 +1008,7 @@ export class MegaRuntime {
 	 *  the panel picks up theme/mode/toggle changes live. */
 	bumpGameState(): void {
 		this.cachedGameState = undefined;
+		this.gameStateBump++;
 	}
 
 	/** S33: player level for game mode — floor(log2(turns+1))+1 (gentle).

package/package.json

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