pi-mega-compact 0.20.19 → 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

@@ -239,6 +239,11 @@ export const VC8A_ENABLED = () => sprintFlag("MEGACOMPACT_VC8A");
  * 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, VC8B_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/route-dispatch.js

@@ -32,6 +32,10 @@ import { handleVectorCortexOutcomes } from "./routes-vector-cortex-outcomes.js";
 // 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).
@@ -135,5 +139,7 @@ export function dispatchRoutes(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

@@ -47,5 +47,6 @@ export const VECTOR_CORTEX_SETTINGS = {
         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/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

@@ -239,6 +239,11 @@ export const VC8A_ENABLED = () => sprintFlag("MEGACOMPACT_VC8A");
  * 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, VC8B_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/migrations/request-hash-v2-ops.js

@@ -48,15 +48,23 @@ function generationFromEconomics(economicsVersion) {
 }
 export function detectCollision(host) {
     const byHash = new Map();
-    const seenIdentities = new Set();
+    // Track the v1 hash seen for each identity so a genuine collision (same
+    // identity, DIFFERENT v1 hash) is distinguished from a benign duplicate
+    // (same identity, SAME v1 hash — an idempotent resume re-reads the same row).
+    const identityHash = new Map();
     for (const v1 of host.v1Rows()) {
         const row = deriveRequestHashRow(host, v1);
         const id = identity(v1.profileId, v1.requestDigest);
-        // Two distinct v1 rows (different v1 hash) with the same v2 hash collide,
-        // even if they share an identity — the v2 table cannot distinguish them.
-        if (seenIdentities.has(id))
-            return true;
-        seenIdentities.add(id);
+        const priorHash = identityHash.get(id);
+        if (priorHash !== undefined) {
+            // Same identity seen before. Only a collision if the v1 hashes differ —
+            // two genuinely distinct v1 rows collapsing to one v2 hash. Identical
+            // duplicates (same hash) are benign and skipped.
+            if (priorHash !== v1.hash)
+                return true;
+            continue;
+        }
+        identityHash.set(id, v1.hash);
         const prior = byHash.get(row.hash);
         if (prior !== undefined && prior !== id)
             return true;
@@ -73,17 +81,25 @@ export function isGenerationInvalidated(host, row) {
 }
 export function m5Copy(host) {
     const existing = new Map(host.existingV2().map((r) => [identity(r.profileId, r.requestDigest), r]));
+    // Track identities already in the `wanted` batch so a benign duplicate v1
+    // row (same identity, same hash) does not produce a duplicate v2 write that
+    // would later trip COUNT_MISMATCH in verify.
+    const batchSeen = new Set();
     const wanted = [];
     for (const v1 of host.v1Rows()) {
         const fresh = deriveRequestHashRow(host, v1);
         if (isGenerationInvalidated(host, fresh))
             continue;
-        const stored = existing.get(identity(v1.profileId, v1.requestDigest));
+        const id = identity(v1.profileId, v1.requestDigest);
+        if (batchSeen.has(id))
+            continue;
+        const stored = existing.get(id);
         if (stored !== undefined &&
             stored.hash === fresh.hash &&
             stored.economicsVersion === fresh.economicsVersion) {
             continue;
         }
+        batchSeen.add(id);
         wanted.push(fresh);
     }
     if (wanted.length > 0)

package/dist/src/vector-cortex/platform/cross-read.js

@@ -0,0 +1,98 @@
+/**
+ * platform/cross-read.ts — VC8C neutral stdin/stdout cross-conformance framing.
+ *
+ * Both the TS reference and an external Rust binary speak ONE neutral wire
+ * format: a sequence of length-prefixed JSON records. Each record is:
+ *
+ *   [4-byte big-endian length][exactly that many bytes of canonical JSON]
+ *
+ * The TS side encodes and decodes this framing; the external runner (a local
+ * subprocess, PREVENT-PI-004: never a URL) reads the same frames on stdin and
+ * writes them back on stdout. Parity is then byte-for-byte: the canonical JSON
+ * bytes of each record and the failure code must match in both directions.
+ *
+ * `outputBytes` is the OCAML-free canonical representation of a fixture's
+ * produced bytes as a HEX STRING, so byte-equality is a plain string compare and
+ * the wire JSON never carries raw binary.
+ *
+ * Everything here is PURE: no clock, no storage, no network, no flag read. The
+ * flag gates only the reporter seam in emit.ts.
+ *
+ * PREVENT-011: no `any` type. PREVENT-PI-004: no network.
+ */
+import { RUST_FRAME_TRUNCATED, RUST_PARITY_MISMATCH } from "./types.js";
+/** Canonical JSON bytes for a neutral record (the wire form of a record body). */
+export function encodeRecordJson(record) {
+    return new TextEncoder().encode(JSON.stringify(record));
+}
+/**
+ * Encode a list of neutral records into the length-framed neutral wire format.
+ * Each record is written as a 4-byte big-endian length followed by exactly that
+ * many canonical JSON bytes, concatenated in order.
+ */
+export function encodeNeutralFrame(fixtures) {
+    const parts = [];
+    for (const fixture of fixtures) {
+        const body = encodeRecordJson(fixture);
+        const header = new Uint8Array(4);
+        new DataView(header.buffer).setUint32(0, body.length, false);
+        parts.push(header, body);
+    }
+    const total = parts.reduce((acc, p) => acc + p.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.length;
+    }
+    return out;
+}
+/**
+ * Decode a neutral frame stream back into records. A partial trailing frame
+ * (a length prefix with fewer body bytes than declared) returns
+ * `{ ok: false, code: "RUST_FRAME_TRUNCATED" }` — the invariant the sprint's
+ * unique failure injection exercises.
+ */
+export function decodeNeutralFrame(bytes) {
+    const records = [];
+    let offset = 0;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const decoder = new TextDecoder();
+    while (offset + 4 <= bytes.byteLength) {
+        const len = view.getUint32(offset, false);
+        offset += 4;
+        if (offset + len > bytes.byteLength) {
+            return { ok: false, code: RUST_FRAME_TRUNCATED };
+        }
+        const body = decoder.decode(bytes.subarray(offset, offset + len));
+        offset += len;
+        try {
+            records.push(JSON.parse(body));
+        }
+        catch {
+            return { ok: false, code: RUST_FRAME_TRUNCATED };
+        }
+    }
+    if (offset !== bytes.byteLength) {
+        // Trailing bytes fewer than one length prefix — the frame was cut mid-header.
+        return { ok: false, code: RUST_FRAME_TRUNCATED };
+    }
+    return { ok: true, records };
+}
+/**
+ * Compare one expected record against one actual record. Both the canonical
+ * output bytes (as hex strings) and the failure code must match. Any byte or
+ * code difference returns `{ ok: false, code: "RUST_PARITY_MISMATCH" }`.
+ */
+export function compareFixtureOutput(expected, actual) {
+    if (expected.fixtureId !== actual.fixtureId) {
+        return { ok: false, code: RUST_PARITY_MISMATCH };
+    }
+    if (expected.outputBytes !== actual.outputBytes) {
+        return { ok: false, code: RUST_PARITY_MISMATCH };
+    }
+    if (expected.failureCode !== actual.failureCode) {
+        return { ok: false, code: RUST_PARITY_MISMATCH };
+    }
+    return { ok: true };
+}