pi-mega-compact 0.9.2 → 0.11.0

package/extensions/dashboard-server/routes-topics.ts

@@ -0,0 +1,119 @@
+/**
+ * routes-topics.ts — S51 auto-categorizing wiki topics route handler.
+ *
+ * GET /api/topics — Returns topic list with memory counts + TF-IDF labels.
+ * Read-only (PREVENT-PI-001/002); parameterized queries (PREVENT-002);
+ * pure local node:sqlite (PREVENT-PI-004).
+ */
+
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RouteContext } from "./routes-core.js";
+import { openTurnStore } from "../../src/store/turns/connection.js";
+import { createTopicStore } from "../../src/topics/store.js";
+import type { TopicsResponse, TopicRow } from "./api-contracts/game-types.js";
+import type { TopicMemoriesResponse } from "./api-contracts/turns.js";
+
+export function handleTopics(
+	req: IncomingMessage,
+	res: ServerResponse,
+	ctx: RouteContext,
+): boolean {
+	const url = req.url ?? "";
+	// ── GET /api/topics/:topicId/memories — wiki topic drill-down (S52) ──
+	const drillMatch =
+		req.method === "GET"
+			? url.match(/^\/api\/topics\/([^/?]+)\/memories$/)
+			: null;
+	if (drillMatch) {
+		try {
+			const topicId = decodeURIComponent(drillMatch[1]);
+			const store = createTopicStore(ctx.stateDir);
+			const topics = store.getTopics();
+			const topic = topics.find((t) => t.id === topicId);
+			const assignments = store.getMemoriesForTopic(topicId, 200);
+			const body: TopicMemoriesResponse = {
+				topicId,
+				label: topic?.label ?? topicId,
+				assignments: assignments.map((a) => ({
+					memoryId: a.memoryId,
+					confidence: a.confidence ?? null,
+					assignedAt: a.assignedAt ?? null,
+				})),
+			};
+			res.writeHead(200, { "Content-Type": "application/json" });
+			res.end(JSON.stringify(body));
+		} catch (e) {
+			res.writeHead(500, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: String(e) }));
+		}
+		return true;
+	}
+
+	if (url !== "/api/topics") return false;
+
+	try {
+		const tdb = openTurnStore(ctx.stateDir);
+		const topics: TopicRow[] = (
+			tdb
+				.prepare(
+					`SELECT id, label, term_scores, memory_count, last_updated
+           FROM topics ORDER BY memory_count DESC, id ASC`,
+				)
+				.all() as Array<{
+				id: string;
+				label: string;
+				term_scores: string | null;
+				memory_count: number;
+				last_updated: number | null;
+			}>
+		).map((r) => ({
+			id: r.id,
+			label: r.label,
+			memoryCount: r.memory_count,
+			lastUpdated: r.last_updated ?? 0,
+			termScore: safeParse(r.term_scores),
+		}));
+
+		const totalAssigned = (
+			tdb.prepare("SELECT COUNT(*) AS c FROM memory_topics").get() as {
+				c: number;
+			}
+		).c;
+
+		const lastRebuildAt = (
+			tdb
+				.prepare("SELECT MAX(cluster_model_built_at) AS m FROM topics")
+				.get() as { m: number | null }
+		).m;
+
+		const body: TopicsResponse = {
+			updatedAt: new Date().toISOString(),
+			totalTopics: topics.length,
+			totalAssigned,
+			lastRebuildAt,
+			topics,
+		};
+
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(JSON.stringify(body));
+	} catch (e) {
+		res.writeHead(500, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ error: String(e) }));
+	}
+
+	return true;
+}
+
+function safeParse(
+	json: string | null,
+): Array<{ term: string; score: number }> {
+	if (!json) return [];
+	try {
+		const v = JSON.parse(json) as unknown;
+		return Array.isArray(v)
+			? (v as Array<{ term: string; score: number }>)
+			: [];
+	} catch {
+		return [];
+	}
+}

package/extensions/dashboard-server/routes-turns.ts

