invarlock 0.3.5__py3-none-any.whl → 0.3.7__py3-none-any.whl

invarlock/reporting/guards_analysis.py

@@ -1,18 +1,32 @@
 # mypy: ignore-errors
 from __future__ import annotations
 
+import hashlib
+import json
 import math
 from typing import Any, no_type_check
 
 from invarlock.core.auto_tuning import get_tier_policies
 
-from .policy_utils import _promote_legacy_multiple_testing_key, _resolve_policy_tier
+from .policy_utils import _resolve_policy_tier
 from .report_types import RunReport
 
 
+def _measurement_contract_digest(contract: Any) -> str | None:
+    if not isinstance(contract, dict) or not contract:
+        return None
+    try:
+        canonical = json.dumps(contract, sort_keys=True, default=str)
+    except Exception:
+        return None
+    return hashlib.sha256(canonical.encode()).hexdigest()[:16]
+
+
 @no_type_check
-def _extract_invariants(report: RunReport) -> dict[str, Any]:
-    """Extract invariant check results (matches legacy shape used in tests)."""
+def _extract_invariants(
+    report: RunReport, baseline: RunReport | None = None
+) -> dict[str, Any]:
+    """Extract invariant check results (matches the shape used in tests)."""
     invariants_data = (report.get("metrics", {}) or {}).get("invariants", {})
     failures: list[dict[str, Any]] = []
     summary: dict[str, Any] = {}
@@ -69,6 +83,108 @@ def _extract_invariants(report: RunReport) -> dict[str, Any]:
             guard_entry = guard
             break
 
+    baseline_guard_entry = None
+    if baseline is not None:
+        for guard in baseline.get("guards", []) or []:
+            if str(guard.get("name", "")).lower() == "invariants":
+                baseline_guard_entry = guard
+                break
+
+    def _coerce_checks(value: Any) -> dict[str, Any] | None:
+        return value if isinstance(value, dict) else None
+
+    def _extract_guard_checks(
+        entry: Any,
+    ) -> tuple[dict[str, Any] | None, dict[str, Any] | None]:
+        if not isinstance(entry, dict):
+            return None, None
+        details = entry.get("details")
+        if not isinstance(details, dict):
+            return None, None
+        return _coerce_checks(details.get("baseline_checks")), _coerce_checks(
+            details.get("current_checks")
+        )
+
+    def _compare_invariants(
+        baseline_checks: dict[str, Any],
+        current_checks: dict[str, Any],
+    ) -> tuple[list[dict[str, Any]], int, int]:
+        violations: list[dict[str, Any]] = []
+
+        # LayerNorm coverage check
+        baseline_layer_norms = set(baseline_checks.get("layer_norm_paths", ()))
+        current_layer_norms = set(current_checks.get("layer_norm_paths", ()))
+        missing_layer_norms = sorted(baseline_layer_norms - current_layer_norms)
+        if missing_layer_norms:
+            violations.append(
+                {
+                    "type": "layer_norm_missing",
+                    "missing": missing_layer_norms,
+                    "message": "Expected LayerNorm modules are missing vs baseline",
+                }
+            )
+
+        # Tokenizer / vocab alignment
+        baseline_vocab_sizes = baseline_checks.get("embedding_vocab_sizes")
+        current_vocab_sizes = current_checks.get("embedding_vocab_sizes")
+        if isinstance(baseline_vocab_sizes, dict):
+            for module_name, baseline_size in baseline_vocab_sizes.items():
+                current_size = None
+                if isinstance(current_vocab_sizes, dict):
+                    current_size = current_vocab_sizes.get(module_name)
+                if current_size is None or int(current_size) != int(baseline_size):
+                    mismatch = {
+                        "module": module_name,
+                        "baseline": int(baseline_size),
+                        "current": None if current_size is None else int(current_size),
+                    }
+                    violations.append(
+                        {
+                            "type": "tokenizer_mismatch",
+                            "message": "Embedding vocabulary size changed vs baseline",
+                            **mismatch,
+                        }
+                    )
+
+        handled_keys = {
+            "layer_norm_paths",
+            "embedding_vocab_sizes",
+            "config_vocab_size",
+        }
+        for check_name, baseline_value in baseline_checks.items():
+            if check_name in handled_keys:
+                continue
+            current_value = current_checks.get(check_name)
+            if current_value != baseline_value:
+                violations.append(
+                    {
+                        "type": "invariant_violation",
+                        "check": check_name,
+                        "baseline": baseline_value,
+                        "current": current_value,
+                        "message": (
+                            f"Invariant {check_name} changed from {baseline_value} to {current_value}"
+                        ),
+                    }
+                )
+
+        fatal_violation_types = {"tokenizer_mismatch"}
+        fatal_count = 0
+        warning_count = 0
+        annotated: list[dict[str, Any]] = []
+        for violation in violations:
+            violation_type = str(violation.get("type") or "")
+            severity = "fatal" if violation_type in fatal_violation_types else "warning"
+            annotated_violation = dict(violation)
+            annotated_violation.setdefault("severity", severity)
+            annotated.append(annotated_violation)
+            if severity == "fatal":
+                fatal_count += 1
+            else:
+                warning_count += 1
+
+        return annotated, fatal_count, warning_count
+
     severity_status = "pass"
     if guard_entry:
         gm = guard_entry.get("metrics", {}) or {}
