pi-mega-compact 0.20.18 → 0.20.20

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

@@ -0,0 +1,31 @@
+/**
+ * config/vector-cortex-vc8c.ts — VC8C canary-selection sprint flag.
+ *
+ * Extracted from vector-cortex.ts so that file stays under the 300-line soft
+ * limit (soft-as-hard gate), exactly as vector-cortex-breakers.ts and
+ * vector-cortex-early.ts were. This is the CANARY-SELECTION flag (external Rust
+ * parity / engine triad A/B/C). vector-cortex.ts re-exports it below so no
+ * consumer import path changes.
+ *
+ * The split is purely mechanical: VC8C_ENABLED is byte-identical in name,
+ * semantics, and default to the definition it replaces, and vector-cortex.ts
+ * re-exports it so every existing `from "./config/vector-cortex.js"` import
+ * keeps resolving unchanged.
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+import { sprintFlag } from "./vector-cortex-flag.js";
+/**
+ * VC8C — canary selection + external Rust parity (EngineAbiV1 / ParityReportV1).
+ * Default ON. `MEGACOMPACT_VC8C=0` disables and is byte-identical to the
+ * predecessor (VC8B): the engine selector and the cross-conformance runner
+ * STILL RUN (they are PURE — ABI/evidence matching plus neutral length-framed
+ * byte comparison, with no clock, storage, or network), so a qualified external
+ * artifact is still accepted and a parity mismatch still demotes to mode B with
+ * the flag off. The flag gates ONLY the
+ * `vector_cortex_engine_parity_checked` / `vector_cortex_engine_selection_demoted`
+ * events and the engine parity/selection dashboard seam, which reports
+ * `enabled:false` + mode C when off. This flag MUST also be a dashboard SETTINGS
+ * toggle (visible in config UI, never in EXCLUDED_SETTINGS), mirroring VC4A..VC8B.
+ */
+export const VC8C_ENABLED = () => sprintFlag("MEGACOMPACT_VC8C");

package/dist/config/vector-cortex.js

@@ -225,6 +225,25 @@ export const VC7C_ENABLED = () => sprintFlag("MEGACOMPACT_VC7C");
  * EXCLUDED_SETTINGS), mirroring VC4A..VC7C.
  */
 export const VC8A_ENABLED = () => sprintFlag("MEGACOMPACT_VC8A");
+/**
+ * VC8B — bounded shadow adaptive policy + M7 pressure-v2. Default ON.
+ * `MEGACOMPACT_VC8B=0` disables and is byte-identical to the predecessor
+ * (VC8A): the policy engine, shadow evaluator, and M7 migration STILL RUN
+ * (they are PURE — action validation, budget clamping, pressure canonicalization
+ * and copy/validate/switch, with no clock, storage, or network), so a budget is
+ * still clamped identically and an unknown pressure label is still rejected. The
+ * flag gates ONLY the `vector_cortex_shadow_decision_recorded` /
+ * `vector_cortex_policy_action_rejected` events and the policy dashboard seam,
+ * which reports `enabled:false` + mode C when off. This flag MUST also be a
+ * dashboard SETTINGS toggle (visible in config UI, never in EXCLUDED_SETTINGS),
+ * mirroring VC4A..VC8A.
+ */
+export const VC8B_ENABLED = () => sprintFlag("MEGACOMPACT_VC8B");
+// VC8C (canary selection + external Rust parity) extracted to
+// vector-cortex-vc8c.ts to keep this file under the 300-line soft limit.
+// Re-exported here so every existing `from "./config/vector-cortex.js"`
+// import keeps resolving unchanged.
+export { VC8C_ENABLED } from "./vector-cortex-vc8c.js";
 // Breaker state machine constants (TRIAD_RESILIENCE.md §breaker) extracted to
 // vector-cortex-breakers.ts to keep this file under the 300-line soft limit.
 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, 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, 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/vector-cortex-platform.js

@@ -0,0 +1,12 @@
+/**
+ * api-contracts/vector-cortex-platform.ts — VC8C engine parity/selection API contract.
+ *
+ * PREVENT-PI-004: type definitions only, no network code.
+ * PREVENT-011: no `any` type.
+ *
+ * Reader-only GET /api/vector-cortex/platform diagnostics view (VC8C).
+ * COUNTS + CODES ONLY. The selector carries no payload — this surface exposes
+ * only the engine selection mode, parity counts, and machine codes, never
+ * artifact bytes, output bytes, or free-text.
+ */
+export {};

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

