pi-mega-compact 0.20.70 → 0.20.71

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/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;

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

@@ -28,18 +28,25 @@ import type { RouteContext } from "./routes-core.js";
 import { VC7B_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
 import { deriveVcStatus } from "./vc-status.js";
+import { readLivewireSnapshot } from "../../src/vector-cortex/livewire/livewire-registry.js";
 import type { VectorCortexEconomicsView } from "./api-contracts/vector-cortex-economics.js";
 
+// The flag-off deferred reason, kept byte-identical to the pre-LIVEWIRE
+// predecessor (VC7B: `economics_not_computed_v0_20_23`).
+const DEFERRED_REASON = "economics_not_computed_v0_20_23";
+
 /**
  * Reader-only GET /api/vector-cortex/cache-economics (VC7B).
  *
- * Counts, profile tallies, and ECON_* codes only — a static reader-only
- * aggregate seam with the same shape as the VC7A crystals handler.
+ * Counts, profile tallies, and ECON_* codes only. With the flag ON it surfaces
+ * the LIVEWIRE-provided profile economics tallies + the runtime `computed` bit;
+ * with the flag OFF it returns the byte-identical legacy deferred view (mode C,
+ * deferredReason present).
  */
 export function handleVectorCortexEconomics(
   req: IncomingMessage,
   res: ServerResponse,
-  _ctx: RouteContext,
+  ctx: RouteContext,
 ): boolean {
   const url = req.url ?? "";
   const path = url.split("?")[0] ?? url;
@@ -50,25 +57,33 @@ export function handleVectorCortexEconomics(
   }
 
   const enabled = VC7B_ENABLED();
-  // Flag-off routes to mode C: with VC7B off no cache economics are served, which
-  // is exactly the spec's "economics bypass" outcome. Reporting A (cached render
-  // priced) or B (fresh render priced) would imply an economics path that is not
-  // wired at all. Mirrors how VC6C/VC7A 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: VectorCortexEconomicsView = {
+      enabled: false,
+      mode: "C",
+      profileCount: 0,
+      provenExclusions: 0,
+      unprovenExclusions: 0,
+      lastFailure: null,
+      updatedAt: new Date().toISOString(),
+      deferredReason: DEFERRED_REASON,
+      status: deriveVcStatus({ enabled: false, hasData: false }),
+    };
+    sendJson(res, 200, body);
+    return true;
+  }
+
+  const econ = readLivewireSnapshot(ctx.stateDir).economics;
   const body: VectorCortexEconomicsView = {
-    enabled,
-    mode,
-    profileCount: 0,
-    provenExclusions: 0,
-    unprovenExclusions: 0,
-    lastFailure: null,
+    enabled: true,
+    mode: "A",
+    profileCount: econ.profileCount,
+    provenExclusions: econ.provenExclusions,
+    unprovenExclusions: econ.unprovenExclusions,
+    lastFailure: econ.lastFailure,
     updatedAt: new Date().toISOString(),
-    deferredReason: "economics_not_computed_v0_20_23",
-    status: deriveVcStatus({
-      enabled,
-      deferredReason: "economics_not_computed_v0_20_23",
-      hasData: false,
-    }),
+    status: deriveVcStatus({ enabled: true, hasData: econ.computed }),
   };
   sendJson(res, 200, body);
   return true;

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

@@ -108,3 +108,87 @@ export async function seedEval(dir: string): Promise<void> {
     { session: "s1", seq: 4, event: "encode", value: 12, unit: "ms", mode: "A" },
   ]);
 }
+
+/**
+ * Seed a LIVEWIRE aggregate snapshot directly on disk so the spawned dashboard
+ * server (a separate process) rehydrates real subsystem counts and its reader-only
+ * routes report LIVE (non-deferred) data. This is how the LIVEWIRE route tests
+ * prove the wiring: the runtimes' persisted counts are exactly what a reader
+ * process reconstructs. Counts + codes + triad mode only (SECURITY_PRIVACY).
+ */
+export async function seedLivewireSnapshot(
+  dir: string,
+  overrides?: {
+    crystals?: Partial<Record<
+      "crystalCount" | "totalBytes" | "hits" | "misses" | "hitBytes" |
+      "writes" | "duplicateWrites" | "collisions",
+      number
+    >>;
+    diagnostics?: Partial<Record<
+      "profileMisses" | "rangeMisses" | "dependencyMisses" | "requestMisses" |
+      "generationMisses" | "unknownMisses" | "serveBlocked",
+      number
+    >> & { breakerState?: string };
+    economics?: {
+      computed?: boolean;
+      profileCount?: number;
+      provenExclusions?: number;
+      unprovenExclusions?: number;
+    };
+    policy?: {
+      shadowDecisions?: number;
+      clampedDecisions?: number;
+      rejectedInputs?: number;
+      pressureVersion?: number;
+      liveMutations?: number;
+    };
+  },
+): Promise<void> {
+  const { saveLivewireSnapshot } = await import(
+    "../../src/vector-cortex/livewire/livewire-snapshot.js"
+  );
+  const c = overrides?.crystals ?? {};
+  const d = overrides?.diagnostics ?? {};
+  const e = overrides?.economics ?? {};
+  const p = overrides?.policy ?? {};
+  saveLivewireSnapshot(dir, {
+    schema: "vector-cortex-livewire-v1",
+    crystals: {
+      mode: "A",
+      crystalCount: c.crystalCount ?? 3,
+      totalBytes: c.totalBytes ?? 1024,
+      hits: c.hits ?? 0,
+      misses: c.misses ?? 0,
+      hitBytes: c.hitBytes ?? 0,
+      writes: c.writes ?? 0,
+      duplicateWrites: c.duplicateWrites ?? 0,
+      collisions: c.collisions ?? 0,
+    },
+    diagnostics: {
+      profileMisses: d.profileMisses ?? 0,
+      rangeMisses: d.rangeMisses ?? 0,
+      dependencyMisses: d.dependencyMisses ?? 0,
+      requestMisses: d.requestMisses ?? 0,
+      generationMisses: d.generationMisses ?? 0,
+      unknownMisses: d.unknownMisses ?? 0,
+      serveBlocked: d.serveBlocked ?? 0,
+      breakerState: d.breakerState ?? "CLOSED_A",
+      lastFailure: null,
+    },
+    economics: {
+      profileCount: e.profileCount ?? 4,
+      provenExclusions: e.provenExclusions ?? 1,
+      unprovenExclusions: e.unprovenExclusions ?? 0,
+      computed: e.computed ?? true,
+      lastFailure: null,
+    },
+    policy: {
+      shadowDecisions: p.shadowDecisions ?? 0,
+      clampedDecisions: p.clampedDecisions ?? 0,
+      rejectedInputs: p.rejectedInputs ?? 0,
+      liveMutations: p.liveMutations ?? 0,
+      pressureVersion: (p.pressureVersion ?? 1) as 1 | 2,
+      lastFailure: null,
+    },
+  });
+}

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