@@ -96,9 +212,51 @@ def _extract_invariants(report: RunReport) -> dict[str, Any]:
                 if detail:
                     row["detail"] = detail
                 failures.append(row)
-        if fatal_count > 0:
+        base_fatal = 0
+        base_warn = 0
+        baseline_failures: list[dict[str, Any]] = []
+        if baseline_guard_entry is not None:
+            baseline_pre, baseline_post = _extract_guard_checks(baseline_guard_entry)
+            current_pre, current_post = _extract_guard_checks(guard_entry)
+            baseline_snapshot = baseline_pre or baseline_post
+            current_snapshot = current_post or current_pre
+            if isinstance(baseline_snapshot, dict) and isinstance(
+                current_snapshot, dict
+            ):
+                baseline_failures, base_fatal, base_warn = _compare_invariants(
+                    baseline_snapshot, current_snapshot
+                )
+                for violation in baseline_failures:
+                    check_name = violation.get("check")
+                    if not check_name:
+                        check_name = (
+                            violation.get("module")
+                            or violation.get("type")
+                            or "invariant"
+                        )
+                    row = {
+                        "check": str(check_name),
+                        "type": str(violation.get("type") or "violation"),
+                        "severity": str(violation.get("severity") or "warning"),
+                    }
+                    detail = {k: v for k, v in violation.items() if k not in row}
+                    if detail:
+                        detail.setdefault("source", "baseline_compare")
+                        row["detail"] = detail
+                    failures.append(row)
+
+        fatal_total = fatal_count + base_fatal
+        warn_total = warning_count + base_warn
+        try:
+            summary["fatal_violations"] = fatal_total
+            summary["warning_violations"] = warn_total
+            summary["violations_found"] = fatal_total + warn_total
+        except Exception:
+            pass
+
+        if fatal_total > 0:
             severity_status = "fail"
-        elif warning_count > 0 or violations:
+        elif warn_total > 0 or violations:
             severity_status = "warn"
 
     # If any error-severity entry exists among failures, escalate to fail
@@ -118,12 +276,16 @@ def _extract_invariants(report: RunReport) -> dict[str, Any]:
             "warning_violations": len(failures),
         }
 
+    details_out = invariants_data
+    if not details_out and guard_entry and isinstance(guard_entry.get("details"), dict):
+        details_out = guard_entry.get("details", {})
+
     return {
         "pre": "pass",
         "post": status,
         "status": status,
         "summary": summary,
-        "details": invariants_data,
+        "details": details_out,
         "failures": failures,
     }
 