@@ -0,0 +1,305 @@
+/**
+ * routes-turns.ts — S52 turn-by-turn memory tracking + recall + rewind routes.
+ *
+ * GET  /api/turns                         — conversation list (turns tab payload)
+ * GET  /api/turns/conversation/:convId    — per-turn detail + recall provenance
+ * GET  /api/turns/intents                 — pending rewind intents (S52A)
+ * POST /api/turns/intent                  — post a rewind intent
+ * POST /api/fork                          — fork a conversation at a turn
+ * POST /api/turns/prune                   — admin prune (capability-gated)
+ * POST /api/turns/vacuum                  — admin vacuum
+ *
+ * Capability-gated per the S49 contract: display via `asReader()`, prune/vacuum
+ * via `asAdmin()`, fork via `asWriter()`. Read-mostly. The store never calls
+ * back into the host (ledger protocol). Loopback-only (PREVENT-PI-004).
+ * Parameterized (PREVENT-002).
+ */
+
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RouteContext } from "./routes-core.js";
+import { createTurnStore } from "../../src/store/turns/index.js";
+import { openTurnStore } from "../../src/store/turns/connection.js";
+import { openIntentQueue } from "../../src/intent.js";
+import { forkFromConversation } from "../../src/fork.js";
+import type {
+	TurnsResponse,
+	ConversationTurnsResponse,
+	ConversationSummary,
+	TurnRow,
+	RecallHit,
+	RewindIntentsResponse,
+	ForkResponse,
+	PostIntentRequest,
+	PruneTurnsResponse,
+} from "./api-contracts/turns.js";
+
+function sendJson(res: ServerResponse, status: number, body: unknown): void {
+	res.writeHead(status, { "Content-Type": "application/json" }); // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+	res.end(JSON.stringify(body));
+}
+
+/** Read a capped JSON body; returns { ok, value } or { error }. */
+function readJsonBody(
+	req: IncomingMessage,
+	cb: (
+		result:
+			| { ok: true; value: Record<string, unknown> }
+			| { ok: false; error: string },
+	) => void,
+): void {
+	let body = "";
+	let tooBig = false;
+	req.on("data", (chunk: Buffer) => {
+		if (body.length > 65536) {
+			tooBig = true;
+			return;
+		}
+		body += chunk.toString();
+	});
+	req.on("end", () => {
+		if (tooBig) return cb({ ok: false, error: "body_too_large" });
+		try {
+			const v = body ? JSON.parse(body) : {};
+			if (typeof v !== "object" || v === null || Array.isArray(v)) {
+				return cb({ ok: false, error: "invalid_object" });
+			}
+			cb({ ok: true, value: v as Record<string, unknown> });
+		} catch {
+			cb({ ok: false, error: "invalid_json" });
+		}
+	});
+}
+
+export function handleTurns(
+	req: IncomingMessage,
+	res: ServerResponse,
+	ctx: RouteContext,
+): boolean {
+	const url = req.url ?? "";
+	if (!url.startsWith("/api/turns") && url !== "/api/fork") return false;
+
+	// ── GET /api/turns — conversation list ─────────────────────────────
+	if (req.method === "GET" && url === "/api/turns") {
+		try {
+			const store = createTurnStore({ stateDir: ctx.stateDir });
+			const reader = store.asReader();
+			// Enumerate conversations via session_conversations + a distinct scan.
+			const tdb = openTurnStore(ctx.stateDir);
+			const convRows = tdb
+				.prepare(
+					`SELECT DISTINCT conversation_id FROM turns ORDER BY conversation_id ASC`,
+				)
+				.all() as Array<{ conversation_id: string }>;
+			const conversations: ConversationSummary[] = convRows.map((r) => {
+				const stats = reader.conversationStats(r.conversation_id);
+				const epochCount = (
+					tdb
+						.prepare(
+							"SELECT COUNT(DISTINCT epoch_id) AS c FROM turns WHERE conversation_id = ? AND epoch_id IS NOT NULL",
+						)
+						.get(r.conversation_id) as { c: number }
+				).c;
+				const totalRecall = (
+					tdb
+						.prepare(
+							`SELECT COUNT(*) AS c FROM turn_recall tr JOIN turns t ON tr.turn_id = t.id
+							WHERE t.conversation_id = ?`,
+						)
+						.get(r.conversation_id) as { c: number }
+				).c;
+				return {
+					conversationId: r.conversation_id,
+					turnCount: stats.turnCount,
+					firstTurnAt: stats.firstTurnAt,
+					lastTurnAt: stats.lastTurnAt,
+					avgCtxPercent: stats.avgCtxPercent,
+					epochCount,
+					totalRecall,
+				};
+			});
+			// Active conversation = the one with the most recent turn across all.
+			let activeConversationId: string | null = null;
+			let lastSeen = 0;
+			for (const c of conversations) {
+				if (c.lastTurnAt > lastSeen) {
+					lastSeen = c.lastTurnAt;
+					activeConversationId = c.conversationId;
+				}
+			}
+			sendJson(res, 200, {
+				conversations,
+				activeConversationId,
+			} satisfies TurnsResponse);
+			return true;
+		} catch (e) {
+			sendJson(res, 500, { error: String(e) });
+			return true;
+		}
+	}
+
+	// ── GET /api/turns/conversation/:convId — per-turn detail + recall ─
+	const convMatch =
+		req.method === "GET"
+			? url.match(/^\/api\/turns\/conversation\/([^/?]+)$/)
+			: null;
+	if (convMatch) {
+		try {
+			const convId = decodeURIComponent(convMatch[1]);
+			const store = createTurnStore({ stateDir: ctx.stateDir });
+			const reader = store.asReader();
+			const entries = reader.query({ conversationId: convId, limit: 10000 });
+			const turns: TurnRow[] = entries.map((e) => ({
+				turnIndex: e.turnIndex,
+				conversationId: e.conversationId,
+				sessionId: e.sessionId,
+				role: e.role,
+				endedAt: e.endedAt,
+				ctxTokens: e.ctxTokens ?? null,
+				ctxPercent: e.ctxPercent ?? null,
+				pressureBand: e.pressureBand ?? null,
+				model: e.model ?? null,
+				epochId: e.epochId ?? null,
+				recall: reader.listRecallByIndex(convId, e.turnIndex).map(
+					(r): RecallHit => ({
+						checkpointId: r.checkpointId,
+						score: r.score,
+						source: r.source,
+						raptorLevel: r.raptorLevel ?? null,
+					}),
+				),
+			}));
+			sendJson(res, 200, {
+				conversationId: convId,
+				turns,
+			} satisfies ConversationTurnsResponse);
+			return true;
+		} catch (e) {
+			sendJson(res, 500, { error: String(e) });
+			return true;
+		}
+	}
+
+	// ── GET /api/turns/intents — pending rewind intents ───────────────
+	if (req.method === "GET" && url === "/api/turns/intents") {
+		try {
+			const tdb = openTurnStore(ctx.stateDir);
+			const q = openIntentQueue(tdb);
+			const intents = q.pendingIntents().map((i) => ({
+				id: i.id,
+				conversationId: i.conversationId,
+				targetTurnIndex: i.targetTurnIndex,
+				createdAt: i.createdAt,
+				status: i.status,
+			}));
+			sendJson(res, 200, { intents } satisfies RewindIntentsResponse);
+			return true;
+		} catch (e) {
+			sendJson(res, 500, { error: String(e) });
+			return true;
+		}
+	}
+
+	// ── POST /api/turns/intent — post a rewind intent ─────────────────
+	if (req.method === "POST" && url === "/api/turns/intent") {
+		readJsonBody(req, (result) => {
+			if (!result.ok) return sendJson(res, 400, { error: result.error });
+			const v = result.value;
+			const conversationId =
+				typeof v.conversationId === "string" ? v.conversationId : "";
+			const targetTurnIndex =
+				typeof v.targetTurnIndex === "number" ? v.targetTurnIndex : -1;
+			if (!conversationId || targetTurnIndex < 0) {
+				return sendJson(res, 400, {
+					error: "missing_conversationId_or_targetTurnIndex",
+				});
+			}
+			try {
+				const tdb = openTurnStore(ctx.stateDir);
+				const q = openIntentQueue(tdb);
+				const intent = q.postIntent({
+					conversationId,
+					targetTurnIndex,
+				} satisfies PostIntentRequest);
+				sendJson(res, 201, intent);
+			} catch (e) {
+				sendJson(res, 500, { error: String(e) });
+			}
+		});
+		return true;
+	}
+
+	// ── POST /api/fork — fork a conversation at a turn ─────────────────
+	if (req.method === "POST" && url === "/api/fork") {
+		readJsonBody(req, (result) => {
+			if (!result.ok) return sendJson(res, 400, { error: result.error });
+			const v = result.value;
+			const conversationId =
+				typeof v.conversationId === "string" ? v.conversationId : "";
+			const turnIndex = typeof v.turnIndex === "number" ? v.turnIndex : -1;
+			if (!conversationId || turnIndex < 0) {
+				return sendJson(res, 400, {
+					error: "missing_conversationId_or_turnIndex",
+				});
+			}
+			try {
+				const store = createTurnStore({ stateDir: ctx.stateDir });
+				const out = forkFromConversation(store, conversationId, turnIndex);
+				sendJson(res, 201, {
+					childConversationId: out.childConversationId,
+					recalledCount: out.recalled.length,
+					checkpointIds: out.checkpointIds,
+				} satisfies ForkResponse);
+			} catch (e) {
+				sendJson(res, 400, { error: String(e) });
+			}
+		});
+		return true;
+	}
+
+	// ── POST /api/turns/prune — admin prune ───────────────────────────
+	if (req.method === "POST" && url === "/api/turns/prune") {
+		readJsonBody(req, (result) => {
+			if (!result.ok) return sendJson(res, 400, { error: result.error });
+			const v = result.value;
+			const maxTurnAgeMs =
+				typeof v.maxTurnAgeMs === "number" ? v.maxTurnAgeMs : 0;
+			const keepMinPerConversation =
+				typeof v.keepMinPerConversation === "number"
+					? v.keepMinPerConversation
+					: 50;
+			if (maxTurnAgeMs <= 0) {
+				return sendJson(res, 400, { error: "invalid_maxTurnAgeMs" });
+			}
+			try {
+				const store = createTurnStore({ stateDir: ctx.stateDir });
+				const report = store.asAdmin().prune({
+					maxTurnAgeMs,
+					keepMinPerConversation,
+					vacuumAfterPrune: true,
+				});
+				sendJson(res, 200, {
+					turnsRemoved: report.turnsRemoved,
+					recallRemoved: report.recallRemoved,
+					branchesPreserved: report.branchesPreserved,
+					freedBytes: report.freedBytes,
+				} satisfies PruneTurnsResponse);
+			} catch (e) {
+				sendJson(res, 500, { error: String(e) });
+			}
+		});
+		return true;
+	}
+
+	// ── POST /api/turns/vacuum — admin vacuum ────────────────────────
+	if (req.method === "POST" && url === "/api/turns/vacuum") {
+		try {
+			createTurnStore({ stateDir: ctx.stateDir }).asAdmin().vacuum();
+			sendJson(res, 200, { ok: true });
+		} catch (e) {
+			sendJson(res, 500, { error: String(e) });
+		}
+		return true;
+	}
+
+	return false;
+}

