pi-mega-compact 0.19.0 → 0.19.2

package/dist/config/vector-cortex.js

@@ -91,6 +91,25 @@ export const VC2B_ENABLED = () => sprintFlag("MEGACOMPACT_VC2B");
  * the encoder-qualification emit seam and the calibrate/select seams.
  */
 export const VC2C_ENABLED = () => sprintFlag("MEGACOMPACT_VC2C");
+/**
+ * VC3A — capability-gated cortex store (CortexReader/Writer/Admin, CortexRecordV1).
+ * Default ON. `MEGACOMPACT_VC3A=0` disables and is byte-identical to the
+ * predecessor (mode C: the derived cortex store is absent, mode B in-memory is
+ * not consulted, zero `vector_cortex_record_append_failed` /
+ * `vector_cortex_generation_rebuilt` emissions; the predecessor derived pointer
+ * and goldens are unchanged). The real consumers are the cortex append seam, the
+ * cortex rebuild/admin seam and the reader-only topology summary seam.
+ */
+export const VC3A_ENABLED = () => sprintFlag("MEGACOMPACT_VC3A");
+/**
+ * VC3B — deterministic cortical topology (TopologyV1 / EdgeV1).
+ * Default ON. `MEGACOMPACT_VC3B=0` disables and is byte-identical to the
+ * predecessor (mode C: no topology graph is built or emitted, the dashboard
+ * topology view returns the VC3A-precise aggregation shape with no node/edge
+ * arrays, zero `vector_cortex_topology_*` emissions). The real consumers are
+ * the topology build seam (build.ts) and the dashboard topology node/edge view.
+ */
+export const VC3B_ENABLED = () => sprintFlag("MEGACOMPACT_VC3B");
 // ---------------------------------------------------------------------------
 // Breaker state machine constants (TRIAD_RESILIENCE.md §breaker).
 // Rolled numbers for one 60s window; VC0C consumes these at its breaker seam.

package/dist/config.js

@@ -114,4 +114,4 @@ export const NEW_UI = () => ragEnabled("MEGACOMPACT_NEW_UI");
 // default ON, `=0`/`_DISABLED` off. Re-exported from src/config/vector-cortex.ts
 // so root consumers share one source of truth.
 // ---------------------------------------------------------------------------
