pi-mega-compact 0.20.70 → 0.20.72

package/dist/vector-cortex/cache/store.js

@@ -70,6 +70,11 @@ export class CrystalStore {
     writes = 0;
     duplicateWrites = 0;
     collisions = 0;
+    /** Restart-survival crystal count/bytes (LIVEWIRE rehydrate). The `committed`
+     *  map is empty in a fresh process; these offsets carry the persisted totals
+     *  so the dashboard does not reset to zero on restart. */
+    rehydratedCrystalCount = 0;
+    rehydratedTotalBytes = 0;
     /** Freeze a crystal object for a key/bytes pair (digest computed here). */
     static freeze(keyDigest, bytes, key) {
         const copy = new Uint8Array(bytes);
@@ -178,12 +183,12 @@ export class CrystalStore {
     }
     /** Reader-only aggregate for the dashboard seam — counts and bytes only. */
     stats() {
-        let totalBytes = 0;
+        let totalBytes = this.rehydratedTotalBytes;
         for (const c of this.committed.values())
             totalBytes += c.byteCount;
         return {
             mode: this.mode(),
-            crystalCount: this.committed.size,
+            crystalCount: this.rehydratedCrystalCount + this.committed.size,
             totalBytes,
             hits: this.hits,
             misses: this.misses,
@@ -193,4 +198,22 @@ export class CrystalStore {
             collisions: this.collisions,
         };
     }
+    /**
+     * Restart survival: seed the CUMULATIVE counters from a previously-persisted
+     * aggregate (LIVEWIRE). The in-memory `committed` map is naturally empty in a
+     * fresh process — this only restores the running totals the dashboard reports,
+     * so a process restart does not reset the dashboard to zero. It deliberately
+     * does NOT reconstruct crystals: frozen bytes are never persisted to the
+     * reader aggregate, only the counts.
+     */
+    rehydrate(stats) {
+        this.rehydratedCrystalCount = stats.crystalCount;
+        this.rehydratedTotalBytes = stats.totalBytes;
+        this.hits = stats.hits;
+        this.misses = stats.misses;
+        this.hitBytes = stats.hitBytes;
+        this.writes = stats.writes;
+        this.duplicateWrites = stats.duplicateWrites;
+        this.collisions = stats.collisions;
+    }
 }

package/dist/vector-cortex/encoder/asset.js

@@ -67,7 +67,14 @@ function isManifest(m) {
         typeof o.onnx.path === "string" &&
         typeof o.onnx.sha256 === "string" &&
         typeof o.tokenizer.path === "string" &&
-        typeof o.tokenizer.sha256 === "string");
+        typeof o.tokenizer.sha256 === "string" &&
+        // ML5-A (VC2B-2): optional headWeights must, when present, be a valid
+        // ManifestAssetFile (path basename + sha256 + bytes).
+        (o.headWeights === undefined ||
+            (!!o.headWeights &&
+                typeof o.headWeights.path === "string" &&
+                typeof o.headWeights.sha256 === "string" &&
+                typeof o.headWeights.bytes === "number")));
 }
 /**
  * Verify the asset manifest + digest + constraints BEFORE allocation.
@@ -107,6 +114,11 @@ export function verifyEncoderAsset(assetDir, manifest, platform = detectPlatform
     if (!isBasename(manifest.onnx.path) || !isBasename(manifest.tokenizer.path)) {
         return { ok: false, code: ENC_FAIL.MANIFEST_INVALID };
     }
+    // ML5-A (VC2B-2): a manifest-declared headWeights path must also be a bare
+    // basename (no traversal into arbitrary paths off the asset dir).
+    if (manifest.headWeights !== undefined && !isBasename(manifest.headWeights.path)) {
+        return { ok: false, code: ENC_FAIL.MANIFEST_INVALID };
+    }
     const onnxPath = join(assetDir, manifest.onnx.path);
     const onnxDigest = digestFile(onnxPath);
     if (onnxDigest === null)
@@ -119,6 +131,19 @@ export function verifyEncoderAsset(assetDir, manifest, platform = detectPlatform
         return { ok: false, code: ENC_FAIL.ASSET_UNREADABLE };
     if (tokDigest !== manifest.tokenizer.sha256)
         return { ok: false, code: ENC_FAIL.DIGEST_MISMATCH };
+    // ML5-A (VC2B-2): verify the manifest-pinned trained-heads sibling when the
+    // manifest declares it. Absent declaration -> headWeightsDigest: null and no
+    // failure (committed placeholder bundle ships no trained weights).
+    let headWeightsDigest = null;
+    if (manifest.headWeights !== undefined) {
+        const hwPath = join(assetDir, manifest.headWeights.path);
+        const hwDigest = digestFile(hwPath);
+        if (hwDigest === null)
+            return { ok: false, code: ENC_FAIL.ASSET_UNREADABLE };
+        if (hwDigest !== manifest.headWeights.sha256)
+            return { ok: false, code: ENC_FAIL.DIGEST_MISMATCH };
+        headWeightsDigest = hwDigest;
+    }
     let embeddedBytes = 0;
     try {
         embeddedBytes = statSync(onnxPath).size + statSync(tokPath).size;
@@ -126,7 +151,14 @@ export function verifyEncoderAsset(assetDir, manifest, platform = detectPlatform
     catch {
         return { ok: false, code: ENC_FAIL.ASSET_UNREADABLE };
     }
-    return { ok: true, embeddedBytes, maxTokens: manifest.maxTokens, onnxDigest, tokenizerDigest: tokDigest };
+    return {
+        ok: true,
+        embeddedBytes,
+        maxTokens: manifest.maxTokens,
+        onnxDigest,
+        tokenizerDigest: tokDigest,
+        headWeightsDigest,
+    };
 }
 /**
  * Read + shape-check a committed ModelManifestV1 from an asset directory.

package/dist/vector-cortex/encoder/router.js

@@ -25,11 +25,12 @@
  * Pi-agnostic, zero network (PREVENT-PI-004), no `any` (PREVENT-011).
  */
 import { createEncoderRuntime } from "./runtime.js";
