pi-mega-compact 0.20.18 → 0.20.19

package/extensions/dashboard-client/src/tabs/VectorCortexPolicyCard.tsx

@@ -0,0 +1,43 @@
+import type React from "react";
+import type { VectorCortexPolicyView } from "../api/vector-cortex";
+import { Card, CardContent, CardHeader, CardTitle } from "../components/ui/card";
+import { Badge } from "../components/ui/badge";
+import { Metric } from "./VectorCortexMetric";
+
+export function VectorCortexPolicyCard({ view }: { view: VectorCortexPolicyView | null }): React.ReactElement {
+	return (
+		<Card>
+			<CardHeader>
+				<div className="flex items-center justify-between">
+					<CardTitle>Shadow Adaptive Policy (VC8B)</CardTitle>
+					{view?.enabled ? (
+						<Badge variant="success">ACTIVE</Badge>
+					) : (
+						<Badge variant="danger">OFF</Badge>
+					)}
+				</div>
+			</CardHeader>
+			<CardContent>
+				{!view?.enabled ? (
+					<div className="vc-empty">Shadow adaptive policy disabled (VC8B off) — no shadow decisions are reported, so the live path uses the predecessor thresholds (mode C). The policy, shadow, and M7 migration arithmetic still run; only this reporting seam is suppressed.</div>
+				) : (
+					<>
+						<div className="grid grid-cols-2 gap-4 md:grid-cols-4">
+							<Metric label="Mode" value={view.mode} />
+							<Metric label="Shadow decisions" value={String(view.shadowDecisions)} />
+							<Metric label="Clamped" value={String(view.clampedDecisions)} />
+							<Metric label="Rejected inputs" value={String(view.rejectedInputs)} />
+							<Metric label="Live mutations" value={String(view.liveMutations)} />
+							<Metric label="Pressure version" value={String(view.pressureVersion)} />
+							<Metric label="Last failure" value={view.lastFailure ?? "none"} />
+							<Metric label="Updated" value={view.updatedAt} />
+						</div>
+						<div className="mt-3 text-xs text-muted-foreground">
+							Reader-only shadow adaptive policy — aggregate counts and POL_/M7_ codes only. Policy actions are from a finite set chosen deterministically by the canonical pressure level; budgets are clamped into a configured window after the pressure factor. Unknown pressure labels are rejected as POL_PRESSURE_UNKNOWN, never coerced. The shadow engine is structurally incapable of affecting the live path — inputs are deep-copied and the prompt digest is pinned before and after — so liveMutations is always zero. M7 migrates legacy pressure labels to the v2 canonical five by copy/validate/switch; an unknown label blocks the switch (M7_PRESSURE_UNKNOWN). No prompt bytes, session content, or free-text ever reaches the client.
+						</div>
+					</>
+				)}
+			</CardContent>
+		</Card>
+	);
+}

package/extensions/dashboard-client/src/tabs/VectorCortexTab.tsx

@@ -26,6 +26,7 @@ import { VectorCortexCrystalsCard } from "./VectorCortexCrystalsCard";
 import { VectorCortexEconomicsCard } from "./VectorCortexEconomicsCard";
 import { VectorCortexDiagnosticsCard } from "./VectorCortexDiagnosticsCard";
 import { VectorCortexOutcomesCard } from "./VectorCortexOutcomesCard";