@@ -21,13 +21,18 @@ import type { RouteContext } from "./routes-core.js";
 import { VC8B_ENABLED } from "../../src/config.js";
 import { sendJson } from "./routes-vector-cortex-shared.js";
 import { deriveVcStatus } from "./vc-status.js";
+import { readLivewireSnapshot } from "../../src/vector-cortex/livewire/livewire-registry.js";
 import type { VectorCortexPolicyView } from "./api-contracts/vector-cortex-policy.js";
 
+// The flag-off deferred reason, kept byte-identical to the pre-LIVEWIRE
+// predecessor (VC8B: `shadow_controller_not_instantiated_v0_20_23`).
+const DEFERRED_REASON = "shadow_controller_not_instantiated_v0_20_23";
+
 /** GET /api/vector-cortex/policy — reader-only policy + shadow aggregate (VC8B). */
 export function handleVectorCortexPolicy(
   req: IncomingMessage,
   res: ServerResponse,
-  _ctx: RouteContext,
+  ctx: RouteContext,
 ): boolean {
   const url = req.url ?? "";
   const path = url.split("?")[0] ?? url;
@@ -39,23 +44,37 @@ export function handleVectorCortexPolicy(
   }
 
   const enabled = VC8B_ENABLED();
-  const mode: VectorCortexPolicyView["mode"] = enabled ? "A" : "C";
+  if (!enabled) {
+    // Flag-off parity: byte-identical to the predecessor (mode C + deferred).
+    const body: VectorCortexPolicyView = {
+      enabled: false,
+      mode: "C",
+      shadowDecisions: 0,
+      clampedDecisions: 0,
+      rejectedInputs: 0,
+      liveMutations: 0,
+      pressureVersion: 1,
+      lastFailure: null,
+      updatedAt: new Date().toISOString(),
+      deferredReason: DEFERRED_REASON,
+      status: deriveVcStatus({ enabled: false, hasData: false }),
+    };
+    sendJson(res, 200, body);
+    return true;
+  }
+
+  const policy = readLivewireSnapshot(ctx.stateDir).policy;
   const body: VectorCortexPolicyView = {
-    enabled,
-    mode,
-    shadowDecisions: 0,
-    clampedDecisions: 0,
-    rejectedInputs: 0,
-    liveMutations: 0,
-    pressureVersion: 1,
-    lastFailure: null,
+    enabled: true,
+    mode: "A",
+    shadowDecisions: policy.shadowDecisions,
+    clampedDecisions: policy.clampedDecisions,
+    rejectedInputs: policy.rejectedInputs,
+    liveMutations: policy.liveMutations,
+    pressureVersion: policy.pressureVersion,
+    lastFailure: policy.lastFailure,
     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,
-    }),
+    status: deriveVcStatus({ enabled: true, hasData: policy.shadowDecisions > 0 }),
   };
   sendJson(res, 200, body);
   return true;

package/package.json

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

package/src/vector-cortex/cache/store.ts

@@ -78,6 +78,11 @@ export class CrystalStore {
   private writes = 0;
   private duplicateWrites = 0;
   private 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. */
+  private rehydratedCrystalCount = 0;
+  private rehydratedTotalBytes = 0;
 
   /** Freeze a crystal object for a key/bytes pair (digest computed here). */
   static freeze(keyDigest: string, bytes: Uint8Array, key: CrystalV1["key"]): CrystalV1 {
@@ -196,11 +201,11 @@ export class CrystalStore {
 
   /** Reader-only aggregate for the dashboard seam — counts and bytes only. */
   stats(): CrystalStoreStats {
-    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,
@@ -210,4 +215,23 @@ 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: CrystalStoreStats): void {
+    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;
+  }
 }