-export { VC0A_ENABLED, VC0B_ENABLED, VC1A_ENABLED, VC0C_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./config/vector-cortex.js";
+export { VC0A_ENABLED, VC0B_ENABLED, VC1A_ENABLED, VC0C_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, VC3A_ENABLED, VC3B_ENABLED, BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./config/vector-cortex.js";

package/dist/extensions/dashboard-server/routes-rag-settings-helpers.js

@@ -143,6 +143,8 @@ export const SETTINGS = [
             boolDirect("MEGACOMPACT_VC2A", "VC2A Offline Model Runtime", "ModelManifestV1 digest-before-load ONNX runtime (opset17/batch1/max512) + asset-free trigram demotion. Asset path assets/vector-cortex/encoder-v1 is immutable/digest-pinned. OFF = mode C, byte-identical to predecessor.", true),
             boolDirect("MEGACOMPACT_VC2B", "VC2B Multi-Head Encoder", "VectorSetV1 five L2-normalized heads (384/128/128/64/32) with head-calibration draft + asset-free trigram B (512d) and lexical C fallbacks, plus the per-head emit seam. OFF = mode C, no per-head vectors emitted, byte-identical predecessor.", true),
             boolDirect("MEGACOMPACT_VC2C", "VC2C Encoder Qualification + Calibration", "QualifiedEncoderV1/CalibrationV1: calibration fit on the calibration split only (held-out labels prohibited) + atomic selection across MODEL_ASSET and per-head EVALUATION thresholds (any field failure demotes all of A). OFF = mode C, no qualification/calibration selection, byte-identical predecessor.", true),
+            boolDirect("MEGACOMPACT_VC3A", "VC3A Cortex Store", "Capability-gated derived cortex store (CortexReader/Writer/Admin + CortexRecordV1): additive, keyed (sourceHighWater, algorithmVersion, id), immutable records, deterministic generation rebuild + one root digest. OFF = mode C, no cortex records written, byte-identical predecessor.", true),
+            boolDirect("MEGACOMPACT_VC3B", "VC3B Deterministic Topology", "Deterministic cortical topology (TopologyV1/EdgeV1): per-(source,head) top-k=16/head calibrated-threshold edges, stable score-desc/then-target-ID sort, dependency directed + contradiction symmetric paired records, one stable generation digest. OFF = mode C, no topology graph built/emitted, predecessor-precise topology view, byte-identical predecessor.", true),
         ],
     },
     {

package/dist/extensions/dashboard-server/routes-vector-cortex-eval.js

@@ -0,0 +1,49 @@
+/**
+ * dashboard-server/routes-vector-cortex-eval.ts — VC0A vector-cortex evaluation
+ * dashboard route.
+ *
+ * A single reader-only GET /api/vector-cortex/evaluation that aggregates redacted
+ * evaluation rows (persisted JSONL under the state dir) via the reader. No
+ * writable capability — no reset/mutation here.
+ *
+ * Guardrails: PREVENT-PI-004 (local filesystem read only), PREVENT-011 (no
+ * `any`), reader-only aggregate (never payloads/prompts/ledger — EVAL-REDACT-002).
+ */
+import { VC0A_ENABLED } from "../../src/config.js";
+import { readEvalRows } from "../../src/vector-cortex/eval/persist.js";
+import { summarizeEvalRows } from "../../src/vector-cortex/eval/reader.js";
+import { sendJson } from "./routes-vector-cortex-shared.js";
+/** Reader-only aggregate GET /api/vector-cortex/evaluation. */
+export function handleVectorCortexEvaluation(req, res, ctx) {
+    const url = req.url ?? "";
+    if (url !== "/api/vector-cortex/evaluation")
+        return false;
+    if (req.method !== "GET") {
+        // Reader-only: no mutation endpoints exist on this path.
+        sendJson(res, 405, { error: "method_not_allowed" });
+        return true;
+    }
+    const enabled = VC0A_ENABLED();
+    const rows = enabled ? readEvalRows(ctx.stateDir) : [];
+    const summary = summarizeEvalRows(rows);
+    const body = {
+        enabled,
+        mode: enabled ? "A" : "C",
+        samples: summary.samples,
+        byMode: {
+            A: summary.byMode.A,
+            B: summary.byMode.B,
+            C: summary.byMode.C,
+        },
+        histogram: {
+            edges: [...summary.histogram.edges],
+            cells: [...summary.histogram.cells],
+            overflow: summary.histogram.overflow,
+            total: summary.histogram.total,
+        },
+        rejects: [], // VC0C wires live breaker/reject telemetry here
+        updatedAt: new Date().toISOString(),
+    };
+    sendJson(res, 200, body);
+    return true;
+}

package/dist/extensions/dashboard-server/routes-vector-cortex-health.js

@@ -0,0 +1,233 @@
+/**
+ * dashboard-server/routes-vector-cortex-health.ts — VC0C vector-cortex breaker
+ * health + reset routes (plus the VC2C encoder-health facts they surface).
+ *
+ *   GET  /api/vector-cortex/health          — reader-only aggregate health card
+ *   POST /api/vector-cortex/breakers/reset  — explicit admin capability
+ *
+ * Guardrails: PREVENT-PI-004 (local filesystem read only), PREVENT-011 (no
+ * `any`), reader-only aggregate (never payloads/prompts/ledger — EVAL-REDACT-002).
+ */
+import { createHash } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { VC0C_ENABLED, VC2C_ENABLED } from "../../src/config.js";
+import { createVectorCortexSafety } from "../mega-runtime/vector-cortex-safety.js";
+import { readEncoderManifest, verifyEncoderAsset, detectPlatform } from "../../src/vector-cortex/encoder/asset.js";
+import { sendJson, readJsonBody } from "./routes-vector-cortex-shared.js";
+/** Resolve the committed encoder-v1 asset dir by walking up to the repo root. */
+function encoderAssetDir() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    const rel = join("assets", "vector-cortex", "encoder-v1");
+    for (let i = 0; i < 8; i++) {
+        const candidate = join(dir, rel);
+        try {
+            // guardrails-allow PREVENT-PI-004: local asset filesystem read (loopback)
+            readFileSync(join(candidate, "manifest.json"));
+            return candidate;
+        }
+        catch {
+            /* keep walking */
+        }
+        const next = dirname(dir);
+        if (next === dir)
+            break;
+        dir = next;
+    }
+    return null;
+}
+let healthCache = null;
+/** Stable cache key: manifest bytes + (size,mtime) of the asset files + platform. */
+function healthFactCacheKey(dir, manifestPath) {
+    const platform = detectPlatform();
+    if (!platform)
+        return null;
+    const parts = [platform];
+    try {
+        for (const p of [manifestPath, join(dir, "model.onnx"), join(dir, "tokenizer.json")]) {
+            const s = statSync(p);
+            parts.push(`${s.size}:${s.mtimeMs}`);
+        }
+        // guardrails-allow PREVENT-PI-004: local manifest filesystem read (loopback)
+        parts.push(createHash("sha256").update(readFileSync(manifestPath)).digest("hex"));
+    }
+    catch {
+        return null;
+    }
+    return parts.join("|");
+}
+function computeEncoderHealthFacts(dir) {
+    const manifest = readEncoderManifest(dir);
+    if (manifest === null)
+        return { assetDigest: null, mode: "C" };
+    const manifestPath = join(dir, "manifest.json");
+    const key = healthFactCacheKey(dir, manifestPath);
+    if (key === null)
+        return null;
+    if (healthCache !== null && healthCache.key === key)
+        return healthCache.facts;
+    let digest;
+    try {
+        // guardrails-allow PREVENT-PI-004: local manifest filesystem read (loopback)
+        digest = createHash("sha256").update(readFileSync(manifestPath)).digest("hex");
+    }
+    catch {
+        return { assetDigest: null, mode: "B" };
+    }
+    const verify = verifyEncoderAsset(dir, manifest, detectPlatform());
+    const facts = { assetDigest: digest, mode: verify.ok ? "A" : "B" };
+    healthCache = { key, facts };
+    return facts;
+}
+function encoderHealthFacts() {
+    if (!VC2C_ENABLED()) {
+        // Rollback: MEGACOMPACT_VC2C=0 selects C — report the inactive (flag-gated)
+        // mode with no asset digest rather than an on-disk-computed A/B.
+        return { assetDigest: null, mode: "C" };
+    }
+    const dir = encoderAssetDir();
+    if (dir === null)
+        return { assetDigest: null, mode: "C" };
+    const facts = computeEncoderHealthFacts(dir);
+    if (facts === null)
+        return { assetDigest: null, mode: "C" };
+    return facts;
+}
+/**
+ * Reader-only GET /api/vector-cortex/health (VC0C).
+ *
+ * Aggregate health card: breaker state (window/probe/backoff), durable spool
+ * frontier/authority/lag, and a worst-state aggregate. Constructs the safety
+ * adapter over the state dir — durable spool state (frontier-frozen, lag) is
+ * read from disk, so it reflects restart. Purely read: no mutation, never
+ * payloads/prompts/ledger.
+ */
+export function handleVectorCortexHealth(req, res, ctx) {
+    const url = req.url ?? "";
+    if (url !== "/api/vector-cortex/health")
+        return false;
+    if (req.method !== "GET") {
+        // Reader-only path: no mutation endpoint lives at /health.
+        sendJson(res, 405, { error: "method_not_allowed" });
+        return true;
+    }
+    const enabled = VC0C_ENABLED();
+    const safety = enabled ? createVectorCortexSafety({ stateDir: ctx.stateDir }) : null;
+    const card = safety ? safety.health() : null;
+    const enc = encoderHealthFacts();
+    const fallback = {
+        enabled: false,
+        mode: "C",
+        state: "CLOSED_A",
+        subsystem: "provider",
+        sinceMs: 0,
+        windowMs: 0,
+        probeCount: 0,
+        backoffDelayMs: 0,
+        frontierFrozen: false,
+        authorityOutage: false,
+        spoolLag: 0,
+        attempts: 0,
+        failures: 0,
+        p95Ms: 0,
+        failureRate: 0,
+        updatedAt: new Date().toISOString(),
+        aggregate: "CLOSED_A",
+        stateSource: "ephemeral",
+        encoderAssetDigest: enc.assetDigest,
+        encoderMode: enc.mode,
+    };
+    if (!card) {
+        sendJson(res, 200, fallback);
+        return true;
+    }
+    const mode = card.state === "CLOSED_A" ? "A" : card.state === "MANUAL_HALT" ? "C" : "B";
+    const aggregate = card.state === "MANUAL_HALT"
+        ? "MANUAL_HALT"
+        : card.state === "OPEN_C"
+            ? "OPEN_C"
+            : card.state === "OPEN_B"
+                ? "OPEN_B"
+                : card.state === "PROBE_B" || card.state === "PROBE_A"
+                    ? "PROBE"
+                    : "CLOSED_A";
+    const body = {
+        enabled,
+        mode,
+        state: card.state,
+        subsystem: card.subsystem,
+        sinceMs: card.sinceMs,
+        reason: card.reason,
+        windowMs: card.windowMs,
+        probeCount: card.probeCount,
+        backoffDelayMs: card.backoffDelayMs,
+        frontierFrozen: card.frontierFrozen,
+        authorityOutage: card.authorityOutage,
+        spoolLag: card.spoolLag,
+        attempts: card.attempts,
+        failures: card.failures,
+        p95Ms: card.p95Ms,
+        failureRate: card.failureRate,
+        updatedAt: new Date().toISOString(),
+        aggregate,
+        stateSource: card.stateSource,
+        encoderAssetDigest: enc.assetDigest,
+        encoderMode: enc.mode,
+    };
+    sendJson(res, 200, body);
+    return true;
+}
+/**
+ * Admin POST /api/vector-cortex/breakers/reset (VC0C).
+ *
+ * Explicit admin capability (separate from the reader GET). Clears a breaker's
+ * cooldown — or unwires a MANUAL_HALT — but NEVER evidence (attempts/failures
+ * are retained, per TRIAD_RESILIENCE). The subsystem is actor-supplied via the
+ * JSON body `{ subsystem }`. Every reset is documented in the returned record
+ * (state, retained evidence, updatedAt) — an auditable mutation surface; the
+ * GET path can never mutate.
+ */
+export function handleVectorCortexBreakersReset(req, res, ctx) {
+    const url = req.url ?? "";
+    if (url !== "/api/vector-cortex/breakers/reset")
+        return false;
+    if (req.method !== "POST") {
+        sendJson(res, 405, { error: "method_not_allowed" });
+        return true;
+    }
+    if (!VC0C_ENABLED()) {
+        sendJson(res, 409, { error: "vco_c_disabled" });
+        return true;
+    }
+    readJsonBody(req, (parsed) => {
+        if (!parsed.ok) {
+            sendJson(res, 400, { error: parsed.error });
+            return;
+        }
+        const subsystem = parsed.value.subsystem;
+        if (typeof subsystem !== "string" || subsystem.length === 0) {
+            sendJson(res, 400, { error: "subsystem_required" });
+            return;
+        }
+        try {
+            const safety = createVectorCortexSafety({ stateDir: ctx.stateDir });
+            const rec = safety.reset(subsystem);
+            const body = {
+                subsystem: rec.subsystem,
+                state: rec.state,
+                cooldownCleared: true,
+                attempts: rec.attempts,
+                failures: rec.failures,
+                probeCount: rec.probeCount,
+                manualReason: rec.manualReason,
+                updatedAt: rec.updatedAt,
+            };
+            sendJson(res, 200, body);
+        }
+        catch {
+            sendJson(res, 500, { error: "reset_failed" });
+        }
+    });
+    return true;
+}

package/dist/extensions/dashboard-server/routes-vector-cortex-ledger.js

@@ -0,0 +1,82 @@
+/**
+ * dashboard-server/routes-vector-cortex-ledger.ts — VC1B vector-cortex ledger
+ * dashboard route.
+ *
+ * Reader-only GET /api/vector-cortex/ledger built on the LedgerReader capability:
+ * opens the occurrence-v2 ledger for this repo's state dir and returns the
+ * session's occurrence IDENTITY rows (seq/eventId/kind/digest/toolCallId) plus
+ * high-water/count. NEVER ships sourceBytes or prompt text (reader-only
+ * no-ledger-text rule). Optional `?session=<id>` query selects the session.
+ *
+ * Guardrails: PREVENT-PI-004 (local filesystem read only), PREVENT-011 (no
+ * `any`), reader-only aggregate/identity only.
+ */
+import { VC1B_ENABLED } from "../../src/config.js";
+import { createLedgerStore } from "../../src/vector-cortex/ledger/store.js";
+import { sendJson } from "./routes-vector-cortex-shared.js";
+/**
+ * Reader-only GET /api/vector-cortex/ledger (VC1B).
+ */
+export function handleVectorCortexLedger(req, res, ctx) {
+    const url = req.url ?? "";
+    const path = url.split("?")[0] ?? url;
+    if (path !== "/api/vector-cortex/ledger")
+        return false;
+    if (req.method !== "GET") {
+        // Reader-only path: no mutation endpoint lives at /ledger.
+        sendJson(res, 405, { error: "method_not_allowed" });
+        return true;
+    }
+    // Parse the optional session query parameter.
+    let session = "default";
+    const qs = url.split("?")[1];
+    if (qs !== undefined) {
+        for (const pair of qs.split("&")) {
+            const [k, v] = pair.split("=");
+            if (k === "session" && v !== undefined && v.length > 0) {
+                session = decodeURIComponent(v);
+            }
+        }
+    }
+    const enabled = VC1B_ENABLED();
+    let active = enabled;
+    let highWater = "0";
+    let count = 0;
+    let occurrences = [];
+    if (enabled) {
+        try {
+            const store = createLedgerStore({ stateDir: ctx.stateDir });
+            try {
+                const reader = store.reader();
+                highWater = reader.highWater(session).toString();
+                const rows = reader.readSession(session);
+                count = rows.length;
+                // Identity only: never sourceBytes or prompt text (reader-only rule).
+                occurrences = rows.slice(-500).map((occ) => ({
+                    seq: occ.seq.toString(),
+                    eventId: occ.eventId,
+                    kind: occ.kind,
+                    digest: occ.digest,
+                    ...(occ.toolCallId !== undefined ? { toolCallId: occ.toolCallId } : {}),
+                }));
+            }
+            finally {
+                store.close();
+            }
+        }
+        catch {
+            // Non-fatal: a missing/corrupt ledger DB degrades to `enabled:false`.
+            active = false;
+        }
+    }
+    const body = {
+        enabled: active,
+        session,
+        highWater,
+        count,
+        occurrences,
+        updatedAt: new Date().toISOString(),
+    };
+    sendJson(res, 200, body);
+    return true;
+}

package/dist/extensions/dashboard-server/routes-vector-cortex-shared.js

@@ -0,0 +1,46 @@
+/**
+ * dashboard-server/routes-vector-cortex-shared.ts — shared HTTP helpers for the
+ * per-feature vector-cortex route modules.
+ *
+ * Homes the small request/response helpers used across the VC0A/VC0C/VC1B/VC3A
+ * handler modules (`sendJson`, `readJsonBody`) so the feature modules stay small
+ * and within extension line limits.
+ *
+ * Guardrails: PREVENT-PI-004 (loopback dashboard response only), PREVENT-011 (no
+ * `any`), PREVENT-001 (JSON.parse guarded by an object/shape check).
+ */
+export 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));
+}
+/**
+ * Parse a JSON request body with a size cap. `cb` receives either a validated
+ * plain object or an error reason. PREVENT-001: JSON.parse is guarded by a
+ * shape check (rejects null / arrays / non-objects).
+ */
+export 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" });
+        }
+    });
+}