@@ -299,10 +461,10 @@ def _extract_spectral_analysis(
     families: dict[str, dict[str, Any]] = {}
     family_caps: dict[str, dict[str, float]] = {}
     top_z_scores: dict[str, list[dict[str, Any]]] = {}
+    deadband_used: float | None = None
 
     if isinstance(guard_metrics, dict):
         # Resolve deadband from policy/metrics/defaults
-        deadband_used: float | None = None
         try:
             db_raw = guard_policy.get("deadband") if guard_policy else None
             if db_raw is None and isinstance(guard_metrics, dict):
@@ -314,16 +476,12 @@ def _extract_spectral_analysis(
         except Exception:
             deadband_used = None
 
-        # Resolve sigma_quantile for summary (policy aliases supported)
+        # Resolve sigma_quantile for summary
         sigma_q_used: float | None = None
         try:
             pol_sq = None
             if isinstance(guard_policy, dict):
-                pol_sq = (
-                    guard_policy.get("sigma_quantile")
-                    or guard_policy.get("contraction")
-                    or guard_policy.get("kappa")
-                )
+                pol_sq = guard_policy.get("sigma_quantile")
             if pol_sq is None:
                 pol_sq = default_sigma_quantile
             if pol_sq is not None:
@@ -371,7 +529,7 @@ def _extract_spectral_analysis(
             else {}
         )
         if not families:
-            # Prefer z-summary when available; accept legacy 'family_stats' too
+            # Prefer z-summary when available; accept 'family_stats' too
             fzs = guard_metrics.get("family_z_summary")
             if not isinstance(fzs, dict) or not fzs:
                 fzs = guard_metrics.get("family_stats")
@@ -493,7 +651,7 @@ def _extract_spectral_analysis(
         for source in sources:
             if not isinstance(source, dict):
                 continue
-            candidate = source.get("multiple_testing") or source.get("multipletesting")
+            candidate = source.get("multiple_testing")
             if isinstance(candidate, dict) and candidate:
                 return candidate
         return None
@@ -505,20 +663,13 @@ def _extract_spectral_analysis(
     policy_out: dict[str, Any] | None = None
     if isinstance(guard_policy, dict) and guard_policy:
         policy_out = dict(guard_policy)
-        _promote_legacy_multiple_testing_key(policy_out)
         if default_sigma_quantile is not None:
-            sq = (
-                policy_out.get("sigma_quantile")
-                or policy_out.get("contraction")
-                or policy_out.get("kappa")
-            )
+            sq = policy_out.get("sigma_quantile")
             if sq is not None:
                 try:
                     policy_out["sigma_quantile"] = float(sq)
                 except Exception:
                     pass
-        policy_out.pop("contraction", None)
-        policy_out.pop("kappa", None)
         if tier == "balanced":
             policy_out["correction_enabled"] = False
             policy_out["max_spectral_norm"] = None
@@ -532,7 +683,7 @@ def _extract_spectral_analysis(
         "families": families,
         "family_caps": family_caps,
     }
-    # Attach status to summary for backward-compatibility in tests
+    # Surface a stable/capped status on the summary for schema parity.
     try:
         summary["status"] = "stable" if int(caps_applied) == 0 else "capped"
     except Exception:
@@ -594,6 +745,40 @@ def _extract_spectral_analysis(
             result["top_violations"] = top_violations
     if family_quantiles:
         result["family_z_quantiles"] = family_quantiles
+    result["evaluated"] = bool(spectral_guard)
+
+    measurement_contract = None
+    try:
+        mc = (
+            guard_metrics.get("measurement_contract")
+            if isinstance(guard_metrics, dict)
+            else None
+        )
+        if isinstance(mc, dict) and mc:
+            measurement_contract = mc
+    except Exception:
+        measurement_contract = None
+    baseline_contract = None
+    try:
+        bc = (
+            baseline_spectral.get("measurement_contract")
+            if isinstance(baseline_spectral, dict)
+            else None
+        )
+        if isinstance(bc, dict) and bc:
+            baseline_contract = bc
+    except Exception:
+        baseline_contract = None
+    mc_hash = _measurement_contract_digest(measurement_contract)
+    baseline_hash = _measurement_contract_digest(baseline_contract)
+    if measurement_contract is not None:
+        result["measurement_contract"] = measurement_contract
+    if mc_hash:
+        result["measurement_contract_hash"] = mc_hash
+    if baseline_hash:
+        result["baseline_measurement_contract_hash"] = baseline_hash
+    if mc_hash and baseline_hash:
+        result["measurement_contract_match"] = bool(mc_hash == baseline_hash)
     result["caps_exceeded"] = bool(caps_exceeded)
     try:
         summary["caps_exceeded"] = bool(caps_exceeded)
@@ -624,24 +809,22 @@ def _extract_spectral_analysis(
 def _extract_rmt_analysis(
     report: RunReport, baseline: dict[str, Any]
 ) -> dict[str, Any]:
+    """Extract RMT analysis using activation edge-risk ε-band semantics."""
     tier = _resolve_policy_tier(report)
     tier_policies = get_tier_policies()
     tier_defaults = tier_policies.get(tier, tier_policies.get("balanced", {}))
+
     default_epsilon_map = (
         tier_defaults.get("rmt", {}).get("epsilon_by_family")
         if isinstance(tier_defaults, dict)
         else {}
     )
-    if not default_epsilon_map and isinstance(tier_defaults, dict):
-        default_epsilon_map = (tier_defaults.get("rmt", {}) or {}).get("epsilon", {})
     default_epsilon_map = {
         str(family): float(value)
         for family, value in (default_epsilon_map or {}).items()
-        if isinstance(value, int | float)
+        if isinstance(value, int | float) and math.isfinite(float(value))
     }
 
-    outliers_guarded = 0
-    outliers_bare = 0
     epsilon_default = 0.1
     try:
         eps_def = (
@@ -653,278 +836,168 @@ def _extract_rmt_analysis(
             epsilon_default = float(eps_def)
     except Exception:
         pass
-    stable = True
-    explicit_stability = False
-    max_ratio = 0.0
-    max_deviation_ratio = 1.0
-    mean_deviation_ratio = 1.0
-    epsilon_map: dict[str, float] = {}
-    baseline_outliers_per_family: dict[str, int] = {}
-    outliers_per_family: dict[str, int] = {}
-    epsilon_violations: list[Any] = []
-    margin_used = None
-    deadband_used = None
-    policy_out: dict[str, Any] | None = None
 
+    baseline_rmt = baseline.get("rmt", {}) if isinstance(baseline, dict) else {}
+    baseline_edge_by_family: dict[str, float] = {}
+    baseline_contract = None
+    if isinstance(baseline_rmt, dict) and baseline_rmt:
+        bc = baseline_rmt.get("measurement_contract")
+        if isinstance(bc, dict) and bc:
+            baseline_contract = bc
+        base = baseline_rmt.get("edge_risk_by_family") or baseline_rmt.get(
+            "edge_risk_by_family_base"
+        )
+        if isinstance(base, dict):
+            for k, v in base.items():
+                if isinstance(v, int | float) and math.isfinite(float(v)):
+                    baseline_edge_by_family[str(k)] = float(v)
+
+    rmt_guard = None
+    guard_metrics: dict[str, Any] = {}
+    guard_policy: dict[str, Any] = {}
     for guard in report.get("guards", []) or []:
         if str(guard.get("name", "")).lower() == "rmt":
+            rmt_guard = guard
             guard_metrics = guard.get("metrics", {}) or {}
             guard_policy = guard.get("policy", {}) or {}
-            if isinstance(guard_policy, dict) and guard_policy:
-                policy_out = dict(guard_policy)
-                if "epsilon_by_family" not in policy_out and isinstance(
-                    policy_out.get("epsilon"), dict
-                ):
-                    policy_out["epsilon_by_family"] = dict(policy_out["epsilon"])
-                if isinstance(policy_out.get("margin"), int | float) and math.isfinite(
-                    float(policy_out.get("margin"))
-                ):
-                    margin_used = float(policy_out.get("margin"))
-                if isinstance(
-                    policy_out.get("deadband"), int | float
-                ) and math.isfinite(float(policy_out.get("deadband"))):
-                    deadband_used = float(policy_out.get("deadband"))
-                if isinstance(
-                    policy_out.get("epsilon_default"), int | float
-                ) and math.isfinite(float(policy_out.get("epsilon_default"))):
-                    epsilon_default = float(policy_out.get("epsilon_default"))
-            if isinstance(
-                guard_metrics.get("epsilon_default"), int | float
-            ) and math.isfinite(float(guard_metrics.get("epsilon_default"))):
-                epsilon_default = float(guard_metrics.get("epsilon_default"))
-            outliers_guarded = guard_metrics.get(
-                "rmt_outliers", guard_metrics.get("layers_flagged", outliers_guarded)
-            )
-            max_ratio = guard_metrics.get("max_ratio", 0.0)
-            epsilon_map = guard_metrics.get("epsilon_by_family", {}) or epsilon_map
-            if not epsilon_map and isinstance(guard_policy, dict):
-                eps_src = guard_policy.get("epsilon_by_family") or guard_policy.get(
-                    "epsilon"
-                )
-                if isinstance(eps_src, dict):
-                    try:
-                        epsilon_map = {
-                            str(k): float(v)
-                            for k, v in eps_src.items()
-                            if isinstance(v, int | float) and math.isfinite(float(v))
-                        }
-                    except Exception:
-                        pass
-            baseline_outliers_per_family = (
-                guard_metrics.get("baseline_outliers_per_family", {})
-                or baseline_outliers_per_family
-            )
-            outliers_per_family = (
-                guard_metrics.get("outliers_per_family", {}) or outliers_per_family
-            )
-            epsilon_violations = guard_metrics.get(
-                "epsilon_violations", epsilon_violations
-            )
-            if outliers_per_family:
-                outliers_guarded = sum(
-                    int(v)
-                    for v in outliers_per_family.values()
-                    if isinstance(v, int | float)
-                )
-            if baseline_outliers_per_family:
-                outliers_bare = sum(
-                    int(v)
-                    for v in baseline_outliers_per_family.values()
-                    if isinstance(v, int | float)
-                )
-            flagged_rate = guard_metrics.get("flagged_rate", 0.0)
-            stable = flagged_rate <= 0.5
-            max_mp_ratio = guard_metrics.get("max_mp_ratio_final", 0.0)
-            mean_mp_ratio = guard_metrics.get("mean_mp_ratio_final", 0.0)
-
-            baseline_max = None
-            baseline_mean = None
-            baseline_rmt = baseline.get("rmt", {}) if isinstance(baseline, dict) else {}
-            if baseline_rmt:
-                baseline_max = baseline_rmt.get(
-                    "max_mp_ratio", baseline_rmt.get("max_mp_ratio_final")
-                )
-                baseline_mean = baseline_rmt.get(
-                    "mean_mp_ratio", baseline_rmt.get("mean_mp_ratio_final")
-                )
-                outliers_bare = baseline_rmt.get(
-                    "outliers", baseline_rmt.get("rmt_outliers", 0)
-                )
-            if baseline_max is None:
-                baseline_metrics = (
-                    baseline.get("metrics", {}) if isinstance(baseline, dict) else {}
-                )
-                if "rmt" in baseline_metrics:
-                    baseline_rmt_metrics = baseline_metrics["rmt"]
-                    baseline_max = baseline_rmt_metrics.get("max_mp_ratio_final")
-                    baseline_mean = baseline_rmt_metrics.get("mean_mp_ratio_final")
-            if baseline_max is None and isinstance(guard.get("baseline_metrics"), dict):
-                gb = guard.get("baseline_metrics")
-                baseline_max = gb.get("max_mp_ratio")
-                baseline_mean = gb.get("mean_mp_ratio")
-            if baseline_max is not None and baseline_max > 0:
-                max_deviation_ratio = max_mp_ratio / baseline_max
-            else:
-                max_deviation_ratio = 1.0
-            if baseline_mean is not None and baseline_mean > 0:
-                mean_deviation_ratio = mean_mp_ratio / baseline_mean
-            else:
-                mean_deviation_ratio = 1.0
-            if isinstance(guard_metrics.get("stable"), bool):
-                stable = bool(guard_metrics.get("stable"))
-                explicit_stability = True
             break
 
-    # Fallback: use metrics.rmt and/or top-level rmt section when guard is absent
-    if outliers_guarded == 0:
-        rmt_metrics = (report.get("metrics", {}) or {}).get("rmt", {})
-        if isinstance(rmt_metrics, dict):
-            try:
-                outliers_guarded = int(rmt_metrics.get("outliers", 0) or 0)
-            except Exception:
-                outliers_guarded = 0
-            if isinstance(rmt_metrics.get("stable"), bool):
-                stable = bool(rmt_metrics.get("stable"))
-                explicit_stability = True
-        rmt_top = report.get("rmt", {}) if isinstance(report.get("rmt"), dict) else {}
-        if isinstance(rmt_top, dict):
-            fams = rmt_top.get("families", {})
-            if isinstance(fams, dict) and fams:
-                for fam, rec in fams.items():
-                    if not isinstance(rec, dict):
-                        continue
-                    try:
-                        outliers_per_family[str(fam)] = int(
-                            rec.get("outliers_guarded", 0) or 0
-                        )
-                        baseline_outliers_per_family[str(fam)] = int(
-                            rec.get("outliers_bare", 0) or 0
-                        )
-                        if rec.get("epsilon") is not None:
-                            try:
-                                epsilon_map[str(fam)] = float(rec.get("epsilon"))
-                            except Exception:
-                                pass
-                    except Exception:
-                        continue
-            try:
-                if outliers_bare == 0:
-                    outliers_bare = int(rmt_top.get("outliers", 0) or 0)
-            except Exception:
-                pass
+    policy_out: dict[str, Any] | None = None
+    if isinstance(guard_policy, dict) and guard_policy:
+        policy_out = dict(guard_policy)
+        if isinstance(policy_out.get("epsilon_default"), int | float) and math.isfinite(
+            float(policy_out.get("epsilon_default"))
+        ):
+            epsilon_default = float(policy_out.get("epsilon_default"))
 
-    # If stability not explicitly provided, derive from outlier behavior
-    if not explicit_stability:
-        try:
-            if outliers_guarded == 0 and outliers_bare == 0:
-                stable = True
-            elif outliers_guarded <= outliers_bare:
-                stable = True
-            else:
-                stable = (outliers_guarded - outliers_bare) / max(
-                    outliers_bare, 1
-                ) <= 0.5
-        except Exception:
-            pass
+    if isinstance(guard_metrics.get("epsilon_default"), int | float) and math.isfinite(
+        float(guard_metrics.get("epsilon_default"))
+    ):
+        epsilon_default = float(guard_metrics.get("epsilon_default"))
 
-    delta_per_family = {
-        k: int(outliers_per_family.get(k, 0))
-        - int(baseline_outliers_per_family.get(k, 0))
-        for k in set(outliers_per_family) | set(baseline_outliers_per_family)
-    }
-    delta_total = int(outliers_guarded) - int(outliers_bare)
-    # Conservative baseline fallback when not available
-    if outliers_bare == 0 and outliers_guarded > 0:
-        # Assume baseline had fewer outliers to make acceptance harder
-        outliers_bare = max(0, outliers_guarded - 1)
-
-    # Recompute stability from epsilon rule when not explicitly provided
-    if not explicit_stability:
-        try:
-            if outliers_per_family and baseline_outliers_per_family:
-                families_union = set(outliers_per_family) | set(
-                    baseline_outliers_per_family
+    edge_base: dict[str, float] = {}
+    edge_cur: dict[str, float] = {}
+    if isinstance(guard_metrics, dict) and guard_metrics:
+        base = guard_metrics.get("edge_risk_by_family_base") or {}
+        cur = guard_metrics.get("edge_risk_by_family") or {}
+        if isinstance(base, dict):
+            for k, v in base.items():
+                if isinstance(v, int | float) and math.isfinite(float(v)):
+                    edge_base[str(k)] = float(v)
+        if isinstance(cur, dict):
+            for k, v in cur.items():
+                if isinstance(v, int | float) and math.isfinite(float(v)):
+                    edge_cur[str(k)] = float(v)
+    if not edge_base and baseline_edge_by_family:
+        edge_base = dict(baseline_edge_by_family)
+
+    epsilon_map: dict[str, float] = {}
+    eps_src = guard_metrics.get("epsilon_by_family") or {}
+    if not eps_src and isinstance(guard_policy, dict):
+        eps_src = guard_policy.get("epsilon_by_family") or {}
+    if isinstance(eps_src, dict):
+        for k, v in eps_src.items():
+            if isinstance(v, int | float) and math.isfinite(float(v)):
+                epsilon_map[str(k)] = float(v)
+
+    epsilon_violations = guard_metrics.get("epsilon_violations") or []
+    if not (isinstance(epsilon_violations, list) and epsilon_violations):
+        epsilon_violations = []
+        families = set(edge_cur) | set(edge_base)
+        for family in families:
+            base = float(edge_base.get(family, 0.0) or 0.0)
+            cur = float(edge_cur.get(family, 0.0) or 0.0)
+            if base <= 0.0:
+                continue
+            eps = float(
+                epsilon_map.get(
+                    family, default_epsilon_map.get(family, epsilon_default)
                 )
-                checks: list[bool] = []
-                for fam in families_union:
-                    guarded = int(outliers_per_family.get(fam, 0) or 0)
-                    bare = int(baseline_outliers_per_family.get(fam, 0) or 0)
-                    eps_val = float(epsilon_map.get(fam, epsilon_default))
-                    allowed = math.ceil(bare * (1.0 + eps_val))
-                    checks.append(guarded <= allowed)
-                if checks:
-                    stable = all(checks)
-            elif outliers_bare > 0:
-                stable = outliers_guarded <= (
-                    outliers_bare * (1.0 + float(epsilon_default))
+            )
+            allowed = (1.0 + eps) * base
+            if cur > allowed:
+                delta = (cur / base) - 1.0 if base > 0 else float("inf")
+                epsilon_violations.append(
+                    {
+                        "family": family,
+                        "edge_base": base,
+                        "edge_cur": cur,
+                        "delta": float(delta),
+                        "allowed": allowed,
+                        "epsilon": eps,
+                    }
                 )
-        except Exception:
-            pass
-
-    # Compute epsilon scalar (fallback) and detailed family breakdown
-    if epsilon_map:
-        epsilon_scalar = max(float(v) for v in epsilon_map.values())
-    elif default_epsilon_map:
-        try:
-            epsilon_scalar = max(float(v) for v in default_epsilon_map.values())
-        except Exception:
-            epsilon_scalar = float(epsilon_default)
-    else:
-        epsilon_scalar = float(epsilon_default)
-    try:
-        epsilon_scalar = round(float(epsilon_scalar), 3)
-    except Exception:
-        epsilon_scalar = float(epsilon_default)
 
-    def _to_int(v: Any) -> int:
-        try:
-            return int(v)
-        except (TypeError, ValueError):
-            return 0
+    stable = bool(guard_metrics.get("stable", not epsilon_violations))
 
-    families = (
-        set(outliers_per_family) | set(baseline_outliers_per_family) | set(epsilon_map)
+    families_all = sorted(
+        set(edge_base) | set(edge_cur) | set(epsilon_map) | set(default_epsilon_map)
     )
-    family_breakdown = {
-        family: {
-            "bare": _to_int(baseline_outliers_per_family.get(family, 0)),
-            "guarded": _to_int(outliers_per_family.get(family, 0)),
-            "epsilon": float(epsilon_map.get(family, epsilon_scalar)),
+    family_breakdown: dict[str, dict[str, Any]] = {}
+    ratios: list[float] = []
+    deltas: list[float] = []
+    for family in families_all:
+        base = float(edge_base.get(family, 0.0) or 0.0)
+        cur = float(edge_cur.get(family, 0.0) or 0.0)
+        eps = float(
+            epsilon_map.get(family, default_epsilon_map.get(family, epsilon_default))
+        )
+        allowed = (1.0 + eps) * base if base > 0.0 else None
+        ratio = (cur / base) if base > 0.0 else None
+        delta = ((cur / base) - 1.0) if base > 0.0 else None
+        if isinstance(ratio, float) and math.isfinite(ratio):
+            ratios.append(ratio)
+        if isinstance(delta, float) and math.isfinite(delta):
+            deltas.append(delta)
+        family_breakdown[family] = {
+            "edge_base": base,
+            "edge_cur": cur,
+            "epsilon": eps,
+            "allowed": allowed,
+            "ratio": ratio,
+            "delta": delta,
         }
-        for family in sorted(families)
-    }
 
-    # Stringify per-family dict keys for stability
-    outliers_per_family = {str(k): _to_int(v) for k, v in outliers_per_family.items()}
-    baseline_outliers_per_family = {
-        str(k): _to_int(v) for k, v in baseline_outliers_per_family.items()
-    }
-    delta_per_family = {str(k): _to_int(v) for k, v in delta_per_family.items()}
+    measurement_contract = None
+    try:
+        mc = (
+            guard_metrics.get("measurement_contract")
+            if isinstance(guard_metrics, dict)
+            else None
+        )
+        if isinstance(mc, dict) and mc:
+            measurement_contract = mc
+    except Exception:
+        measurement_contract = None
+
+    mc_hash = _measurement_contract_digest(measurement_contract)
+    baseline_hash = _measurement_contract_digest(baseline_contract)
 
-    result = {
-        "outliers_bare": outliers_bare,
-        "outliers_guarded": outliers_guarded,
-        "epsilon": epsilon_scalar,
+    result: dict[str, Any] = {
+        "tier": tier,
+        "edge_risk_by_family_base": dict(edge_base),
+        "edge_risk_by_family": dict(edge_cur),
         "epsilon_default": float(epsilon_default),
-        "epsilon_by_family": epsilon_map,
-        "outliers_per_family": outliers_per_family,
-        "baseline_outliers_per_family": baseline_outliers_per_family,
-        "delta_per_family": delta_per_family,
-        "delta_total": delta_total,
-        "epsilon_violations": epsilon_violations,
+        "epsilon_by_family": dict(epsilon_map),
+        "epsilon_violations": list(epsilon_violations),
         "stable": stable,
         "status": "stable" if stable else "unstable",
-        "max_ratio": max_ratio,
-        "max_deviation_ratio": max_deviation_ratio,
-        "mean_deviation_ratio": mean_deviation_ratio,
+        "max_edge_ratio": max(ratios) if ratios else None,
+        "max_edge_delta": max(deltas) if deltas else None,
+        "mean_edge_delta": (sum(deltas) / len(deltas)) if deltas else None,
         "families": family_breakdown,
+        "evaluated": bool(rmt_guard),
     }
-    if margin_used is not None:
-        result["margin"] = float(margin_used)
-    if deadband_used is not None:
-        result["deadband"] = float(deadband_used)
     if policy_out:
         result["policy"] = policy_out
+    if measurement_contract is not None:
+        result["measurement_contract"] = measurement_contract
+    if mc_hash:
+        result["measurement_contract_hash"] = mc_hash
+    if baseline_hash:
+        result["baseline_measurement_contract_hash"] = baseline_hash
+    if mc_hash and baseline_hash:
+        result["measurement_contract_match"] = bool(mc_hash == baseline_hash)
     return result