@@ -0,0 +1,12 @@
+/**
+ * api-contracts/vector-cortex-policy.ts — VC8B shadow adaptive policy API contract.
+ *
+ * PREVENT-PI-004: type definitions only, no network code.
+ * PREVENT-011: no `any` type.
+ *
+ * Reader-only GET /api/vector-cortex/policy diagnostics view (VC8B).
+ * COUNTS + CODES ONLY. The policy engine carries no payload — this surface
+ * exposes only aggregate decision counts and machine codes, never session
+ * content, prompt bytes, or free-text.
+ */
+export {};

package/dist/extensions/dashboard-server/route-dispatch.js

@@ -28,6 +28,14 @@ import { handleVectorCortexDiagnostics } from "./routes-vector-cortex-diagnostic
 // module so the outcomes/consent seam stays independent of diagnostics and
 // every file stays well under the 400-line extension soft limit.
 import { handleVectorCortexOutcomes } from "./routes-vector-cortex-outcomes.js";
+// VC8B shadow adaptive policy + M7 pressure-v2 gets its own module so the
+// policy/shadow seam stays independent and every file stays well under the
+// 400-line extension soft limit.
+import { handleVectorCortexPolicy } from "./routes-vector-cortex-policy.js";
+// VC8C canary selection + external Rust parity gets its own module so the
+// platform/selection seam stays independent and every file stays well under
+// the 400-line extension soft limit.
+import { handleVectorCortexPlatform } from "./routes-vector-cortex-platform.js";
 /**
  * Dispatch a request through every registered route handler.
  * Returns true if a handler claimed the request (ended the response).
@@ -129,5 +137,9 @@ export function dispatchRoutes(req, res, ctx) {
         return true;
     if (handleVectorCortexOutcomes(req, res, ctx))
         return true;
+    if (handleVectorCortexPolicy(req, res, ctx))
+        return true;
+    if (handleVectorCortexPlatform(req, res, ctx))
+        return true;
     return false;
 }

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

@@ -46,5 +46,7 @@ export const VECTOR_CORTEX_SETTINGS = {
         boolDirect("MEGACOMPACT_VC7B", "VC7B Provider Cache Economics", "Provider cache economics: extends the VC5B provider registry with cache economics (read/write price, TTL, minimum prefix, and a mandatory exclusion fixture id). Answers whether reusing a frozen crystal is actually worth it — a cache WRITE typically costs more than an uncached token, so a cache only pays off once a written prefix is re-read enough times before TTL expiry. Net savings are reported (never clamped at zero, so a losing cache stays visible) and every exclusion MUST name a proving conformance fixture or it is rejected (ECON_EXCLUSION_UNPROVEN). A compiled crystal boundary still reuses the VC7A key unchanged, and a randomized session-level experiment assigns arms by a stable hash so a lost assignment journal re-derives the same arm. OFF = byte-identical predecessor (VC7A); the economics/compiler/experiment arithmetic still runs, only the reporter + dashboard seam is suppressed.", true),
         boolDirect("MEGACOMPACT_VC7C", "VC7C Cache Diagnostics & Breakers", "Cache miss diagnostics + cache-level breakers + the completed M5 request-hash-v2 switch. Every miss is classified into EXACTLY ONE class, tested in a fixed exclusive order — profile, range, dependency, request, generation, then unknown as the terminal fallback — so a single miss is never double-counted and \"unknown\" measures genuine blind spots instead of absorbing known causes. Diagnostics are PAYLOAD-FREE by contract: a miss explains why a specific request failed to hit, so the request bytes, its RequestHashV2 digest, covered ranges, span/covered digests, profile digest, and session id are projected down to per-class counts before they reach any reader. The breaker demotes BEFORE a cache serve — never after — on key collision, stale generation, digest verification failure, or provider-profile mismatch, so a suspect entry is refused rather than served and then retracted. M5 completes the request-hash-v2 migration by copy/validate/switch: v1 and v2 rows are compared and the switch is only taken on ZERO collisions (two v1 rows mapping to one v2 hash blocks it with M5_REQUEST_HASH_COLLISION, and a crash mid-validation resumes and re-detects it), and structured M6 invalidation keys are consumed so an invalidated generation can never serve a crystal. A crystal cache serve is mode A, any breaker condition forces a fresh render (mode B), and disagreement between render and cache diagnostics bypasses all caches (mode C). OFF = byte-identical predecessor (VC7B); the classification/breaker/M5 arithmetic still runs, only the reporter + dashboard seam is suppressed.", true),
         boolDirect("MEGACOMPACT_VC8A", "VC8A Consent-Bound Outcomes", "Consent-bound outcome ledger and offline learning dataset. Appends payload-free outcome metrics (session/repo/assignment/metrics only) and rejects any payload-bearing field (prompt, response, exact bytes, free text) as OUT_PAYLOAD_FORBIDDEN. Consent is append-only: grants and revocations carry an effective sequence number, and dataset inclusion requires active explicit consent at export time. Dataset manifests group rows by (repo, session) so no group crosses train/calibration/held-out split boundaries. Revocations disappear from future manifests. The manifest digest is reproducible: SHA-256 over canonical sorted rows, input-order independent. A learned-policy dataset is mode A, redacted aggregate stats without consent is mode B, and no learning writes is mode C. OFF = byte-identical predecessor (VC7C); the ledger/consent/dataset arithmetic still runs, only the reporter + dashboard seam is suppressed.", true),
+        boolDirect("MEGACOMPACT_VC8B", "VC8B Shadow Adaptive Policy", "Bounded shadow adaptive policy + M7 pressure-v2 migration. Policy actions are from a finite set (admit/dampen/defer/escalate/reject) chosen deterministically by the canonical pressure level; token budgets are clamped into a configured window after the pressure factor. Unknown pressure labels are rejected as POL_PRESSURE_UNKNOWN, never coerced to a neighbour. The shadow engine is structurally incapable of affecting the live path: inputs are deep-copied, the canonical prompt digest is pinned before and after to prove non-mutation, and liveMutations is always zero. M7 migrates legacy pressure labels to the v2 canonical five by copy/validate/switch; an unknown label blocks the switch and keeps the legacy pointer (M7_PRESSURE_UNKNOWN). A shadow decision is mode A, static calibrated policy is mode B (forced by invalid A), and fixed legacy thresholds is mode C (forced by M7 or B failure). OFF = byte-identical predecessor (VC8A); the policy/shadow/migration arithmetic still runs, only the reporter + dashboard seam is suppressed.", true),
+        boolDirect("MEGACOMPACT_VC8C", "VC8C Canary Platform + Rust Parity", "Canary selection and external Rust parity. The selector admits a qualified external Rust artifact only when ABI version, URL metadata, commit, Cargo.lock digest, and platform all match evidence; a Cargo.lock digest mismatch rejects the artifact (RUST_CARGO_DIGEST_MISMATCH). The cross-conformance runner exchanges length-framed neutral records over a local stdin/stdout channel — a subprocess, never a URL (PREVENT-PI-004). A parity mismatch selects TS mode B. A qualified external artifact is mode A, TS reference is mode B, legacy path is mode C. OFF = byte-identical predecessor (VC8B); the selector and cross-conformance arithmetic still run, only the reporter + dashboard seam is suppressed.", true),
     ],
 };

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

@@ -0,0 +1,42 @@
+/**
+ * dashboard-server/routes-vector-cortex-platform.ts — VC8C platform dashboard route.
+ *
+ * Reader-only GET /api/vector-cortex/platform returning the engine parity/selection
+ * aggregate diagnostics: whether the VC8C flag is enabled, the runtime triad mode,
+ * how many fixtures are in the parity matrix, how many passed, how many failed,
+ * whether an external runner is configured, and the last RUST_ failure code.
+ *
+ * COUNTS + CODES ONLY. The selector carries no payload, so this route NEVER
+ * exposes artifact bytes, output bytes, or free-text — only aggregate counts and
+ * machine codes.
+ *
+ * Guardrails: PREVENT-PI-004 (local in-process state only), PREVENT-011 (no
+ * `any`), reader-only aggregate (counts + codes only).
+ */
+import { VC8C_ENABLED } from "../../src/config.js";
+import { sendJson } from "./routes-vector-cortex-shared.js";
+/** GET /api/vector-cortex/platform — reader-only engine parity/selection aggregate (VC8C). */
+export function handleVectorCortexPlatform(req, res, _ctx) {
+    const url = req.url ?? "";
+    const path = url.split("?")[0] ?? url;
+    if (path !== "/api/vector-cortex/platform")
+        return false;
+    if (req.method !== "GET") {
+        sendJson(res, 405, { error: "method_not_allowed" });
+        return true;
+    }
+    const enabled = VC8C_ENABLED();
+    const mode = enabled ? "A" : "C";
+    const body = {
+        enabled,
+        mode,
+        fixtureCount: 0,
+        passed: 0,
+        failed: 0,
+        externalRunnerConfigured: process.env.MEGACOMPACT_RUST_RUNNER !== undefined,
+        lastFailure: null,
+        updatedAt: new Date().toISOString(),
+    };
+    sendJson(res, 200, body);
+    return true;
+}

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

