pi-mega-compact 0.9.0 → 0.9.2

package/extensions/mega-config.ts

@@ -147,6 +147,13 @@ export interface MegaConfig {
    *  a hit whose summary is ≥ dedupSim similar to a live message — "dedupe on
    *  inline/read" so we never re-inject context already resident. */
   windowDedupe: boolean;
+  /** Render the above-editor TUI widget (MEGACOMPACT_TUI_WIDGET). Default true.
+   *  Set to 0 to suppress the panel entirely — the widget is a persistent,
+   *  animated, full-width region that repaints on its own cadence, which fights
+   *  terminals where the user drives scrollback themselves (notably pi running
+   *  inside a Neovim `:terminal`, where every repaint yanks the view back to
+   *  the bottom). Compaction is unaffected; only the panel is suppressed. */
+  tuiWidget: boolean;
   debug: boolean;
 }
 
@@ -292,6 +299,7 @@ export function loadConfig(): MegaConfig {
     memoryReviewInterval: envFlag("MEGACOMPACT_MEMORY_REVIEW_INTERVAL", 10),
     recallMaxTokens: envFlag("MEGACOMPACT_RECALL_MAX_TOKENS", 1500),
     windowDedupe: envBool("MEGACOMPACT_WINDOW_DEDUPE", true),
+    tuiWidget: envBool("MEGACOMPACT_TUI_WIDGET", true),
     debug: envBool("MEGACOMPACT_DEBUG", false),
   };
 }

package/extensions/mega-runtime/game-state.ts

@@ -14,6 +14,8 @@ import { disposePerf, type PerfContext } from "./perf.js";
 
 export interface GameWatcherLike {
 	close(): void;
+	/** fs.FSWatcher has it; test doubles need not. */
+	unref?(): unknown;
 }
 
 export interface GameStateContext {
@@ -142,6 +144,13 @@ export function ensureGameStateWatcherImpl(self: GameStateContext, view: GameSta
 				}
 			},
 		);