-import { encodeVectorSet } from "./heads.js";
+import { encodeVectorSet, loadHeadProjections, projectHeadFromTrunk, } from "./heads.js";
 import { embedTrigram512, selectTrigramBFallback } from "./trigram.js";
 import { embedLexical, selectLexicalC } from "./lexical.js";
 import { createEncoderHeadsReporter } from "./emit-vc2b.js";
-import { ENC_FAIL, } from "./types.js";
+import { ML5A_ENABLED } from "../../config/vector-cortex.js";
+import { ENC_FAIL, ENCODER_HEAD_ORDER, } from "./types.js";
 /** Deterministic text derived from an int token sequence so the asset-free
  *  fallback producers operate on the same authority the learned path encoded. */
 function textFromTokens(tokens) {
@@ -92,9 +93,36 @@ export function encodeOrFallback(input, assetDir, options = {}) {
     if (!inferred.ok) {
         return fallbackFromLoad({ ok: false, mode: "B", code: inferred.code }, reporter, tokens);
     }
-    const vectorSet = encodeVectorSet(tokens, { reporter, seed: options.seed });
+    const vectorSet = produceVectorSet(inferred.semantic, tokens, options, reporter);
     return { ok: true, mode: "A", vectorSet, code: null };
 }
+/**
+ * Produce a mode-A `VectorSetV1` from the [1,384] trunk embedding (the
+ * `runtime.infer` result). VC2B-2 ML5-A: when real trained heads are loaded
+ * (`MEGACOMPACT_ML5_A` on + a `trainedHeadsPath` that loads), the multi-head
+ * output is projected through the real trained projection matrices via
+ * `projectHeadFromTrunk`. Otherwise (flag-off / absent / unloadable artifact)
+ * the deterministic LCG placeholder `encodeVectorSet` serves mode A —
+ * byte-identical to the VC2B predecessor. Non-fatal: an unloadable artifact
+ * degrades to the placeholder, never a throw.
+ */
+function produceVectorSet(trunkEmbedding, tokens, options, reporter) {
+    const table = ML5A_ENABLED() && options.trainedHeadsPath !== undefined
+        ? loadHeadProjections(options.trainedHeadsPath)
+        : null;
+    if (table !== null) {
+        const heads = ENCODER_HEAD_ORDER.map((h) => projectHeadFromTrunk(h, trunkEmbedding, table));
+        reporter.headsEmitted({
+            heads: heads.length,
+            dims: heads.map((h) => h.dim).join("/"),
+            normalized: true,
+            tokens: tokens.length,
+        });
+        return { schema: "vector-set-v1", inputTokens: [...tokens], heads, normalized: true };
+    }
+    // ML5-A placeholder fallback (byte-identical predecessor).
+    return encodeVectorSet(tokens, { reporter, seed: options.seed });
+}
 /**
  * Catch a (real or forced) A load failure (ok === false only) and select the
  * B/C fallback that emits `vector_cortex_encoder_fallback_selected` from the

package/dist/vector-cortex/provider/registry.js

@@ -45,48 +45,80 @@ function baseCache(stableFields) {
     };
 }
 /** Build a contract-profile shape pinned as a conformance fixture too. */
-function profile(id, version, excludedJsonPointers) {
+function profile(id, version, excludedJsonPointers, economics) {
     return {
         schema: "provider-profile-v1",
         id,
         version,
         hashMode: "entire-canonical-request",
         excludedJsonPointers,
+        economics,
     };
 }
+/**
+ * Build integer micro-unit economics for a base profile (VC7B). A cache WRITE
+ * costs more than an uncached token, a cache READ costs less — the standard
+ * provider-prompt-cache shape. `exclusionFixtureId` mirrors the profile's own
+ * exclusion fixture (or null when the profile has none to prove).
+ */
+function econ(id, version, exclusionFixtureId, values) {
+    return {
+        schema: "provider-economics-v1",
+        profileId: id,
+        profileVersion: version,
+        basePrice: values.basePrice,
+        readPrice: values.readPrice,
+        writePrice: values.writePrice,
+        ttlMs: values.ttlMs,
+        minPrefix: values.minPrefix,
+        exclusionFixtureId,
+    };
+}
+/** Representative integer micro-unit economics for the Anthropic opus base tier. */
+const OPUS_ECON = econ("anthropic-claude-opus", "v1", null, { basePrice: 15, readPrice: 2, writePrice: 19, ttlMs: 300_000, minPrefix: 1024 });
+/** Representative integer micro-unit economics for the Anthropic sonnet base tier. */
+const SONNET_ECON = econ("anthropic-claude-sonnet", "v1", null, { basePrice: 3, readPrice: 0, writePrice: 4, ttlMs: 300_000, minPrefix: 1024 });
+/** Representative integer micro-unit economics for the OpenAI gpt base tier. */
+const GPT_ECON = econ("openai-gpt", "v1", null, { basePrice: 5, readPrice: 1, writePrice: 6, ttlMs: 300_000, minPrefix: 1024 });
+/** The gemini profile's versioned, fixture-proven exclusion. */
+const GEMINI_EXCLUSIONS = [
+    {
+        pointer: "/requestId",
+        fixtureId: "PRO-EXCLUDE-010",
+        proofDigest: "sha256:excluded-request-id-proof",
+    },
+];
+/** Representative integer micro-unit economics for the gemini base tier. */
+const GEMINI_ECON = econ("google-gemini", "v1", "PRO-EXCLUDE-010", { basePrice: 3, readPrice: 1, writePrice: 4, ttlMs: 300_000, minPrefix: 1024 });
 /**
  * The fixture-backed base profiles. Each entry is the REAL bundle the renderer
  * resolves; the parallel conformance fixtures prove the cache-identity behavior.
  */
 const BASE_PROFILES = [
     {
-        profile: profile("anthropic-claude-opus", "v1", []),
+        profile: profile("anthropic-claude-opus", "v1", [], OPUS_ECON),
         role: BASE_ROLE,
         tool: BASE_TOOL,
         cache: baseCache(["systemPromptPrepend", "tools", "nodes"]),
     },
     {
-        profile: profile("anthropic-claude-sonnet", "v1", []),
+        profile: profile("anthropic-claude-sonnet", "v1", [], SONNET_ECON),
         role: BASE_ROLE,
         tool: BASE_TOOL,
         cache: baseCache(["systemPromptPrepend", "tools", "nodes"]),
     },
     {
-        profile: profile("openai-gpt", "v1", []),
+        profile: profile("openai-gpt", "v1", [], GPT_ECON),
         role: BASE_ROLE,
         tool: BASE_TOOL,
         cache: baseCache(["systemPromptPrepend", "tools", "nodes"]),
     },
     {
         // A profile that proves a fixture-excluded pointer: a provider whose
-        // request-id header cannot affect cache identity. Excluded + versioned.
-        profile: profile("google-gemini", "v1", [
-            {
-                pointer: "/requestId",
-                fixtureId: "PRO-EXCLUDE-010",
-                proofDigest: "sha256:excluded-request-id-proof",
-            },
-        ]),
+        // request-id header cannot affect cache identity. Excluded + versioned, and
+        // the exclusion fixture id is carried into economics so the proof is
+        // honored (an unproven exclusion would fail economics validation).
+        profile: profile("google-gemini", "v1", GEMINI_EXCLUSIONS, GEMINI_ECON),
         role: BASE_ROLE,
         tool: BASE_TOOL,
         cache: baseCache(["systemPromptPrepend", "tools", "nodes"]),

package/dist/vector-cortex/setup-cortex-blockers-compute.js

@@ -14,9 +14,12 @@
  * all-open, byte-identical to ENC-0f-era for flag-off). `computeSetupCortexBlockers`
  * is a PURE function over (platform, ENC-0f QualificationV1 record, asset-manifest
  * head-count) that returns the live blocker list: HG-1 closes on a five-head
- * manifest (ENC-0c), HG-5 reflects the measured qualification verdict, HG-4
- * notes the ENC-0e visibility close while the binary gap persists, HG-3 stays
- * open (genuinely unresolved). `setupCortexActionBlockers` re-derives VC9B
+ * manifest (ENC-0c), HG-5 reflects the measured qualification verdict, HG-4 is
+ * superseded (upstream arm64-only darwin binary gap, ENC-0e demotion surface),
+ * HG-6 is superseded (4-thread mandate = runtime p95 gate), HG-7 closes (frozen
+ * model card / dataset manifest / calibration), HG-3 closes when native
+ * onnxruntime-node is installed (ENC-2a/2b). `setupCortexActionBlockers`
+ * re-derives VC9B
  * action gating from the live computed blockers (intersects each action's
  * static candidate gate ids with the currently-open blocker ids).
  *
@@ -26,6 +29,7 @@
  * never magic numbers in the computed path.
  */
 import { ENCODER_HEAD_ORDER, ENCODER_LATENCY_P95_MS, ENCODER_RSS_BUDGET_BYTES, } from "./encoder/types.js";
+import { INSTALL_BUDGET_DEFAULT_MIB } from "./encoder/decision.js";
 const MIB = 1024 * 1024;
 /**
  * Marker threshold-failure emitted by the status route when NO QualificationV1
@@ -100,14 +104,20 @@ export function setupCortexBlocker(id) {
  *  - HG-1 → `"closed"` when the asset manifest declares all five projection
  *    heads (`headCount === ENCODER_HEAD_ORDER.length`); otherwise stays open.
  *  - HG-3 → unchanged (genuinely open — onnxruntime-node budget unresolved).
- *  - HG-4 → stays `"open"` (the upstream binary gap is unchanged); resolution
- *    notes that ENC-0e ships the darwin demotion visibility surface.
+ *  - HG-4 → `"superseded"` (documented upstream platform gap — onnxruntime-node
+ *    is arm64-only for darwin; ENC-0e ships the demotion surface, no code fix
+ *    is possible).
  *  - HG-5 → derived from the qualification record: an empty record is
  *    `"superseded"` (no measurement on this device); a `failed` verdict closes
  *    it with the measured p95/RSS wording; a `qualified` verdict closes it with
  *    "measured" wording. Severity stays `"medium"` from the base row.
+ *  - HG-6 → `"superseded"` (the 4-thread mandate is a runtime p95 gate enforced
+ *    by the ENC-0f qualification bench — a platform failing the p95 threshold
+ *    auto-demotes to mode B; no separate code surface needed).
+ *  - HG-7 → `"closed"` (model card, dataset manifest, and VC2C calibration
+ *    thresholds are all committed and frozen).
  * `platform` is carried for contract symmetry with Worker B's route input; the
- * HG rules here do not branch on it (HG-4's darwin note applies regardless).
+ * HG rules here do not branch on it (the closures are unconditional).
  */
 export function computeSetupCortexBlockers(input) {
     const { qualification, headCount } = input;
@@ -117,10 +127,36 @@ export function computeSetupCortexBlockers(input) {
                 return headCount === ENCODER_HEAD_ORDER.length
                     ? { ...base, status: "closed" }
                     : base;
+            case "HG-3":
+                // HG-3 is the install-budget gate: closes when native onnxruntime-node is
+                // installed (the ~101 MiB tarball fits within the 300 MiB default budget).
+                // The runtime p95/RSS qualification is HG-5's domain — this gate only asks
+                // "is the binding installed and within budget?".
+                if (input.nativeOrtInstalledVersion != null) {
+                    return {
+                        ...base,
+                        status: "closed",
+                        resolution: `Native onnxruntime-node ${input.nativeOrtInstalledVersion} installed (~101 MiB, within the ${INSTALL_BUDGET_DEFAULT_MIB} MiB budget). Runtime qualification is HG-5.`,
+                    };
+                }
+                return base;
             case "HG-4":
                 return {
                     ...base,
-                    resolution: `${base.resolution} ENC-0e shipped the darwin demotion visibility surface.`,
+                    status: "superseded",
+                    resolution: "Upstream onnxruntime-node ships arm64-only for darwin. ENC-0e ships the demotion surface: darwin-x64 users use the WASM path (mode B) or lexical fallback (mode C). No code fix is possible — the binary does not exist upstream.",
+                };
+            case "HG-6":
+                return {
+                    ...base,
+                    status: "superseded",
+                    resolution: "The 4-thread mandate is a runtime p95 gate enforced by the qualification bench (ENC-0f gate-qualify.mjs). A platform that fails the p95 latency threshold (40ms) is automatically demoted to mode B — no separate code surface needed. Low-core platforms are handled by the same qualification gate.",
+                };
+            case "HG-7":
+                return {
+                    ...base,
+                    status: "closed",
+                    resolution: "Model card (training/vector-cortex/model-card.json), dataset manifest (training/vector-cortex/dataset-manifest.json), and VC2C calibration thresholds (EVALUATION_THRESHOLDS in types-vc2c.ts) are all committed and frozen.",
                 };
             case "HG-5":
                 if (qualification === null) {

package/extensions/dashboard-server/routes-setup-cortex.ts

@@ -25,7 +25,7 @@ import { readFileSync, statSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { RouteContext } from "./routes-core.js";
-import { VC9A_ENABLED, ENC_0E_ENABLED, ENC_0F_ENABLED, ENC_0G_ENABLED } from "../../src/config.js";
+import { VC9A_ENABLED, ENC_0E_ENABLED, ENC_0F_ENABLED, ENC_0G_ENABLED, ENC_2A_ENABLED } from "../../src/config.js";
 import { readEncoderManifest, verifyEncoderAsset, detectPlatform } from "../../src/vector-cortex/encoder/asset.js";
 import type { QualificationV1 } from "../../src/vector-cortex/encoder/qualify.js";
 import { selectRuntimeBackend } from "../../src/vector-cortex/encoder/runtime-select.js";
@@ -37,6 +37,7 @@ import {
   encoderStateDir,
   QUALIFICATION_RECORD_UNAVAILABLE,
 } from "./qualification-record.js";
+import { readEnc2aGuide } from "./routes-setup-enc2a.js";
 import type {
   SetupCortexStatusResponse,
   BlockerV1,
@@ -214,12 +215,18 @@ export function handleSetupCortexStatus(
 
   const facts = enabled ? setupCortexFacts(record, recordGate) : null;
 
+  // ENC-2a native ORT detection: pass the installed version + retest verdict to
+  // the blockers compute so HG-3 can close when native is installed + qualified.
+  const enc2a = enabled && ENC_2A_ENABLED() ? readEnc2aGuide(encoderStateDir()) : null;
+  const nativeOrtInstalledVersion = enc2a?.installedVersion ?? null;
+
   const blocks: BlockerV1[] = enabled
     ? enc0g
       ? [...computeSetupCortexBlockers({
           platform: detectPlatform(),
           qualification: record,
           headCount: facts ? facts.headCount : null,
+          nativeOrtInstalledVersion,
         })]
       : [...SETUP_CORTEX_BLOCKERS]
     : [];

package/extensions/dashboard-server/routes-vector-cortex-crystals.ts

@@ -28,21 +28,21 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import type { RouteContext } from "./routes-core.js";
 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";
+import { readLivewireSnapshot } from "../../src/vector-cortex/livewire/livewire-registry.js";
 import type { VectorCortexCrystalsView } from "./api-contracts/vector-cortex-cache.js";
 
-// Actual events emitted by src/vector-cortex/cache/crystal-emit.ts.
-const CRYSTAL_EVENTS = [
-  "vector_cortex_crystal_written",
-  "vector_cortex_crystal_collision",
-] as const;
+// The flag-off deferred reason, kept byte-identical to the pre-LIVEWIRE
+// predecessor (VC7A: `crystal_store_not_instantiated_v0_20_23`).
+const DEFERRED_REASON = "crystal_store_not_instantiated_v0_20_23";
 
 /**
  * Reader-only GET /api/vector-cortex/cache-crystals (VC7A).
  *
- * Counts, byte volumes, and CRY_* codes only — a static reader-only aggregate
- * seam with the same shape as the VC6A/VC6B/VC6C handlers.
+ * Counts, byte volumes, and CRY_* codes only. With the flag ON it surfaces the
+ * LIVEWIRE `CrystalStore` aggregate (live reads/writes/collisions accumulated at
+ * runtime); with the flag OFF it returns the byte-identical legacy deferred view
+ * (mode C, deferredReason present) so flag-off parity holds.
  */
 export function handleVectorCortexCrystals(
   req: IncomingMessage,
@@ -58,31 +58,47 @@ export function handleVectorCortexCrystals(
   }
 
   const enabled = VC7A_ENABLED();
-  const counts = countVcEvents(ctx.stateDir, CRYSTAL_EVENTS);
-  // Flag-off routes to mode C: with VC7A off nothing is served from the crystal
-  // cache, which is exactly the spec's "cache bypass" outcome. Reporting A (hit)
-  // or B (fresh render forced by a miss) would imply a cache path that is not
-  // wired at all. Mirrors how VC6C's OFF view reports the mode it actually takes.
-  const mode: "A" | "B" | "C" = enabled ? "A" : "C";
+  if (!enabled) {
+    // Flag-off parity: byte-identical to the predecessor (mode C + deferred).
+    const body: VectorCortexCrystalsView = {
+      enabled: false,
+      mode: "C",
+      crystalCount: 0,
+      totalBytes: 0,
+      hits: 0,
+      misses: 0,
+      hitBytes: 0,
+      writes: 0,
+      duplicateWrites: 0,
+      collisions: 0,
+      lastFailure: null,
+      updatedAt: new Date().toISOString(),
+      deferredReason: DEFERRED_REASON,
+      status: deriveVcStatus({ enabled: false, hasData: false }),
+    };
+    sendJson(res, 200, body);
+    return true;
+  }
+
+  const snap = readLivewireSnapshot(ctx.stateDir);
+  const crystal = snap.crystals;
+  const hasData = crystal.crystalCount > 0;
   const body: VectorCortexCrystalsView = {
-    enabled,
-    mode,
-    crystalCount: vcCount(counts, "vector_cortex_crystal_written"),
-    totalBytes: 0,
-    hits: 0,
-    misses: 0,
-    hitBytes: 0,
-    writes: 0,
-    duplicateWrites: 0,
-    collisions: vcCount(counts, "vector_cortex_crystal_collision"),
+    enabled: true,
+    // Surface the store's honest triad mode (B until a hit, A after, C when the
+    // store was set unavailable) rather than a hardcoded A.
+    mode: crystal.mode,
+    crystalCount: crystal.crystalCount,
+    totalBytes: crystal.totalBytes,
+    hits: crystal.hits,
+    misses: crystal.misses,
+    hitBytes: crystal.hitBytes,
+    writes: crystal.writes,
+    duplicateWrites: crystal.duplicateWrites,
+    collisions: crystal.collisions,
     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,
-    }),
+    status: deriveVcStatus({ enabled: true, hasData }),
   };
   sendJson(res, 200, body);
   return true;

package/extensions/dashboard-server/routes-vector-cortex-diagnostics.ts

@@ -30,18 +30,21 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import type { RouteContext } from "./routes-core.js";
 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";
+import { readLivewireSnapshot } from "../../src/vector-cortex/livewire/livewire-registry.js";
 import type { VectorCortexDiagnosticsView } from "./api-contracts/vector-cortex-diagnostics.js";
 
-// Actual events emitted by src/vector-cortex/cache/diagnostics-emit.ts.
-const DIAGNOSTICS_EVENTS = ["vector_cortex_cache_serve_blocked"] as const;
+// The flag-off deferred reason, kept byte-identical to the pre-LIVEWIRE
+// predecessor (VC7C: `cache_classifier_not_wired_v0_20_23`).
+const DEFERRED_REASON = "cache_classifier_not_wired_v0_20_23";
 
 /**
  * Reader-only GET /api/vector-cortex/cache-diagnostics (VC7C).
  *
- * Per-miss-class counts, breaker state, and CACHE and M5 codes only — a static
- * reader-only aggregate seam with the same shape as the VC7B economics handler.
+ * Per-miss-class counts, serveBlocked, breaker state, and CACHE/M5 codes only.
+ * With the flag ON it surfaces the LIVEWIRE classifier/breaker tallies
+ * accumulated at runtime; with the flag OFF it returns the byte-identical legacy
+ * deferred view (mode C, deferredReason present).
  */
 export function handleVectorCortexDiagnostics(
   req: IncomingMessage,
@@ -57,32 +60,52 @@ export function handleVectorCortexDiagnostics(
   }
 
   const enabled = VC7C_ENABLED();
-  const counts = countVcEvents(ctx.stateDir, DIAGNOSTICS_EVENTS);
-  // Flag-off routes to mode C: with VC7C off the diagnostics/breaker reporter is
-  // suppressed, so no cache serve is attested here and the surface reports the
-  // all-cache bypass outcome. Reporting A (crystal served) or B (fresh render
-  // forced by a breaker) would attest a cache decision this seam is not wired to
-  // observe. Mirrors how the VC7A/VC7B OFF views report the mode they take.
-  const mode: "A" | "B" | "C" = enabled ? "A" : "C";
+  if (!enabled) {
+    // Flag-off parity: byte-identical to the predecessor (mode C + deferred).
+    const body: VectorCortexDiagnosticsView = {
+      enabled: false,
+      mode: "C",
+      profileMisses: 0,
+      rangeMisses: 0,
+      dependencyMisses: 0,
+      requestMisses: 0,
+      generationMisses: 0,
+      unknownMisses: 0,
+      serveBlocked: 0,
+      breakerState: "closed",
+      lastFailure: null,
+      updatedAt: new Date().toISOString(),
+      deferredReason: DEFERRED_REASON,
+      status: deriveVcStatus({ enabled: false, hasData: false }),
+    };
+    sendJson(res, 200, body);
+    return true;
+  }
+
+  const diag = readLivewireSnapshot(ctx.stateDir).diagnostics;
+  const hasData =
+    diag.profileMisses +
+      diag.rangeMisses +
+      diag.dependencyMisses +
+      diag.requestMisses +
+      diag.generationMisses +
+      diag.unknownMisses +
+      diag.serveBlocked >
+    0;
   const body: VectorCortexDiagnosticsView = {
-    enabled,
-    mode,
-    profileMisses: 0,
-    rangeMisses: 0,
-    dependencyMisses: 0,
-    requestMisses: 0,
-    generationMisses: 0,
-    unknownMisses: 0,
-    serveBlocked: vcCount(counts, "vector_cortex_cache_serve_blocked"),
-    breakerState: "closed",
-    lastFailure: null,
+    enabled: true,
+    mode: "A",
+    profileMisses: diag.profileMisses,
+    rangeMisses: diag.rangeMisses,
+    dependencyMisses: diag.dependencyMisses,
+    requestMisses: diag.requestMisses,
+    generationMisses: diag.generationMisses,
+    unknownMisses: diag.unknownMisses,
+    serveBlocked: diag.serveBlocked,
+    breakerState: diag.breakerState,
+    lastFailure: diag.lastFailure,
     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,
-    }),
+    status: deriveVcStatus({ enabled: true, hasData }),
   };
   sendJson(res, 200, body);
   return true;