pi-mega-compact 0.20.13 → 0.20.15

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

@@ -0,0 +1,89 @@
+/**
+ * config/vector-cortex-early.ts — VC0/VC1/VC2 phase sprint flags.
+ *
+ * Extracted from vector-cortex.ts to keep that file under the 300-line soft
+ * limit (soft-as-hard gate), exactly as vector-cortex-breakers.ts was. These are
+ * the FOUNDATION-phase flags (observability, ledger, conformance, encoder); the
+ * VC3+ derived-state and prompt-path flags stay in vector-cortex.ts alongside
+ * the shared `sprintFlag` reader they are documented against.
+ *
+ * The split is purely mechanical: every flag below is byte-identical in name,
+ * semantics, and default to its previous definition, and vector-cortex.ts
+ * re-exports all of them so no consumer import path changes.
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+import { sprintFlag } from "./vector-cortex-flag.js";
+/** VC0A — baseline observability (MetricEventV1 / AnnotationV1). Default ON. */
+export const VC0A_ENABLED = () => sprintFlag("MEGACOMPACT_VC0A");
+/**
+ * VC0B — replay correctness (ReplayCutV2 / ReplayReportV2, M3 effective-cut-v2).
+ * Default ON. `MEGACOMPACT_VC0B=0` disables and is byte-identical to the
+ * predecessor (legacy capped-replay behavior preserved; the v2 cut/replay is
+ * only consulted on the vector-cortex path).
+ */
+export const VC0B_ENABLED = () => sprintFlag("MEGACOMPACT_VC0B");
+/**
+ * VC1A — canonical byte events (EventV2 / EventCodec).
+ * Default ON. `MEGACOMPACT_VC1A=0` disables and is byte-identical to the
+ * predecessor (mode C: ledger absent, current transcript codec unchanged).
+ * The single real consumer is the ledger emit seam (`ledger/emit.ts`): flag OFF
+ * gates zero observability writes.
+ */
+export const VC1A_ENABLED = () => sprintFlag("MEGACOMPACT_VC1A");
+/**
+ * VC1B — occurrence ledger + tool identity + compat journal (LedgerReader/
+ * Writer/Admin, CompatJournalV1, M2 occurrence-v2 migration).
+ * Default ON. `MEGACOMPACT_VC1B=0` disables and is byte-identical to the
+ * predecessor (mode C: the neutral occurrence ledger is not written, no
+ * journal rows, zero `vector_cortex_occurrence_appended` emissions). The real
+ * consumers are the ledger write integration seam and the compat-journal
+ * switch seam.
+ */
+export const VC1B_ENABLED = () => sprintFlag("MEGACOMPACT_VC1B");
+/**
+ * VC0C — live safety envelope (TriadResult / Breaker / KillDecision + durable
+ * spool). Default ON. `MEGACOMPACT_VC0C=0` disables and is byte-identical to
+ * the predecessor (mode C: selected before provider invocation, unchanged host
+ * transcript, breaker/spool idle and emitting nothing). The single real
+ * consumer is the resilience emit seam + the safety adapter's triad selection.
+ */
+export const VC0C_ENABLED = () => sprintFlag("MEGACOMPACT_VC0C");
+/**
+ * VC1C — cross-language conformance v2 (FixtureManifestV2 / DowngradeReport /
+ * MinHashV2 + M4 minhash-v2 migration).
+ * Default ON. `MEGACOMPACT_VC1C=0` disables and is byte-identical to the
+ * predecessor (mode C: a v2 conformance runner that accepts authority fixtures
+ * and the manifest validator idle; the sync dedup scan stays on the v1 path;
+ * zero `vector_cortex_*` VC1C emissions). The real consumers are the conformance
+ * emit seam, the minhash-v2 backfill seam and the downgrade-export seam.
+ */
+export const VC1C_ENABLED = () => sprintFlag("MEGACOMPACT_VC1C");
+/**
+ * VC2A — offline model runtime and asset decision (ModelManifestV1 /
+ * EncoderRuntime).
+ * Default ON. `MEGACOMPACT_VC2A=0` disables and is byte-identical to the
+ * predecessor (mode C: no asset manifest is read/verified, the encoder runtime
+ * idles in mode C, zero `vector_cortex_encoder_*` emissions; the trigram/lexical
+ * paths are unchanged). The real consumers are the encoder emit seam and the
+ * encoder runtime's A/B/C selection.
+ */
+export const VC2A_ENABLED = () => sprintFlag("MEGACOMPACT_VC2A");
+/**
+ * VC2B — multi-head encoder (VectorSetV1 / HeadCalibrationDraft).
+ * Default ON. `MEGACOMPACT_VC2B=0` disables and is byte-identical to the
+ * predecessor (the encoder emits no per-head vectors and no fallback-selected
+ * event; the trigram/lexical paths themselves are unchanged and are the
+ * predecessor's mode-B/C producers). The real consumers are the encoder-heads
+ * emit seam and the multi-head encoder producers (heads/trigram/lexical).
+ */
+export const VC2B_ENABLED = () => sprintFlag("MEGACOMPACT_VC2B");
+/**
+ * VC2C — encoder qualification + calibration (QualifiedEncoderV1 / CalibrationV1).
+ * Default ON. `MEGACOMPACT_VC2C=0` disables and is byte-identical to the
+ * predecessor (mode C: no qualification manifest is read or selected, the
+ * calibrate/select/fallback seams are idle, zero `vector_cortex_encoder_qualification_*`
+ * emissions; the trigram/lexical paths are unchanged). The real consumers are
+ * the encoder-qualification emit seam and the calibrate/select seams.
+ */
+export const VC2C_ENABLED = () => sprintFlag("MEGACOMPACT_VC2C");

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

