pi-mega-compact 0.20.70 → 0.20.72

package/dist/src/vector-cortex/livewire/livewire-live.js

@@ -0,0 +1,163 @@
+/**
+ * vector-cortex/livewire/livewire-live.ts — LIVEWIRE in-process live state.
+ *
+ * Holds the LIVE subsystem objects for ONE stateDir: the VC7A `CrystalStore`,
+ * the VC7C cache breaker, the per-miss-class tallies, the VC8B shadow metrics,
+ * and the VC7B economics computed bit. This is the object the RUNTIME accumulates
+ * into (`recordMiss`, `recordServeBlocked`, `recordShadowRun`, ...) and that the
+ * reader-only dashboard routes snapshot out of. Kept separate from the registry
+ * (which owns the per-stateDir `Map` + persistence) so neither file crosses the
+ * 300-line soft-as-hard gate.
+ *
+ * AGGREGATE-FIRST, COUNTS ONLY. `snapshotOf` projects the live objects down to
+ * the SECURITY_PRIVACY-safe `LivewireSnapshot` (counts + codes + triad mode) that
+ * gets persisted and rendered. No session id, digest, range, profile id, bytes,
+ * or prompt text can pass through ANY of these fields.
+ *
+ * PREVENT-PI-004: no network. PREVENT-011: no `any`. Non-fatal: every derive is
+ * a pure read.
+ */
+import { CrystalStore } from "../cache/store.js";
+import { createCacheBreaker } from "../cache/breaker.js";
+import { validateProfileEconomics } from "../provider/economics.js";
+import { BASE_PROVIDER_PROFILES } from "../provider/registry.js";
+/**
+ * Static VC7B economics profile tallies derived from the base provider registry.
+ * `profileCount` counts profiles that declare economics; `provenExclusions` /
+ * `unprovenExclusions` tally the exclusion sets validated against the fixture
+ * rule. This is PURE (no storage/clock/network) and identical regardless of the
+ * `MEGACOMPACT_VC7B` flag — only the emission/route seam is flag-gated.
+ */
+function baseEconomicsTallies() {
+    let profileCount = 0;
+    let provenExclusions = 0;
+    let unprovenExclusions = 0;
+    for (const bundle of BASE_PROVIDER_PROFILES) {
+        const econ = bundle.profile.economics;
+        if (econ === null)
+            continue;
+        profileCount += 1;
+        const codes = validateProfileEconomics(bundle.profile, econ);
+        const failed = new Set(codes);
+        for (const _ex of bundle.profile.excludedJsonPointers) {
+            if (failed.has("ECON_EXCLUSION_UNPROVEN")) {
+                unprovenExclusions += 1;
+            }
+            else {
+                provenExclusions += 1;
+            }
+        }
+    }
+    return { profileCount, provenExclusions, unprovenExclusions };
+}
+/** A zeroed per-class tally map. */
+function zeroTallies() {
+    return {
+        profile: 0,
+        range: 0,
+        dependency: 0,
+        request: 0,
+        generation: 0,
+        unknown: 0,
+    };
+}
+/** Build a fresh (empty) live state with real subsystem objects. */
+export function createLiveState() {
+    const econTallies = baseEconomicsTallies();
+    return {
+        crystalStore: new CrystalStore(),
+        breaker: createCacheBreaker(),
+        diagnostics: {
+            tallies: zeroTallies(),
+            serveBlocked: 0,
+            breakerState: "CLOSED_A",
+            lastFailure: null,
+        },
+        economics: {
+            computed: false,
+            profileCount: econTallies.profileCount,
+            provenExclusions: econTallies.provenExclusions,
+            unprovenExclusions: econTallies.unprovenExclusions,
+            lastFailure: null,
+        },
+        shadow: {
+            shadowDecisions: 0,
+            clampedDecisions: 0,
+            rejectedInputs: 0,
+            liveMutations: 0,
+            pressureVersion: 1,
+            lastFailure: null,
+        },
+    };
+}
+/** Project the live state down to the persisted, reader-only aggregate. */
+export function snapshotOf(state) {
+    const crystals = state.crystalStore.stats();
+    const diag = {
+        profileMisses: state.diagnostics.tallies.profile,
+        rangeMisses: state.diagnostics.tallies.range,
+        dependencyMisses: state.diagnostics.tallies.dependency,
+        requestMisses: state.diagnostics.tallies.request,
+        generationMisses: state.diagnostics.tallies.generation,
+        unknownMisses: state.diagnostics.tallies.unknown,
+        serveBlocked: state.diagnostics.serveBlocked,
+        breakerState: state.diagnostics.breakerState,
+        lastFailure: state.diagnostics.lastFailure,
+    };
+    const econ = {
+        profileCount: state.economics.profileCount,
+        provenExclusions: state.economics.provenExclusions,
+        unprovenExclusions: state.economics.unprovenExclusions,
+        computed: state.economics.computed,
+        lastFailure: state.economics.lastFailure,
+    };
+    const policy = {
+        shadowDecisions: state.shadow.shadowDecisions,
+        clampedDecisions: state.shadow.clampedDecisions,
+        rejectedInputs: state.shadow.rejectedInputs,
+        liveMutations: state.shadow.liveMutations,
+        pressureVersion: state.shadow.pressureVersion,
+        lastFailure: state.shadow.lastFailure,
+    };
+    return {
+        schema: "vector-cortex-livewire-v1",
+        crystals: {
+            mode: crystals.mode,
+            crystalCount: crystals.crystalCount,
+            totalBytes: crystals.totalBytes,
+            hits: crystals.hits,
+            misses: crystals.misses,
+            hitBytes: crystals.hitBytes,
+            writes: crystals.writes,
+            duplicateWrites: crystals.duplicateWrites,
+            collisions: crystals.collisions,
+        },
+        diagnostics: diag,
+        economics: econ,
+        policy,
+    };
+}
+/** Seed a fresh live state's CUMULATIVE counters from a persisted snapshot. */
+export function rehydrateLive(state, snap) {
+    state.crystalStore.rehydrate(snap.crystals);
+    state.diagnostics.tallies.profile = snap.diagnostics.profileMisses;
+    state.diagnostics.tallies.range = snap.diagnostics.rangeMisses;
+    state.diagnostics.tallies.dependency = snap.diagnostics.dependencyMisses;
+    state.diagnostics.tallies.request = snap.diagnostics.requestMisses;
+    state.diagnostics.tallies.generation = snap.diagnostics.generationMisses;
+    state.diagnostics.tallies.unknown = snap.diagnostics.unknownMisses;
+    state.diagnostics.serveBlocked = snap.diagnostics.serveBlocked;
+    state.diagnostics.breakerState = snap.diagnostics.breakerState;
+    state.diagnostics.lastFailure = snap.diagnostics.lastFailure;
+    state.economics.computed = snap.economics.computed;
+    state.economics.profileCount = snap.economics.profileCount;
+    state.economics.provenExclusions = snap.economics.provenExclusions;
+    state.economics.unprovenExclusions = snap.economics.unprovenExclusions;
+    state.economics.lastFailure = snap.economics.lastFailure;
+    state.shadow.shadowDecisions = snap.policy.shadowDecisions;
+    state.shadow.clampedDecisions = snap.policy.clampedDecisions;
+    state.shadow.rejectedInputs = snap.policy.rejectedInputs;
+    state.shadow.liveMutations = snap.policy.liveMutations;
+    state.shadow.pressureVersion = snap.policy.pressureVersion;
+    state.shadow.lastFailure = snap.policy.lastFailure;
+}

