pi-mega-compact 0.20.18 → 0.20.19

package/dist/config/vector-cortex.js

@@ -225,6 +225,20 @@ export const VC7C_ENABLED = () => sprintFlag("MEGACOMPACT_VC7C");
  * EXCLUDED_SETTINGS), mirroring VC4A..VC7C.
  */
 export const VC8A_ENABLED = () => sprintFlag("MEGACOMPACT_VC8A");
+/**
+ * VC8B — bounded shadow adaptive policy + M7 pressure-v2. Default ON.
+ * `MEGACOMPACT_VC8B=0` disables and is byte-identical to the predecessor
+ * (VC8A): the policy engine, shadow evaluator, and M7 migration STILL RUN
+ * (they are PURE — action validation, budget clamping, pressure canonicalization
+ * and copy/validate/switch, with no clock, storage, or network), so a budget is
+ * still clamped identically and an unknown pressure label is still rejected. The
+ * flag gates ONLY the `vector_cortex_shadow_decision_recorded` /
+ * `vector_cortex_policy_action_rejected` events and the policy dashboard seam,
+ * which reports `enabled:false` + mode C when off. This flag MUST also be a
+ * dashboard SETTINGS toggle (visible in config UI, never in EXCLUDED_SETTINGS),
+ * mirroring VC4A..VC8A.
+ */
+export const VC8B_ENABLED = () => sprintFlag("MEGACOMPACT_VC8B");
 // Breaker state machine constants (TRIAD_RESILIENCE.md §breaker) extracted to
 // vector-cortex-breakers.ts to keep this file under the 300-line soft limit.
 export { BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./vector-cortex-breakers.js";

package/dist/config.js

@@ -114,4 +114,4 @@ export const NEW_UI = () => ragEnabled("MEGACOMPACT_NEW_UI");
 // default ON, `=0`/`_DISABLED` off. Re-exported from src/config/vector-cortex.ts
 // so root consumers share one source of truth.
 // ---------------------------------------------------------------------------
-export { VC0A_ENABLED, VC0B_ENABLED, VC1A_ENABLED, VC0C_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, VC3A_ENABLED, VC3B_ENABLED, VC3C_ENABLED, VC4A_ENABLED, VC4B_ENABLED, VC4C_ENABLED, VC5A_ENABLED, VC5B_ENABLED, VC5C_ENABLED, VC6A_ENABLED, VC6B_ENABLED, VC6C_ENABLED, VC7A_ENABLED, VC7B_ENABLED, VC7C_ENABLED, VC8A_ENABLED, BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./config/vector-cortex.js";
+export { VC0A_ENABLED, VC0B_ENABLED, VC1A_ENABLED, VC0C_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, VC3A_ENABLED, VC3B_ENABLED, VC3C_ENABLED, VC4A_ENABLED, VC4B_ENABLED, VC4C_ENABLED, VC5A_ENABLED, VC5B_ENABLED, VC5C_ENABLED, VC6A_ENABLED, VC6B_ENABLED, VC6C_ENABLED, VC7A_ENABLED, VC7B_ENABLED, VC7C_ENABLED, VC8A_ENABLED, VC8B_ENABLED, 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-policy.js

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

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

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

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

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

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

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

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

@@ -225,6 +225,20 @@ export const VC7C_ENABLED = () => sprintFlag("MEGACOMPACT_VC7C");
  * EXCLUDED_SETTINGS), mirroring VC4A..VC7C.
  */
 export const VC8A_ENABLED = () => sprintFlag("MEGACOMPACT_VC8A");
+/**
+ * VC8B — bounded shadow adaptive policy + M7 pressure-v2. Default ON.
+ * `MEGACOMPACT_VC8B=0` disables and is byte-identical to the predecessor
+ * (VC8A): the policy engine, shadow evaluator, and M7 migration STILL RUN
+ * (they are PURE — action validation, budget clamping, pressure canonicalization
+ * and copy/validate/switch, with no clock, storage, or network), so a budget is
+ * still clamped identically and an unknown pressure label is still rejected. The
+ * flag gates ONLY the `vector_cortex_shadow_decision_recorded` /
+ * `vector_cortex_policy_action_rejected` events and the policy dashboard seam,
+ * which reports `enabled:false` + mode C when off. This flag MUST also be a
+ * dashboard SETTINGS toggle (visible in config UI, never in EXCLUDED_SETTINGS),
+ * mirroring VC4A..VC8A.
+ */
+export const VC8B_ENABLED = () => sprintFlag("MEGACOMPACT_VC8B");
 // Breaker state machine constants (TRIAD_RESILIENCE.md §breaker) extracted to
 // vector-cortex-breakers.ts to keep this file under the 300-line soft limit.
 export { BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./vector-cortex-breakers.js";

package/dist/src/config.js

@@ -114,4 +114,4 @@ export const NEW_UI = () => ragEnabled("MEGACOMPACT_NEW_UI");
 // default ON, `=0`/`_DISABLED` off. Re-exported from src/config/vector-cortex.ts
 // so root consumers share one source of truth.
 // ---------------------------------------------------------------------------
-export { VC0A_ENABLED, VC0B_ENABLED, VC1A_ENABLED, VC0C_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, VC3A_ENABLED, VC3B_ENABLED, VC3C_ENABLED, VC4A_ENABLED, VC4B_ENABLED, VC4C_ENABLED, VC5A_ENABLED, VC5B_ENABLED, VC5C_ENABLED, VC6A_ENABLED, VC6B_ENABLED, VC6C_ENABLED, VC7A_ENABLED, VC7B_ENABLED, VC7C_ENABLED, VC8A_ENABLED, BREAKER_WINDOW_MS, BREAKER_MIN_ATTEMPTS, BREAKER_PERF_FAILURES, BREAKER_PERF_FAILURE_RATE, BREAKER_CORRECTNESS_FAILURES, BREAKER_COOLDOWN_MS, BREAKER_PROBE_COUNT, BREAKER_RETRY_BASE_MS, BREAKER_RETRY_CAP_MS, BREAKER_RETRY_JITTER, BREAKER_HYSTERESIS_FAILURE_RATE, BREAKER_HYSTERESIS_BUDGET_P95_MS, BREAKER_MIN_HEALTHY_RESIDENCE_MS, } from "./config/vector-cortex.js";
+export { VC0A_ENABLED, VC0B_ENABLED, VC1A_ENABLED, VC0C_ENABLED, VC1B_ENABLED, VC1C_ENABLED, VC2A_ENABLED, VC2B_ENABLED, VC2C_ENABLED, VC3A_ENABLED, VC3B_ENABLED, VC3C_ENABLED, VC4A_ENABLED, VC4B_ENABLED, VC4C_ENABLED, VC5A_ENABLED, VC5B_ENABLED, VC5C_ENABLED, VC6A_ENABLED, VC6B_ENABLED, VC6C_ENABLED, VC7A_ENABLED, VC7B_ENABLED, VC7C_ENABLED, VC8A_ENABLED, VC8B_ENABLED, 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/controller/policy-emit.js

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

package/dist/src/vector-cortex/migrations/pressure-v2-ops.js

@@ -0,0 +1,166 @@
+/**
+ * pressure-v2-ops.ts — M7 migration operational logic (copy/validate/switch).
+ *
+ * Extracted from pressure-v2.ts to keep the parent file under the 300-line
+ * soft limit (soft-as-hard gate). Pure logic over an injected M7Host;
+ * deterministic + testable; no console. PREVENT-002/011/PI-004 honored.
+ *
+ * WHY THE LABEL CHECK RE-READS THE HOST AT SWITCH TIME. The sprint's failure
+ * injection is explicit: kill the process after the copy phase, insert an
+ * unknown legacy pressure row, then resume — and the resumed run must return
+ * M7_PRESSURE_UNKNOWN and KEEP THE OLD POINTER. If the switch trusted the
+ * verdict of an earlier verify call, the injected row would be invisible and
+ * the pointer would flip over a store that still holds an uncanonical label.
+ * So `m7Switch` re-reads `v1Rows`/`existingV2`/`activeVersion` and re-validates
+ * against that live state. Validation is a precondition; the switch is the only
+ * place that proves the hazard is absent *right now*.
+ */
+import { createHash } from "node:crypto";
+import { isPressureLevel } from "../controller/policy.js";
+import { M7_FAIL, PRESSURE_LEGACY_VERSION } from "./pressure-v2-types.js";
+/** Length-prefixed framing so the folded fields cannot alias. */
+function field(value) {
+    return `${Buffer.byteLength(value, "utf8")}:${value}`;
+}
+/** Row identity is (session, effectiveSeq) — one pressure per sequence point. */
+const identity = (sessionId, effectiveSeq) => `${sessionId}::${effectiveSeq}`;
+/** The authoritative v2 digest: SHA-256 over the length-prefixed fields. */
+export function derivePressureDigest(sessionId, level, effectiveSeq, ts) {
+    return createHash("sha256")
+        .update(field("pressure-v2") +
+        field(sessionId) +
+        field(level) +
+        field(String(effectiveSeq)) +
+        field(ts), "utf8")
+        .digest("hex");
+}
+/**
+ * Map ONE legacy row to its v2 form. ONLY the canonical five labels map;
+ * anything else throws `{ code: M7_PRESSURE_UNKNOWN }`. There is deliberately
+ * no fallback branch — a coerced label is a silently misclassified workload.
+ */
+export function mapPressureRow(v1) {
+    if (!isPressureLevel(v1.label)) {
+        throw { code: M7_FAIL.PRESSURE_UNKNOWN };
+    }
+    return {
+        sessionId: v1.sessionId,
+        level: v1.label,
+        effectiveSeq: v1.effectiveSeq,
+        ts: v1.ts,
+        digest: derivePressureDigest(v1.sessionId, v1.label, v1.effectiveSeq, v1.ts),
+    };
+}
+/** True when every legacy row carries a canonical label. */
+export function allLabelsCanonical(host) {
+    return host.v1Rows().every((r) => isPressureLevel(r.label));
+}
+/**
+ * COPY: resumable per (session, effectiveSeq). An interrupted run resumes
+ * without duplicate rows. An uncanonical label aborts the copy with
+ * M7_PRESSURE_UNKNOWN before anything is written.
+ */
+export function m7Copy(host) {
+    const existing = new Map(host.existingV2().map((r) => [identity(r.sessionId, r.effectiveSeq), r]));
+    const wanted = [];
+    for (const v1 of host.v1Rows()) {
+        // Throws M7_PRESSURE_UNKNOWN for a non-canonical label.
+        const fresh = mapPressureRow(v1);
+        const stored = existing.get(identity(v1.sessionId, v1.effectiveSeq));
+        if (stored !== undefined && stored.digest === fresh.digest)
+            continue;
+        wanted.push(fresh);
+    }
+    if (wanted.length > 0)
+        host.putV2(wanted);
+    return { written: wanted, all: [...host.existingV2()] };
+}
+function dedupe(codes) {
+    const out = [];
+    for (const c of codes)
+        if (!out.includes(c))
+            out.push(c);
+    return out;
+}
+/**
+ * VALIDATE: compare counts and digests between v1 and v2, and re-check every
+ * legacy label. Returns codes rather than throwing so a caller sees every
+ * problem at once.
+ */
+export function m7Verify(host) {
+    const codes = [];
+    const v1Rows = host.v1Rows();
+    const stored = host.existingV2();
+    // Label check first: an uncanonical legacy label invalidates the whole run.
+    for (const v1 of v1Rows) {
+        if (!isPressureLevel(v1.label))
+            codes.push(M7_FAIL.PRESSURE_UNKNOWN);
+    }
+    const counts = new Map();
+    for (const r of stored) {
+        const id = identity(r.sessionId, r.effectiveSeq);
+        counts.set(id, (counts.get(id) ?? 0) + 1);
+    }
+    const expected = new Set();
+    for (const v1 of v1Rows) {
+        if (!isPressureLevel(v1.label))
+            continue;
+        const id = identity(v1.sessionId, v1.effectiveSeq);
+        expected.add(id);
+        const n = counts.get(id) ?? 0;
+        if (n === 0)
+            codes.push(M7_FAIL.COPY_PARTIAL);
+        if (n > 1)
+            codes.push(M7_FAIL.COUNT_MISMATCH);
+    }
+    // Every stored row must re-derive its own digest and correspond to a v1 row.
+    for (const r of stored) {
+        const fresh = derivePressureDigest(r.sessionId, r.level, r.effectiveSeq, r.ts);
+        if (r.digest !== fresh)
+            codes.push(M7_FAIL.DIGEST_MISMATCH);
+        if (!expected.has(identity(r.sessionId, r.effectiveSeq))) {
+            codes.push(M7_FAIL.COUNT_MISMATCH);
+        }
+    }
+    return { ok: codes.length === 0, codes: dedupe(codes) };
+}
+/**
+ * SWITCH: atomically flip the active pointer to v2 — but ONLY after
+ * re-validating against freshly-read host state (see the module note on the
+ * post-copy failure injection). The pointer is left untouched on any failure.
+ */
+export function m7Switch(host) {
+    if (host.activeVersion() !== PRESSURE_LEGACY_VERSION) {
+        return { ok: false, codes: [M7_FAIL.NOT_ON_LEGACY] };
+    }
+    // Re-read the live rows: an unknown label injected after the copy is caught
+    // here, and the old pointer survives.
+    if (!allLabelsCanonical(host)) {
+        return { ok: false, codes: [M7_FAIL.PRESSURE_UNKNOWN] };
+    }
+    const verify = m7Verify(host);
+    if (!verify.ok)
+        return verify;
+    host.switchToV2();
+    return { ok: true, codes: [] };
+}
+/**
+ * Full M7 migration: copy, then validate + switch. An uncanonical label thrown
+ * during the copy is converted to a result code so the caller sees the same
+ * shape as a validation failure, and the pointer is left on legacy.
+ */
+export function migratePressureV2(host) {
+    try {
+        m7Copy(host);
+    }
+    catch (err) {
+        const code = typeof err === "object" && err !== null && "code" in err
+            ? err.code
+            : undefined;
+        if (code === M7_FAIL.PRESSURE_UNKNOWN) {
+            return { ok: false, codes: [M7_FAIL.PRESSURE_UNKNOWN] };
+        }
+        throw err;
+    }
+    return m7Switch(host);
+}

package/dist/src/vector-cortex/migrations/pressure-v2-types.js

@@ -0,0 +1,32 @@
+/**
+ * pressure-v2-types.ts — M7 pressure-v2 migration types.
+ *
+ * Extracted from pressure-v2.ts to keep the parent file under the 300-line
+ * soft limit (soft-as-hard gate). Pure type + constant definitions; no logic.
+ * PREVENT-002/011/PI-004 honored.
+ */
+/** The active-version value the v2 pointer is switched to. */
+export const PRESSURE_V2_VERSION = 2;
+/** The legacy (predecessor) active version. */
+export const PRESSURE_LEGACY_VERSION = 1;
+/** M7 failure codes. */
+export const M7_FAIL = {
+    /** A legacy row carries a label outside the canonical five levels. */
+    PRESSURE_UNKNOWN: "M7_PRESSURE_UNKNOWN",
+    /** Copied row count does not match the legacy row count. */
+    COUNT_MISMATCH: "M7_COUNT_MISMATCH",
+    /** A v2 row digest does not re-derive from its own declared fields. */
+    DIGEST_MISMATCH: "M7_DIGEST_MISMATCH",
+    /** A legacy row has no corresponding v2 row (interrupted copy). */
+    COPY_PARTIAL: "M7_COPY_PARTIAL",
+    /** The active pointer is not on v1; switching would regress or no-op. */
+    NOT_ON_LEGACY: "M7_NOT_ON_LEGACY",
+};
+/**
+ * Registered M7 conformance IDs (M7-001..015). The acceptance test reads these
+ * rows from the v2 `adaptive-policy/` domain and asserts each returns its
+ * manifest bytes or exactly its listed failure code. Mirrors M5_IDS / M6_IDS.
+ */
+export const M7_IDS = Array.from({ length: 15 }, (_v, i) => `M7-${String(i + 1).padStart(3, "0")}`);
+/** Named M7 rows surfaced by the conformance corpus. */
+export const M7_NAMED_IDS = ["M7-PRESSURE-003"];

package/dist/src/vector-cortex/migrations/pressure-v2.js

@@ -0,0 +1,36 @@
+/**
+ * vector-cortex/migrations/pressure-v2.ts — M7 pressure-v2 migration
+ * (COPY + VALIDATE + SWITCH).
+ *
+ * Delegate-shell: types + constants live in pressure-v2-types.ts and the
+ * operational logic (copy/verify/switch/label mapping) lives in
+ * pressure-v2-ops.ts. This file re-exports the public surface so callers import
+ * from a single module. Split to keep under the 300-line soft limit
+ * (soft-as-hard gate).
+ *
+ * M7 canonicalizes the context-pressure label. The predecessor stored whatever
+ * label a producer happened to write; v2 admits EXACTLY five — `low`, `medium`,
+ * `high`, `ultra`, `mega` — and rejects everything else as
+ * `M7_PRESSURE_UNKNOWN`. The rejection is the feature: coercing an unrecognized
+ * legacy label onto the nearest level would silently reclassify a workload, and
+ * the direction of that error is unknowable from the label alone.
+ *
+ * Like M4/M5/M6 it follows the copy/validate/switch contract:
+ *
+ *   - copy:     resumable per (session, effectiveSeq) — an interrupted run
+ *               resumes without duplicate rows or active-pointer drift.
+ *   - validate: every v1 row has exactly one v2 row, every v2 digest re-derives
+ *               from its own declared fields, and every legacy label is
+ *               canonical.
+ *   - switch:   ATOMICALLY flip the active pointer via `host.switchToV2()`, but
+ *               only after RE-READING host state and re-validating. The sprint's
+ *               failure injection kills the process after the copy and then
+ *               inserts an unknown legacy pressure; the resumed run must return
+ *               `M7_PRESSURE_UNKNOWN` and KEEP THE OLD POINTER. A migration that
+ *               trusts a stale verification is a migration that corrupts on
+ *               restart.
+ *
+ * PREVENT-002/011/PI-004 honored.
+ */
+export { PRESSURE_V2_VERSION, PRESSURE_LEGACY_VERSION, M7_FAIL, M7_IDS, M7_NAMED_IDS, } from "./pressure-v2-types.js";
+export { derivePressureDigest, mapPressureRow, allLabelsCanonical, m7Copy, m7Verify, m7Switch, migratePressureV2, } from "./pressure-v2-ops.js";

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

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

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

@@ -0,0 +1,158 @@
+/**
+ * controller/policy.ts — VC8B bounded policy engine (PURE).
+ *
+ * Three guarantees, all structural rather than conventional:
+ *
+ *   1. FINITE ACTIONS. `evaluatePolicy` can only ever return a member of
+ *      POLICY_ACTIONS. The action is chosen by a total function over the
+ *      canonical pressure levels, so there is no path that invents one.
+ *   2. BOUNDED BUDGETS. Every returned budget is clamped into
+ *      `[minBudget, maxBudget]`. Clamping is applied AFTER the pressure-driven
+ *      adjustment, never before — otherwise a dampen/escalate step could carry
+ *      an in-bounds budget back out of bounds.
+ *   3. UNKNOWN PRESSURE REJECTS. A label outside the canonical five is
+ *      rejected as POL_PRESSURE_UNKNOWN. It is never coerced to a neighbour:
+ *      quietly mapping an unrecognized label onto "low" would silently
+ *      downgrade a workload that the caller believed was protected.
+ *
+ * Everything here is PURE: no clock, no storage, no network, no flag read. The
+ * flag gates only the reporter seam in policy-emit.ts, which is why flag-off is
+ * byte-identical to the predecessor.
+ *
+ * PREVENT-002/011/PI-004 honored.
+ */
+import { POLICY_ACTIONS, POLICY_DECISION_SCHEMA_V1, POL_ACTION_FORBIDDEN, POL_BUDGET_OUT_OF_BOUNDS, POL_PRESSURE_UNKNOWN, PRESSURE_LEVELS, } from "./types.js";
+/** Construct a policy failure. */
+function fail(code) {
+    return { code };
+}
+/** Type guard: is this a canonical pressure level? */
+export function isPressureLevel(label) {
+    return PRESSURE_LEVELS.includes(label);
+}
+/** Type guard: is this an allowed policy action? */
+export function isPolicyAction(action) {
+    return POLICY_ACTIONS.includes(action);
+}
+/**
+ * Validate a pressure label against the canonical five. Throws
+ * `{ code: POL_PRESSURE_UNKNOWN }` rather than coercing — see the module note.
+ */
+export function validatePressureLabel(label) {
+    if (!isPressureLevel(label))
+        throw fail(POL_PRESSURE_UNKNOWN);
+    return label;
+}
+/**
+ * Validate an action against the allowed finite set. Throws
+ * `{ code: POL_ACTION_FORBIDDEN }` for anything else.
+ */
+export function validateAction(action) {
+    if (!isPolicyAction(action))
+        throw fail(POL_ACTION_FORBIDDEN);
+    return action;
+}
+/**
+ * Validate the bound pair itself. A window with min > max, or a non-finite
+ * bound, has no correct clamp result, so it is rejected rather than guessed at.
+ */
+export function validateBounds(bounds) {
+    const { minBudget, maxBudget } = bounds;
+    if (!Number.isFinite(minBudget) || !Number.isFinite(maxBudget)) {
+        throw fail(POL_BUDGET_OUT_OF_BOUNDS);
+    }
+    if (minBudget > maxBudget)
+        throw fail(POL_BUDGET_OUT_OF_BOUNDS);
+    if (minBudget < 0)
+        throw fail(POL_BUDGET_OUT_OF_BOUNDS);
+    return bounds;
+}
+/**
+ * Clamp a budget into `[minBudget, maxBudget]`.
+ *
+ * A NaN budget clamps to `minBudget`: NaN comparisons are all false, so a naive
+ * Math.min/Math.max chain would propagate NaN straight through the "bounded"
+ * guarantee. The safest interpretation of an unusable request is the floor.
+ */
+export function clampBudget(budget, minBudget, maxBudget) {
+    validateBounds({ minBudget, maxBudget });
+    if (!Number.isFinite(budget))
+        return minBudget;
+    if (budget < minBudget)
+        return minBudget;
+    if (budget > maxBudget)
+        return maxBudget;
+    return budget;
+}
+/** The multiplier applied to the requested budget at each pressure level. */
+const PRESSURE_FACTOR = {
+    low: 1,
+    medium: 1,
+    high: 0.75,
+    ultra: 0.5,
+    mega: 0.25,
+};
+/**
+ * The action selected at each pressure level. Total over PressureLevel, so the
+ * action space cannot grow: `mega` refuses outright, `ultra` defers, `high`
+ * dampens, and the quiet levels admit.
+ */
+const PRESSURE_ACTION = {
+    low: "admit",
+    medium: "admit",
+    high: "dampen",
+    ultra: "defer",
+    mega: "reject",
+};
+/** Select the reason code that explains the decision. */
+function reasonFor(pressure, requested, clamped, bounds) {
+    if (clamped === bounds.maxBudget && requested > bounds.maxBudget) {
+        return "budget_clamped_high";
+    }
+    if (clamped === bounds.minBudget && requested < bounds.minBudget) {
+        return "budget_clamped_low";
+    }
+    if (pressure === "mega" || pressure === "ultra")
+        return "pressure_critical";
+    if (pressure === "high")
+        return "pressure_elevated";
+    return "within_bounds";
+}
+/**
+ * Evaluate one policy input into a bounded decision.
+ *
+ * Order matters: validate the label, validate the window, apply the
+ * pressure factor, THEN clamp. Clamping last is what makes the bounded-budget
+ * guarantee hold for every action including escalate.
+ *
+ * Throws `{ code }` on an unknown pressure label or an invalid bound pair.
+ */
+export function evaluatePolicy(input) {
+    const pressure = validatePressureLabel(input.pressure);
+    const bounds = validateBounds(input.bounds);
+    const requested = Number.isFinite(input.requestedBudget)
+        ? input.requestedBudget
+        : bounds.minBudget;
+    const adjusted = requested * PRESSURE_FACTOR[pressure];
+    const budget = clampBudget(adjusted, bounds.minBudget, bounds.maxBudget);
+    return {
+        schema: POLICY_DECISION_SCHEMA_V1,
+        decisionId: input.decisionId,
+        sessionId: input.sessionId,
+        action: PRESSURE_ACTION[pressure],
+        budget,
+        pressure,
+        reason: reasonFor(pressure, input.requestedBudget, budget, bounds),
+        ts: input.ts,
+    };
+}
+/**
+ * Assert a decision satisfies the sprint invariant: allowed action AND bounded
+ * budget. Used by the acceptance aggregator to check every produced row.
+ */
+export function isDecisionWithinBounds(decision, bounds) {
+    return (isPolicyAction(decision.action) &&
+        Number.isFinite(decision.budget) &&
+        decision.budget >= bounds.minBudget &&
+        decision.budget <= bounds.maxBudget);
+}