@@ -0,0 +1,25 @@
+/**
+ * config/vector-cortex-flag.ts — the single positive sprint-flag reader.
+ *
+ * Extracted from vector-cortex.ts so the flag groups split across
+ * vector-cortex.ts and vector-cortex-early.ts share ONE definition of what
+ * "enabled" means. Duplicating this three-line function into each group would
+ * be the classic way a sprint flag silently acquires different off-semantics in
+ * different files; there is exactly one implementation and both groups import it.
+ *
+ * Semantics (unchanged, byte-identical to the original in-place definition):
+ * every sprint flag is POSITIVE and defaults ON. `MEGACOMPACT_<SPRINT>=0` or
+ * `=false` disables it, as does `MEGACOMPACT_<SPRINT>_DISABLED=true`/`=1`.
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+/** Positive sprint flag: `=0` or `_DISABLED=true` disables (default ON). */
+export function sprintFlag(name) {
+    const v = process.env[name];
+    if (v === "0" || v === "false")
+        return false;
+    const disabled = process.env[name + "_DISABLED"];
+    if (disabled === "true" || disabled === "1")
+        return false;
+    return true;
+}

package/dist/config/vector-cortex.js

@@ -8,89 +8,11 @@
  * The breaker/triad constants (TRIAD_RESILIENCE.md) live here so VC0C consumes
  * them without re-declaring the ownership boundary. Pi-agnostic, dependency-free.
  */
