pi-mega-compact 0.20.24 → 0.20.25

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

@@ -26,6 +26,7 @@
 import { VC7A_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
 import { countVcEvents, vcCount } from "./vc-event-counts.js";
+import { deriveVcStatus } from "./vc-status.js";
 // Actual events emitted by src/vector-cortex/cache/crystal-emit.ts.
 const CRYSTAL_EVENTS = [
     "vector_cortex_crystal_written",
@@ -67,6 +68,11 @@ export function handleVectorCortexCrystals(req, res, ctx) {
         lastFailure: null,
         updatedAt: new Date().toISOString(),
         deferredReason: "crystal_store_not_instantiated_v0_20_23",
+        status: deriveVcStatus({
+            enabled,
+            deferredReason: "crystal_store_not_instantiated_v0_20_23",
+            hasData: vcCount(counts, "vector_cortex_crystal_written") > 0,
+        }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -28,6 +28,7 @@
 import { VC7C_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
 import { countVcEvents, vcCount } from "./vc-event-counts.js";
+import { deriveVcStatus } from "./vc-status.js";
 // Actual events emitted by src/vector-cortex/cache/diagnostics-emit.ts.
 const DIAGNOSTICS_EVENTS = ["vector_cortex_cache_serve_blocked"];
 /**
@@ -67,6 +68,11 @@ export function handleVectorCortexDiagnostics(req, res, ctx) {
         lastFailure: null,
         updatedAt: new Date().toISOString(),
         deferredReason: "cache_classifier_not_wired_v0_20_23",
+        status: deriveVcStatus({
+            enabled,
+            deferredReason: "cache_classifier_not_wired_v0_20_23",
+            hasData: vcCount(counts, "vector_cortex_cache_serve_blocked") > 0,
+        }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -24,6 +24,7 @@
  */
 import { VC7B_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { deriveVcStatus } from "./vc-status.js";
 /**
  * Reader-only GET /api/vector-cortex/cache-economics (VC7B).
  *
@@ -54,6 +55,11 @@ export function handleVectorCortexEconomics(req, res, _ctx) {
         lastFailure: null,
         updatedAt: new Date().toISOString(),
         deferredReason: "economics_not_computed_v0_20_23",
+        status: deriveVcStatus({
+            enabled,
+            deferredReason: "economics_not_computed_v0_20_23",
+            hasData: false,
+        }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -13,6 +13,7 @@ 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";
+import { deriveVcStatus } from "./vc-status.js";
 /** Reader-only aggregate GET /api/vector-cortex/evaluation. */
 export function handleVectorCortexEvaluation(req, res, ctx) {
     const url = req.url ?? "";
@@ -43,6 +44,7 @@ export function handleVectorCortexEvaluation(req, res, ctx) {
         },
         rejects: [], // VC0C wires live breaker/reject telemetry here
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({ enabled, hasData: summary.samples > 0 }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -22,6 +22,7 @@
 import { VC6A_ENABLED, VC6B_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
 import { countVcEvents, vcCount } from "./vc-event-counts.js";
+import { deriveVcStatus } from "./vc-status.js";
 // Actual event names emitted by src/vector-cortex/heal/emit.ts + restore-emit.ts.
 const CLOSURE_EVENTS = [
     "vector_cortex_closure_optimized",
@@ -56,6 +57,10 @@ export function handleVectorCortexClosureProof(req, res, ctx) {
         optimizedTraversalTotal: 0,
         lastRejection: null,
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({
+            enabled,
+            hasData: vcCount(counts, "vector_cortex_closure_optimized") > 0,
+        }),
     };
     sendJson(res, 200, body);
     return true;
@@ -92,6 +97,10 @@ export function handleVectorCortexRestore(req, res, ctx) {
         digestRejections: vcCount(counts, "vector_cortex_restore_digest_rejected"),
         lastRejection: null,
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({
+            enabled,
+            hasData: vcCount(counts, "vector_cortex_source_restored") > 0,
+        }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -16,6 +16,7 @@ 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";
+import { deriveVcStatus } from "./vc-status.js";
 /** Resolve the committed encoder-v1 asset dir by walking up to the repo root. */
 function encoderAssetDir() {
     let dir = dirname(fileURLToPath(import.meta.url));
@@ -137,6 +138,7 @@ export function handleVectorCortexHealth(req, res, ctx) {
         stateSource: "ephemeral",
         encoderAssetDigest: enc.assetDigest,
         encoderMode: enc.mode,
+        status: deriveVcStatus({ enabled: false, hasData: false }),
     };
     if (!card) {
         sendJson(res, 200, fallback);
@@ -174,6 +176,7 @@ export function handleVectorCortexHealth(req, res, ctx) {
         stateSource: card.stateSource,
         encoderAssetDigest: enc.assetDigest,
         encoderMode: enc.mode,
+        status: deriveVcStatus({ enabled, hasData: true, structuralOnly: true }),
     };
     sendJson(res, 200, body);
     return true;
@@ -222,6 +225,7 @@ export function handleVectorCortexBreakersReset(req, res, ctx) {
                 probeCount: rec.probeCount,
                 manualReason: rec.manualReason,
                 updatedAt: rec.updatedAt,
+                status: deriveVcStatus({ enabled: true, hasData: true }),
             };
             sendJson(res, 200, body);
         }

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

@@ -14,6 +14,7 @@
 import { VC1B_ENABLED } from "../../src/config.js";
 import { createLedgerStore } from "../../src/vector-cortex/ledger/store.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { deriveVcStatus } from "./vc-status.js";
 /**
  * Reader-only GET /api/vector-cortex/ledger (VC1B).
  */
@@ -76,6 +77,7 @@ export function handleVectorCortexLedger(req, res, ctx) {
         count,
         occurrences,
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({ enabled: active, hasData: count > 0 }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -18,11 +18,16 @@
  */
 import { VC8A_ENABLED } from "../../src/config.js";
 import { sendJson, readJsonBody } from "./routes-vector-cortex-shared.js";
+import { countVcEvents, vcCount } from "./vc-event-counts.js";
+import { deriveVcStatus } from "./vc-status.js";
+// Actual events emitted by src/vector-cortex/outcomes/* — the outcome append is
+// the sole aggregate signal (consent grants/revokes are not emitted as events).
+const OUTCOME_EVENTS = ["vector_cortex_outcome_appended"];
 /**
  * GET /api/vector-cortex/outcomes — reader-only outcomes aggregate (VC8A).
  * POST /api/vector-cortex/outcomes/consent — audited consent admin API.
  */
-export function handleVectorCortexOutcomes(req, res, _ctx) {
+export function handleVectorCortexOutcomes(req, res, ctx) {
     const url = req.url ?? "";
     const path = url.split("?")[0] ?? url;
     if (path === "/api/vector-cortex/outcomes/consent") {
@@ -62,17 +67,20 @@ export function handleVectorCortexOutcomes(req, res, _ctx) {
         return true;
     }
     const enabled = VC8A_ENABLED();
+    const counts = countVcEvents(ctx.stateDir, OUTCOME_EVENTS);
+    const outcomeCount = vcCount(counts, "vector_cortex_outcome_appended");
     const mode = enabled ? "A" : "C";
     const body = {
         enabled,
         mode,
-        outcomeCount: 0,
+        outcomeCount,
         consentedSessions: 0,
         revokedSessions: 0,
         manifestCount: 0,
         excludedCount: 0,
         lastFailure: null,
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({ enabled, hasData: outcomeCount > 0 }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -23,6 +23,7 @@ import { VC5A_ENABLED } from "../../src/config.js";
 import { DAG_IDS } from "../../src/vector-cortex/prompt-dag/types.js";
 import { PLN_IDS } from "../../src/vector-cortex/planner/types.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { deriveVcStatus } from "./vc-status.js";
 /**
  * Reader-only GET /api/vector-cortex/plans (VC5A).
  */
@@ -43,6 +44,7 @@ export function handleVectorCortexPlans(req, res, _ctx) {
         plannerCount: enabled ? PLN_IDS.length : 0,
         plans: [],
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({ enabled, hasData: true, structuralOnly: true }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -15,8 +15,16 @@
  */
 import { VC8C_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { countVcEvents, vcCount } from "./vc-event-counts.js";
+import { deriveVcStatus } from "./vc-status.js";
+// Actual events emitted by src/vector-cortex/platform/* — a parity run checks
+// fixtures and a demotion records an engine-selection downgrade.
+const PLATFORM_EVENTS = [
+    "vector_cortex_engine_parity_checked",
+    "vector_cortex_engine_selection_demoted",
+];
 /** GET /api/vector-cortex/platform — reader-only engine parity/selection aggregate (VC8C). */
-export function handleVectorCortexPlatform(req, res, _ctx) {
+export function handleVectorCortexPlatform(req, res, ctx) {
     const url = req.url ?? "";
     const path = url.split("?")[0] ?? url;
     if (path !== "/api/vector-cortex/platform")
@@ -26,16 +34,19 @@ export function handleVectorCortexPlatform(req, res, _ctx) {
         return true;
     }
     const enabled = VC8C_ENABLED();
+    const counts = countVcEvents(ctx.stateDir, PLATFORM_EVENTS);
     const mode = enabled ? "A" : "C";
+    const fixtureCount = vcCount(counts, "vector_cortex_engine_parity_checked");
     const body = {
         enabled,
         mode,
-        fixtureCount: 0,
+        fixtureCount,
         passed: 0,
         failed: 0,
         externalRunnerConfigured: process.env.MEGACOMPACT_RUST_RUNNER !== undefined,
         lastFailure: null,
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({ enabled, hasData: fixtureCount > 0 }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -17,6 +17,7 @@
  */
 import { VC8B_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { deriveVcStatus } from "./vc-status.js";
 /** GET /api/vector-cortex/policy — reader-only policy + shadow aggregate (VC8B). */
 export function handleVectorCortexPolicy(req, res, _ctx) {
     const url = req.url ?? "";
@@ -40,6 +41,11 @@ export function handleVectorCortexPolicy(req, res, _ctx) {
         lastFailure: null,
         updatedAt: new Date().toISOString(),
         deferredReason: "shadow_controller_not_instantiated_v0_20_23",
+        status: deriveVcStatus({
+            enabled,
+            deferredReason: "shadow_controller_not_instantiated_v0_20_23",
+            hasData: false,
+        }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -15,6 +15,7 @@
 import { VC3C_ENABLED } from "../../src/config.js";
 import { ROUTER_KEY_VERSION } from "../../src/vector-cortex/topology/query.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { deriveVcStatus } from "./vc-status.js";
 /**
  * Reader-only GET /api/vector-cortex/query (VC3C query-layer diagnostics).
  */
@@ -40,6 +41,7 @@ export function handleVectorCortexQuery(req, res, _ctx) {
         enabled,
         routerVersion: ROUTER_KEY_VERSION,
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({ enabled, hasData: true, structuralOnly: true }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -9,6 +9,7 @@
 import { VC4C_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
 import { countVcEvents, vcCount } from "./vc-event-counts.js";
+import { deriveVcStatus } from "./vc-status.js";
 // Closure attempt/rejection events emitted by src/vector-cortex/heal/emit.ts.
 const RECONSTRUCT_EVENTS = [
     "vector_cortex_closure_optimized",
@@ -34,6 +35,10 @@ export function handleVectorCortexReconstruct(req, res, ctx) {
         spanTotal: 0,
         byteTotal: 0,
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({
+            enabled,
+            hasData: vcCount(counts, "vector_cortex_closure_optimized") > 0,
+        }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -17,6 +17,7 @@ import { REN_IDS } from "../../src/vector-cortex/render/types.js";
 import { PRO_IDS } from "../../src/vector-cortex/provider/types.js";
 import { KNOWN_PROVIDER_KEYS } from "../../src/vector-cortex/provider/registry.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { deriveVcStatus } from "./vc-status.js";
 /** Reader-only GET /api/vector-cortex/render (VC5B). */
 export function handleVectorCortexRender(req, res, _ctx) {
     const url = req.url ?? "";
@@ -34,6 +35,7 @@ export function handleVectorCortexRender(req, res, _ctx) {
         providerCount: enabled ? PRO_IDS.length : 0,
         knownProfiles: enabled ? KNOWN_PROVIDER_KEYS : [],
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({ enabled, hasData: true, structuralOnly: true }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -23,6 +23,7 @@
 import { VC6C_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
 import { countVcEvents, vcCount } from "./vc-event-counts.js";
+import { deriveVcStatus } from "./vc-status.js";
 // Actual event names emitted by src/vector-cortex/heal/repair-emit.ts.
 const REPAIR_EVENTS = [
     "vector_cortex_repair_planned",
@@ -65,6 +66,10 @@ export function handleVectorCortexRepair(req, res, ctx) {
         lastBackoffMs: null,
         lastFailure: null,
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({
+            enabled,
+            hasData: vcCount(counts, "vector_cortex_repair_planned") > 0,
+        }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -20,6 +20,7 @@
  */
 import { VC4B_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { deriveVcStatus } from "./vc-status.js";
 /**
  * Reader-only GET /api/vector-cortex/residual (VC4B).
  */
@@ -45,6 +46,7 @@ export function handleVectorCortexResidual(req, res, _ctx) {
         encodedByteTotal: 0,
         exactByteTotal: 0,
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({ enabled, hasData: false, structuralOnly: true }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -11,11 +11,22 @@
  * Guardrails: PREVENT-PI-004 (local in-process state only), PREVENT-011 (no
  * `any`), reader-only aggregate (counts + gate state only).
  */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import { VC5C_ENABLED } from "../../src/config.js";
 import { ROLLOUT_GATES, ROLLOUT_BUCKETS } from "../../src/vector-cortex/rollout/types.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
+import { countVcEvents, vcCount } from "./vc-event-counts.js";
+import { deriveVcStatus } from "./vc-status.js";
+// Rollout events: assigned/promotion-blocked from rollout/emit.ts, plus the
+// explicit decision event appended by pipelineRun.ts:79 after decideLivePath.
+const ROLLOUT_EVENTS = [
+    "vector_cortex_rollout_assigned",
+    "vector_cortex_rollout_promotion_blocked",
+    "vector_cortex_rollout_decision",
+];
 /** Reader-only GET /api/vector-cortex/rollout (VC5C). */
-export function handleVectorCortexRollout(req, res, _ctx) {
+export function handleVectorCortexRollout(req, res, ctx) {
     const url = req.url ?? "";
     const path = url.split("?")[0] ?? url;
     if (path !== "/api/vector-cortex/rollout")
@@ -25,6 +36,11 @@ export function handleVectorCortexRollout(req, res, _ctx) {
         return true;
     }
     const enabled = VC5C_ENABLED();
+    const counts = countVcEvents(ctx.stateDir, ROLLOUT_EVENTS);
+    const eventCount = vcCount(counts, "vector_cortex_rollout_assigned") +
+        vcCount(counts, "vector_cortex_rollout_promotion_blocked") +
+        vcCount(counts, "vector_cortex_rollout_decision");
+    const sessionCount = enabled ? distinctRolloutSessions(ctx.stateDir) : 0;
     const gateIndex = 0; // Ephemeral rollout state: no durable gate in this sprint.
     const gatePct = ROLLOUT_GATES[gateIndex];
     const body = {
@@ -33,11 +49,48 @@ export function handleVectorCortexRollout(req, res, _ctx) {
         gatePct: enabled ? gatePct : 0,
         buckets: ROLLOUT_BUCKETS,
         bucketCount: enabled ? gatePct * 100 : 0,
-        events: 0,
-        sessions: 0,
+        events: enabled ? eventCount : 0,
+        sessions: enabled ? sessionCount : 0,
         promotionBlocked: false,
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({ enabled, hasData: eventCount > 0 }),
     };
     sendJson(res, 200, body);
     return true;
 }
+/**
+ * Count distinct session ids among rollout_assigned events in the tail of
+ * events.log. Best-effort: a missing/unreadable log or malformed lines yield 0.
+ * Only the `sessionId` field of rollout_assigned lines is inspected (aggregate
+ * only, never session payloads/prompts).
+ */
+function distinctRolloutSessions(stateDir) {
+    const seen = new Set();
+    let raw;
+    try {
+        raw = readFileSync(join(stateDir, "events.log"), "utf-8");
+    }
+    catch {
+        return 0;
+    }
+    const lines = raw.split("\n");
+    const start = Math.max(0, lines.length - 10000);
+    for (let i = start; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.length === 0)
+            continue;
+        let ev = null;
+        try {
+            ev = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (ev?.event === "vector_cortex_rollout_assigned" &&
+            typeof ev.sessionId === "string" &&
+            ev.sessionId.length > 0) {
+            seen.add(ev.sessionId);
+        }
+    }
+    return seen.size;
+}

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

@@ -20,6 +20,7 @@
 import { VC4A_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
 import { countVcEvents, vcCount } from "./vc-event-counts.js";
+import { deriveVcStatus } from "./vc-status.js";
 // Actual events emitted by src/vector-cortex/shards/manifest.ts. VC4A has no
 // per-tier (semantic/exact) write event — the manifest build is the single
 // shard-write signal — so semanticCount is wired to it and exactCount stays 0
@@ -50,6 +51,10 @@ export function handleVectorCortexShards(req, res, ctx) {
         byteTotal: 0,
         protectedByteTotal: 0,
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({
+            enabled,
+            hasData: vcCount(counts, "vector_cortex_shard_manifest_built") > 0,
+        }),
     };
     sendJson(res, 200, body);
     return true;

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

@@ -26,6 +26,7 @@ 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";
+import { deriveVcStatus } from "./vc-status.js";
 /** Well-known cortex record kind that carries a canonical candidate payload. */
 const TOPOLOGY_RECORD_KIND = "topology";
 /**
@@ -88,6 +89,7 @@ export function handleVectorCortexTopology(req, res, ctx) {
             ? { nodes, edges, generationDigest }
             : {}),
         updatedAt: new Date().toISOString(),
+        status: deriveVcStatus({ enabled: active, hasData: summary.recordCount > 0 }),
     };
     sendJson(res, 200, body);
     return true;

package/dist/extensions/dashboard-server/vc-status.js

@@ -0,0 +1,17 @@
+/**
+ * dashboard-server/vc-status.ts — shared status derivation for Vector Cortex
+ * dashboard routes. Every VC route computes a status field so the client can
+ * show meaningful state (live / awaiting data / deferred / structural) instead
+ * of bare zeros.
+ *
+ * Guardrails: PREVENT-011 (no `any`).
+ */
+export function deriveVcStatus(opts) {
+    if (!opts.enabled)
+        return "off";
+    if (opts.deferredReason)
+        return "deferred";
+    if (opts.structuralOnly)
+        return "structural";
+    return opts.hasData ? "live" : "awaiting_data";
+}

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

@@ -237,9 +237,9 @@ export async function persistEpochAndMaintain(runtime, config, ran) {
         try {
             reportRepairPlanned((name, payload) => runtime.appendEvent(name, payload), {
                 subsystem: "post_compact",
-                generation: 1,
+                generation: runtime.rt.compactCount,
                 backoffMs: 0,
-                gapSize: 0,
+                gapSize: ran.result.compactedFrom,
             });
         }
         catch {

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

@@ -2,6 +2,7 @@ import { runCompact } from "../../mega-pipeline.js";
 import { pressureFromPct, pressureRatio } from "../../mega-config.js";
 import { recordCompactLatency } from "../../mega-runtime/vc-observer.js";
 import { decideLivePath } from "../../mega-runtime/vector-cortex-live.js";
+import { defaultClock } from "../../../src/vector-cortex/rollout/gate.js";
 import { VC5C_ENABLED } from "../../../src/config/vector-cortex.js";
 /**
  * Invoke the compaction pipeline with adaptive pressure. Returns a tailed view
@@ -14,11 +15,25 @@ export function invokePipeline(pi, runtime, config, ctx, opts) {
     // rollout shapes. Best-effort + non-fatal; decision does NOT gate behavior yet.
     if (VC5C_ENABLED()) {
         try {
+            const clock = defaultClock();
+            // Conservative evidence: fresh in-memory window (elapsed=0), not
+            // powered, so the gate can't advance — but events/sessions carry real
+            // values so the decision events reflect actual runtime activity rather
+            // than degrading every epoch to an empty mode-C read.
+            const evidence = {
+                windowStartMs: clock.now(),
+                powered: false,
+                events: runtime.rt.compactCount,
+                sessions: 1,
+                hardFaults: runtime.rt
+                    .vcHardFaults ?? [],
+            };
             const decision = decideLivePath(runtime.rt.sessionId, {
                 emit: runtime.appendEvent.bind(runtime),
+                clock,
                 currentGate: runtime.rt.vcGate ?? 0,
-                hardFaults: runtime.rt
-                    .vcHardFaults ?? [],
+                evidence,
+                hardFaults: evidence.hardFaults,
             });
             runtime.appendEvent("vector_cortex_rollout_decision", {
                 sessionId: runtime.rt.sessionId,

package/dist/extensions/mega-events/register.js

@@ -3,6 +3,7 @@ import { registerAgentHandlers } from "./agent-handlers.js";
 import { registerContextHandler } from "./context-handler.js";
 import { registerCompactHandlers } from "./compact-handlers.js";
 import { registerPerfHandler } from "./perf-handler.js";
+import { registerVectorCortexRender } from "../mega-context/vector-cortex.js";
 /**
  * DIAG accessor for the headless test harness: the most recently constructed
  * MegaRuntime, so a test that loads the compiled extension via its default
@@ -14,6 +15,22 @@ export let lastRuntime;
 /** Register all pi lifecycle event handlers. */
 export function registerEventHandlers(pi, runtime, config) {
     lastRuntime = runtime;
+    // VC5B: wire the render+validate seam into the before_agent_start lifecycle.
+    // Registered FIRST so its no-op return (no render input on ctx) doesn't
+    // clobber a systemPrompt that a later before_agent_start handler (e.g. the
+    // legacy recall prepend in session-handlers) returns. When VC5B does
+    // prepend, it returns a new systemPrompt; the later handlers run on the
+    // recallTailInject=ON path and return undefined, so VC5B's return survives.
+    // The _ctx param is unused by the seam; pass empty for the registered seam.
+    try {
+        registerVectorCortexRender(pi, undefined, (event, fields) => {
+            try {
+                runtime.appendEvent(event, fields);
+            }
+            catch { /* non-fatal */ }
+        });
+    }
+    catch { /* non-fatal: VC5B registration never breaks startup */ }
     // ---- Session lifecycle (state reset points) -------------------------------
     registerSessionHandlers(pi, runtime, config);
     registerAgentHandlers(pi, runtime, config);

package/dist/extensions/mega-pipeline/recall.js

@@ -11,6 +11,7 @@ import { normalizeSessionId } from "../../src/store.js";
 import { incRecallInjected, incCacheHitTokens, getIndexDir, } from "../../src/store/sqlite.js";
 import { ensureConversationIdFor, recordTurnWrite, recordRecallWrite, } from "../mega-turn-store.js";
 import { C } from "../mega-runtime.js";
+import { recordRecallLatency } from "../mega-runtime/vc-observer.js";
 /**
  * Unified recall (Layer 5). The ONE path that injects. Returns the recall
  * result; callers decide whether to stage it for before_agent_start (resume)
@@ -23,6 +24,7 @@ export function doRecall(runtime, config, ctx, query, source) {
     // are already resident in the session, so recall never re-injects context the
     // model can already see. Best-effort — an empty window just skips dedupe.
     const liveWindow = config.windowDedupe ? extractLiveWindow(ctx) : undefined;
+    const recallStartMs = Date.now();
     const result = recallAndInline({
         sessionId: sid,
         query,
@@ -124,6 +126,15 @@ export function doRecall(runtime, config, ctx, query, source) {
             /* non-fatal: recall provenance never breaks the recall path */
         }
     }
+    // VC0A: record recall latency on the eval observer (mode A) so the dashboard
+    // histogram reflects real data. No-op when the observer is absent (flag off /
+    // construction failure).
+    try {
+        recordRecallLatency(runtime, Date.now() - recallStartMs, sid, 0);
+    }
+    catch {
+        /* non-fatal: latency recording never breaks recall */
+    }
     return result;
 }
 /**