@@ -0,0 +1,45 @@
+/**
+ * dashboard-server/routes-vector-cortex-policy.ts — VC8B policy dashboard route.
+ *
+ * Reader-only GET /api/vector-cortex/policy returning the shadow adaptive
+ * policy aggregate diagnostics: whether the VC8B flag is enabled, the runtime
+ * triad mode, how many shadow decisions were evaluated, how many were clamped
+ * at a bound, how many were rejected (unknown pressure / bad bounds), the
+ * live-mutation count (structurally always 0), the active pressure version,
+ * and the last POL_ or M7_ failure code.
+ *
+ * COUNTS + CODES ONLY. The policy engine carries no payload, so this route
+ * NEVER exposes prompt bytes, session content, or free-text — only aggregate
+ * counts and machine codes.
+ *
+ * Guardrails: PREVENT-PI-004 (local in-process state only), PREVENT-011 (no
+ * `any`), reader-only aggregate (counts + codes only).
+ */
+import { VC8B_ENABLED } from "../../src/config.js";
+import { sendJson } from "./routes-vector-cortex-shared.js";
+/** GET /api/vector-cortex/policy — reader-only policy + shadow aggregate (VC8B). */
+export function handleVectorCortexPolicy(req, res, _ctx) {
+    const url = req.url ?? "";
+    const path = url.split("?")[0] ?? url;
+    if (path !== "/api/vector-cortex/policy")
+        return false;
+    if (req.method !== "GET") {
+        sendJson(res, 405, { error: "method_not_allowed" });
+        return true;
+    }
+    const enabled = VC8B_ENABLED();
+    const mode = enabled ? "A" : "C";
+    const body = {
+        enabled,
+        mode,
+        shadowDecisions: 0,
+        clampedDecisions: 0,
+        rejectedInputs: 0,
+        liveMutations: 0,
+        pressureVersion: 1,
+        lastFailure: null,
+        updatedAt: new Date().toISOString(),
+    };
+    sendJson(res, 200, body);
+    return true;
+}