-/** Positive sprint flag: `=0` or `_DISABLED=true` disables (default ON). */
-function sprintFlag(name) {
-    const v = process.env[name];
-    if (v === "0" || v === "false")
-        return false;
-    const disabled = process.env[name + "_DISABLED"];
-    if (disabled === "true" || disabled === "1")
-        return false;
-    return true;
-}
-/** VC0A — baseline observability (MetricEventV1 / AnnotationV1). Default ON. */
-export const VC0A_ENABLED = () => sprintFlag("MEGACOMPACT_VC0A");
-/**
- * VC0B — replay correctness (ReplayCutV2 / ReplayReportV2, M3 effective-cut-v2).
- * Default ON. `MEGACOMPACT_VC0B=0` disables and is byte-identical to the
- * predecessor (legacy capped-replay behavior preserved; the v2 cut/replay is
- * only consulted on the vector-cortex path).
- */
-export const VC0B_ENABLED = () => sprintFlag("MEGACOMPACT_VC0B");
-/**
- * VC1A — canonical byte events (EventV2 / EventCodec).
- * Default ON. `MEGACOMPACT_VC1A=0` disables and is byte-identical to the
- * predecessor (mode C: ledger absent, current transcript codec unchanged).
- * The single real consumer is the ledger emit seam (`ledger/emit.ts`): flag OFF
- * gates zero observability writes.
- */
-export const VC1A_ENABLED = () => sprintFlag("MEGACOMPACT_VC1A");
-/**
- * VC1B — occurrence ledger + tool identity + compat journal (LedgerReader/
- * Writer/Admin, CompatJournalV1, M2 occurrence-v2 migration).
- * Default ON. `MEGACOMPACT_VC1B=0` disables and is byte-identical to the
- * predecessor (mode C: the neutral occurrence ledger is not written, no
- * journal rows, zero `vector_cortex_occurrence_appended` emissions). The real
- * consumers are the ledger write integration seam and the compat-journal
- * switch seam.
- */
-export const VC1B_ENABLED = () => sprintFlag("MEGACOMPACT_VC1B");
-/**
- * VC0C — live safety envelope (TriadResult / Breaker / KillDecision + durable
- * spool). Default ON. `MEGACOMPACT_VC0C=0` disables and is byte-identical to
- * the predecessor (mode C: selected before provider invocation, unchanged host
- * transcript, breaker/spool idle and emitting nothing). The single real
- * consumer is the resilience emit seam + the safety adapter's triad selection.
- */
-export const VC0C_ENABLED = () => sprintFlag("MEGACOMPACT_VC0C");
-/**
- * VC1C — cross-language conformance v2 (FixtureManifestV2 / DowngradeReport /
- * MinHashV2 + M4 minhash-v2 migration).
- * Default ON. `MEGACOMPACT_VC1C=0` disables and is byte-identical to the
- * predecessor (mode C: a v2 conformance runner that accepts authority fixtures
- * and the manifest validator idle; the sync dedup scan stays on the v1 path;
- * zero `vector_cortex_*` VC1C emissions). The real consumers are the conformance
- * emit seam, the minhash-v2 backfill seam and the downgrade-export seam.
- */
-export const VC1C_ENABLED = () => sprintFlag("MEGACOMPACT_VC1C");
-/**
- * VC2A — offline model runtime and asset decision (ModelManifestV1 /
- * EncoderRuntime).
- * Default ON. `MEGACOMPACT_VC2A=0` disables and is byte-identical to the
- * predecessor (mode C: no asset manifest is read/verified, the encoder runtime
- * idles in mode C, zero `vector_cortex_encoder_*` emissions; the trigram/lexical
- * paths are unchanged). The real consumers are the encoder emit seam and the
- * encoder runtime's A/B/C selection.
- */
-export const VC2A_ENABLED = () => sprintFlag("MEGACOMPACT_VC2A");
-/**
- * VC2B — multi-head encoder (VectorSetV1 / HeadCalibrationDraft).
- * Default ON. `MEGACOMPACT_VC2B=0` disables and is byte-identical to the
- * predecessor (the encoder emits no per-head vectors and no fallback-selected
- * event; the trigram/lexical paths themselves are unchanged and are the
- * predecessor's mode-B/C producers). The real consumers are the encoder-heads
- * emit seam and the multi-head encoder producers (heads/trigram/lexical).
- */
-export const VC2B_ENABLED = () => sprintFlag("MEGACOMPACT_VC2B");
-/**
- * VC2C — encoder qualification + calibration (QualifiedEncoderV1 / CalibrationV1).
- * Default ON. `MEGACOMPACT_VC2C=0` disables and is byte-identical to the
- * predecessor (mode C: no qualification manifest is read or selected, the
- * calibrate/select/fallback seams are idle, zero `vector_cortex_encoder_qualification_*`
- * emissions; the trigram/lexical paths are unchanged). The real consumers are
- * the encoder-qualification emit seam and the calibrate/select seams.
- */
-export const VC2C_ENABLED = () => sprintFlag("MEGACOMPACT_VC2C");
+import { sprintFlag } from "./vector-cortex-flag.js";
+// VC0/VC1/VC2 foundation-phase flags extracted to vector-cortex-early.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 { VC0A_ENABLED, VC0B_ENABLED, VC0C_ENABLED, VC1A_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, } from "./vector-cortex-early.js";
 /**
  * VC3A — capability-gated cortex store (CortexReader/Writer/Admin, CortexRecordV1).
  * Default ON. `MEGACOMPACT_VC3A=0` disables and is byte-identical to the
@@ -251,6 +173,44 @@ export const VC6C_ENABLED = () => sprintFlag("MEGACOMPACT_VC6C");
  * UI, never in EXCLUDED_SETTINGS), mirroring VC4A..VC6C.
  */
 export const VC7A_ENABLED = () => sprintFlag("MEGACOMPACT_VC7A");
+/**
+ * VC7B — provider cache economics + crystal compiler. Default ON.
+ * `MEGACOMPACT_VC7B=0` disables and is byte-identical to the predecessor
+ * (VC7A): `computeEconomics`, `compileCrystalBoundaries` and `assignExperiment`
+ * STILL RUN (they are PURE — exact integer/rational arithmetic and a SHA-256
+ * session bucket, with no clock, storage, or network), so a session keeps its
+ * SAME experiment arm and the compiler keeps producing the SAME boundaries with
+ * the flag off. Crucially the compiler never changes request identity in either
+ * state, so the outbound canonical request — and therefore the VC7A crystal key
+ * and the predecessor golden bytes — are unaffected by this flag.
+ *
+ * The flag gates ONLY the `vector_cortex_cache_experiment_assigned` /
+ * `vector_cortex_cache_economics_estimated` events and the cache-economics
+ * 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..VC7A.
+ */
+export const VC7B_ENABLED = () => sprintFlag("MEGACOMPACT_VC7B");
+/**
+ * VC7C — cache miss diagnostics, cache-level breakers and the completed M5
+ * request-hash-v2 switch. Default ON. `MEGACOMPACT_VC7C=0` disables and is
+ * byte-identical to the predecessor (VC7B): the miss `classify`, the breaker
+ * demotion decision and the M5 request-hash-v2 ARITHMETIC STILL RUN (they are
+ * PURE — an exclusive ordered comparison over already-computed digests plus a
+ * canonical length-prefixed SHA-256, with no clock, storage, or network), so a
+ * miss is classified into the SAME single class, a collision / stale generation
+ * / digest failure / profile mismatch still demotes BEFORE any cache serve, and
+ * the v2 hash of a given request is unchanged with the flag off. A cache is
+ * never allowed to serve a stale or colliding entry merely because reporting is
+ * off — that would be a correctness change, not a reporting change.
+ *
+ * The flag gates ONLY the `vector_cortex_cache_miss_classified` /
+ * `vector_cortex_cache_serve_blocked` events and the cache-diagnostics 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..VC7B.
+ */
+export const VC7C_ENABLED = () => sprintFlag("MEGACOMPACT_VC7C");
 // 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, 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, 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-economics.js