package/extensions/dashboard-server/routes.ts

@@ -9,5 +9,12 @@ export { buildRouteContext } from "./routes-core.js";
 export type { RouteContext } from "./routes-core.js";
 
 export { handleIndex, handleRepoIndex, handleStatic } from "./routes-repo.js";
-export { handleGameState, handleGameScores, handlePerf, handleAchievements } from "./routes-game.js";
+export {
+	handleGameState,
+	handleGameScores,
+	handlePerf,
+	handleAchievements,
+} from "./routes-game.js";
 export { handleEvents, handleSessions } from "./routes-sessions.js";
+export { handleTopics } from "./routes-topics.js";
+export { handleTurns } from "./routes-turns.js";

package/extensions/dashboard-server/server.ts

@@ -34,6 +34,8 @@ import {
 	handlePerf,
 	handleAchievements,
 	handleSessions,
+	handleTopics,
+	handleTurns,
 	handleStatic,
 } from "./routes.js";
 
@@ -201,7 +203,7 @@ export async function launchDashboardServer(
 			res.setHeader("Access-Control-Allow-Origin", origin);
 			res.setHeader("Vary", "Origin");
 		}
-		res.setHeader("Access-Control-Allow-Methods", "GET, PUT, OPTIONS");
+		res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, OPTIONS");
 		res.setHeader("Access-Control-Allow-Headers", "Content-Type");
 
 		if (req.method === "OPTIONS") {
@@ -219,6 +221,8 @@ export async function launchDashboardServer(
 		if (handlePerf(req, res, ctx)) return;
 		if (handleAchievements(req, res, ctx)) return;
 		if (handleSessions(req, res, ctx)) return;
+		if (handleTopics(req, res, ctx)) return;
+		if (handleTurns(req, res, ctx)) return;
 		handleStatic(req, res, ctx);
 	});
 