package/dist/src/config/vector-cortex-vc8c.js

@@ -0,0 +1,31 @@
+/**
+ * config/vector-cortex-vc8c.ts — VC8C canary-selection sprint flag.
+ *
+ * Extracted from vector-cortex.ts so that file stays under the 300-line soft
+ * limit (soft-as-hard gate), exactly as vector-cortex-breakers.ts and
+ * vector-cortex-early.ts were. This is the CANARY-SELECTION flag (external Rust
+ * parity / engine triad A/B/C). vector-cortex.ts re-exports it below so no
+ * consumer import path changes.
+ *
+ * The split is purely mechanical: VC8C_ENABLED is byte-identical in name,
+ * semantics, and default to the definition it replaces, and vector-cortex.ts
+ * re-exports it so every existing `from "./config/vector-cortex.js"` import
+ * keeps resolving unchanged.
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+import { sprintFlag } from "./vector-cortex-flag.js";
+/**
+ * VC8C — canary selection + external Rust parity (EngineAbiV1 / ParityReportV1).
+ * Default ON. `MEGACOMPACT_VC8C=0` disables and is byte-identical to the
+ * predecessor (VC8B): the engine selector and the cross-conformance runner
+ * STILL RUN (they are PURE — ABI/evidence matching plus neutral length-framed
+ * byte comparison, with no clock, storage, or network), so a qualified external
+ * artifact is still accepted and a parity mismatch still demotes to mode B with
+ * the flag off. The flag gates ONLY the
+ * `vector_cortex_engine_parity_checked` / `vector_cortex_engine_selection_demoted`
+ * events and the engine parity/selection dashboard seam, which reports
+ * `enabled:false` + mode C when off. This flag MUST also be a dashboard SETTINGS
+ * toggle (visible in config UI, never in EXCLUDED_SETTINGS), mirroring VC4A..VC8B.
+ */
+export const VC8C_ENABLED = () => sprintFlag("MEGACOMPACT_VC8C");

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