@@ -0,0 +1,20 @@
+/**
+ * api-contracts/vector-cortex-economics.ts — VC7B cache-economics API contract.
+ *
+ * PREVENT-PI-004: type definitions only, no network code.
+ * PREVENT-011: no `any` type.
+ *
+ * Reader-only GET /api/vector-cortex/cache-economics diagnostics view (VC7B).
+ *
+ * COUNTS + CODES ONLY. Cache economics price a FROZEN RENDERED PROMPT's reuse, so
+ * this is the surface where an unguarded payload field would leak the frozen
+ * bytes, the covered ranges, the span/covered digests, the request digests, or
+ * the session ids that identify the framed conversation. It exposes ONLY:
+ *   - whether the VC7B flag is enabled and the runtime triad mode it implies;
+ *   - how many provider profiles carry economics and how many exclusions are
+ *     proven vs unproven (a count, never the excluded pointer or its bytes);
+ *   - the last ECON_* rejection code (an outcome code, not a payload).
+ * Per-profile prices, digests, ranges, and session ids live in the structured
+ * event log / conformance corpus, never here (SECURITY_PRIVACY).
+ */
+export {};

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

@@ -16,6 +16,11 @@ import { handleVectorCortexRepair } from "./routes-vector-cortex-repair.js";
 // stays independent of the heal/repair handlers and every file stays well under
 // the 400-line extension limit.
 import { handleVectorCortexCrystals } from "./routes-vector-cortex-crystals.js";
