pi-mega-compact 0.13.5 → 0.13.6

package/dist/extensions/dashboard-server/routes-wiki.js

@@ -0,0 +1,330 @@
+/**
+ * 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 { 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";
+function sendJson(res, status, body) {
+    // 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) {
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/** Read a capped JSON body; returns { ok, value } or { error }. */
+function readJsonBody(req, cb) {
+    let body = "";
+    let tooBig = false;
+    req.on("data", (chunk) => {
+        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 });
+        }
+        catch {
+            cb({ ok: false, error: "invalid_json" });
+        }
+    });
+}
+export function handleWiki(req, res, ctx) {
+    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 = {
+                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();
+            const edges = overrides.flatMap((o) => {
+                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();
+            const body = {
+                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);
+            const body = {
+                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) => 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 = {
+                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);
+            }
+            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);
+            }
+            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) => 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);
+            }
+            catch (e) {
+                sendJson(res, 500, { error: String(e) });
+            }
+        });
+        return true;
+    }
+    return false;
+}

package/dist/extensions/dashboard-server/routes.js

@@ -20,3 +20,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/dist/extensions/dashboard-server/server.js

@@ -11,8 +11,9 @@ import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from
 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, handleIndex, handleRepoIndex, handleEvents, handleGameState, handleGameScores, handlePerf, handleAchievements, handleSessions, handleTopics, handleTurns, handleMaintenance, handleProviderCache, handleCacheStripes, handleMemoryStatus, handleSetupStatus, handleSetupDetect, handleSetupConfigure, handleMemoryMap, handleRaptorTree, handleContextHealth, handleCachePoison, handleHealthSettings, handleEmbedderHealth, handleRagSettings, handleStatic, } from "./routes.js";