@@ -320,4 +324,4 @@ if (process.argv[1] && process.argv[1].includes("dashboard-server")) {
 		console.error("[mega-compact] dashboard server failed:", err);
 		process.exit(1);
 	});
-}
+}

package/extensions/mega-compact.ts

@@ -37,65 +37,81 @@ import { registerDashboardCommands } from "./mega-dashboard-cmds.js";
 import { registerConflictCommands } from "./mega-conflict-cmds.js";
 import { registerDbCommands } from "./mega-db-cmds.js";
 import { registerGameCommands } from "./mega-game-cmds.js";
+import { registerMetricsCommands } from "./mega-metrics-cmds.js";
+import { registerTopicsCommands } from "./mega-topics-cmds.js";
 
 export default function (pi: ExtensionAPI) {
-  const config = loadConfig();
-  // S38.9: preflight env validation — check for obviously invalid values at startup.
-  // Non-fatal: log warnings and fall back to defaults.
-  if (config.autoRetryTransientMax < 0) {
-    console.warn('[mega-compact] MEGACOMPACT_AUTO_RETRY_TRANSIENT_MAX must be >= 0; using default 5');
-    config.autoRetryTransientMax = 5;
-  }
-  if (config.autoRetryPermanentMax < 0) {
-    console.warn('[mega-compact] MEGACOMPACT_AUTO_RETRY_PERMANENT_MAX must be >= 0; using default 1');
-    config.autoRetryPermanentMax = 1;
-  }
-  if (config.maxConsecutiveErrors < 1) {
-    console.warn('[mega-compact] MEGACOMPACT_MAX_CONSECUTIVE_ERRORS must be >= 1; using default 10');
-    config.maxConsecutiveErrors = 10;
-  }
-  // R2: session-global cap validation — 0 disables (valid), negative is invalid.
-  if (config.errorRetrySessionMax < 0) {
-    console.warn('[mega-compact] MEGACOMPACT_ERROR_RETRY_SESSION_MAX must be >= 0; using default 3');
-    config.errorRetrySessionMax = 3;
-  }
-  // R1: backoff base must be >= 0 (0 means no gating, useful for tests).
-  if (config.errorRetryBackoffMs < 0) {
-    console.warn('[mega-compact] MEGACOMPACT_ERROR_RETRY_BACKOFF_MS must be >= 0; using default 5000');
-    config.errorRetryBackoffMs = 5000;
-  }
-  // R3: repeat threshold must be >= 1.
-  if (config.poisonedContextRepeatThreshold < 1) {
-    console.warn('[mega-compact] MEGACOMPACT_POISONED_REPEAT_THRESHOLD must be >= 1; using default 3');
-    config.poisonedContextRepeatThreshold = 3;
-  }
-  const runtime = new MegaRuntime(config);
-  registerEventHandlers(pi, runtime, config);
-  registerCommands(pi, runtime, config);
-  registerDashboardCommands(pi, runtime);
-  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.
-  // The PGlite indexes (vectorIndex / memoryIndex) are lazily opened module
-  // singletons. closeVectorIndex()/closeMemoryIndex() existed but had no
-  // non-test callers, so a session left both open: PGlite is WASM Postgres and
-  // its handles keep node's event loop alive, so `pi -p` produced its answer
-  // and then hung until killed rather than exiting. dispose() only released the
-  // fs.watch handle and the perf interval, neither of which was the culprit
-  // (the interval is unref'd).
-  //
-  // Both closes are idempotent and safe when the index was never opened, and
-  // the next initVectorIndex()/initMemoryIndex() re-opens lazily.
-  pi.on("session_shutdown", async () => {
-    runtime.dispose();
-    await Promise.all([closeVectorIndex(), closeMemoryIndex()]);
-  });
+	const config = loadConfig();
+	// S38.9: preflight env validation — check for obviously invalid values at startup.
+	// Non-fatal: log warnings and fall back to defaults.
+	if (config.autoRetryTransientMax < 0) {
+		console.warn(
+			"[mega-compact] MEGACOMPACT_AUTO_RETRY_TRANSIENT_MAX must be >= 0; using default 5",
+		);
+		config.autoRetryTransientMax = 5;
+	}
+	if (config.autoRetryPermanentMax < 0) {
+		console.warn(
+			"[mega-compact] MEGACOMPACT_AUTO_RETRY_PERMANENT_MAX must be >= 0; using default 1",
+		);
+		config.autoRetryPermanentMax = 1;
+	}
+	if (config.maxConsecutiveErrors < 1) {
+		console.warn(
+			"[mega-compact] MEGACOMPACT_MAX_CONSECUTIVE_ERRORS must be >= 1; using default 10",
+		);
+		config.maxConsecutiveErrors = 10;
+	}
+	// R2: session-global cap validation — 0 disables (valid), negative is invalid.
+	if (config.errorRetrySessionMax < 0) {
+		console.warn(
+			"[mega-compact] MEGACOMPACT_ERROR_RETRY_SESSION_MAX must be >= 0; using default 3",
+		);
+		config.errorRetrySessionMax = 3;
+	}
+	// R1: backoff base must be >= 0 (0 means no gating, useful for tests).
+	if (config.errorRetryBackoffMs < 0) {
+		console.warn(
+			"[mega-compact] MEGACOMPACT_ERROR_RETRY_BACKOFF_MS must be >= 0; using default 5000",
+		);
+		config.errorRetryBackoffMs = 5000;
+	}
+	// R3: repeat threshold must be >= 1.
+	if (config.poisonedContextRepeatThreshold < 1) {
+		console.warn(
+			"[mega-compact] MEGACOMPACT_POISONED_REPEAT_THRESHOLD must be >= 1; using default 3",
+		);
+		config.poisonedContextRepeatThreshold = 3;
+	}
+	const runtime = new MegaRuntime(config);
+	registerEventHandlers(pi, runtime, config);
+	registerCommands(pi, runtime, config);
+	registerDashboardCommands(pi, runtime);
+	registerConflictCommands(pi, runtime);
+	registerDbCommands(pi, runtime);
+	registerMetricsCommands(pi, runtime, config);
+	registerGameCommands(pi, runtime);
+	registerTopicsCommands(pi, runtime, config);
+	// 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.
+	// The PGlite indexes (vectorIndex / memoryIndex) are lazily opened module
+	// singletons. closeVectorIndex()/closeMemoryIndex() existed but had no
+	// non-test callers, so a session left both open: PGlite is WASM Postgres and
+	// its handles keep node's event loop alive, so `pi -p` produced its answer
+	// and then hung until killed rather than exiting. dispose() only released the
+	// fs.watch handle and the perf interval, neither of which was the culprit
+	// (the interval is unref'd).
+	//
+	// Both closes are idempotent and safe when the index was never opened, and
+	// the next initVectorIndex()/initMemoryIndex() re-opens lazily.
+	pi.on("session_shutdown", async () => {
+		runtime.dispose();
+		await Promise.all([closeVectorIndex(), closeMemoryIndex()]);
+	});
 }