package/dist/extensions/dashboard-server/routes-vector-cortex-topology.js

@@ -0,0 +1,208 @@
+/**
+ * dashboard-server/routes-vector-cortex-topology.ts — VC3A/VC3B vector-cortex
+ * topology dashboard route.
+ *
+ * Reader-only GET /api/vector-cortex/topology built ENTIRELY on the CortexReader
+ * capability: opens the isolated cortex DB for this repo's state dir and returns
+ * the topology summary (enabled, active generation identity, one root digest,
+ * derived frontier, record count, ordinal). It is query-only — never
+ * append/rebuild/switch. No writer or admin capability is reachable on this path
+ * (no writer/admin leakage). Non-fatal: a missing or corrupt cortex DB degrades
+ * to `enabled:false`.
+ *
+ * VC3B adds the deterministic node/edge shapes (TopologyV1) when both VC3A and
+ * VC3B are enabled: the accepted derived records of kind "topology" that carry a
+ * canonical TopologyCandidate JSON payload are fed through the deterministic
+ * build (buildTopologyGraph), whose stable generation digest + sorted node/edge
+ * arrays are returned. Bad/unparseable records are skipped (PREVENT-001), and
+ * with VC3B off the node/edge fields are omitted entirely — byte-identical to
+ * the VC3A predecessor view.
+ *
+ * Guardrails: PREVENT-PI-004 (local filesystem read only), PREVENT-011 (no
+ * `any`), reader-only aggregate.
+ */
+import { VC3A_ENABLED, VC3B_ENABLED } from "../../src/config.js";
+import { Logger } from "../../src/log.js";
+import { createCortexStore } from "../../src/vector-cortex/cortex/store.js";
+import { buildTopologyGraph } from "../../src/vector-cortex/topology/index.js";
+import { sendJson } from "./routes-vector-cortex-shared.js";
+/** Well-known cortex record kind that carries a canonical candidate payload. */
+const TOPOLOGY_RECORD_KIND = "topology";
+/**
+ * Reader-only GET /api/vector-cortex/topology (VC3A + VC3B node/edge shapes).
+ */
+export function handleVectorCortexTopology(req, res, ctx) {
+    const url = req.url ?? "";
+    const path = url.split("?")[0] ?? url;
+    if (path !== "/api/vector-cortex/topology")
+        return false;
+    if (req.method !== "GET") {
+        // Reader-only path: no mutation endpoint lives at /topology.
+        sendJson(res, 405, { error: "method_not_allowed" });
+        return true;
+    }
+    const enabled = VC3A_ENABLED();
+    const topologyEnabled = VC3B_ENABLED();
+    let active = enabled;
+    let summary = { generationId: null, rootDigest: null, sourceHighWater: "0", recordCount: 0, ordinal: null };
+    let nodes;
+    let edges;
+    let generationDigest;
+    if (enabled) {
+        try {
+            const store = createCortexStore({ stateDir: ctx.stateDir });
+            try {
+                const reader = store.reader();
+                const s = reader.topologySummary();
+                summary = {
+                    generationId: s.generationId,
+                    rootDigest: s.rootDigest,
+                    sourceHighWater: s.sourceHighWater,
+                    recordCount: s.recordCount,
+                    ordinal: s.ordinal,
+                };
+                if (topologyEnabled) {
+                    const built = buildFromRecords(reader.readRecords());
+                    nodes = built.nodes;
+                    edges = built.edges;
+                    generationDigest = built.generationDigest;
+                }
+            }
+            finally {
+                store.close();
+            }
+        }
+        catch {
+            // Non-fatal: a missing/corrupt cortex DB degrades to `enabled:false`.
+            active = false;
+        }
+    }
+    const body = {
+        enabled: active,
+        generationId: summary.generationId,
+        rootDigest: summary.rootDigest,
+        sourceHighWater: summary.sourceHighWater,
+        recordCount: summary.recordCount,
+        ordinal: summary.ordinal,
+        ...(topologyEnabled
+            ? { nodes, edges, generationDigest }
+            : {}),
+        updatedAt: new Date().toISOString(),
+    };
+    sendJson(res, 200, body);
+    return true;
+}
+/**
+ * Reconstruct the deterministic topology graph from the accepted derived records
+ * (reader-only, best-effort). Only records of kind "topology" whose payload is a
+ * canonical TopologyCandidate JSON are consumed; everything else is ignored.
+ * Returns empty arrays + null digest when no valid candidates are stored.
+ *
+ * The build seam is invoked with a logger-derived emit so the VC3B observability
+ * events (`vector_cortex_topology_built` / `vector_cortex_topology_edge_rejected`)
+ * fire on this production path — not just under unit tests. Best-effort and
+ * non-fatal: a failing emitter never breaks the agent loop.
+ *
+ * Q04 — DIVERGENCE RISK (documented, currently latent): the build is invoked
+ * with a hardcoded `threshold: 0` (plus `sessionId: "dashboard"` and
+ * `sourceHighWater: 0n`). This reflects the VC3B state where no production
+ * writer emits calibrated-threshold candidates yet, so retaining ALL stored
+ * "topology" records is correct for now. Once a real calibrated-threshold
+ * producer lands (VC3C), this dashboard digest will NOT derive from the
+ * authoritative threshold and can diverge from the canonical build for the same
+ * stored candidate set. The calibrated threshold must then be threaded through
+ * (e.g. sourced from the authority/config, not zero) before this route is treated
+ * as authoritative. Until then the route is explicitly best-effort display only.
+ */
+function buildFromRecords(records) {
+    const candidates = [];
+    for (const r of records) {
+        if (r.kind !== TOPOLOGY_RECORD_KIND)
+            continue;
+        const parsed = parseCandidatePayload(r);
+        if (parsed)
+            candidates.push(parsed);
+    }
+    const result = buildTopologyGraph({ sessionId: "dashboard", sourceHighWater: 0n, threshold: 0, candidates }, topologyEmit);
+    if (!result.ok)
+        return { nodes: [], edges: [], generationDigest: null };
+    return {
+        nodes: result.topology.nodes.map((n) => ({ id: n.id, kind: n.kind })),
+        edges: result.topology.edges.map((e) => ({
+            source: e.source,
+            target: e.target,
+            head: e.head,
+            score: e.score,
+            direction: e.direction,
+        })),
+        generationDigest: result.topology.generationDigest,
+    };
+}
+/**
+ * Logger-derived default emitter for the VC3B topology events. Mirrors the
+ * cortex store's `defaultEmitFor()` convention: a REAL structured-log producer so
+ * a caller that invokes the build seam without injecting an emitter still yields
+ * telemetry (best-effort, non-fatal). This is the production invoke point that
+ * makes the task-5 emission capable live (not dead under unit tests only).
+ */
+const topologyEmit = (event, fields) => {
+    new Logger().info(event, fields);
+};
+/**
+ * PREVENT-001: parse + shape-check a candidate payload before use. Returns
+ * undefined on any malformed/non-object input (best-effort, non-fatal).
+ *
+ * Q04 — FRAMING HARDENING: the canonical digest serialization in index.ts uses
+ * `|` (FIELD_SEP) and `~` (RECORD_SEP) as unambiguous delimiters between node
+ * ids/kinds and edge fields. That framing is collision-free only while id values
+ * (source/target/head) contain neither byte. Today ids are project-controlled, so
+ * this is latent, but a stored topology record could in principle carry a
+ * content-derived id containing those bytes, making the digest ambiguous
+ * (distinct graphs could collide) or the serialization injection-prone. To keep
+ * the digest well-defined for ANY input, reject candidates whose source/target/
+ * head contain the field/record separators; such a record is skipped (non-fatal)
+ * rather than fed into the digest.
+ */
+function parseCandidatePayload(r) {
+    let text;
+    try {
+        text = new TextDecoder().decode(r.payloadBytes);
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const v = JSON.parse(text);
+        if (v === null ||
+            typeof v !== "object" ||
+            Array.isArray(v)) {
+            return undefined;
+        }
+        const o = v;
+        if (typeof o.source !== "string" ||
+            typeof o.target !== "string" ||
+            typeof o.head !== "string" ||
+            typeof o.score !== "number" ||
+            (o.kind !== "dependency" && o.kind !== "contradiction")) {
+            return undefined;
+        }
+        // Q04: reject any id that would corrupt the `|`/`~` digest framing.
+        if (FRAMING_SEP.test(o.source) ||
+            FRAMING_SEP.test(o.target) ||
+            FRAMING_SEP.test(o.head)) {
+            return undefined;
+        }
+        return {
+            source: o.source,
+            target: o.target,
+            head: o.head,
+            score: o.score,
+            kind: o.kind,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Field (`|`) and record (`~`) separators used by the canonical digest framing. */
+const FRAMING_SEP = /[|~]/;