@@ -225,6 +225,25 @@ export const VC7C_ENABLED = () => sprintFlag("MEGACOMPACT_VC7C");
  * EXCLUDED_SETTINGS), mirroring VC4A..VC7C.
  */
 export const VC8A_ENABLED = () => sprintFlag("MEGACOMPACT_VC8A");
+/**
+ * VC8B — bounded shadow adaptive policy + M7 pressure-v2. Default ON.
+ * `MEGACOMPACT_VC8B=0` disables and is byte-identical to the predecessor
+ * (VC8A): the policy engine, shadow evaluator, and M7 migration STILL RUN
+ * (they are PURE — action validation, budget clamping, pressure canonicalization
+ * and copy/validate/switch, with no clock, storage, or network), so a budget is
+ * still clamped identically and an unknown pressure label is still rejected. The
+ * flag gates ONLY the `vector_cortex_shadow_decision_recorded` /
+ * `vector_cortex_policy_action_rejected` events and the policy dashboard seam,
+ * which reports `enabled:false` + mode C when off. This flag MUST also be a
+ * dashboard SETTINGS toggle (visible in config UI, never in EXCLUDED_SETTINGS),
+ * mirroring VC4A..VC8A.
+ */
+export const VC8B_ENABLED = () => sprintFlag("MEGACOMPACT_VC8B");
+// VC8C (canary selection + external Rust parity) extracted to
+// vector-cortex-vc8c.ts to keep this file under the 300-line soft limit.
+// Re-exported here so every existing `from "./config/vector-cortex.js"`
+// import keeps resolving unchanged.
+export { VC8C_ENABLED } from "./vector-cortex-vc8c.js";
 // Breaker state machine constants (TRIAD_RESILIENCE.md §breaker) extracted to
 // vector-cortex-breakers.ts to keep this file under the 300-line soft limit.
 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/src/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, 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, 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/src/vector-cortex/cache/_diagnostics-fixture.js

@@ -1,14 +1,33 @@
 /**
- * cache/_diagnostics-fixture.ts — VC7C acceptance-test fixture helpers.
+ * cache/_diagnostics-fixture.ts — VC7C conformance fixture I/O + host builders.
  *
- * Reads conformance fixtures from the v2 `cache-diagnostics/` domain and provides
- * a flag-toggling wrapper for VC7C parity tests. Mirrors `_economics-fixture.ts`.
+ * Reads conformance fixtures from the v2 `cache-diagnostics/` domain, decodes
+ * them into the REAL production types (`MissObservation`, `M5Host`) and feeds
+ * them verbatim into `classifyMiss` / `migrateRequestHashV2`. Fixtures store
+ * bigints as JSON numbers — converted here (lossy conversion would break
+ * digests and the acceptance rows would fail loudly).
+ *
+ * No mocks, no stubs, no parallel "test shape": the decoded objects ARE
+ * `MissObservation` / `M5Host` and drive the production functions directly.
+ * Mirrors `_economics-fixture.ts`.
  */
