pi-mega-compact 0.13.4 → 0.13.6

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

@@ -0,0 +1,376 @@
+/**
+ * dashboard-server/routes-wiki.ts — W2 wiki revival routes (curation + provenance).
+ *
+ * GET  /api/wiki/index                     — topics with resolved labels
+ * GET  /api/wiki/evolution                 — D3 nodes/edges/time buckets
+ * GET  /api/wiki/topic/:topicId            — single topic page + provenance
+ * GET  /api/wiki/topic/:topicId/timeline   — per-topic time buckets
+ * PUT  /api/wiki/topic/:topicId/label      — rename (emits wiki_topic_renamed)
+ * POST /api/wiki/merge                     — merge (emits wiki_topics_merged)
+ * POST /api/wiki/topic/:topicId/split      — split (emits wiki_topic_split)
+ *
+ * Flag-gated by MEGACOMPACT_WIKI_ENHANCED (flag-OFF → 404 for all /api/wiki/*).
+ * Read/build helpers live in routes-wiki-helpers.ts (pointer-file split).
+ * Loopback-only (PREVENT-PI-004); parameterized (PREVENT-002); no `any`.
+ */
+
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RouteContext } from "./routes-core.js";
+import { TurnsConfig } from "../../src/config/turns.js";
+import { openTurnStore } from "../../src/store/turns/connection.js";
+import { createTopicStore } from "../../src/topics/store.js";
+import { extractiveSummary } from "../../src/wiki.js";
+import { createWikiCuration } from "../../src/wiki/curation.js";
+import {
+	emitWikiEvent,
+	ensureWikiBuilt,
+	toIndexEntry,
+	toProvenance,
+	bucketize,
+	memberContent,
+} from "./routes-wiki-helpers.js";
+import type {
+	WikiIndexResponse,
+	WikiPageResponse,
+	TopicEvolutionResponse,
+	TopicTimelineResponse,
+	CurationResult,
+} from "./api-contracts/wiki.js";
+
+function sendJson(res: ServerResponse, status: number, body: unknown): void {
+	// guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+	res.writeHead(status, { "Content-Type": "application/json" });
+	res.end(JSON.stringify(body));
+}
+
+/** Decode a percent-encoded path segment; null on malformed encoding (%zz). */
+function decodeSegment(raw: string): string | null {
+	try {
+		return decodeURIComponent(raw);
+	} catch {
+		return null;
+	}
+}
+
+/** 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 handleWiki(
+	req: IncomingMessage,
+	res: ServerResponse,
+	ctx: RouteContext,
+): boolean {
+	const url = req.url ?? "";
+	if (!url.startsWith("/api/wiki")) return false;
+
+	// Flag gate: feature-OFF → 404 for every wiki endpoint.
+	if (!TurnsConfig.WIKI_ENHANCED_ENABLED) {
+		sendJson(res, 404, { error: "wiki_enhanced_disabled" });
+		return true;
+	}
+
+	// ── GET /api/wiki/index ──────────────────────────────────────────
+	if (req.method === "GET" && url === "/api/wiki/index") {
+		try {
+			const tdb = openTurnStore(ctx.stateDir);
+			ensureWikiBuilt(ctx, tdb);
+			const store = createTopicStore(ctx.stateDir);
+			const curation = createWikiCuration(ctx.stateDir);
+			const entries = store.getTopics().map((t) => toIndexEntry(t, curation));
+			const totalMemories = entries.reduce((s, e) => s + e.memoryCount, 0);
+			const lastRebuildAt =
+				entries.length > 0 ? Math.max(...entries.map((e) => e.lastUpdated)) : null;
+			const body: WikiIndexResponse = {
+				topics: entries,
+				totalTopics: entries.length,
+				totalMemories,
+				lastRebuildAt,
+			};
+			sendJson(res, 200, body);
+		} catch (e) {
+			sendJson(res, 500, { error: String(e) });
+		}
+		return true;
+	}
+
+	// ── GET /api/wiki/evolution ──────────────────────────────────────
+	if (req.method === "GET" && url === "/api/wiki/evolution") {
+		try {
+			const tdb = openTurnStore(ctx.stateDir);
+			const curation = createWikiCuration(ctx.stateDir);
+			const nodes = createTopicStore(ctx.stateDir)
+				.getTopics()
+				.map((t) => ({
+					id: t.id,
+					label: curation.resolveLabel(t.id, t.label).label,
+					memoryCount: t.memoryCount,
+				}));
+			const overrides = tdb
+				.prepare(
+					`SELECT kind, topic_id, merged_into, split_from, overridden_at
+					 FROM topic_overrides WHERE kind IN ('merge','split')`,
+				)
+				.all() as Array<{
+				kind: string;
+				topic_id: string;
+				merged_into: string | null;
+				split_from: string | null;
+				overridden_at: number;
+			}>;
+			const edges = overrides.flatMap(
+				(o): TopicEvolutionResponse["edges"][number][] => {
+					if (o.kind === "merge" && o.merged_into) {
+						return [
+							{
+								source: o.topic_id,
+								target: o.merged_into,
+								kind: "merge",
+								at: o.overridden_at,
+							},
+						];
+					}
+					if (o.kind === "split" && o.split_from) {
+						return [
+							{
+								source: o.split_from,
+								target: o.topic_id,
+								kind: "split",
+								at: o.overridden_at,
+							},
+						];
+					}
+					return [];
+				},
+			);
+			const evoRows = tdb
+				.prepare("SELECT assigned_at FROM topic_evolution")
+				.all() as Array<{ assigned_at: number }>;
+			const body: TopicEvolutionResponse = {
+				nodes,
+				edges,
+				buckets: bucketize(evoRows.map((r) => r.assigned_at)),
+			};
+			sendJson(res, 200, body);
+		} catch (e) {
+			sendJson(res, 500, { error: String(e) });
+		}
+		return true;
+	}
+
+	// ── GET /api/wiki/topic/:topicId/timeline ────────────────────────
+	const timelineMatch =
+		req.method === "GET"
+			? url.match(/^\/api\/wiki\/topic\/([^/?]+)\/timeline$/)
+			: null;
+	if (timelineMatch) {
+		const topicId = decodeSegment(timelineMatch[1]);
+		if (topicId === null) {
+			sendJson(res, 400, { error: "malformed_topic_id" });
+			return true;
+		}
+		try {
+			const tdb = openTurnStore(ctx.stateDir);
+			const rows = tdb
+				.prepare("SELECT assigned_at FROM memory_topics WHERE topic_id = ?")
+				.all(topicId) as Array<{ assigned_at: number }>;
+			const body: TopicTimelineResponse = {
+				topicId,
+				buckets: bucketize(rows.map((r) => r.assigned_at)),
+				total: rows.length,
+			};
+			sendJson(res, 200, body);
+		} catch (e) {
+			sendJson(res, 500, { error: String(e) });
+		}
+		return true;
+	}
+
+	// ── GET /api/wiki/topic/:topicId ─────────────────────────────────
+	const topicMatch =
+		req.method === "GET" ? url.match(/^\/api\/wiki\/topic\/([^/?]+)$/) : null;
+	if (topicMatch) {
+		const topicId = decodeSegment(topicMatch[1]);
+		if (topicId === null) {
+			sendJson(res, 400, { error: "malformed_topic_id" });
+			return true;
+		}
+		try {
+			const store = createTopicStore(ctx.stateDir);
+			const topic = store.getTopics().find((t) => t.id === topicId);
+			if (!topic) {
+				sendJson(res, 404, { error: "topic_not_found" });
+				return true;
+			}
+			const members = store.getMemoriesForTopic(topicId, 200);
+			const content = memberContent(ctx, members);
+			const getText = (memId: string): string => content.get(memId)?.text ?? "";
+			const summary = extractiveSummary(topic, members, getText);
+			const present = members.filter((m) => content.has(m.memoryId));
+			const keyMemories = [...present]
+				.sort(
+					(a, b) =>
+						(content.get(b.memoryId)?.text.length ?? 0) -
+						(content.get(a.memoryId)?.text.length ?? 0),
+				)
+				.slice(0, 10)
+				.map((m) => ({
+					memoryId: m.memoryId,
+					content: content.get(m.memoryId)?.text ?? "",
+					timestamp: content.get(m.memoryId)?.timestamp ?? 0,
+					importance: Math.round(
+						(content.get(m.memoryId)?.text.length ?? 0) / 40,
+					),
+				}));
+			const relatedTopicIds = store
+				.getTopics()
+				.filter((t) => t.id !== topicId && t.memoryCount > 0)
+				.slice(0, 3)
+				.map((t) => t.id);
+			const body: WikiPageResponse = {
+				topic: toIndexEntry(topic, createWikiCuration(ctx.stateDir)),
+				summary,
+				keyMemories,
+				provenance: members.map(toProvenance),
+				relatedTopicIds,
+				generatedAt: Date.now(),
+			};
+			sendJson(res, 200, body);
+		} catch (e) {
+			sendJson(res, 500, { error: String(e) });
+		}
+		return true;
+	}
+
+	// ── PUT /api/wiki/topic/:topicId/label ───────────────────────────
+	const renameMatch =
+		req.method === "PUT"
+			? url.match(/^\/api\/wiki\/topic\/([^/?]+)\/label$/)
+			: null;
+	if (renameMatch) {
+		readJsonBody(req, (result) => {
+			if (!result.ok) return sendJson(res, 400, { error: result.error });
+			const topicId = decodeSegment(renameMatch[1]);
+			if (topicId === null) return sendJson(res, 400, { error: "malformed_topic_id" });
+			const label = typeof result.value.label === "string" ? result.value.label : "";
+			try {
+				const curation = createWikiCuration(ctx.stateDir);
+				const out = curation.renameTopic(topicId, label);
+				if (!out.ok) return sendJson(res, 404, { error: "topic_not_found" });
+				emitWikiEvent(ctx, {
+					type: "wiki_topic_renamed",
+					topicId,
+					label: out.label,
+					edited: out.edited,
+				});
+				sendJson(res, 200, out satisfies CurationResult);
+			} catch (e) {
+				sendJson(res, 500, { error: String(e) });
+			}
+		});
+		return true;
+	}
+
+	// ── POST /api/wiki/merge ─────────────────────────────────────────
+	if (req.method === "POST" && url === "/api/wiki/merge") {
+		readJsonBody(req, (result) => {
+			if (!result.ok) return sendJson(res, 400, { error: result.error });
+			const sourceTopicId =
+				typeof result.value.sourceTopicId === "string"
+					? result.value.sourceTopicId
+					: "";
+			const targetTopicId =
+				typeof result.value.targetTopicId === "string"
+					? result.value.targetTopicId
+					: "";
+			if (!sourceTopicId || !targetTopicId) {
+				return sendJson(res, 400, { error: "missing_source_or_target" });
+			}
+			try {
+				const curation = createWikiCuration(ctx.stateDir);
+				const out = curation.mergeTopics(sourceTopicId, targetTopicId);
+				if (!out.ok) {
+					return sendJson(res, 400, {
+						error:
+							sourceTopicId === targetTopicId
+								? "cannot_merge_into_itself"
+								: "topic_not_found",
+					});
+				}
+				emitWikiEvent(ctx, {
+					type: "wiki_topics_merged",
+					sourceTopicId,
+					targetTopicId,
+				});
+				sendJson(res, 200, out satisfies CurationResult);
+			} catch (e) {
+				sendJson(res, 500, { error: String(e) });
+			}
+		});
+		return true;
+	}
+
+	// ── POST /api/wiki/topic/:topicId/split ──────────────────────────
+	const splitMatch =
+		req.method === "POST"
+			? url.match(/^\/api\/wiki\/topic\/([^/?]+)\/split$/)
+			: null;
+	if (splitMatch) {
+		readJsonBody(req, (result) => {
+			if (!result.ok) return sendJson(res, 400, { error: result.error });
+			const topicId = decodeSegment(splitMatch[1]);
+			if (topicId === null) return sendJson(res, 400, { error: "malformed_topic_id" });
+			const raw = result.value.memoryIds;
+			const memoryIds = Array.isArray(raw)
+				? raw.filter((m): m is string => typeof m === "string")
+				: [];
+			if (memoryIds.length === 0) {
+				return sendJson(res, 400, { error: "empty_memoryIds" });
+			}
+			try {
+				const curation = createWikiCuration(ctx.stateDir);
+				const out = curation.splitTopic(topicId, memoryIds);
+				if (!out.ok) return sendJson(res, 404, { error: "topic_not_found" });
+				emitWikiEvent(ctx, {
+					type: "wiki_topic_split",
+					fromTopicId: topicId,
+					toTopicId: out.topicId,
+				});
+				sendJson(res, 200, out satisfies CurationResult);
+			} catch (e) {
+				sendJson(res, 500, { error: String(e) });
+			}
+		});
+		return true;
+	}
+
+	return false;
+}

package/extensions/dashboard-server/routes.ts

@@ -28,3 +28,5 @@ export { handleCacheStripes } from "./routes-cache.js";
 export { handleContextHealth, handleCachePoison, handleHealthSettings } from "./routes-health.js";
 export { handleEmbedderHealth } from "./routes-embedder-health.js";
 export { handleRagSettings } from "./routes-rag-settings.js";
+export { handleRagMetrics } from "./routes-rag-metrics.js";
+export { handleWiki } from "./routes-wiki.js";

package/extensions/dashboard-server/server.ts

@@ -23,6 +23,7 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 
+import { NEW_UI } from "../../src/config.js";
 import { log, setLogPath, setDashboardServerVersion } from "./state.js";
 import {
 	buildRouteContext,
@@ -50,6 +51,8 @@ import {
 	handleHealthSettings,
 	handleEmbedderHealth,
 	handleRagSettings,
+	handleRagMetrics,
+	handleWiki,
 	handleStatic,
 } from "./routes.js";
 
@@ -119,6 +122,15 @@ export async function launchDashboardServer(
 	const hasClientBuild = existsSync(clientIndexHtml);
 	if (hasClientBuild) log("client build present", { clientDist });
 
+	function injectUiFlag(html: string): string {
+		const flag = NEW_UI() ? "true" : "false";
+		const script = `<script>window.MEGACOMPACT_NEW_UI=${flag}</script>`;
+		if (html.includes("</head>")) {
+			return html.replace("</head>", `${script}</head>`);
+		}
+		return html + script;
+	}
+
 	// guardrails-allow PREVENT-PI-004: read-only static file serving from the local dashboard-client/dist bundle (loopback-only UI).
 	const serveClientAsset = (reqPath: string, res: ServerResponse): boolean => {
 		if (!hasClientBuild) return false;
@@ -131,7 +143,7 @@ export async function launchDashboardServer(
 		if (!file.startsWith(clientDist) || !existsSync(file)) {
 			// SPA fallback: unknown non-asset routes serve index.html (client-side routing).
 			res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-			res.end(readFileSync(clientIndexHtml));
+			res.end(injectUiFlag(readFileSync(clientIndexHtml, "utf-8")));
 			return true;
 		}
 		const ext = rel.slice(rel.lastIndexOf(".") + 1);
@@ -145,10 +157,12 @@ export async function launchDashboardServer(
 			ico: "image/x-icon",
 			map: "application/json",
 		};
+		const payload: string | Uint8Array =
+			ext === "html" ? injectUiFlag(readFileSync(file, "utf-8")) : readFileSync(file);
 		res.writeHead(200, {
 			"Content-Type": types[ext] ?? "application/octet-stream",
 		});
-		res.end(readFileSync(file));
+		res.end(payload);
 		return true;
 	};
 
@@ -251,6 +265,8 @@ export async function launchDashboardServer(
 		if (handleHealthSettings(req, res, ctx)) return;
 		if (handleEmbedderHealth(req, res, ctx)) return;
 		if (handleRagSettings(req, res, ctx)) return;
+		if (handleRagMetrics(req, res, ctx)) return;
+		if (handleWiki(req, res, ctx)) return;
 		handleStatic(req, res, ctx);
 	});
 

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

@@ -21,7 +21,10 @@ import {
 	buildTopicModel,
 	createTopicStore,
 	bumpWikiCompactCounter,
+	applyOverridesAfterRebuild,
+	applyFullOverridesAfterRebuild,
 } from "../../../src/topics/index.js";
+import { assignNewMemoriesIncremental } from "../../../src/wiki/index.js";
 import { TrigramEmbedder } from "../../../src/embedder.js";
 import type { EmbeddedChunk } from "../../../src/topics/types.js";
 import type { MegaConfig } from "../../mega-config.js";
@@ -89,7 +92,36 @@ export async function persistEpochAndMaintain(
 					);
 					const tdb = openTurnStore(runtime.currentStateDir);
 					const n = bumpWikiCompactCounter(tdb);
-					if (n % every === 0) {
+					// W5-B: on the Nth compact we full-rebuild; otherwise try the
+					// cheap incremental path (assign new memories to nearest
+					// centroid) and only force a full rebuild when the mean
+					// silhouette has degraded below the configured floor.
+					let rebuildNow = n % every === 0;
+					if (
+						!rebuildNow &&
+						TurnsConfig.WIKI_INCREMENTAL_ENABLED &&
+						TurnsConfig.WIKI_ENHANCED_ENABLED
+					) {
+						const inc = assignNewMemoriesIncremental(
+							db,
+							runtime.currentStateDir,
+						);
+						if (
+							inc.silhouette !== null &&
+							inc.silhouette < TurnsConfig.WIKI_INCREMENTAL_SILHOUETTE_MIN
+						) {
+							// Silhouette degraded — fall through to a full rebuild.
+							rebuildNow = true;
+						} else {
+							runtime.logger.info("wiki_incremental", {
+								assigned: inc.assigned,
+								pending: inc.pending,
+								silhouetteScore: inc.silhouette,
+								uncalibrated: false,
+							});
+						}
+					}
+					if (rebuildNow) {
 						const model = buildTopicModel(db, {
 							kRange: [TurnsConfig.WIKI_K_MIN, TurnsConfig.WIKI_K_MAX],
 							labelTopTerms: TurnsConfig.WIKI_LABEL_TOP_TERMS,
@@ -99,6 +131,13 @@ export async function persistEpochAndMaintain(
 						createTopicStore(runtime.currentStateDir).replaceTopicModel(
 							model,
 						);
+						// W5-A: full hybrid replay — label + merge + split overrides
+						// survive the rebuild (feature A, not just the label fast path).
+						applyFullOverridesAfterRebuild(tdb);
+						// SSE push so the dashboard Wiki/Evolution views refresh (non-fatal).
+						runtime.dashboard.event("wiki_rebuilt", {
+							topicCount: model.k,
+						});
 						runtime.logger.info("wiki_rebuild", {
 							clusterCount: model.k,
 							totalChunks: model.totalChunks,
@@ -177,6 +216,10 @@ export async function persistEpochAndMaintain(
 								createTopicStore(
 									runtime.currentStateDir,
 								).replaceTopicModel(model);
+								// Re-stamp custom label overrides wiped by the seed rebuild.
+								applyOverridesAfterRebuild(
+									openTurnStore(runtime.currentStateDir),
+								);
 								runtime.logger.info("wiki_seed", {
 									clusterCount: model.k,
 									sourceChunks: seedChunks.length,

package/extensions/mega-pipeline/recall.ts

@@ -66,6 +66,32 @@ export function doRecall(
 		injected: result.toInject.length,
 		empty: result.empty,
 	});
+	if (config.ragRecallMetrics && result.hydeInfo) {
+		runtime.dashboard.event("hyde_executed", {
+			sessionId: sid,
+			ran: result.hydeInfo.ran,
+			skipped: result.hydeInfo.skipped,
+			reason: result.hydeInfo.reason,
+			hypotheticalDoc: result.hydeInfo.hypotheticalDoc.slice(0, 400),
+			generationMs: result.hydeInfo.generationMs,
+			rawHitCount: result.hydeInfo.rawHitCount,
+			hydeHitCount: result.hydeInfo.hydeHitCount,
+			fusedHitCount: result.hydeInfo.fusedHitCount,
+			lift: result.hydeInfo.lift,
+		});
+	}
+	if (config.ragRecallMetrics && result.recallMetrics) {
+		runtime.dashboard.event("recall_metrics", {
+			sessionId: sid,
+			hitCount: result.recallMetrics.hitCount,
+			score: result.recallMetrics.score,
+			pass: result.recallMetrics.pass,
+			relevance: result.recallMetrics.relevance,
+			coverage: result.recallMetrics.coverage,
+			diversity: result.recallMetrics.diversity,
+			specificity: result.recallMetrics.specificity,
+		});
+	}
 	if (!result.empty && result.toInject.length > 0) {
 		const top = result.toInject[0];
 		const scorePct = Math.round((top.score ?? 0) * 100);
@@ -105,6 +131,8 @@ export function doRecall(
 					turnIndex: runtime.currentTurn,
 					role: "assistant",
 					startedAt: Date.now(),
+					hyde: result.hydeInfo ?? undefined,
+					recallMetrics: result.recallMetrics ?? undefined,
 				},
 				runtime.currentStateDir,
 			);
@@ -229,6 +257,9 @@ export async function doRecallAsync(
 			),
 			block,
 			empty: merged.length === 0,
+			// H1: merged cross-repo result reuses the same-repo pass's telemetry.
+			hydeInfo: sameRepo.hydeInfo,
+			recallMetrics: sameRepo.recallMetrics,
 		};
 	} catch {
 		return sameRepo; // cross-repo failure → same-repo only (non-fatal)

package/extensions/mega-turn-store.ts

@@ -14,6 +14,8 @@ import {
 	type TurnStore,
 	type TurnEntry,
 	type TurnRecallEntry,
+	type TurnHydeTelemetry,
+	type TurnRecallTelemetry,
 } from "../src/store/turns/index.js";
 import {
 	recordTurn as legacyRecordTurn,
@@ -64,6 +66,11 @@ export function ensureConversationIdFor(
 }
 
 /** Record one turn row (turn_end). Returns the contract TurnId (string). */