+import { buildRouteContext, handleIndex, handleRepoIndex, handleEvents, handleGameState, handleGameScores, handlePerf, handleAchievements, handleSessions, handleTopics, handleTurns, handleMaintenance, handleProviderCache, handleCacheStripes, handleMemoryStatus, handleSetupStatus, handleSetupDetect, handleSetupConfigure, handleMemoryMap, handleRaptorTree, handleContextHealth, handleCachePoison, handleHealthSettings, handleEmbedderHealth, handleRagSettings, handleRagMetrics, handleWiki, handleStatic, } from "./routes.js";
 export async function launchDashboardServer(stateDir) {
     // Our own package version — exposed at /api/version so the launcher can
     // detect a stale server (started by an older build) and replace it on
@@ -71,6 +72,14 @@ export async function launchDashboardServer(stateDir) {
     const hasClientBuild = existsSync(clientIndexHtml);
     if (hasClientBuild)
         log("client build present", { clientDist });
+    function injectUiFlag(html) {
+        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, res) => {
         if (!hasClientBuild)
@@ -84,7 +93,7 @@ export async function launchDashboardServer(stateDir) {
         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);
@@ -98,10 +107,11 @@ export async function launchDashboardServer(stateDir) {
             ico: "image/x-icon",
             map: "application/json",
         };
+        const payload = 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;
     };
     log("launch invoked", { stateDir });
@@ -219,6 +229,10 @@ export async function launchDashboardServer(stateDir) {
             return;
         if (handleRagSettings(req, res, ctx))
             return;
+        if (handleRagMetrics(req, res, ctx))
+            return;
+        if (handleWiki(req, res, ctx))
+            return;
         handleStatic(req, res, ctx);
     });
     // Bind base + range are env-configurable so tests can use a private,

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

@@ -12,7 +12,8 @@ import { epochIdFor } from "../../../src/mirror/epoch.js";
 import { stampTurnsEpochFor } from "../../mega-turn-store.js";
 import { TurnsConfig } from "../../../src/config/turns.js";
 import { openTurnStore } from "../../../src/store/turns/connection.js";
-import { buildTopicModel, createTopicStore, bumpWikiCompactCounter, } from "../../../src/topics/index.js";
+import { buildTopicModel, createTopicStore, bumpWikiCompactCounter, applyOverridesAfterRebuild, applyFullOverridesAfterRebuild, } from "../../../src/topics/index.js";
+import { assignNewMemoriesIncremental } from "../../../src/wiki/index.js";
 import { TrigramEmbedder } from "../../../src/embedder.js";
 /**
  * Persist the checkpoint_epoch, stamp turns, rebuild the auto-wiki, seed the
@@ -58,7 +59,30 @@ export async function persistEpochAndMaintain(runtime, config, ran) {
                     const every = Math.max(1, TurnsConfig.WIKI_REBUILD_EVERY_N_COMPACTS);
                     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,
@@ -66,6 +90,13 @@ export async function persistEpochAndMaintain(runtime, config, ran) {
                             seed: 0x9e3779b9,
                         });
                         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,
@@ -130,6 +161,8 @@ export async function persistEpochAndMaintain(runtime, config, ran) {
                                     seed: 0x9e3779b9,
                                 }, seedChunks);
                                 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/dist/extensions/mega-pipeline/recall.js

@@ -40,6 +40,32 @@ export function doRecall(runtime, config, ctx, query, source) {
         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);
@@ -72,6 +98,8 @@ export function doRecall(runtime, config, ctx, query, source) {
                 turnIndex: runtime.currentTurn,
                 role: "assistant",
                 startedAt: Date.now(),
+                hyde: result.hydeInfo ?? undefined,
+                recallMetrics: result.recallMetrics ?? undefined,
             }, runtime.currentStateDir);
             recordRecallWrite(config, turnId, result.toInject.map((h) => ({
                 checkpointId: h.checkpoint.checkpointId,
@@ -173,6 +201,9 @@ export async function doRecallAsync(runtime, config, ctx, query, source, opts =
             report: merged.map((h) => `  • ${h.checkpoint.checkpointId}${h.repoId ? ` (from ${h.repoId.split("/").filter(Boolean).pop()})` : ""}`),
             block,
             empty: merged.length === 0,
+            // H1: merged cross-repo result reuses the same-repo pass's telemetry.
+            hydeInfo: sameRepo.hydeInfo,
+            recallMetrics: sameRepo.recallMetrics,
         };
     }
     catch {

package/dist/extensions/mega-turn-store.js

@@ -43,7 +43,6 @@ export function ensureConversationIdFor(config, sessionId, stateDir) {
         ? storeFor(stateDir).ensureConversationId(sessionId)
         : legacyEnsureConversationId(sessionId, stateDir);
 }
-/** Record one turn row (turn_end). Returns the contract TurnId (string). */
 export function recordTurnWrite(config, input, stateDir) {
     if (!config.turnsDbEnabled) {
         legacyRecordTurn(input, stateDir);
@@ -60,6 +59,8 @@ export function recordTurnWrite(config, input, stateDir) {
         pressureBand: input.pressureBand,
         model: input.modelId,
         epochId: input.epochId,
+        hyde: input.hyde,
+        recallMetrics: input.recallMetrics,
     };
     return storeFor(stateDir).appendTurn(entry);
 }

package/dist/src/config/turns.js

@@ -22,6 +22,13 @@ function envNum(name, def) {
     const n = Number(v);
     return Number.isFinite(n) ? n : def;
 }
+/** Default-ON toggle honoring the MEGACOMPACT_<NAME>_DISABLED opt-out convention. */
+function envEnabled(name, def) {
+    if (process.env[`${name}_DISABLED`] === "true" || process.env[`${name}_DISABLED`] === "1") {
+        return false;
+    }
+    return envBool(name, def);
+}
 function envKRange(defMin, defMax) {
     const v = process.env.MEGACOMPACT_WIKI_K_RANGE;
     if (v) {
@@ -44,6 +51,9 @@ export function loadTurnsConfig() {
         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),
     };
 }
 export const TurnsConfig = loadTurnsConfig();

package/dist/src/config.js

@@ -107,3 +107,5 @@ export const RAG_MEMORY_GRAPH = () => ragEnabled("MEGACOMPACT_MEMORY_GRAPH");
  * HttpEmbedder is active (the LLM is configured for indexing); opt OUT with
  * MEGACOMPACT_HYDE_DISABLED=true. TrigramEmbedder path is unaffected. */
 export const RAG_HYDE_ENABLED = () => ragEnabled("MEGACOMPACT_HYDE");
+/** Spec 1: vbrainstorm visual design migration for the dashboard. */
+export const NEW_UI = () => ragEnabled("MEGACOMPACT_NEW_UI");

package/dist/src/recall/async.js

@@ -108,5 +108,14 @@ export async function recallAndInlineAsync(opts, store) {
     // has repoId + score for proper labeling.
     const block = toInject.length > 0 ? formatRecallBlock(toInject) : "";
     const report = toInject.map((h) => `  • ${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,
+    };
 }

package/dist/src/recall/format.js

@@ -142,8 +142,17 @@ export function scoreAndLogRecallMetrics(query, toInject) {
                 diversity: metrics.breakdown.diversity,
             });
         }
+        return {
+            hitCount: toInject.length,
+            score: metrics.score,
+            pass: metrics.pass,
+            relevance: metrics.breakdown.relevance,
+            coverage: metrics.breakdown.coverage,
+            diversity: metrics.breakdown.diversity,
+            specificity: metrics.breakdown.specificity,
+        };
     }
     catch {
-        /* non-fatal: metrics never break recall */
+        return null; // non-fatal: metrics never break recall
     }
 }

package/dist/src/recall/hydeTelemetry.js

@@ -0,0 +1,22 @@
+export function buildHydeInfo(outcome, hypotheticalDoc, generationMs, rawHitCount, hydeHitCount, fusedHitCount) {
+    const ran = outcome === "ran";
+    const skipped = !ran;
+    // Lift = fusedHitCount / max(1, rawHitCount) — how much HyDE changed recall
+    // breadth. Skipped passes yield 1 (raw hits cascade unchanged) unless there
+    // were no raw hits to compare against.
+    const lift = fusedHitCount / Math.max(1, rawHitCount);
+    return {
+        ran,
+        skipped,
+        reason: outcome,
+        hypotheticalDoc,
+        generationMs: ran ? generationMs : 0,
+        rawHitCount,
+        hydeHitCount: ran ? hydeHitCount : 0,
+        fusedHitCount,
+        lift: Math.round(lift * 100) / 100,
+    };
+}
+export function hydeSkipped(reason, rawHitCount, fusedHitCount) {
+    return buildHydeInfo(reason, "", 0, rawHitCount, 0, fusedHitCount);
+}