pi-mega-compact 0.8.4 → 0.8.5

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-runtime/state.js

@@ -119,6 +119,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;
@@ -253,6 +264,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 +305,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 +623,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 +637,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
@@ -803,6 +861,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 +908,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-runtime/state.ts

@@ -158,6 +158,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;
@@ -303,6 +314,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 +355,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 +691,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 +716,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
@@ -887,6 +946,7 @@ export class MegaRuntime {
 				(_eventType, filename) => {
 					if (typeof filename === "string" && filename.startsWith("sqlite.db")) {
 						this.cachedGameState = undefined;
+						this.gameStateBump++;
 					}
 				},
 			);
@@ -932,6 +992,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.5",
   "description": "Layered, local, vector-backed context compressor for pi — supersede/collapse/cluster compaction with deduped inline recall.",
   "type": "module",
   "license": "BSD-2-Clause",