+import { VectorCortexPolicyCard } from "./VectorCortexPolicyCard";
 import {
 	VectorCortexShardsCard,
 	VectorCortexReconstructCard,
@@ -204,6 +205,7 @@ export default function VectorCortexTab(): React.ReactElement {
 			<VectorCortexEconomicsCard view={poll.economics} />
 			<VectorCortexDiagnosticsCard view={poll.diagnostics} />
 			<VectorCortexOutcomesCard view={poll.outcomes} />
+			<VectorCortexPolicyCard view={poll.policy} />
 			<VectorCortexLedgerCard ledger={poll.ledger} />
 		</div>
 	);

package/extensions/dashboard-client/src/tabs/useVectorCortexPoll.ts

@@ -20,6 +20,7 @@ import {
 	fetchVectorCortexEconomics,
 	fetchVectorCortexDiagnostics,
 	fetchVectorCortexOutcomes,
+	fetchVectorCortexPolicy,
 	fetchVectorCortexShards,
 	fetchVectorCortexTopology,
 	type VectorCortexEvaluationSummary,
@@ -37,6 +38,7 @@ import {
 	type VectorCortexEconomicsView,
 	type VectorCortexDiagnosticsView,
 	type VectorCortexOutcomesView,
+	type VectorCortexPolicyView,
 	type VectorCortexShardsView,
 	type VectorCortexTopologyView,
 } from "../api/vector-cortex";
@@ -61,6 +63,7 @@ export interface VectorCortexPollState {
 	economics: VectorCortexEconomicsView | null;
 	diagnostics: VectorCortexDiagnosticsView | null;
 	outcomes: VectorCortexOutcomesView | null;
+	policy: VectorCortexPolicyView | null;
 }
 
 export function useVectorCortexPoll(): [
@@ -87,6 +90,7 @@ export function useVectorCortexPoll(): [
 		economics: null,
 		diagnostics: null,
 		outcomes: null,
+		policy: null,
 	});
 
 	const poll = useCallback(() => {
@@ -116,6 +120,7 @@ export function useVectorCortexPoll(): [
 		fetchVectorCortexEconomics().then((economics) => setState((p) => ({ ...p, economics }))).catch(() => {});
 		fetchVectorCortexDiagnostics().then((diagnostics) => setState((p) => ({ ...p, diagnostics }))).catch(() => {});
 		fetchVectorCortexOutcomes().then((outcomes) => setState((p) => ({ ...p, outcomes }))).catch(() => {});
+		fetchVectorCortexPolicy().then((policy) => setState((p) => ({ ...p, policy }))).catch(() => {});
 	}, []);
 
 	useEffect(() => {

package/extensions/dashboard-client/src/types/vector-cortex-vc8.ts

@@ -23,3 +23,20 @@ export interface VectorCortexOutcomesView {
   lastFailure: string | null;
   updatedAt: string;
 }
+
+/**
+ * Reader-only shadow adaptive policy aggregate view (VC8B). Counts + POL_ and M7_
+ * codes only — the policy engine carries no payload, so no prompt bytes,
+ * session content, or free-text ever reaches the client.
+ */
+export interface VectorCortexPolicyView {
+  enabled: boolean;
+  mode: "A" | "B" | "C";
+  shadowDecisions: number;
+  clampedDecisions: number;
+  rejectedInputs: number;
+  liveMutations: number;
+  pressureVersion: number;
+  lastFailure: string | null;
+  updatedAt: string;
+}

package/extensions/dashboard-client/src/types/vector-cortex.ts

@@ -262,4 +262,4 @@ export type {
   VectorCortexDiagnosticsView,
 } from "./vector-cortex-vc7.js";
 
-export type { VectorCortexOutcomesView } from "./vector-cortex-vc8.js";
+export type { VectorCortexOutcomesView, VectorCortexPolicyView } from "./vector-cortex-vc8.js";

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

@@ -0,0 +1,36 @@
+/**
+ * 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.
+ */
+
+/** Runtime triad mode implied by the VC8B flag state. */
+export type VectorCortexPolicyMode = "A" | "B" | "C";
+
+/** Reader-only policy + shadow aggregate view for GET /api/vector-cortex/policy. */
+export interface VectorCortexPolicyView {
+  /** Whether the VC8B policy flag is enabled. */
+  readonly enabled: boolean;
+  /** Runtime triad mode: A=shadow candidate, B=static calibrated, C=fixed legacy. */
+  readonly mode: VectorCortexPolicyMode;
+  /** Total shadow decisions evaluated (count only). */
+  readonly shadowDecisions: number;
+  /** Decisions whose budget was clamped at a bound (count only). */
+  readonly clampedDecisions: number;
+  /** Shadow rejections (unknown pressure / bad bounds) (count only). */
+  readonly rejectedInputs: number;
+  /** Live mutations detected (structurally always 0). */
+  readonly liveMutations: number;
+  /** M7 migration state: active pressure version (1 or 2). */
+  readonly pressureVersion: number;
+  /** Last POL_ or M7_ failure code, or null if none. */
+  readonly lastFailure: string | null;
+  /** ISO timestamp of the snapshot. */
+  readonly updatedAt: string;
+}

package/extensions/dashboard-server/route-dispatch.ts

@@ -77,6 +77,11 @@ import { handleVectorCortexDiagnostics } from "./routes-vector-cortex-diagnostic
 // 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).
@@ -134,5 +139,6 @@ export function dispatchRoutes(
 	if (handleVectorCortexEconomics(req, res, ctx)) return true;
 	if (handleVectorCortexDiagnostics(req, res, ctx)) return true;
 	if (handleVectorCortexOutcomes(req, res, ctx)) return true;
+	if (handleVectorCortexPolicy(req, res, ctx)) return true;
 	return false;
 }

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

@@ -180,5 +180,11 @@ export const VECTOR_CORTEX_SETTINGS: SettingGroup = {
 			"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/extensions/dashboard-server/routes-vector-cortex-policy.ts

@@ -0,0 +1,55 @@
+/**
+ * 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 type { IncomingMessage, ServerResponse } from "node:http";
+import type { RouteContext } from "./routes-core.js";
+import { VC8B_ENABLED } from "../../src/config.js";
+import { sendJson } from "./routes-vector-cortex-shared.js";
+import type { VectorCortexPolicyView } from "./api-contracts/vector-cortex-policy.js";
+
+/** GET /api/vector-cortex/policy — reader-only policy + shadow aggregate (VC8B). */
+export function handleVectorCortexPolicy(
+  req: IncomingMessage,
+  res: ServerResponse,
+  _ctx: RouteContext,
+): boolean {
+  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: VectorCortexPolicyView["mode"] = enabled ? "A" : "C";
+  const body: VectorCortexPolicyView = {
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.20.18",
+  "version": "0.20.19",
   "description": "Layered, local, vector-backed context compressor for pi — supersede/collapse/cluster compaction with deduped inline recall.",
   "type": "module",
   "license": "BSD-3-Clause",

package/src/config/vector-cortex.ts

@@ -254,6 +254,21 @@ export const VC7C_ENABLED = (): boolean => sprintFlag("MEGACOMPACT_VC7C");
  */
 export const VC8A_ENABLED = (): boolean => 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 = (): boolean => 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 {

package/src/config.ts

@@ -176,6 +176,7 @@ export {
   VC7B_ENABLED,
   VC7C_ENABLED,
   VC8A_ENABLED,
+  VC8B_ENABLED,
   BREAKER_WINDOW_MS,
   BREAKER_MIN_ATTEMPTS,
   BREAKER_PERF_FAILURES,

package/src/vector-cortex/controller/policy-emit.ts

@@ -0,0 +1,82 @@
+/**
+ * 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";
+import type { PolicyAction, PolicyReason, PressureLevel } from "./types.js";
+
+/** The two structured events the VC8B reporter emits. */
+export type PolicyEventName =
+  | "vector_cortex_shadow_decision_recorded"
+  | "vector_cortex_policy_action_rejected";
+
+/** Optional emit fn injected by the runtime; tests pass `undefined`. */
+export type PolicyEmit = (name: string, payload: unknown) => void;
+
+/** Run `fn` only when an emit exists; a reporting failure is never fatal. */
+function safe(emit: PolicyEmit | undefined, fn: (emit: PolicyEmit) => void): void {
+  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: PolicyEmit | undefined,
+  decision: {
+    readonly decisionId: string;
+    readonly sessionId: string;
+    readonly action: PolicyAction;
+    readonly budget: number;
+    readonly pressure: PressureLevel;
+    readonly reason: PolicyReason;
+  },
+): void {
+  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: PolicyEmit | undefined,
+  rejection: { readonly decisionId: string; readonly code: string },
+): void {
+  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/src/vector-cortex/migrations/pressure-v2-ops.ts

@@ -0,0 +1,204 @@
+/**
+ * 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 type {
+  M7Host,
+  M7MigrationCode,
+  M7ValidateResult,
+  PressureV1Row,
+  PressureV2Row,
+} from "./pressure-v2-types.js";
+import { M7_FAIL, PRESSURE_LEGACY_VERSION } from "./pressure-v2-types.js";
+
+/** Length-prefixed framing so the folded fields cannot alias. */
+function field(value: string): string {
+  return `${Buffer.byteLength(value, "utf8")}:${value}`;
+}
+
+/** Row identity is (session, effectiveSeq) — one pressure per sequence point. */
+const identity = (sessionId: string, effectiveSeq: number): string =>
+  `${sessionId}::${effectiveSeq}`;
+
+/** The authoritative v2 digest: SHA-256 over the length-prefixed fields. */
+export function derivePressureDigest(
+  sessionId: string,
+  level: string,
+  effectiveSeq: number,
+  ts: string,
+): string {
+  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: PressureV1Row): PressureV2Row {
+  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: M7Host): boolean {
+  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: M7Host): {
+  readonly written: readonly PressureV2Row[];
+  readonly all: readonly PressureV2Row[];
+} {
+  const existing = new Map(
+    host.existingV2().map((r) => [identity(r.sessionId, r.effectiveSeq), r]),
+  );
+  const wanted: PressureV2Row[] = [];
+  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: readonly M7MigrationCode[]): M7MigrationCode[] {
+  const out: M7MigrationCode[] = [];
+  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: M7Host): M7ValidateResult {
+  const codes: M7MigrationCode[] = [];
+  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<string, number>();
+  for (const r of stored) {
+    const id = identity(r.sessionId, r.effectiveSeq);
+    counts.set(id, (counts.get(id) ?? 0) + 1);
+  }
+
+  const expected = new Set<string>();
+  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: M7Host): M7ValidateResult {
+  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: M7Host): M7ValidateResult {
+  try {
+    m7Copy(host);
+  } catch (err) {
+    const code =
+      typeof err === "object" && err !== null && "code" in err
+        ? (err as { code: unknown }).code
+        : undefined;
+    if (code === M7_FAIL.PRESSURE_UNKNOWN) {
+      return { ok: false, codes: [M7_FAIL.PRESSURE_UNKNOWN] };
+    }
+    throw err;
+  }
+  return m7Switch(host);
+}

package/src/vector-cortex/migrations/pressure-v2-types.ts

@@ -0,0 +1,83 @@
+/**
+ * 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",
+} as const;
+export type M7MigrationCode = (typeof M7_FAIL)[keyof typeof M7_FAIL];
+
+/**
+ * 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: readonly string[] = 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"] as const;
+
+/**
+ * A predecessor (v1) pressure row. `label` is UNTRUSTED: the whole point of
+ * the migration is that a legacy store may hold labels outside the canonical
+ * five, and those must reject rather than be coerced.
+ */
+export interface PressureV1Row {
+  readonly sessionId: string;
+  readonly label: string;
+  readonly effectiveSeq: number;
+  readonly ts: string;
+}
+
+/** A v2 pressure row: canonical level + a digest over its own fields. */
+export interface PressureV2Row {
+  readonly sessionId: string;
+  /** One of the canonical five levels — validated, never coerced. */
+  readonly level: string;
+  readonly effectiveSeq: number;
+  readonly ts: string;
+  /** SHA-256 over the length-prefixed canonical fields. */
+  readonly digest: string;
+}
+
+/** The host the migration reads from / writes to (capability-shaped). */
+export interface M7Host {
+  /** Every predecessor row being migrated. */
+  readonly v1Rows: () => readonly PressureV1Row[];
+  /** Persisted v2 rows already written (for resume). */
+  readonly existingV2: () => readonly PressureV2Row[];
+  /** Idempotent write of v2 rows (never mutates v1 rows). */
+  readonly putV2: (rows: readonly PressureV2Row[]) => void;
+  /** The currently ACTIVE version (1 = legacy; only v1 -> v2 switching). */
+  readonly activeVersion: () => number;
+  /** Atomically flip the active pointer to v2. */
+  readonly switchToV2: () => void;
+}
+
+/** An M7 validation result. */
+export interface M7ValidateResult {
+  readonly ok: boolean;
+  readonly codes: readonly M7MigrationCode[];
+}