pi-mega-compact 0.20.69 → 0.20.71

package/dist/config/vector-cortex-enc2c.js

@@ -0,0 +1,38 @@
+/**
+ * config/vector-cortex-enc2c.ts — ENC-2c native onnxruntime lazy-download
+ * install-action flag (dashboard-triggered install).
+ *
+ * Sibling of vector-cortex-enc2a.ts / vector-cortex-enc2b.ts so vector-cortex.ts
+ * stays under the 300-line soft limit (soft-as-hard gate). vector-cortex.ts
+ * re-exports the flag below and root src/config.ts re-exports it, so no consumer
+ * import path changes.
+ *
+ * ENC-2c turns ENC-2a's operator run-script assist into a dashboard action: the
+ * Setup Cortex sub-tab gains an "Install Native ORT" button that, when confirmed
+ * by the operator, 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. This is a PREVENT-PI-004 opt-in exemption:
+ * it is confirm-gated (never automatic), delegated to a local subprocess of a
+ * committed repo script, and carries NO URL literals in src/ or extensions/
+ * (the registry URL + sha256 live only in the artifacts-module constants).
+ *
+ * `MEGACOMPACT_ENC_2C=0` disables: no install action branch, no UI button, no
+ * install-related result fields — byte-identical to the ENC-2b predecessor. The
+ * flag MUST also be a dashboard SETTINGS toggle (visible in config UI, never in
+ * EXCLUDED_SETTINGS — see `feedback_dashboard-flags-toggleable` memory).
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ *
+ * guardrails-allow PREVENT-PI-004: opt-in confirm-gated install action;
+ * delegates to local npm install subprocess, no URL literals (registry URL +
+ * sha256 live only in native-install-artifacts.ts)
+ */
+import { sprintFlag } from "./vector-cortex-flag.js";
+/**
+ * ENC-2c — lazy-download native onnxruntime install action (dashboard-triggered,
+ * npm-delegated, confirm-gated). Default ON. `MEGACOMPACT_ENC_2C=0` disables and
+ * is byte-identical to the ENC-2b predecessor: no install action POST branch, no
+ * UI button, no install result fields. This flag MUST also be a dashboard SETTINGS
+ * toggle (visible in config UI, never in EXCLUDED_SETTINGS).
+ */
+export const ENC_2C_ENABLED = () => sprintFlag("MEGACOMPACT_ENC_2C");

package/dist/config/vector-cortex.js