+/** H1: HyDE telemetry write — a structural subset of HydeInvocationInfo. */
+export type RecallHydeWrite = TurnHydeTelemetry;
+/** H1: recall-quality write — a structural subset of RecallMetricsSnapshot. */
+export type RecallMetricsWrite = TurnRecallTelemetry;
+
 export function recordTurnWrite(
 	config: MegaConfig,
 	input: {
@@ -78,6 +85,10 @@ export function recordTurnWrite(
 		pressureBand?: string;
 		modelId?: string;
 		epochId?: string;
+		/** H1: HyDE invocation telemetry (persisted to hyde_* columns). */
+		hyde?: RecallHydeWrite;
+		/** H1: recall-quality snapshot (persisted to recall_* columns). */
+		recallMetrics?: RecallMetricsWrite;
 	},
 	stateDir: string,
 ): string {
@@ -96,6 +107,8 @@ export function recordTurnWrite(
 		pressureBand: input.pressureBand as TurnEntry["pressureBand"],
 		model: input.modelId,
 		epochId: input.epochId,
+		hyde: input.hyde,
+		recallMetrics: input.recallMetrics,
 	};
 	return storeFor(stateDir).appendTurn(entry);
 }

package/package.json

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

package/src/config/turns.ts

@@ -23,6 +23,14 @@ function envNum(name: string, def: number): number {
 	return Number.isFinite(n) ? n : def;
 }
 
+/** Default-ON toggle honoring the MEGACOMPACT_<NAME>_DISABLED opt-out convention. */
+function envEnabled(name: string, def: boolean): boolean {
+	if (process.env[`${name}_DISABLED`] === "true" || process.env[`${name}_DISABLED`] === "1") {
+		return false;
+	}
+	return envBool(name, def);
+}
+
 export interface TurnsConfigShape {
 	/** Isolated turns.db store enabled (default true). OFF = legacy main-db path. */
 	TURNS_DB_ENABLED: boolean;
@@ -41,6 +49,12 @@ export interface TurnsConfigShape {
 	WIKI_REBUILD_EVERY_N_COMPACTS: number;
 	/** D1: seed the topic model from raw_transcript when context_chunks is thin (default true). */
 	WIKI_SEED_FROM_TURNS: boolean;
+	/** W2: wiki revival curation + provenance endpoints. Default ON; off via MEGACOMPACT_WIKI_ENHANCED_DISABLED. */
+	WIKI_ENHANCED_ENABLED: boolean;
+	/** W5: incremental topic assignment for new memories (default ON when WIKI_ENHANCED is ON). */
+	WIKI_INCREMENTAL_ENABLED: boolean;
+	/** W5: full rebuild triggers when mean silhouette drops below this (default 0.2). */
+	WIKI_INCREMENTAL_SILHOUETTE_MIN: number;
 }
 
 function envKRange(defMin: number, defMax: number): [number, number] {
@@ -66,6 +80,9 @@ export function loadTurnsConfig(): TurnsConfigShape {
 		WIKI_LABEL_TOP_TERMS: envNum("MEGACOMPACT_WIKI_LABEL_TOP_TERMS", 5),
 		WIKI_REBUILD_EVERY_N_COMPACTS: envNum("MEGACOMPACT_WIKI_REBUILD_EVERY", 3),
 		WIKI_SEED_FROM_TURNS: envBool("MEGACOMPACT_WIKI_SEED_FROM_TURNS", true),
+		WIKI_ENHANCED_ENABLED: envEnabled("MEGACOMPACT_WIKI_ENHANCED", true),
+		WIKI_INCREMENTAL_ENABLED: envEnabled("MEGACOMPACT_WIKI_INCREMENTAL", true),
+		WIKI_INCREMENTAL_SILHOUETTE_MIN: envNum("MEGACOMPACT_WIKI_SILHOUETTE_MIN", 0.2),
 	};
 }
 

package/src/config.ts

@@ -140,3 +140,6 @@ export const RAG_MEMORY_GRAPH = (): boolean =>
  * MEGACOMPACT_HYDE_DISABLED=true. TrigramEmbedder path is unaffected. */
 export const RAG_HYDE_ENABLED = (): boolean =>
   ragEnabled("MEGACOMPACT_HYDE");
+
+/** Spec 1: vbrainstorm visual design migration for the dashboard. */
+export const NEW_UI = (): boolean => ragEnabled("MEGACOMPACT_NEW_UI");

package/src/recall/async.ts

@@ -138,5 +138,14 @@ export async function recallAndInlineAsync(
 			`  • ${h.checkpoint.checkpointId} (${h.checkpoint.summary.slice(0, 60).replace(/\n/g, " ")}…)`,
 	);
 
-	return { toInject, report, block, empty: toInject.length === 0 };
+	return {
+		toInject,
+		report,
+		block,
+		empty: toInject.length === 0,
+		// H1: cross-repo async path is HyDE-free; telemetry stays null until a
+		// future sprint threads it here.
+		hydeInfo: null,
+		recallMetrics: null,
+	};
 }