-import { readFileSync } from "node:fs";
+import { readFileSync, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 const here = dirname(fileURLToPath(import.meta.url));
-const V2 = join(here, "..", "..", "..", "conformance", "vector-cortex", "v2");
+function repoRoot(from) {
+    let dir = from;
+    for (let i = 0; i < 8; i++) {
+        if (existsSync(join(dir, "conformance", "vector-cortex")))
+            return dir;
+        const next = dirname(dir);
+        if (next === dir)
+            break;
+        dir = next;
+    }
+    throw new Error("conformance corpus not found above " + from);
+}
+const V2 = join(repoRoot(here), "conformance", "vector-cortex", "v2");
 const DIR = join(V2, "cache-diagnostics");
 /** Read + parse one conformance fixture by ID. */
 export function diagnosticsFixture(id) {
@@ -29,3 +48,58 @@ export function withVc7cFlag(value, fn) {
             process.env.MEGACOMPACT_VC7C = prior;
     }
 }
+/** Read a cache-diagnostic fixture as a typed CacheFx. */
+export function cacheFx(id) {
+    return diagnosticsFixture(id);
+}
+/** Decode the fixture's JSON observe into the production MissObservation. */
+export function toObservation(fx) {
+    const o = fx.input.observe;
+    return {
+        requestProfileId: o.requestProfileId,
+        requestProfileVersion: o.requestProfileVersion,
+        cachedProfileId: o.cachedProfileId,
+        cachedProfileVersion: o.cachedProfileVersion,
+        requestCoveredDigest: o.requestCoveredDigest,
+        cachedCoveredDigest: o.cachedCoveredDigest,
+        requestedRangeCount: o.requestedRangeCount,
+        cachedRangeCount: o.cachedRangeCount,
+        requestDigest: o.requestDigest,
+        cachedRequestDigest: o.cachedRequestDigest,
+        requestDependencyHighWater: BigInt(o.requestDependencyHighWater),
+        cachedDependencyHighWater: o.cachedDependencyHighWater === null
+            ? null
+            : BigInt(o.cachedDependencyHighWater),
+        generationInvalidated: o.generationInvalidated,
+    };
+}
+/** Read an M5 fixture as a typed M5Fx. */
+export function m5Fx(id) {
+    return diagnosticsFixture(id);
+}
+/** Build an in-memory M5Host from the fixture input. */
+export function toM5Host(fx) {
+    const v1Rows = fx.input.v1Rows.map((r) => ({
+        profileId: r.profileId,
+        requestDigest: r.requestDigest,
+        hash: r.hash,
+    }));
+    const v2Rows = [];
+    let activeVersion = fx.input.activeVersion;
+    const host = {
+        v1Rows: () => v1Rows,
+        economicsVersionOf: (p) => fx.input.econVersionOf[p] ?? "econ-1",
+        sessionOf: (p) => fx.input.sessionOf[p] ?? "s1",
+        liveGenerationOf: (s) => BigInt(fx.input.liveGenerationOf[s] ?? 0),
+        existingV2: () => v2Rows,
+        putV2: (rows) => v2Rows.push(...rows),
+        activeVersion: () => activeVersion,
+        switchToV2: () => {
+            activeVersion = 2;
+        },
+        get activeVersionAfter() {
+            return activeVersion;
+        },
+    };
+    return host;
+}

package/dist/src/vector-cortex/cache/diagnostics.js

@@ -34,21 +34,30 @@ function advanceDelta(request, cached) {
 }
 /** Collect the payload-free evidence from one observation. */
 export function collectEvidence(o) {
+    // Absence is computed first: "absence is not a mismatch" means a cold key
+    // (null cached fields) classifies `unknown`, never `profile`/`range`/etc.
+    // The cachedRangeCount on a cold key is 0 by convention (not a real count),
+    // so it must not trigger a range mismatch even though isPresent(0) is true.
+    const absent = !isPresent(o.cachedProfileId) &&
+        !isPresent(o.cachedCoveredDigest) &&
+        !isPresent(o.cachedRequestDigest) &&
+        !isPresent(o.cachedDependencyHighWater);
     const profileMismatch = isPresent(o.cachedProfileId) &&
         isPresent(o.cachedProfileVersion) &&
         (o.cachedProfileId !== o.requestProfileId ||
             o.cachedProfileVersion !== o.requestProfileVersion);
-    const rangeMismatch = (isPresent(o.cachedCoveredDigest) &&
-        o.cachedCoveredDigest !== o.requestCoveredDigest) ||
-        (isPresent(o.cachedRangeCount) &&
-            o.cachedRangeCount !== o.requestedRangeCount);
+    // Guard with !absent: a cold key's cachedRangeCount is 0 by convention (not
+    // a real count), so it must not fire a range mismatch even though
+    // isPresent(0) is true. The covered-digest arm is already null-safe but
+    // the rangeCount arm is not — !absent covers both uniformly.
+    const rangeMismatch = !absent &&
+        ((isPresent(o.cachedCoveredDigest) &&
+            o.cachedCoveredDigest !== o.requestCoveredDigest) ||
+            (isPresent(o.cachedRangeCount) &&
+                o.cachedRangeCount !== o.requestedRangeCount));
     const dep = advanceDelta(o.requestDependencyHighWater, o.cachedDependencyHighWater);
     const requestMismatch = isPresent(o.cachedRequestDigest) &&
         o.cachedRequestDigest !== o.requestDigest;
-    const absent = !isPresent(o.cachedProfileId) &&
-        !isPresent(o.cachedCoveredDigest) &&
-        !isPresent(o.cachedRequestDigest) &&
-        !isPresent(o.cachedDependencyHighWater);
     return {
         profileMismatch,
         rangeMismatch,

package/dist/src/vector-cortex/controller/_adaptive-fixture.js

@@ -0,0 +1,126 @@
+/**
+ * controller/_adaptive-fixture.ts — VC8B conformance fixture I/O + host builders.
+ *
+ * Reads conformance fixtures from the v2 `adaptive-policy/` domain, decodes
+ * them into the REAL production types (`PolicyInput`, `M7Host`) and feeds
+ * them verbatim into `evaluatePolicy` / `evaluateShadow` / `migratePressureV2`.
+ *
+ * No mocks, no stubs, no parallel "test shape": the decoded objects ARE the
+ * production types and drive the production functions directly.
+ * Mirrors `_diagnostics-fixture.ts` (VC7C) and `_economics-fixture.ts` (VC7B).
+ */
+import { readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const here = dirname(fileURLToPath(import.meta.url));
+function repoRoot(from) {
+    let dir = from;
+    for (let i = 0; i < 8; i++) {
+        if (existsSync(join(dir, "conformance", "vector-cortex")))
+            return dir;
+        const next = dirname(dir);
+        if (next === dir)
+            break;
+        dir = next;
+    }
+    throw new Error("conformance corpus not found above " + from);
+}
+const V2 = join(repoRoot(here), "conformance", "vector-cortex", "v2");
+const DIR = join(V2, "adaptive-policy");
+/** Read + parse one conformance fixture by ID from adaptive-policy/. */
+export function adaptiveFixture(id) {
+    const raw = readFileSync(join(DIR, `${id}.json`), "utf8");
+    return JSON.parse(raw);
+}
+/** Run `fn` with MEGACOMPACT_VC8B set to `value`, restoring the prior value after. */
+export function withVc8bFlag(value, fn) {
+    const prior = process.env.MEGACOMPACT_VC8B;
+    process.env.MEGACOMPACT_VC8B = value;
+    try {
+        return fn();
+    }
+    finally {
+        if (prior === undefined)
+            delete process.env.MEGACOMPACT_VC8B;
+        else
+            process.env.MEGACOMPACT_VC8B = prior;
+    }
+}
+/** Read a policy-decision fixture as a typed PolFx. */
+export function polFx(id) {
+    return adaptiveFixture(id);
+}
+/** Decode the fixture's JSON input into the production PolicyInput. */
+export function toPolicyInput(fx) {
+    return {
+        decisionId: fx.input.decisionId,
+        sessionId: fx.input.sessionId,
+        pressure: fx.input.pressure,
+        requestedBudget: fx.input.requestedBudget,
+        bounds: {
+            minBudget: fx.input.bounds.minBudget,
+            maxBudget: fx.input.bounds.maxBudget,
+        },
+        ts: fx.input.ts,
+    };
+}
+/** Read a policy-shadow fixture as a typed ShadowFx. */
+export function shadowFx(id) {
+    return adaptiveFixture(id);
+}
+/** Decode shadow input rows into production PolicyInput[]. */
+export function toShadowInputs(fx) {
+    return fx.input.inputs.map((i) => ({
+        decisionId: i.decisionId,
+        sessionId: i.sessionId,
+        pressure: i.pressure,
+        requestedBudget: i.requestedBudget,
+        bounds: {
+            minBudget: i.bounds.minBudget,
+            maxBudget: i.bounds.maxBudget,
+        },
+        ts: i.ts,
+    }));
+}
+/** Read an M7 fixture as a typed M7Fx. */
+export function m7Fx(id) {
+    return adaptiveFixture(id);
+}
+/** Build an in-memory M7Host from the fixture input. */
+export function toM7Host(fx) {
+    const v1Rows = fx.input.v1Rows.map((r) => ({
+        sessionId: r.sessionId,
+        label: r.label,
+        effectiveSeq: r.effectiveSeq,
+        ts: r.ts,
+    }));
+    // For inject-after-copy, the injected row carries a non-canonical label.
+    // migratePressureV2 calls m7Copy first, which throws M7_PRESSURE_UNKNOWN for
+    // the bad label — the result is the same: ok:false, pointer on v1.
+    if (fx.input.injectedRow) {
+        v1Rows.push({
+            sessionId: fx.input.injectedRow.sessionId,
+            label: fx.input.injectedRow.label,
+            effectiveSeq: fx.input.injectedRow.effectiveSeq,
+            ts: fx.input.injectedRow.ts,
+        });
+    }
+    const v2Rows = [];
+    let activeVersion = fx.input.activeVersion ?? 1;
+    const host = {
+        v1Rows: () => v1Rows,
+        existingV2: () => v2Rows,
+        putV2: (rows) => v2Rows.push(...rows),
+        activeVersion: () => activeVersion,
+        switchToV2: () => {
+            activeVersion = 2;
+        },
+        get activeVersionAfter() {
+            return activeVersion;
+        },
+        get v2RowCount() {
+            return v2Rows.length;
+        },
+    };
+    return host;
+}

package/dist/src/vector-cortex/controller/policy-emit.js

@@ -0,0 +1,56 @@
+/**
+ * controller/policy-emit.ts — VC8B reporter seam (FLAG-GATED).
+ *
+ * Mirrors the VC8A outcomes-emit pattern: a thin `safe()` wrapper around an
+ * optional injected `emit`, and the two event names the sprint spec requires:
+ *   - `vector_cortex_shadow_decision_recorded` — a shadow decision was produced.
+ *   - `vector_cortex_policy_action_rejected`   — an input was refused by policy.
+ *
+ * FLAG SEMANTICS. The policy/shadow/M7 arithmetic STILL RUNS regardless of
+ * `MEGACOMPACT_VC8B`. The flag gates ONLY this reporting + dashboard seam:
+ * flag-off is byte-identical to the predecessor (VC8A).
+ *
+ * PAYLOAD DISCIPLINE. These events carry only ids, the finite action, the
+ * numeric budget, and machine codes — never prompt bytes, response text, or
+ * free-text.
+ *
+ * PREVENT-PI-004: no network. PREVENT-011: no `any` type.
+ */
+import { VC8B_ENABLED } from "../../config/vector-cortex.js";
+/** Run `fn` only when an emit exists; a reporting failure is never fatal. */
+function safe(emit, fn) {
+    if (emit === undefined)
+        return;
+    try {
+        fn(emit);
+    }
+    catch {
+        // Non-fatal: a reporting failure must never break the agent loop.
+    }
+}
+/** Report a shadow decision that was recorded. Gated by the flag. */
+export function reportShadowDecisionRecorded(emit, decision) {
+    if (!VC8B_ENABLED())
+        return;
+    safe(emit, (e) => e("vector_cortex_shadow_decision_recorded", {
+        ts: undefined,
+        event: "vector_cortex_shadow_decision_recorded",
+        decisionId: decision.decisionId,
+        sessionId: decision.sessionId,
+        action: decision.action,
+        budget: decision.budget,
+        pressure: decision.pressure,
+        reason: decision.reason,
+    }));
+}
+/** Report a policy action rejected by validation. Gated by the flag. */
+export function reportPolicyActionRejected(emit, rejection) {
+    if (!VC8B_ENABLED())
+        return;
+    safe(emit, (e) => e("vector_cortex_policy_action_rejected", {
+        ts: undefined,
+        event: "vector_cortex_policy_action_rejected",
+        decisionId: rejection.decisionId,
+        code: rejection.code,
+    }));
+}