package/dist/src/vector-cortex/livewire/livewire-registry.js

@@ -0,0 +1,73 @@
+/**
+ * vector-cortex/livewire/livewire-registry.ts — per-stateDir LIWIRE registry.
+ *
+ * The single seam the runtime and the reader-only dashboard routes BOTH access.
+ * It owns a `Map<stateDir, LivewireLiveState>` (one live subsystem cluster per
+ * repo) and lazily opens a state on first access, rehydrating its cumulative
+ * counters from the persisted aggregate snapshot (`livewire-snapshot.ts`) so a
+ * freshly-spawned process — e.g. the dashboard server — reports the same counts
+ * the runtime has already accumulated.
+ *
+ * The runtime WRITES through this registry (see `livewire-runtime.ts`): each
+ * mutation persists a reduced, count-only snapshot. The routes READ through
+ * `livewireOf(stateDir)` and call the pure `snapshotOf`. There is no other path.
+ *
+ * BEST-EFFORT + NON-FATAL. `openLivewire` never throws: persistence failures are
+ * swallowed by the snapshot layer and state is always returned. PREVENT-PI-004
+ * (local in-process Map + filesystem only), PREVENT-011 (no `any`).
+ */
+import { createLiveState, rehydrateLive, snapshotOf, } from "./livewire-live.js";
+import { loadLivewireSnapshot, saveLivewireSnapshot, } from "./livewire-snapshot.js";
+/** The per-stateDir registry (process-local; a fresh process starts empty). */
+const REGISTRY = new Map();
+let activeLogger;
+/**
+ * Bind the structured logger the snapshot layer uses for its non-fatal write
+ * failures. The runtime calls this once at startup with its JSON logger.
+ */
+export function setLivewireLogger(logger) {
+    activeLogger = logger;
+}
+/**
+ * Open (or return the cached) live state for a stateDir. Lazy: on first access
+ * it rehydrates from the persisted aggregate so a separate dashboard process
+ * reflects prior runtime work. Never throws.
+ */
+export function livewireOf(stateDir) {
+    const cached = REGISTRY.get(stateDir);
+    if (cached !== undefined)
+        return cached;
+    const state = createLiveState();
+    const snap = loadLivewireSnapshot(stateDir);
+    if (snap !== null)
+        rehydrateLive(state, snap);
+    REGISTRY.set(stateDir, state);
+    return state;
+}
+/**
+ * Persist a state's reduced aggregate (counts + codes only). Best-effort and
+ * non-fatal. Called by the runtime after every mutation so the snapshot stays
+ * fresh for any reader process.
+ */
+export function persistLivewire(state, stateDir) {
+    saveLivewireSnapshot(stateDir, snapshotOf(state), activeLogger);
+}
+/** Persist the live state for a stateDir (convenience over open + persist). */
+export function flushLivewire(stateDir) {
+    const state = REGISTRY.get(stateDir);
+    if (state === undefined)
+        return;
+    persistLivewire(state, stateDir);
+}
+/**
+ * Build the reader aggregate for one stateDir WITHOUT persisting — the reader
+ * seam the dashboard routes call. Reads the live state (rehydrated from disk on
+ * first access) and projects it to the count-only snapshot.
+ */
+export function readLivewireSnapshot(stateDir) {
+    return snapshotOf(livewireOf(stateDir));
+}
+/** For tests: drop the registry so a fresh stateDir is fully rehydrated. */
+export function _resetLivewireRegistryForTests() {
+    REGISTRY.clear();
+}