+// VC7B cache economics likewise get their own module so the economics seam stays
+// independent of the crystals handler and every file stays well under the
+// 400-line extension soft limit.
+import { handleVectorCortexEconomics } from "./routes-vector-cortex-economics.js";
+// VC7C cache miss diagnostics + breakers handler will be imported here when VC7C ships.
 /**
  * Dispatch a request through every registered route handler.
  * Returns true if a handler claimed the request (ended the response).
@@ -111,5 +116,7 @@ export function dispatchRoutes(req, res, ctx) {
         return true;
     if (handleVectorCortexCrystals(req, res, ctx))
         return true;
+    if (handleVectorCortexEconomics(req, res, ctx))
+        return true;
     return false;
 }

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

@@ -43,5 +43,7 @@ export const VECTOR_CORTEX_SETTINGS = {
         boolDirect("MEGACOMPACT_VC6B", "VC6B Exact Source Restoration", "Exact source restoration: restores the original bytes of closure spans ONLY from an exact shard (mode A) or a verified ledger range scan (mode B) — never inferred, reconstructed, or paraphrased from embeddings or semantic text. Requests are hard-bounded at 64 spans / 4MiB (HEAL_RESTORE_LIMIT); every span's SHA-256 is recomputed and bytes are inserted only after all requested span metadata validates, so a single bad span fails the whole request closed (HEAL_RESTORE_DIGEST_MISMATCH, HEAL_RESTORE_RANGE_MISMATCH). When no exact source exists (HEAL_RESTORE_SOURCE_MISSING) the old context is omitted and the loss is disclosed (mode C) rather than filled in. OFF = byte-identical predecessor (VC6A).", true),
         boolDirect("MEGACOMPACT_VC6C", "VC6C Self-Healing Derived State", "Self-healing derived-state controller: detects gaps between each derived subsystem's high-water mark and the durable authority high-water, then rebuilds derived state by copy -> root-digest verification -> atomic pointer switch, so a partially rebuilt subsystem is never made visible. A targeted single-subsystem rebuild is mode A; an ambiguous gap escalates to a full deterministic rebuild (mode B); if both rebuild paths fail the derived state is disabled rather than served stale (mode C). Rebuilds are rate-limited to one per subsystem per 5 minutes with deterministic exponential backoff, so a persistently failing subsystem cannot spin. OFF = byte-identical predecessor (VC6B); no controller runs, so the dashboard reports mode C.", true),
         boolDirect("MEGACOMPACT_VC7A", "VC7A Frozen Range Crystals", "Frozen range crystals: caches a rendered prompt under an IMMUTABLE key built from the source ranges it covers, the digest of those covered bytes, the validated durable dependency high-water, and the renderer + provider profile — and deliberately NOT the global ledger frontier, so an unrelated append leaves the key unchanged instead of invalidating every crystal on every turn. Any covered-byte, dependency, renderer, or profile change invalidates 100%. Ranges are sorted by source start and overlapping ranges are rejected (CRY_RANGE_OVERLAP) rather than merged. The store is content-addressed and write-once: identical bytes re-written are idempotent, but a same-key/different-bytes write returns CRY_KEY_COLLISION and never overwrites, surfacing renderer non-determinism instead of hiding it. A store hit is mode A, a miss/collision forces a fresh deterministic render (mode B), and an unavailable store bypasses the cache entirely (mode C). OFF = byte-identical predecessor (VC6C); the crystal/store arithmetic still runs, only the reporter + dashboard seam is suppressed.", true),
+        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),
     ],
 };

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

@@ -0,0 +1,59 @@
+/**
+ * dashboard-server/routes-vector-cortex-economics.ts — VC7B cache-economics
+ * dashboard route.
+ *
+ * Reader-only GET /api/vector-cortex/cache-economics returning the cache-
+ * economics aggregate diagnostics: whether the VC7B flag is enabled, the runtime
+ * triad mode, how many provider profiles carry economics, how many exclusions
+ * are proven vs unproven, and the last ECON_* failure code.
+ *
+ * COUNTS + CODES ONLY. Cache economics price a FROZEN RENDERED PROMPT's reuse,
+ * so a careless payload field would leak the frozen bytes, the covered ranges,
+ * the span/covered digests, the request digests, or session ids that identify
+ * the framed conversation. This route NEVER exposes frozen bytes, ranges,
+ * digests, session ids, or request digests — only aggregate counts and the
+ * observable ECON_* outcome code (reader-only, SECURITY_PRIVACY). There is no
+ * mutation seam: economics are computed by the render path, never by a dashboard
+ * request. Non-GET is rejected outright.
+ *
+ * Split into its own file (rather than grown into routes-vector-cortex-crystals.ts)
+ * to keep every extensions/ file well under the 400-line soft-as-hard limit.
+ *
+ * Guardrails: PREVENT-PI-004 (local in-process state only), PREVENT-011 (no
+ * `any`), reader-only aggregate (counts + codes only).
+ */
+import { VC7B_ENABLED } from "../../src/config.js";
+import { sendJson } from "./routes-vector-cortex-shared.js";
+/**
+ * Reader-only GET /api/vector-cortex/cache-economics (VC7B).
+ *
+ * Counts, profile tallies, and ECON_* codes only — a static reader-only
+ * aggregate seam with the same shape as the VC7A crystals handler.
+ */
+export function handleVectorCortexEconomics(req, res, _ctx) {
+    const url = req.url ?? "";
+    const path = url.split("?")[0] ?? url;
+    if (path !== "/api/vector-cortex/cache-economics")
+        return false;
+    if (req.method !== "GET") {
+        sendJson(res, 405, { error: "method_not_allowed" });
+        return true;
+    }
+    const enabled = VC7B_ENABLED();
+    // Flag-off routes to mode C: with VC7B off no cache economics are served, which
+    // is exactly the spec's "economics bypass" outcome. Reporting A (cached render
+    // priced) or B (fresh render priced) would imply an economics path that is not
+    // wired at all. Mirrors how VC6C/VC7A OFF views report the mode they take.
+    const mode = enabled ? "A" : "C";
+    const body = {
+        enabled,
+        mode,
+        profileCount: 0,
+        provenExclusions: 0,
+        unprovenExclusions: 0,
+        lastFailure: null,
+        updatedAt: new Date().toISOString(),
+    };
+    sendJson(res, 200, body);
+    return true;
+}

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