+		// The watcher is a cache-eviction convenience, never a reason to stay
+		// alive: an active+referenced fs_event handle holds node's event loop
+		// open, so a runtime that was never dispose()d (every extension test, and
+		// any `pi -p` run that skips session_shutdown) hangs the process after all
+		// work is done. unref'd like the perf interval — while pi runs there are
+		// always other referenced handles, so the watcher still fires normally.
+		self.gameStateWatcher.unref?.();
 		self.gameStateWatchDir = self.currentStateDir;
 	} catch {
 		/* non-fatal: missing dir / platform issue — next snapshot re-queries */

package/extensions/mega-runtime/reset-runtime.ts

@@ -0,0 +1,88 @@
+/**
+ * reset-runtime.ts — extracted `MegaRuntime.resetRuntime()`: the per-session
+ * state reset used by the session_start / session_tree handlers. The class
+ * keeps a thin `resetRuntimeImpl(this, sessionId)` delegate so every call
+ * site is unchanged.
+ *
+ * Follows the same context-interface + free-function + thin-delegate pattern as
+ * effects.ts / game-state.ts / capture-model.ts / bind-repo.ts / perf.ts /
+ * runtime-helpers.ts.
+ */
+
+import { normalizeSessionId } from "../../src/store.js";
+import type { TickerEntry } from "./widget.js";
+import type { GameState } from "../../src/store/sqlite.js";
+import type { SessionRuntime } from "./helpers.js";
+
+// ---------------------------------------------------------------------- types
+
+/**
+ * The slice of `MegaRuntime` resetRuntime mutates. `trimCache` is typed
+ * `unknown` — this function only ever *clears* it, so the precise
+ * snapshot-cache shape does not need to be imported.
+ */
+export interface ResetRuntimeContext {
+	rt: SessionRuntime;
+	trimCache: unknown;
+	ticker: TickerEntry[];
+	cachedGameState: GameState | undefined;
+	statusKey: string | undefined;
+	activeAgents: number;
+	currentTurn: number;
+	lastActivityAt: number;
+	tierTrace: string | undefined;
+	pulsing: boolean;
+	savedGoal: number;
+	lastWhy: string | undefined;
+}
+
+// --------------------------------------------------------------- resetRuntime
+
+export function resetRuntimeImpl(
+	self: ResetRuntimeContext,
+	sessionId: string | undefined,
+): void {
+	const sid = normalizeSessionId(sessionId);
+	if (self.rt.sessionId === sid && self.rt.persistedThisSession) return; // same session, keep checkpoint memory
+	self.rt = {
+		sessionId: sid,
+		persistedThisSession: false,
+		lastCheckpointId: undefined,
+		lastCompactedFrom: 0,
+		lastCompactedTokens: 0,
+		dedupSkips: 0,
+		dedupAttempts: 0,
+		tokensSaved: 0,
+		lastCompactAt: null,
+		lastNativeCompactAt: null,
+		compactCount: 0,
+		recallInjections: 0,
+		cacheHitTokens: 0,
+		lengthStopPending: false,
+		errorRetryCount: 0,
+		errorRetryUntil: 0,
+		consecutiveErrors: 0,
+		lastErrorRetryAt: 0,
+		retryNudgePending: false,
+		errorRetrySessionCount: 0,
+		lastErrorText: undefined,
+		errorTextRepeatCount: 0,
+		poisonedAdviseSent: false,
+		poisonedCompactSignatures: new Set(),
+		poisonedCount: 0,
+	};
+	self.trimCache = null; // v0.8.6: never replay a stale trim into a new session
+	self.statusKey = undefined;
+	self.activeAgents = 0;
+	self.currentTurn = 0;
+	self.lastActivityAt = 0;
+	self.tierTrace = undefined;
+	self.ticker.length = 0;
+	self.pulsing = false;
+	self.savedGoal = 50_000;
+	self.lastWhy = undefined;
+	// S31 audit P2: symmetry with bindRepo — a reset can coincide with a context
+	// that re-binds the repo, so drop the memo too. Cheap; the next
+	// getCachedGameState() re-queries lazily.
+	self.cachedGameState = undefined;
+}

package/extensions/mega-runtime/runtime.ts

@@ -20,11 +20,22 @@ import { VectorStore } from "../../src/vectorStore.js";
 import type { toEngineMessages } from "../../src/adapt.js";
 import { normalizeSessionId } from "../../src/store.js";
 import { Logger } from "../../src/log.js";
-import type { ModelSnapshot, GameState } from "../../src/store/sqlite.js";
-import type { MegaConfig, PressureBand } from "../mega-config.js";
+import type {
+	ModelSnapshot,
+	GameState,
+} from "../../src/store/sqlite.js";
+import type {
+	MegaConfig,
+	PressureBand,
+} from "../mega-config.js";
 import { Dashboard } from "../mega-dashboard.js";
-import type { SessionRuntime } from "./helpers.js";
-import type { TickerEntry, WidgetData } from "./widget.js";
+import type {
+	SessionRuntime,
+} from "./helpers.js";
+import type {
+	TickerEntry,
+	WidgetData,
+} from "./widget.js";
 import {
 	ensureGameStateWatcherImpl,
 	getCachedGameStateImpl,
@@ -48,6 +59,7 @@ import {
 	effectiveThresholdImpl,
 	pressureBandImpl,
 } from "./pressure-getters.js";
+import { resetRuntimeImpl } from "./reset-runtime.js";
 import { appendEventImpl } from "./append-event.js";
 import { getStateDirImpl } from "./get-state-dir.js";
 import { renderWidgetImpl } from "./render-widget.js";
@@ -83,7 +95,6 @@ export class MegaRuntime {
 		errorRetryCount: 0,
 		errorRetryUntil: 0,
 		consecutiveErrors: 0,
-		// R1-R3 (retry redesign): in-flight dedup, session cap, poisoned-context state.
 		lastErrorRetryAt: 0,
 		retryNudgePending: false,
 		errorRetrySessionCount: 0,
@@ -122,12 +133,7 @@ export class MegaRuntime {
 	 *  compaction start). Threaded into widgetData as `activeEffect`; the widget
 	 *  computes the per-frame phase from startedAt vs Date.now() (non-expired).
 	 *  Null when idle/expired. */
-	activeEffect: {
-		type: "pulse" | "flash";
-		role: "accent" | "mega" | "red";
-		startedAt: number;
-		durationMs: number;
-	} | null = null;
+	activeEffect: { type: "pulse" | "flash"; role: "accent" | "mega" | "red"; startedAt: number; durationMs: number } | null = null;
 	megaCacheFlarePct = 0;
 	levelUpFlare = false;
 	lastLevel = 0;
@@ -307,8 +313,14 @@ export class MegaRuntime {
 	}
 
 	/** Width-aware above-editor widget factory registration — thin delegate to
-	 *  `renderWidgetImpl` (render-widget.ts). */
+	 *  `renderWidgetImpl` (render-widget.ts).
+	 *
+	 *  Gated on `config.tuiWidget` (MEGACOMPACT_TUI_WIDGET=0 to disable). This
+	 *  is the single chokepoint every caller funnels through, so returning here
+	 *  means setWidget is never called and the panel is never registered — as
+	 *  opposed to registering an empty one, which would still occupy a row. */
 	renderWidget(ctx: ExtensionContext): void {
+		if (!this.config.tuiWidget) return;
 		renderWidgetImpl(this, ctx);
 	}
 
@@ -318,54 +330,10 @@ export class MegaRuntime {
 		setStatusImpl(this, ctx, text);
 	}
 
-	/** Per-session state reset (session_start / session_tree) — inlined by the
-	 *  raptor-promotion merge (R1–R3 retry-redesign fields); reset-runtime.ts was
-	 *  retired by that branch. */
+	/** Per-session state reset (session_start / session_tree) — thin delegate to
+	 *  `resetRuntimeImpl` (reset-runtime.ts). */
 	resetRuntime(sessionId: string | undefined): void {
-		const sid = normalizeSessionId(sessionId);
-		if (this.rt.sessionId === sid && this.rt.persistedThisSession) return; // same session, keep checkpoint memory
-		this.rt = {
-			sessionId: sid,
-			persistedThisSession: false,
-			lastCheckpointId: undefined,
-			lastCompactedFrom: 0,
-			lastCompactedTokens: 0,
-			dedupSkips: 0,
-			dedupAttempts: 0,
-			tokensSaved: 0,
-			lastCompactAt: null,
-			lastNativeCompactAt: null,
-			compactCount: 0,
-			recallInjections: 0,
-			cacheHitTokens: 0,
-			lengthStopPending: false,
-			errorRetryCount: 0,
-			errorRetryUntil: 0,
-			consecutiveErrors: 0,
-			// R1-R3 (retry redesign): in-flight dedup, session cap, poisoned-context state.
-			lastErrorRetryAt: 0,
-			retryNudgePending: false,
-			errorRetrySessionCount: 0,
-			lastErrorText: undefined,
-			errorTextRepeatCount: 0,
-			poisonedAdviseSent: false,
-			poisonedCompactSignatures: new Set(),
-			poisonedCount: 0,
-		};
-		this.trimCache = null; // v0.8.6: never replay a stale trim into a new session
-		this.statusKey = undefined;
-		this.activeAgents = 0;
-		this.currentTurn = 0;
-		this.lastActivityAt = 0;
-		this.tierTrace = undefined;
-		this.ticker.length = 0;
-		this.pulsing = false;
-		this.savedGoal = 50_000;
-		this.lastWhy = undefined;
-		// S31 audit P2: symmetry with bindRepo — a reset can coincide with a context
-		// that re-binds the repo, so drop the memo too. Cheap; the next
-		// getCachedGameState() re-queries lazily.
-		this.cachedGameState = undefined;
+		resetRuntimeImpl(this, sessionId);
 	}
 
 	captureModel(ctx: ExtensionContext): void {

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

@@ -0,0 +1,141 @@
+/**
+ * mega-shutdown-widget.test.ts — regression cover for two host-integration
+ * fixes that the rest of the suite cannot see, because both are about what
+ * happens at the boundary with pi rather than inside the compaction engine:
+ *
+ *  1. session_shutdown must close the PGlite indexes. They are lazily-opened
+ *     module singletons whose handles keep node's event loop alive, so leaving
+ *     them open made `pi -p` produce its answer and then hang instead of
+ *     exiting. closeVectorIndex()/closeMemoryIndex() existed but had no
+ *     non-test callers.
+ *
+ *  2. The above-editor widget must be suppressible. It is a persistent,
+ *     animated, full-width panel that repaints on its own cadence, which fights
+ *     terminals where the user drives scrollback (pi inside a Neovim
+ *     `:terminal`). MEGACOMPACT_TUI_WIDGET=0 turns it off without touching
+ *     compaction.
+ */
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+	closeVectorIndex,
+	initVectorIndex,
+	isVectorIndexDisabled,
+} from "../src/store/vectorIndex.js";
+import { closeMemoryIndex } from "../src/store/memoryIndex.js";
+import { loadConfig } from "./mega-config.js";
+import { MegaRuntime } from "./mega-runtime.js";
+
+const baseTmp = mkdtempSync(join(tmpdir(), "mc-shutdown-"));
+process.env.MEGACOMPACT_INDEX_DIR = join(baseTmp, "index");
+let counter = 0;
+
+/** Fresh per-test state dir so concurrent runs never collide on disk. */
+function isolate(): void {
+	process.env.MEGACOMPACT_STATE_DIR = join(baseTmp, `run-${counter++}`);
+}
+
+/** Minimal ExtensionContext slice: renderWidget only reaches ctx.ui.setWidget. */
+function widgetCtx(calls: string[]): any {
+	return {
+		ui: {
+			setWidget: (key: string) => calls.push(key),
+		},
+	};
+}
+
+test.after(async () => {
+	// This file is itself a demonstration of the bug under test: without these
+	// closes the PGlite handles opened above keep the event loop alive and the
+	// test process never exits.
+	await Promise.all([closeVectorIndex(), closeMemoryIndex()]);
+	rmSync(baseTmp, { recursive: true, force: true });
+});
+
+test("MEGACOMPACT_TUI_WIDGET defaults on and is disabled by 0", () => {
+	isolate();
+	delete process.env.MEGACOMPACT_TUI_WIDGET;
+	assert.equal(loadConfig().tuiWidget, true, "widget should default to on");
+
+	process.env.MEGACOMPACT_TUI_WIDGET = "0";
+	assert.equal(loadConfig().tuiWidget, false);
+
+	process.env.MEGACOMPACT_TUI_WIDGET = "1";
+	assert.equal(loadConfig().tuiWidget, true);
+
+	delete process.env.MEGACOMPACT_TUI_WIDGET;
+});
+
+test("renderWidget registers the panel when tuiWidget is on", () => {
+	isolate();
+	delete process.env.MEGACOMPACT_TUI_WIDGET;
+	const runtime = new MegaRuntime(loadConfig());
+	try {
+		const calls: string[] = [];
+		runtime.renderWidget(widgetCtx(calls));
+		assert.equal(calls.length, 1, "expected one setWidget registration");
+	} finally {
+		runtime.dispose();
+	}
+});
+
+test("renderWidget registers nothing when tuiWidget is off", () => {
+	isolate();
+	process.env.MEGACOMPACT_TUI_WIDGET = "0";
+	const runtime = new MegaRuntime(loadConfig());
+	try {
+		const calls: string[] = [];
+		// Repeated calls, because the panel is re-registered on every snapshot
+		// and every game-state change — one guarded path is not enough.
+		runtime.renderWidget(widgetCtx(calls));
+		runtime.renderWidget(widgetCtx(calls));
+		assert.deepEqual(calls, [], "widget must never be registered when disabled");
+	} finally {
+		runtime.dispose();
+		delete process.env.MEGACOMPACT_TUI_WIDGET;
+	}
+});
+
+test("the extension's session_shutdown handler awaits index teardown", async () => {
+	isolate();
+	const handlers: Record<string, Function[]> = {};
+	const pi: any = {
+		on(event: string, handler: Function) {
+			(handlers[event] ??= []).push(handler);
+		},
+		registerCommand() {},
+		registerProvider() {},
+	};
+
+	const { default: extension } = await import("./mega-compact.js");
+	extension(pi);
+
+	const shutdown = handlers["session_shutdown"] ?? [];
+	assert.ok(shutdown.length, "extension must register a session_shutdown handler");
+
+	const event = { type: "session_shutdown" } as any;
+	const ctx = {
+		ui: { setStatus: () => {}, notify: () => {}, setWidget: () => {} },
+		cwd: process.env.MEGACOMPACT_STATE_DIR,
+	} as any;
+
+	// Assert the close by identity rather than by "some handler returned a
+	// promise": several modules register on session_shutdown and at least one
+	// other is already async, so a promise proves nothing about teardown. The
+	// index is a module singleton, so if shutdown really closed it, re-init
+	// hands back a *different* instance.
+	const before = await initVectorIndex();
+	if (isVectorIndexDisabled() || !before) return; // PGlite unavailable — nothing to close
+
+	await Promise.all(shutdown.map((handler) => handler(event, ctx)));
+
+	const after = await initVectorIndex();
+	assert.notEqual(after, before, "session_shutdown must close the PGlite vector index");
+
+	// Idempotent: a second shutdown (reload, double-fire) must not throw.
+	await Promise.all(shutdown.map((handler) => handler(event, ctx)));
+});

package/package.json

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