package/dist/src/vector-cortex/livewire/livewire-runtime.js

@@ -0,0 +1,107 @@
+/**
+ * vector-cortex/livewire/livewire-runtime.ts — LIVEWIRE runtime accumulation seam.
+ *
+ * The WRITE side of LIVEWIRE: the runtime calls these methods wherever the
+ * corresponding subsystem path actually runs, and each call accumulates into the
+ * per-stateDir live state and persists a reduced count-only snapshot (best-effort,
+ * non-fatal). This is the seam that turns the pure VC7A/VC7B/VC7C/VC8B arithmetic
+ * into LIVE dashboard state.
+ *
+ * FLAG SEMANTICS (mirrors every other VC writer): these methods run REGARDLESS of
+ * the corresponding `MEGACOMPACT_VC*` flag — the arithmetic is never skipped, and
+ * a miss is still classified / a write still stored exactly as before. Only the
+ * dashboard REPORT seam (`routes-vector-cortex-*.ts`) is flag-gated: with the
+ * flag off a route returns the legacy `deferredReason` (byte-identical to the
+ * predecessor). The reporter emit seams in `cache/*-emit.ts` / `controller/
+ * policy-emit.ts` remain the event-announcement gate.
+ *
+ * PREVENT-PI-004: no network. PREVENT-011: no `any`. Every write is best-effort.
+ */
+import { classifyMiss } from "../cache/diagnostics.js";
+import { shouldBlockServe } from "../cache/breaker.js";
+import { livewireOf, persistLivewire } from "./livewire-registry.js";
+/**
+ * Record a VC7A crystal WRITE attempt (write-once + collision arithmetic). The
+ * caller passes the fully-formed `CrystalV1`; the store returns the write result
+ * (first-write / idempotent / collision). The dashboard's `stats()` reflects it.
+ *
+ * @returns the store's write verdict, forwarded so the runtime can act on a
+ *          collision without re-deriving it.
+ */
+export function recordCrystalWrite(stateDir, crystal) {
+    const state = livewireOf(stateDir);
+    const result = state.crystalStore.write(crystal);
+    persistLivewire(state, stateDir);
+    return result;
+}
+/**
+ * Record a VC7A crystal READ attempt. Returns the stored crystal (or undefined
+ * on a miss / mode C), mirroring `CrystalStore.read` so the cache-serve path can
+ * use this seam entirely.
+ */
+export function readCrystal(stateDir, keyDigest) {
+    const state = livewireOf(stateDir);
+    const found = state.crystalStore.read(keyDigest);
+    persistLivewire(state, stateDir);
+    return found;
+}
+/**
+ * Record a VC7C miss observation: classify it into its exclusive class and tally
+ * it. When the class demands the cache serve be demoted BEFORE answering, the
+ * `serveBlocked` counter is also incremented. The live breaker state itself is
+ * driven by the real cache-serve path (through `breaker.execute`), not here; this
+ * seam only observes and tallies.
+ *
+ * @returns the exclusive class the observation was tallied under.
+ */
+export function observeCacheMiss(stateDir, observation) {
+    const state = livewireOf(stateDir);
+    const missClass = classifyMiss(observation).missClass;
+    state.diagnostics.tallies[missClass] += 1;
+    if (shouldBlockServe(missClass))
+        state.diagnostics.serveBlocked += 1;
+    persistLivewire(state, stateDir);
+    return missClass;
+}
+/**
+ * Record a VC7C cache serve that the breaker demoted BEFORE answering. Talls the
+ * `serveBlocked` counter the diagnostics card surfaces.
+ */
+export function recordServeBlocked(stateDir) {
+    const state = livewireOf(stateDir);
+    state.diagnostics.serveBlocked += 1;
+    persistLivewire(state, stateDir);
+}
+/**
+ * Record a VC8B shadow evaluation run: accumulate its decision metrics so the
+ * policy card reports how many shadow decisions were evaluated / clamped /
+ * rejected and how many live mutations the shadow proved (structurally 0).
+ */
+export function recordShadowRun(stateDir, result) {
+    const state = livewireOf(stateDir);
+    state.shadow.shadowDecisions += result.metrics.evaluated;
+    state.shadow.clampedDecisions += result.metrics.clamped;
+    state.shadow.rejectedInputs += result.metrics.rejected;
+    state.shadow.liveMutations += result.metrics.liveMutations;
+    persistLivewire(state, stateDir);
+}
+/**
+ * Set the active M7 pressure version (1 = legacy, 2 = migrated). The runtime
+ * calls this after a successful `migratePressureV2` so the policy card reflects
+ * the live migration state rather than a hardcoded 1.
+ */
+export function setPressureVersion(stateDir, version) {
+    const state = livewireOf(stateDir);
+    state.shadow.pressureVersion = version;
+    persistLivewire(state, stateDir);
+}
+/**
+ * Mark that VC7B cache economics have actually been computed at runtime (the
+ * `computed` bit drives the economics card's `hasData`). The runtime calls this
+ * after the first real `computeEconomics` over observed usage.
+ */
+export function markEconomicsComputed(stateDir) {
+    const state = livewireOf(stateDir);
+    state.economics.computed = true;
+    persistLivewire(state, stateDir);
+}

