pi-mega-compact 0.20.69 → 0.20.71

package/extensions/dashboard-client/src/types/setup-cortex.ts

@@ -73,7 +73,11 @@ export interface SetupCortexStatusResponse {
 }
 
 /** The set of developer actions the Setup Cortex action drivers can run. */
-export type SetupCortexActionKind = "fetch-model" | "bench" | "verify-asset";
+export type SetupCortexActionKind =
+  | "fetch-model"
+  | "bench"
+  | "verify-asset"
+  | "install-native-ort";
 
 /** Request body for POST /api/setup-cortex-action. confirm:true required. */
 export interface SetupCortexActionRequest {
@@ -81,6 +85,17 @@ export interface SetupCortexActionRequest {
   readonly confirm: boolean;
 }
 
+/** ENC-2b/ENC-2c: the native onnxruntime qualification retest result (server
+ *  shape mirror from api-contracts/setup-cortex-native-ort.ts). */
+export interface NativeOrtRetestResult {
+  readonly platform: string;
+  readonly version: string;
+  readonly verdict: "qualified" | "degraded" | "failed";
+  readonly p95Ms: number;
+  readonly rssMiB: number;
+  readonly testedAt: string;
+}
+
 /** Outcome of running one Setup Cortex action. */
 export interface SetupCortexActionResult {
   readonly action: SetupCortexActionKind;
@@ -89,6 +104,12 @@ export interface SetupCortexActionResult {
   readonly logPath: string;
   readonly logName: string;
   readonly spawned: boolean;
+  /** ENC-2c: fresh retest result for install-native-ort (null when retest
+   *  could not run / no binding). Present ONLY for install-native-ort. */
+  readonly nativeOrtRetestResult?: NativeOrtRetestResult | null;
+  /** ENC-2c: effective backend after install retest — "native" when verdict is
+   *  "qualified", else "wasm". Present ONLY for install-native-ort. */
+  readonly nativeOrtBackendEffective?: "native" | "wasm";
 }
 
 /** Error body used when a hard gate blocks the requested action. */

package/extensions/dashboard-server/api-contracts/setup-cortex-native-ort.ts

@@ -0,0 +1,52 @@
+/**
+ * api-contracts/setup-cortex-native-ort.ts — ENC-2c native onnxruntime
+ * lazy-download INSTALL action contract types.
+ *
+ * Sibling additive types for the VC9B action driver: POST /api/setup-cortex-action
+ * gains the `install-native-ort` action that, when confirmed, runs the committed
+ * scripts/encoder/install-native-ort.mjs subprocess locally (npm-delegated,
+ * sha256-verified) and then re-qualifies the binding via the ENC-2b retest path.
+ *
+ * The retest result shape mirrors `RetestResult` from
+ * extensions/dashboard-server/api-contracts/setup.ts (and
+ * src/vector-cortex/encoder/native-qualify-retest.ts): { platform, version,
+ * verdict, p95Ms, rssMiB, testedAt }. It is declared here rather than imported
+ * from src/ so the contract lives wholly in the extensions layer (PREVENT-PI —
+ * extensions never import impl internals) and stays self-contained.
+ *
+ * PREVENT-PI-004: type definitions only, no network code. The install action is
+ * a confirm-gated, npm-delegated local subprocess with NO URL literals (registry
+ * URL + sha256 live only in native-install-artifacts.ts).
+ * PREVENT-011: no `any` type — all types explicit.
+ */
+
+import type { SetupCortexActionResult } from "./setup-cortex.js";
+
+/** ENC-2b/ENC-2c: the native onnxruntime qualification retest result (shape
+ *  mirror of api-contracts/setup.ts `RetestResult`). Surfaces only platform,
+ *  version, verdict, p95/RSS, testedAt — never binding binary contents or model
+ *  weights (SECURITY_PRIVACY). */
+export interface NativeOrtRetestResult {
+  readonly platform: string;
+  readonly version: string;
+  readonly verdict: "qualified" | "degraded" | "failed";
+  readonly p95Ms: number;
+  readonly rssMiB: number;
+  readonly testedAt: string;
+}
+
+/** The action kind union, which now includes the ENC-2c lazy-download install
+ *  action (widen source: setup-cortex.ts). */
+export type SetupCortexActionKindWithInstall = SetupCortexActionResult["action"];
+
+/** ENC-2c additive fields appended to the setup-cortex action result once the
+ *  install subprocess completes (retest ran regardless of install exit code). */
+export interface SetupCortexActionResultWithNativeOrt
+  extends SetupCortexActionResult {
+  /** Fresh ENC-2b qualification retest result after install (null when the
+   *  retest could not run / no binding). Present ONLY for install-native-ort. */
+  readonly nativeOrtRetestResult?: NativeOrtRetestResult | null;
+  /** Effective backend after the retest: "native" when verdict is `qualified`,
+   *  otherwise "wasm". Present ONLY for install-native-ort. */
+  readonly nativeOrtBackendEffective?: "native" | "wasm";
+}

package/extensions/dashboard-server/api-contracts/setup-cortex.ts

@@ -82,8 +82,14 @@ export interface SetupCortexStatusResponse {
 
 // ─── VC9B action drivers ────────────────────────────────────────────────────
 
-/** The set of developer actions the Setup Cortex action drivers can run. */
-export type SetupCortexActionKind = "fetch-model" | "bench" | "verify-asset";
+/** The set of developer actions the Setup Cortex action drivers can run.
+ *  ENC-2c adds `install-native-ort` (confirm-gated lazy-download native install
+ *  + re-qualification), surfaced additively via setup-cortex-native-ort.ts. */
+export type SetupCortexActionKind =
+  | "fetch-model"
+  | "bench"
+  | "verify-asset"
+  | "install-native-ort";
 
 /**
  * Request body for POST /api/setup-cortex-action. `confirm:true` is the

package/extensions/dashboard-server/routes-rag-settings-vector-cortex.ts

@@ -326,6 +326,12 @@ export const VECTOR_CORTEX_SETTINGS: SettingGroup = {
 			"ENC-2b re-probes and re-qualifies the installed native onnxruntime binding (onnxruntime-node in ~/.pi/mega-compact/native-ort/, operator-installed via the ENC-2a guide): loads the LOCAL on-disk binding, runs a bounded warmup + p95 probe, measures RSS, and computes a fresh qualification verdict against the ENC-0f p95 budget + the operator install-budget. Never downloads or trains (PREVENT-PI-004 / HG-1 unchanged); surfaces nativeOrtRetestResult + nativeOrtBackendEffective on the GET /api/setup-status. OFF = no retest GET fields, no retest POST branch, no retest card (byte-identical ENC-2a predecessor).",
 			true,
 		),
+		boolDirect(
+			"MEGACOMPACT_ENC_2C",
+			"ENC-2c native ONNX runtime lazy-download INSTALL action (dashboard-triggered)",
+			"ENC-2c turns ENC-2a's operator run-script assist into a confirm-gated dashboard action: the Setup Cortex sub-tab gains an Install Native ORT button that, when the operator confirms, runs the committed scripts/encoder/install-native-ort.mjs subprocess locally (npm-delegated, sha256-verified) and then re-qualifies the binding via the ENC-2b retest path, exposing nativeOrtRetestResult / nativeOrtBackendEffective on the completion. PREVENT-PI-004 opt-in exemption: confirm-gated, npm-delegated, no URL literals (registry URL + sha256 live only in native-install-artifacts.ts). OFF = no install action POST branch, no UI button, no install result fields (byte-identical ENC-2b predecessor).",
+			true,
+		),
 		boolDirect(
 			"MEGACOMPACT_COSINE_FP_BENCH",
 			"COS-FP-A Synthetic FP Bench",

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

@@ -5,13 +5,14 @@
  *   GET  /api/setup-cortex-action-log        — bounded, redacted log tail
  *
  * Reader/actor-only: NEVER exposes payload bytes, prompts, or ledger. Actions
- * only spawn the committed local vc2-model-prep scripts or re-read the committed
- * encoder assets (verify-asset) — no network (PREVENT-PI-004). A hard gate
- * (HG-1/HG-3) blocking the requested action yields 423 action_blocked_by_open_item
- * with the blocker ids and NO subprocess is spawned. Missing confirm:true yields
- * 400 confirmation_required. Flag-off (MEGACOMPACT_VC9B=0) is byte-identical to
- * the VC9A-era predecessor: the routes are absent, so they return the 404
- * disabled shape and no action runs.
+ * only spawn the committed local vc2-model-prep scripts, re-read the committed
+ * encoder assets (verify-asset), or — ENC-2c — run the confirm-gated npm-delegated
+ * native onnxruntime install (install-native-ort) + re-qualify — no network in
+ * this layer (PREVENT-PI-004). A hard gate (HG-1/HG-3) blocking the requested
+ * action yields 423 action_blocked_by_open_item with the blocker ids and NO
+ * subprocess is spawned. Missing confirm:true yields 400 confirmation_required.
+ * Flag-off (MEGACOMPACT_VC9B=0) is byte-identical to the VC9A-era predecessor:
+ * the routes are absent, so they return the 404 disabled shape and no action runs.
  *
  * Guardrails: PREVENT-011 (no `any`), PREVENT-001 (guarded JSON.parse via
  * readJsonBody), no string literals for scripts/blockers (delegated to
@@ -24,7 +25,12 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { RouteContext } from "./routes-core.js";
 import { sendJson, readJsonBody } from "./routes-vector-cortex-shared.js";
-import { VC9B_ENABLED, ENC_0G_ENABLED, ENC_0F_ENABLED } from "../../src/config.js";
+import {
+  VC9B_ENABLED,
+  ENC_0G_ENABLED,
+  ENC_0F_ENABLED,
+  ENC_2C_ENABLED,
+} from "../../src/config.js";
 import { setupCortexActionBlockers, computeSetupCortexBlockers } from "./setup-cortex-blockers.js";
 import { readEncoderManifest, detectPlatform } from "../../src/vector-cortex/encoder/asset.js";
 import {
@@ -41,6 +47,7 @@ const ACTION_KINDS = new Set<SetupCortexActionKind>([
   "fetch-model",
   "bench",
   "verify-asset",
+  "install-native-ort",
 ]);
 
 function isActionKind(v: unknown): v is SetupCortexActionKind {
@@ -113,7 +120,9 @@ export function handleSetupCortexAction(
     }
     const value = parsed.value;
     const action = value.action;
-    if (!isActionKind(action)) {
+    // ENC-2c: install-native-ort is recognized ONLY while ENC_2C is on —
+    // flag-off is byte-identical to the ENC-2b predecessor (invalid_action).
+    if (!isActionKind(action) || (action === "install-native-ort" && !ENC_2C_ENABLED())) {
       sendJson(res, 400, { error: "invalid_action" });
       return;
     }
@@ -134,8 +143,10 @@ export function handleSetupCortexAction(
       });
       return;
     }
-    const result = runSetupCortexAction(action, ctx.stateDir);
-    sendJson(res, result.ok ? 200 : 500, result);
+    void (async () => {
+      const result = await runSetupCortexAction(action, ctx.stateDir);
+      sendJson(res, result.ok ? 200 : 500, result);
+    })();
   });
   return true;
 }

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;