@@ -0,0 +1,89 @@
+/**
+ * config/vector-cortex-early.ts — VC0/VC1/VC2 phase sprint flags.
+ *
+ * Extracted from vector-cortex.ts to keep that file under the 300-line soft
+ * limit (soft-as-hard gate), exactly as vector-cortex-breakers.ts was. These are
+ * the FOUNDATION-phase flags (observability, ledger, conformance, encoder); the
+ * VC3+ derived-state and prompt-path flags stay in vector-cortex.ts alongside
+ * the shared `sprintFlag` reader they are documented against.
+ *
+ * The split is purely mechanical: every flag below is byte-identical in name,
+ * semantics, and default to its previous definition, and vector-cortex.ts
+ * re-exports all of them so no consumer import path changes.
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+import { sprintFlag } from "./vector-cortex-flag.js";
+/** VC0A — baseline observability (MetricEventV1 / AnnotationV1). Default ON. */
+export const VC0A_ENABLED = () => sprintFlag("MEGACOMPACT_VC0A");
+/**
+ * VC0B — replay correctness (ReplayCutV2 / ReplayReportV2, M3 effective-cut-v2).
+ * Default ON. `MEGACOMPACT_VC0B=0` disables and is byte-identical to the
+ * predecessor (legacy capped-replay behavior preserved; the v2 cut/replay is
+ * only consulted on the vector-cortex path).
+ */
+export const VC0B_ENABLED = () => sprintFlag("MEGACOMPACT_VC0B");
+/**
+ * VC1A — canonical byte events (EventV2 / EventCodec).
+ * Default ON. `MEGACOMPACT_VC1A=0` disables and is byte-identical to the
+ * predecessor (mode C: ledger absent, current transcript codec unchanged).
+ * The single real consumer is the ledger emit seam (`ledger/emit.ts`): flag OFF
+ * gates zero observability writes.
+ */
+export const VC1A_ENABLED = () => sprintFlag("MEGACOMPACT_VC1A");
+/**
+ * VC1B — occurrence ledger + tool identity + compat journal (LedgerReader/
+ * Writer/Admin, CompatJournalV1, M2 occurrence-v2 migration).
+ * Default ON. `MEGACOMPACT_VC1B=0` disables and is byte-identical to the
+ * predecessor (mode C: the neutral occurrence ledger is not written, no
+ * journal rows, zero `vector_cortex_occurrence_appended` emissions). The real
+ * consumers are the ledger write integration seam and the compat-journal
+ * switch seam.
+ */
+export const VC1B_ENABLED = () => sprintFlag("MEGACOMPACT_VC1B");
+/**
+ * VC0C — live safety envelope (TriadResult / Breaker / KillDecision + durable
+ * spool). Default ON. `MEGACOMPACT_VC0C=0` disables and is byte-identical to
+ * the predecessor (mode C: selected before provider invocation, unchanged host
+ * transcript, breaker/spool idle and emitting nothing). The single real
+ * consumer is the resilience emit seam + the safety adapter's triad selection.
+ */
+export const VC0C_ENABLED = () => sprintFlag("MEGACOMPACT_VC0C");
+/**
+ * VC1C — cross-language conformance v2 (FixtureManifestV2 / DowngradeReport /
+ * MinHashV2 + M4 minhash-v2 migration).
+ * Default ON. `MEGACOMPACT_VC1C=0` disables and is byte-identical to the
+ * predecessor (mode C: a v2 conformance runner that accepts authority fixtures
+ * and the manifest validator idle; the sync dedup scan stays on the v1 path;
+ * zero `vector_cortex_*` VC1C emissions). The real consumers are the conformance
+ * emit seam, the minhash-v2 backfill seam and the downgrade-export seam.
+ */
+export const VC1C_ENABLED = () => sprintFlag("MEGACOMPACT_VC1C");
+/**
+ * VC2A — offline model runtime and asset decision (ModelManifestV1 /
+ * EncoderRuntime).
+ * Default ON. `MEGACOMPACT_VC2A=0` disables and is byte-identical to the
+ * predecessor (mode C: no asset manifest is read/verified, the encoder runtime
+ * idles in mode C, zero `vector_cortex_encoder_*` emissions; the trigram/lexical
+ * paths are unchanged). The real consumers are the encoder emit seam and the
+ * encoder runtime's A/B/C selection.
+ */
+export const VC2A_ENABLED = () => sprintFlag("MEGACOMPACT_VC2A");
+/**
+ * VC2B — multi-head encoder (VectorSetV1 / HeadCalibrationDraft).
+ * Default ON. `MEGACOMPACT_VC2B=0` disables and is byte-identical to the
+ * predecessor (the encoder emits no per-head vectors and no fallback-selected
+ * event; the trigram/lexical paths themselves are unchanged and are the
+ * predecessor's mode-B/C producers). The real consumers are the encoder-heads
+ * emit seam and the multi-head encoder producers (heads/trigram/lexical).
+ */
+export const VC2B_ENABLED = () => sprintFlag("MEGACOMPACT_VC2B");
+/**
+ * VC2C — encoder qualification + calibration (QualifiedEncoderV1 / CalibrationV1).
+ * Default ON. `MEGACOMPACT_VC2C=0` disables and is byte-identical to the
+ * predecessor (mode C: no qualification manifest is read or selected, the
+ * calibrate/select/fallback seams are idle, zero `vector_cortex_encoder_qualification_*`
+ * emissions; the trigram/lexical paths are unchanged). The real consumers are
+ * the encoder-qualification emit seam and the calibrate/select seams.
+ */
+export const VC2C_ENABLED = () => sprintFlag("MEGACOMPACT_VC2C");

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