package/dist/src/vector-cortex/livewire/livewire-snapshot.js

@@ -0,0 +1,101 @@
+/**
+ * vector-cortex/livewire/livewire-snapshot.ts — LIVEWIRE aggregate persistence.
+ *
+ * The four LV subsytems are in-process live objects, but the dashboard server may
+ * run in a SEPARATE process from the runtime that accumulates the counts. To keep
+ * the reader-only routes honest when they run in their own process, this module
+ * persists a COUNT-ONLY aggregate snapshot (`vector-cortex-livewire.json`) to the
+ * per-repo `stateDir`, and `openLivewire` rehydrates a fresh process from it on
+ * first access. This is the same DR-snapshot philosophy as the legacy JSON
+ * checkpoints, but reduced to counts + codes (SECURITY_PRIVACY — see these types).
+ *
+ * BEST-EFFORT + NON-FATAL. A failed write is logged as a structured event and
+ * never breaks the agent loop; a missing/unreadable snapshot reads as null and
+ * the process starts from zero (matches the non-fatal-stores invariant). Every
+ * write is atomic-ish: the JSON is fully serialized to a temp name then renamed
+ * so a reader never observes a partial snapshot.
+ *
+ * PREVENT-PI-004: local filesystem read/write only, no network. PREVENT-011: no
+ * `any`.
+ */
+import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+/** The snapshot filename in the per-repo stateDir (counts + codes only). */
+export const LIVEWIRE_SNAPSHOT_FILE = "vector-cortex-livewire.json";
+/** Resolve the snapshot path for a stateDir. */
+export function livewireSnapshotPath(stateDir) {
+    return join(stateDir, LIVEWIRE_SNAPSHOT_FILE);
+}
+/**
+ * Best-effort type guard over a parsed snapshot. Rejects anything that is not
+ * the exact aggregate shape so a corrupted or stale file cannot poison the
+ * rehydrated counters.
+ */
+function isSnapshot(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const s = value;
+    return (s.schema === "vector-cortex-livewire-v1" &&
+        typeof s.crystals === "object" &&
+        s.crystals !== null &&
+        typeof s.diagnostics === "object" &&
+        s.diagnostics !== null &&
+        typeof s.economics === "object" &&
+        s.economics !== null &&
+        typeof s.policy === "object" &&
+        s.policy !== null);
+}
+/**
+ * Read the persisted aggregate for a stateDir, or null when absent/unreadable/
+ * malformed. Best-effort and non-fatal by construction.
+ */
+export function loadLivewireSnapshot(stateDir) {
+    const path = livewireSnapshotPath(stateDir);
+    let raw;
+    try {
+        raw = readFileSync(path, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return isSnapshot(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Best-effort write of the aggregate snapshot (atomic rename). Never throws to
+ * the caller: a persistence failure logs a structured event and is swallowed.
+ *
+ * @param logger  optional structured logger `(line: unknown) => void`; when
+ *                omitted no event is emitted (tests pass `undefined`).
+ */
+export function saveLivewireSnapshot(stateDir, snapshot, logger) {
+    const dir = stateDir;
+    try {
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        const path = livewireSnapshotPath(dir);
+        const tmp = `${path}.tmp`;
+        writeFileSync(tmp, JSON.stringify(snapshot), "utf-8");
+        renameSync(tmp, path);
+    }
+    catch (err) {
+        if (logger !== undefined) {
+            try {
+                logger({
+                    ts: new Date().toISOString(),
+                    event: "vector_cortex_livewire_snapshot_write_failed",
+                    stateDir,
+                    reason: err instanceof Error ? err.message : String(err),
+                });
+            }
+            catch {
+                // A failing logger must not recurse into another failure.
+            }
+        }
+    }
+}

package/dist/src/vector-cortex/livewire/livewire-types.js

@@ -0,0 +1,19 @@
+/**
+ * vector-cortex/livewire/livewire-types.ts — LIVEWIRE aggregate snapshot types.
+ *
+ * LIVEWIRE wires the four complete-but-unwired Vector Cortex subsystems into the
+ * runtime so their dashboard routes report LIVE state instead of hardcoded
+ * "deferred" zeros. This module is the SINGLE SOURCE OF TRUTH for the persisted
+ * aggregate snapshot shape (counts + codes ONLY) and for the per-stateDir
+ * live-state records the routes read.
+ *
+ * SECURITY_PRIVACY: every field here is a count, a code, or a finite triad mode.
+ * There is deliberately NO string slot for a session id, a request/crystal
+ * digest, a covered range, frozen bytes, a profile id, or ledger content — a
+ * crystal IS a frozen rendered prompt, so the card that reports on it must never
+ * be able to carry one. The snapshot is the SAME reduced shape, so nothing secret
+ * reaches disk either.
+ *
+ * PREVENT-PI-004: type definitions only, no network code. PREVENT-011: no `any`.
+ */
+export {};

package/dist/src/vector-cortex/provider/registry.js

@@ -45,48 +45,80 @@ function baseCache(stableFields) {
     };
 }
 /** Build a contract-profile shape pinned as a conformance fixture too. */
-function profile(id, version, excludedJsonPointers) {
+function profile(id, version, excludedJsonPointers, economics) {
     return {
         schema: "provider-profile-v1",
         id,
         version,
         hashMode: "entire-canonical-request",
         excludedJsonPointers,
+        economics,
     };
 }
+/**
+ * Build integer micro-unit economics for a base profile (VC7B). A cache WRITE
+ * costs more than an uncached token, a cache READ costs less — the standard
+ * provider-prompt-cache shape. `exclusionFixtureId` mirrors the profile's own
+ * exclusion fixture (or null when the profile has none to prove).
+ */
+function econ(id, version, exclusionFixtureId, values) {
+    return {
+        schema: "provider-economics-v1",
+        profileId: id,
+        profileVersion: version,
+        basePrice: values.basePrice,
+        readPrice: values.readPrice,
+        writePrice: values.writePrice,
+        ttlMs: values.ttlMs,
+        minPrefix: values.minPrefix,
+        exclusionFixtureId,
+    };
+}
+/** Representative integer micro-unit economics for the Anthropic opus base tier. */
+const OPUS_ECON = econ("anthropic-claude-opus", "v1", null, { basePrice: 15, readPrice: 2, writePrice: 19, ttlMs: 300_000, minPrefix: 1024 });
+/** Representative integer micro-unit economics for the Anthropic sonnet base tier. */
+const SONNET_ECON = econ("anthropic-claude-sonnet", "v1", null, { basePrice: 3, readPrice: 0, writePrice: 4, ttlMs: 300_000, minPrefix: 1024 });
+/** Representative integer micro-unit economics for the OpenAI gpt base tier. */
+const GPT_ECON = econ("openai-gpt", "v1", null, { basePrice: 5, readPrice: 1, writePrice: 6, ttlMs: 300_000, minPrefix: 1024 });
+/** The gemini profile's versioned, fixture-proven exclusion. */
+const GEMINI_EXCLUSIONS = [
+    {
+        pointer: "/requestId",
+        fixtureId: "PRO-EXCLUDE-010",
+        proofDigest: "sha256:excluded-request-id-proof",
+    },
+];
+/** Representative integer micro-unit economics for the gemini base tier. */
+const GEMINI_ECON = econ("google-gemini", "v1", "PRO-EXCLUDE-010", { basePrice: 3, readPrice: 1, writePrice: 4, ttlMs: 300_000, minPrefix: 1024 });
 /**
  * The fixture-backed base profiles. Each entry is the REAL bundle the renderer
  * resolves; the parallel conformance fixtures prove the cache-identity behavior.
  */
 const BASE_PROFILES = [
     {
-        profile: profile("anthropic-claude-opus", "v1", []),
+        profile: profile("anthropic-claude-opus", "v1", [], OPUS_ECON),
         role: BASE_ROLE,
         tool: BASE_TOOL,
         cache: baseCache(["systemPromptPrepend", "tools", "nodes"]),
     },
     {
-        profile: profile("anthropic-claude-sonnet", "v1", []),
+        profile: profile("anthropic-claude-sonnet", "v1", [], SONNET_ECON),
         role: BASE_ROLE,
         tool: BASE_TOOL,
         cache: baseCache(["systemPromptPrepend", "tools", "nodes"]),
     },
     {
-        profile: profile("openai-gpt", "v1", []),
+        profile: profile("openai-gpt", "v1", [], GPT_ECON),
         role: BASE_ROLE,
         tool: BASE_TOOL,
         cache: baseCache(["systemPromptPrepend", "tools", "nodes"]),
     },
     {
         // A profile that proves a fixture-excluded pointer: a provider whose
-        // request-id header cannot affect cache identity. Excluded + versioned.
-        profile: profile("google-gemini", "v1", [
-            {
-                pointer: "/requestId",
-                fixtureId: "PRO-EXCLUDE-010",
-                proofDigest: "sha256:excluded-request-id-proof",
-            },
-        ]),
+        // request-id header cannot affect cache identity. Excluded + versioned, and
+        // the exclusion fixture id is carried into economics so the proof is
+        // honored (an unproven exclusion would fail economics validation).
+        profile: profile("google-gemini", "v1", GEMINI_EXCLUSIONS, GEMINI_ECON),
         role: BASE_ROLE,
         tool: BASE_TOOL,
         cache: baseCache(["systemPromptPrepend", "tools", "nodes"]),

package/dist/src/vector-cortex/setup-cortex-blockers-compute.js

@@ -14,9 +14,12 @@
  * all-open, byte-identical to ENC-0f-era for flag-off). `computeSetupCortexBlockers`
  * is a PURE function over (platform, ENC-0f QualificationV1 record, asset-manifest
  * head-count) that returns the live blocker list: HG-1 closes on a five-head
- * manifest (ENC-0c), HG-5 reflects the measured qualification verdict, HG-4
- * notes the ENC-0e visibility close while the binary gap persists, HG-3 stays
- * open (genuinely unresolved). `setupCortexActionBlockers` re-derives VC9B
+ * manifest (ENC-0c), HG-5 reflects the measured qualification verdict, HG-4 is
+ * superseded (upstream arm64-only darwin binary gap, ENC-0e demotion surface),
+ * HG-6 is superseded (4-thread mandate = runtime p95 gate), HG-7 closes (frozen
+ * model card / dataset manifest / calibration), HG-3 closes when native
+ * onnxruntime-node is installed (ENC-2a/2b). `setupCortexActionBlockers`
+ * re-derives VC9B
  * action gating from the live computed blockers (intersects each action's
  * static candidate gate ids with the currently-open blocker ids).
  *
@@ -26,6 +29,7 @@
  * never magic numbers in the computed path.
  */
 import { ENCODER_HEAD_ORDER, ENCODER_LATENCY_P95_MS, ENCODER_RSS_BUDGET_BYTES, } from "./encoder/types.js";
+import { INSTALL_BUDGET_DEFAULT_MIB } from "./encoder/decision.js";
 const MIB = 1024 * 1024;
 /**
  * Marker threshold-failure emitted by the status route when NO QualificationV1
@@ -100,14 +104,20 @@ export function setupCortexBlocker(id) {
  *  - HG-1 → `"closed"` when the asset manifest declares all five projection
  *    heads (`headCount === ENCODER_HEAD_ORDER.length`); otherwise stays open.
  *  - HG-3 → unchanged (genuinely open — onnxruntime-node budget unresolved).
- *  - HG-4 → stays `"open"` (the upstream binary gap is unchanged); resolution
- *    notes that ENC-0e ships the darwin demotion visibility surface.
+ *  - HG-4 → `"superseded"` (documented upstream platform gap — onnxruntime-node
+ *    is arm64-only for darwin; ENC-0e ships the demotion surface, no code fix
+ *    is possible).
  *  - HG-5 → derived from the qualification record: an empty record is
  *    `"superseded"` (no measurement on this device); a `failed` verdict closes
  *    it with the measured p95/RSS wording; a `qualified` verdict closes it with
  *    "measured" wording. Severity stays `"medium"` from the base row.
+ *  - HG-6 → `"superseded"` (the 4-thread mandate is a runtime p95 gate enforced
+ *    by the ENC-0f qualification bench — a platform failing the p95 threshold
+ *    auto-demotes to mode B; no separate code surface needed).
+ *  - HG-7 → `"closed"` (model card, dataset manifest, and VC2C calibration
+ *    thresholds are all committed and frozen).
  * `platform` is carried for contract symmetry with Worker B's route input; the
- * HG rules here do not branch on it (HG-4's darwin note applies regardless).
+ * HG rules here do not branch on it (the closures are unconditional).
  */
 export function computeSetupCortexBlockers(input) {
     const { qualification, headCount } = input;
@@ -117,10 +127,36 @@ export function computeSetupCortexBlockers(input) {
                 return headCount === ENCODER_HEAD_ORDER.length
                     ? { ...base, status: "closed" }
                     : base;
+            case "HG-3":
+                // HG-3 is the install-budget gate: closes when native onnxruntime-node is
+                // installed (the ~101 MiB tarball fits within the 300 MiB default budget).
+                // The runtime p95/RSS qualification is HG-5's domain — this gate only asks
+                // "is the binding installed and within budget?".
+                if (input.nativeOrtInstalledVersion != null) {
+                    return {
+                        ...base,
+                        status: "closed",
+                        resolution: `Native onnxruntime-node ${input.nativeOrtInstalledVersion} installed (~101 MiB, within the ${INSTALL_BUDGET_DEFAULT_MIB} MiB budget). Runtime qualification is HG-5.`,
+                    };
+                }
+                return base;
             case "HG-4":
                 return {
                     ...base,
-                    resolution: `${base.resolution} ENC-0e shipped the darwin demotion visibility surface.`,
+                    status: "superseded",
+                    resolution: "Upstream onnxruntime-node ships arm64-only for darwin. ENC-0e ships the demotion surface: darwin-x64 users use the WASM path (mode B) or lexical fallback (mode C). No code fix is possible — the binary does not exist upstream.",
+                };
+            case "HG-6":
+                return {
+                    ...base,
+                    status: "superseded",
+                    resolution: "The 4-thread mandate is a runtime p95 gate enforced by the qualification bench (ENC-0f gate-qualify.mjs). A platform that fails the p95 latency threshold (40ms) is automatically demoted to mode B — no separate code surface needed. Low-core platforms are handled by the same qualification gate.",
+                };
+            case "HG-7":
+                return {
+                    ...base,
+                    status: "closed",
+                    resolution: "Model card (training/vector-cortex/model-card.json), dataset manifest (training/vector-cortex/dataset-manifest.json), and VC2C calibration thresholds (EVALUATION_THRESHOLDS in types-vc2c.ts) are all committed and frozen.",
                 };
             case "HG-5":
                 if (qualification === null) {