@@ -54,5 +54,7 @@ export { ENC_2BUDGET_ENABLED, ENC_2BUDGET_NATIVE_ORT_BUDGET_ENV, ENC_2BUDGET_MAX
 export { ENC_2A_ENABLED } from "./vector-cortex-enc2a.js";
 // ENC-2b native onnxruntime qualification-retest flag extracted to vector-cortex-enc2b.ts.
 export { ENC_2B_ENABLED } from "./vector-cortex-enc2b.js";
+// ENC-2c native onnxruntime lazy-download install-action flag extracted to vector-cortex-enc2c.ts.
+export { ENC_2C_ENABLED } from "./vector-cortex-enc2c.js";
 // Breaker constants (TRIAD_RESILIENCE.md §breaker) extracted to vector-cortex-breakers.ts.
 export { BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./vector-cortex-breakers.js";

package/dist/config.js

@@ -114,4 +114,4 @@ export const NEW_UI = () => ragEnabled("MEGACOMPACT_NEW_UI");
 // default ON, `=0`/`_DISABLED` off. Re-exported from src/config/vector-cortex.ts
 // so root consumers share one source of truth.
 // ---------------------------------------------------------------------------
-export { VC0A_ENABLED, VC0B_ENABLED, VC1A_ENABLED, VC0C_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, VC3A_ENABLED, VC3B_ENABLED, VC3C_ENABLED, VC4A_ENABLED, VC4B_ENABLED, VC4C_ENABLED, VC5A_ENABLED, VC5B_ENABLED, VC5C_ENABLED, VC6A_ENABLED, VC6B_ENABLED, VC6C_ENABLED, VC7A_ENABLED, VC7B_ENABLED, VC7C_ENABLED, VC8A_ENABLED, VC8B_ENABLED, VC8C_ENABLED, VC9A_ENABLED, VC9B_ENABLED, VC9C_ENABLED, VC9D_ENABLED, PCC_ENABLED, ML5A_ENABLED, ML5B_ENABLED, ML5C_ENABLED, ML5D_ENABLED, ML5E_ENABLED, DEDUP_ATTR_ENABLED, ENC_0A_ENABLED, ENC_0B_ENABLED, ENC_0C_ENABLED, ENC_0D_ENABLED, ENC_0E_ENABLED, ENC_0F_ENABLED, ENC_0G_ENABLED, ENC_1A_ENABLED, ENC_1B_ENABLED, ENC_2BUDGET_ENABLED, ENC_2BUDGET_NATIVE_ORT_BUDGET_ENV, ENC_2BUDGET_MAX_MIB, ENC_2BUDGET_DEFAULT_MIB, ENC_2A_ENABLED, ENC_2B_ENABLED, COSINE_FP_BENCH_ENABLED, COSINE_FP_REAL_ENABLED, REPO_CORPUS_ENABLED, DASH_0A_ENABLED, DASH_0B_ENABLED, DASH_0C_ENABLED, DASH_0D_ENABLED, BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./config/vector-cortex.js";
+export { VC0A_ENABLED, VC0B_ENABLED, VC1A_ENABLED, VC0C_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, VC3A_ENABLED, VC3B_ENABLED, VC3C_ENABLED, VC4A_ENABLED, VC4B_ENABLED, VC4C_ENABLED, VC5A_ENABLED, VC5B_ENABLED, VC5C_ENABLED, VC6A_ENABLED, VC6B_ENABLED, VC6C_ENABLED, VC7A_ENABLED, VC7B_ENABLED, VC7C_ENABLED, VC8A_ENABLED, VC8B_ENABLED, VC8C_ENABLED, VC9A_ENABLED, VC9B_ENABLED, VC9C_ENABLED, VC9D_ENABLED, PCC_ENABLED, ML5A_ENABLED, ML5B_ENABLED, ML5C_ENABLED, ML5D_ENABLED, ML5E_ENABLED, DEDUP_ATTR_ENABLED, ENC_0A_ENABLED, ENC_0B_ENABLED, ENC_0C_ENABLED, ENC_0D_ENABLED, ENC_0E_ENABLED, ENC_0F_ENABLED, ENC_0G_ENABLED, ENC_1A_ENABLED, ENC_1B_ENABLED, ENC_2BUDGET_ENABLED, ENC_2BUDGET_NATIVE_ORT_BUDGET_ENV, ENC_2BUDGET_MAX_MIB, ENC_2BUDGET_DEFAULT_MIB, ENC_2A_ENABLED, ENC_2B_ENABLED, ENC_2C_ENABLED, COSINE_FP_BENCH_ENABLED, COSINE_FP_REAL_ENABLED, REPO_CORPUS_ENABLED, DASH_0A_ENABLED, DASH_0B_ENABLED, DASH_0C_ENABLED, DASH_0D_ENABLED, BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./config/vector-cortex.js";

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

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ */
+export {};

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

@@ -72,6 +72,7 @@ export const VECTOR_CORTEX_SETTINGS = {
         boolDirect("MEGACOMPACT_ENC_2BUDGET", "ENC-2a operator-configurable native install-budget knob", "ENC-2a exposes the runtime operator knob MEGACOMPACT_NATIVE_ORT_BUDGET_MIB (default 300 MiB, clamp 8192) as a dashboard Settings field. The knob gates budgetOk in the encoder runtime decision (decision.ts installBudgetMib + runtime-select.ts selectRuntimeBackend). Persisted to the per-repo .mega-compact.env via the setup-configure writer branch; the GET status route surfaces the persisted value AND the effective integer installBudgetMib() resolves to (so the dashboard shows the runtime's actual operand). OFF = no new GET fields, no writer branch, no new Settings rows (byte-identical ENC-1b predecessor).", true),
         boolDirect("MEGACOMPACT_ENC_2A", "ENC-2a native onnxruntime install GUIDE (detect + copy-paste)", "ENC-2a surfaces the platform-matched native onnxruntime install-guide (three copy-paste steps + script path) on the Setup Cortex sub-tab when the operator opted into the native backend but the effective runtime is still wasm (onnxruntime-node absent). Pure guidance — the extension NEVER executes or fetches (PREVENT-PI-004 unchanged); the committed operator script scripts/encoder/install-native-ort.mjs runs in the USER's shell. OFF = no guide GET fields, no guide-request POST branch, no install card (byte-identical ENC-1b predecessor).", true),
         boolDirect("MEGACOMPACT_ENC_2B", "ENC-2b native ONNX runtime qualification retest (detect + re-qualify)", "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", "Synthetic FP harness + L2 cosine threshold calibration (COS-FP-A): drives the deterministic synthetic-corpus grid sweep (scripts/cosine-fp/bench.mjs) that measures L2 cosine false-positive rates and emits a recommended default, and serves the reader-only GET /api/cosine-fp-report. Synthetic-corpus-only — never reads real session/ledger bytes. OFF = bench inert, endpoint 404s, no report write, L2_COSINE plain MEGACOMPACT_L2_THRESHOLD (byte-identical predecessor).", true),
         boolDirect("MEGACOMPACT_COSINE_FP_REAL", "COS-FP-R Real-Corpus Validation", "Real-corpus L2 cosine FP validation (COS-FP-R): runs the real-corpus grid sweep (scripts/cosine-fp/real-bench.mjs) against donated, consent-approved sessions only (SECURITY_PRIVACY Lifecycle/Consent), scoring FP/FN with Wilson intervals + session-grouped bootstrap, and appends CI-backed per-content-type recommendations to the cosine-threshold report. Runs only when a valid consented corpus exists; absent corpus = no_corpus (normative pre-donation state, nothing written). OFF = script inert, nothing executes, no writes (byte-identical predecessor).", true),
         boolDirect("MEGACOMPACT_REPO_CORPUS", "Cross-Repo Corpus (REPO-A)", "Cross-repo corpus preparation (REPO-A): the governed, consent-gated reader-only path that builds a pseudonymous corpus manifest from per-repo events.log slices and serves GET /api/repo-corpus answering which pseudonymous repos/sessions are in the corpus, what cross-repo overlap exists, and whether consent is active for each — counts + IDs + status only, never payload content. Consent is append-only (consent.mjs, CLI/ops-only); revocation freezes the builder + route. OFF = builder refuses to run, reader route 404s, single-repo recall untouched (byte-identical predecessor).", true),

package/dist/extensions/dashboard-server/routes-setup-cortex-actions.js

@@ -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
@@ -21,7 +22,7 @@ import { existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 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 { readQualificationRecord, encoderStateDir, } from "./qualification-record.js";
@@ -30,6 +31,7 @@ const ACTION_KINDS = new Set([
     "fetch-model",
     "bench",
     "verify-asset",
+    "install-native-ort",
 ]);
 function isActionKind(v) {
     return typeof v === "string" && ACTION_KINDS.has(v);
@@ -98,7 +100,9 @@ export function handleSetupCortexAction(req, res, ctx) {
         }
         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;
         }
@@ -119,8 +123,10 @@ export function handleSetupCortexAction(req, res, ctx) {
             });
             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/dist/extensions/dashboard-server/routes-vector-cortex-crystals.js

@@ -25,18 +25,18 @@
  */
 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",
-    "vector_cortex_crystal_collision",
-];
+import { readLivewireSnapshot } from "../../src/vector-cortex/livewire/livewire-registry.js";
+// 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, res, ctx) {
     const url = req.url ?? "";
@@ -48,31 +48,46 @@ export function handleVectorCortexCrystals(req, res, ctx) {
         return true;
     }
     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 = enabled ? "A" : "C";
+    if (!enabled) {
+        // Flag-off parity: byte-identical to the predecessor (mode C + deferred).
+        const body = {
+            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 = {
-        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/dist/extensions/dashboard-server/routes-vector-cortex-diagnostics.js

@@ -27,15 +27,18 @@
  */
 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"];
+import { readLivewireSnapshot } from "../../src/vector-cortex/livewire/livewire-registry.js";
+// 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, res, ctx) {
     const url = req.url ?? "";
@@ -47,32 +50,50 @@ export function handleVectorCortexDiagnostics(req, res, ctx) {
         return true;
     }
     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 = enabled ? "A" : "C";
+    if (!enabled) {
+        // Flag-off parity: byte-identical to the predecessor (mode C + deferred).
+        const body = {
+            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 = {
-        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/dist/extensions/dashboard-server/routes-vector-cortex-economics.js

@@ -25,13 +25,19 @@
 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";
+// 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, res, _ctx) {
+export function handleVectorCortexEconomics(req, res, ctx) {
     const url = req.url ?? "";
     const path = url.split("?")[0] ?? url;
     if (path !== "/api/vector-cortex/cache-economics")
@@ -41,25 +47,32 @@ export function handleVectorCortexEconomics(req, res, _ctx) {
         return true;
     }
     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 = enabled ? "A" : "C";
+    if (!enabled) {
+        // Flag-off parity: byte-identical to the predecessor (mode C + deferred).
+        const body = {
+            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 = {
-        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/dist/extensions/dashboard-server/routes-vector-cortex-helpers.js

@@ -98,3 +98,57 @@ export async function seedEval(dir) {
         { 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, overrides) {
+    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),
+            lastFailure: null,
+        },
+    });
+}

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

@@ -18,8 +18,12 @@
 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";
+// 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, res, _ctx) {
+export function handleVectorCortexPolicy(req, res, ctx) {
     const url = req.url ?? "";
     const path = url.split("?")[0] ?? url;
     if (path !== "/api/vector-cortex/policy")
@@ -29,23 +33,36 @@ export function handleVectorCortexPolicy(req, res, _ctx) {
         return true;
     }
     const enabled = VC8B_ENABLED();
-    const mode = enabled ? "A" : "C";
+    if (!enabled) {
+        // Flag-off parity: byte-identical to the predecessor (mode C + deferred).
+        const body = {
+            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 = {
-        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;