@@ -0,0 +1,25 @@
+/**
+ * config/vector-cortex-flag.ts — the single positive sprint-flag reader.
+ *
+ * Extracted from vector-cortex.ts so the flag groups split across
+ * vector-cortex.ts and vector-cortex-early.ts share ONE definition of what
+ * "enabled" means. Duplicating this three-line function into each group would
+ * be the classic way a sprint flag silently acquires different off-semantics in
+ * different files; there is exactly one implementation and both groups import it.
+ *
+ * Semantics (unchanged, byte-identical to the original in-place definition):
+ * every sprint flag is POSITIVE and defaults ON. `MEGACOMPACT_<SPRINT>=0` or
+ * `=false` disables it, as does `MEGACOMPACT_<SPRINT>_DISABLED=true`/`=1`.
+ *
+ * Pi-agnostic, dependency-free (PREVENT-PI-004 / PREVENT-011).
+ */
+/** Positive sprint flag: `=0` or `_DISABLED=true` disables (default ON). */
+export function sprintFlag(name) {
+    const v = process.env[name];
+    if (v === "0" || v === "false")
+        return false;
+    const disabled = process.env[name + "_DISABLED"];
+    if (disabled === "true" || disabled === "1")
+        return false;
+    return true;
+}

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

@@ -8,89 +8,11 @@
  * The breaker/triad constants (TRIAD_RESILIENCE.md) live here so VC0C consumes
  * them without re-declaring the ownership boundary. Pi-agnostic, dependency-free.
  */
-/** Positive sprint flag: `=0` or `_DISABLED=true` disables (default ON). */
-function sprintFlag(name) {
-    const v = process.env[name];
-    if (v === "0" || v === "false")
-        return false;
-    const disabled = process.env[name + "_DISABLED"];
-    if (disabled === "true" || disabled === "1")
-        return false;
-    return true;
-}
-/** VC0A — baseline observability (MetricEventV1 / AnnotationV1). Default ON. */
-export const VC0A_ENABLED = () => sprintFlag("MEGACOMPACT_VC0A");
-/**
- * VC0B — replay correctness (ReplayCutV2 / ReplayReportV2, M3 effective-cut-v2).
- * Default ON. `MEGACOMPACT_VC0B=0` disables and is byte-identical to the
- * predecessor (legacy capped-replay behavior preserved; the v2 cut/replay is
- * only consulted on the vector-cortex path).
- */
-export const VC0B_ENABLED = () => sprintFlag("MEGACOMPACT_VC0B");
-/**
- * VC1A — canonical byte events (EventV2 / EventCodec).
- * Default ON. `MEGACOMPACT_VC1A=0` disables and is byte-identical to the
- * predecessor (mode C: ledger absent, current transcript codec unchanged).
- * The single real consumer is the ledger emit seam (`ledger/emit.ts`): flag OFF
- * gates zero observability writes.
- */
-export const VC1A_ENABLED = () => sprintFlag("MEGACOMPACT_VC1A");
-/**
- * VC1B — occurrence ledger + tool identity + compat journal (LedgerReader/
- * Writer/Admin, CompatJournalV1, M2 occurrence-v2 migration).
- * Default ON. `MEGACOMPACT_VC1B=0` disables and is byte-identical to the
- * predecessor (mode C: the neutral occurrence ledger is not written, no
- * journal rows, zero `vector_cortex_occurrence_appended` emissions). The real
- * consumers are the ledger write integration seam and the compat-journal
- * switch seam.
- */
-export const VC1B_ENABLED = () => sprintFlag("MEGACOMPACT_VC1B");
-/**
- * VC0C — live safety envelope (TriadResult / Breaker / KillDecision + durable
- * spool). Default ON. `MEGACOMPACT_VC0C=0` disables and is byte-identical to
- * the predecessor (mode C: selected before provider invocation, unchanged host
- * transcript, breaker/spool idle and emitting nothing). The single real
- * consumer is the resilience emit seam + the safety adapter's triad selection.
- */
-export const VC0C_ENABLED = () => sprintFlag("MEGACOMPACT_VC0C");
-/**
- * VC1C — cross-language conformance v2 (FixtureManifestV2 / DowngradeReport /
- * MinHashV2 + M4 minhash-v2 migration).
- * Default ON. `MEGACOMPACT_VC1C=0` disables and is byte-identical to the
- * predecessor (mode C: a v2 conformance runner that accepts authority fixtures
- * and the manifest validator idle; the sync dedup scan stays on the v1 path;
- * zero `vector_cortex_*` VC1C emissions). The real consumers are the conformance
- * emit seam, the minhash-v2 backfill seam and the downgrade-export seam.
- */
-export const VC1C_ENABLED = () => sprintFlag("MEGACOMPACT_VC1C");
-/**
- * VC2A — offline model runtime and asset decision (ModelManifestV1 /
- * EncoderRuntime).
- * Default ON. `MEGACOMPACT_VC2A=0` disables and is byte-identical to the
- * predecessor (mode C: no asset manifest is read/verified, the encoder runtime
- * idles in mode C, zero `vector_cortex_encoder_*` emissions; the trigram/lexical
- * paths are unchanged). The real consumers are the encoder emit seam and the
- * encoder runtime's A/B/C selection.
- */
-export const VC2A_ENABLED = () => sprintFlag("MEGACOMPACT_VC2A");
-/**
- * VC2B — multi-head encoder (VectorSetV1 / HeadCalibrationDraft).
- * Default ON. `MEGACOMPACT_VC2B=0` disables and is byte-identical to the
- * predecessor (the encoder emits no per-head vectors and no fallback-selected
- * event; the trigram/lexical paths themselves are unchanged and are the
- * predecessor's mode-B/C producers). The real consumers are the encoder-heads
- * emit seam and the multi-head encoder producers (heads/trigram/lexical).
- */
-export const VC2B_ENABLED = () => sprintFlag("MEGACOMPACT_VC2B");
-/**
- * VC2C — encoder qualification + calibration (QualifiedEncoderV1 / CalibrationV1).
- * Default ON. `MEGACOMPACT_VC2C=0` disables and is byte-identical to the
- * predecessor (mode C: no qualification manifest is read or selected, the
- * calibrate/select/fallback seams are idle, zero `vector_cortex_encoder_qualification_*`
- * emissions; the trigram/lexical paths are unchanged). The real consumers are
- * the encoder-qualification emit seam and the calibrate/select seams.
- */
-export const VC2C_ENABLED = () => sprintFlag("MEGACOMPACT_VC2C");
+import { sprintFlag } from "./vector-cortex-flag.js";
+// VC0/VC1/VC2 foundation-phase flags extracted to vector-cortex-early.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 { VC0A_ENABLED, VC0B_ENABLED, VC0C_ENABLED, VC1A_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, } from "./vector-cortex-early.js";
 /**
  * VC3A — capability-gated cortex store (CortexReader/Writer/Admin, CortexRecordV1).
  * Default ON. `MEGACOMPACT_VC3A=0` disables and is byte-identical to the
@@ -251,6 +173,44 @@ export const VC6C_ENABLED = () => sprintFlag("MEGACOMPACT_VC6C");
  * UI, never in EXCLUDED_SETTINGS), mirroring VC4A..VC6C.
  */
 export const VC7A_ENABLED = () => sprintFlag("MEGACOMPACT_VC7A");
+/**
+ * VC7B — provider cache economics + crystal compiler. Default ON.
+ * `MEGACOMPACT_VC7B=0` disables and is byte-identical to the predecessor
+ * (VC7A): `computeEconomics`, `compileCrystalBoundaries` and `assignExperiment`
+ * STILL RUN (they are PURE — exact integer/rational arithmetic and a SHA-256
+ * session bucket, with no clock, storage, or network), so a session keeps its
+ * SAME experiment arm and the compiler keeps producing the SAME boundaries with
+ * the flag off. Crucially the compiler never changes request identity in either
+ * state, so the outbound canonical request — and therefore the VC7A crystal key
+ * and the predecessor golden bytes — are unaffected by this flag.
+ *
+ * The flag gates ONLY the `vector_cortex_cache_experiment_assigned` /
+ * `vector_cortex_cache_economics_estimated` events and the cache-economics
+ * 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..VC7A.
+ */
+export const VC7B_ENABLED = () => sprintFlag("MEGACOMPACT_VC7B");
+/**
+ * VC7C — cache miss diagnostics, cache-level breakers and the completed M5
+ * request-hash-v2 switch. Default ON. `MEGACOMPACT_VC7C=0` disables and is
+ * byte-identical to the predecessor (VC7B): the miss `classify`, the breaker
+ * demotion decision and the M5 request-hash-v2 ARITHMETIC STILL RUN (they are
+ * PURE — an exclusive ordered comparison over already-computed digests plus a
+ * canonical length-prefixed SHA-256, with no clock, storage, or network), so a
+ * miss is classified into the SAME single class, a collision / stale generation
+ * / digest failure / profile mismatch still demotes BEFORE any cache serve, and
+ * the v2 hash of a given request is unchanged with the flag off. A cache is
+ * never allowed to serve a stale or colliding entry merely because reporting is
+ * off — that would be a correctness change, not a reporting change.
+ *
+ * The flag gates ONLY the `vector_cortex_cache_miss_classified` /
+ * `vector_cortex_cache_serve_blocked` events and the cache-diagnostics 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..VC7B.
+ */
+export const VC7C_ENABLED = () => sprintFlag("MEGACOMPACT_VC7C");
 // 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";