invarlock 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

invarlock/reporting/certificate.py

@@ -29,7 +29,7 @@ try:  # pragma: no cover - exercised in integration
 except Exception:  # pragma: no cover
     jsonschema = None  # type: ignore
 
-from invarlock.core.auto_tuning import TIER_POLICIES
+from invarlock.core.auto_tuning import get_tier_policies
 from invarlock.core.bootstrap import (
     compute_paired_delta_log_ci,
     logspace_to_ratio_ci,
@@ -538,6 +538,175 @@ def _enforce_ratio_ci_alignment(
             )
 
 
+def _enforce_display_ci_alignment(
+    ratio_ci_source: str,
+    primary_metric: Any,
+    logloss_delta_ci: Any,
+    window_plan_profile: str | None,
+) -> None:
+    """Ensure display_ci matches exp(ci) for ppl-like metrics when paired."""
+    if ratio_ci_source != "paired_baseline":
+        return
+    if not isinstance(primary_metric, dict) or not primary_metric:
+        return
+    try:
+        kind = str(primary_metric.get("kind", "")).lower()
+    except Exception:
+        return
+    if not kind.startswith("ppl"):
+        return
+
+    def _finite_bounds(bounds: Any) -> bool:
+        return (
+            isinstance(bounds, tuple | list)
+            and len(bounds) == 2
+            and all(isinstance(v, int | float) and math.isfinite(v) for v in bounds)
+        )
+
+    ci = primary_metric.get("ci")
+    if not _finite_bounds(ci):
+        if _finite_bounds(logloss_delta_ci):
+            primary_metric["ci"] = (
+                float(logloss_delta_ci[0]),
+                float(logloss_delta_ci[1]),
+            )
+            ci = primary_metric["ci"]
+        else:
+            profile = (window_plan_profile or "dev").lower()
+            if profile in {"ci", "release"}:
+                raise ValueError(
+                    "primary_metric.ci missing for ppl-like metric under paired baseline."
+                )
+            return
+
+    expected = tuple(math.exp(float(bound)) for bound in ci)
+    display_ci = primary_metric.get("display_ci")
+    if not _finite_bounds(display_ci):
+        profile = (window_plan_profile or "dev").lower()
+        if profile in {"ci", "release"}:
+            raise ValueError(
+                "primary_metric.display_ci missing for ppl-like metric under paired baseline."
+            )
+        primary_metric["display_ci"] = [expected[0], expected[1]]
+        return
+
+    for observed, exp_val in zip(display_ci, expected, strict=False):
+        tolerance = 5e-4 * max(1.0, abs(exp_val))
+        if abs(float(observed) - float(exp_val)) > tolerance:
+            profile = (window_plan_profile or "dev").lower()
+            if profile in {"ci", "release"}:
+                raise ValueError(
+                    "primary_metric.display_ci mismatch: bounds do not match exp(ci)."
+                )
+            primary_metric["display_ci"] = [expected[0], expected[1]]
+            break
+
+
+def _enforce_pairing_and_coverage(
+    stats: dict[str, Any] | None,
+    window_plan_profile: str | None,
+    tier: str | None,
+) -> None:
+    """Enforce pairing and coverage contracts for CI/Release profiles."""
+    profile = (window_plan_profile or "dev").lower()
+    if profile not in {"ci", "release"}:
+        return
+    if not isinstance(stats, dict):
+        raise ValueError("Missing dataset window stats for CI/Release enforcement.")
+
+    match_fraction = stats.get("window_match_fraction")
+    overlap_fraction = stats.get("window_overlap_fraction")
+    if not (
+        isinstance(match_fraction, (int | float))
+        and math.isfinite(float(match_fraction))
+    ):
+        raise ValueError("CI/Release requires window_match_fraction.")
+    if float(match_fraction) < 0.999999:
+        raise ValueError(
+            f"CI/Release requires perfect pairing (window_match_fraction={float(match_fraction):.6f})."
+        )
+
+    if not (
+        isinstance(overlap_fraction, (int | float))
+        and math.isfinite(float(overlap_fraction))
+    ):
+        raise ValueError("CI/Release requires window_overlap_fraction.")
+    if float(overlap_fraction) > 1e-9:
+        raise ValueError(
+            f"CI/Release requires non-overlapping windows (window_overlap_fraction={float(overlap_fraction):.6f})."
+        )
+
+    def _coerce_count(value: Any) -> int | None:
+        if value is None or isinstance(value, bool):
+            return None
+        try:
+            val = float(value)
+        except (TypeError, ValueError):
+            return None
+        if not math.isfinite(val) or val < 0:
+            return None
+        if abs(val - round(val)) > 1e-9:
+            return None
+        return int(round(val))
+
+    actual_preview = _coerce_count(stats.get("actual_preview"))
+    actual_final = _coerce_count(stats.get("actual_final"))
+    if actual_preview is None or actual_final is None:
+        coverage = stats.get("coverage")
+        if isinstance(coverage, dict):
+            if actual_preview is None:
+                actual_preview = _coerce_count(coverage.get("preview", {}).get("used"))
+            if actual_final is None:
+                actual_final = _coerce_count(coverage.get("final", {}).get("used"))
+
+    if actual_preview is None or actual_final is None:
+        raise ValueError("CI/Release requires preview/final window counts.")
+    if actual_preview != actual_final:
+        raise ValueError(
+            f"CI/Release requires matching preview/final counts "
+            f"(preview={actual_preview}, final={actual_final})."
+        )
+
+    from invarlock.core.runner import BOOTSTRAP_COVERAGE_REQUIREMENTS
+
+    tier_key = str(tier or "balanced").lower()
+    floors = BOOTSTRAP_COVERAGE_REQUIREMENTS.get(
+        tier_key, BOOTSTRAP_COVERAGE_REQUIREMENTS["balanced"]
+    )
+    preview_floor = int(floors.get("preview", 0))
+    final_floor = int(floors.get("final", 0))
+    replicates_floor = int(floors.get("replicates", 0))
+
+    coverage = stats.get("coverage")
+    if not isinstance(coverage, dict):
+        raise ValueError("CI/Release requires bootstrap coverage stats.")
+
+    preview_used = _coerce_count(coverage.get("preview", {}).get("used"))
+    final_used = _coerce_count(coverage.get("final", {}).get("used"))
+    replicates_used = _coerce_count(coverage.get("replicates", {}).get("used"))
+
+    if replicates_used is None:
+        bootstrap = stats.get("bootstrap")
+        if isinstance(bootstrap, dict):
+            replicates_used = _coerce_count(
+                bootstrap.get("replicates", bootstrap.get("n"))
+            )
+
+    if preview_used is None or final_used is None or replicates_used is None:
+        raise ValueError("CI/Release requires preview/final/replicates coverage stats.")
+
+    if preview_used < preview_floor or final_used < final_floor:
+        raise ValueError(
+            "CI/Release requires preview/final coverage at or above tier floors "
+            f"(preview={preview_used}/{preview_floor}, final={final_used}/{final_floor})."
+        )
+    if replicates_used < replicates_floor:
+        raise ValueError(
+            "CI/Release requires bootstrap replicates at or above tier floors "
+            f"(replicates={replicates_used}/{replicates_floor})."
+        )
+
+
 def _fallback_paired_windows(
     paired_windows: int, coverage_summary: dict[str, Any]
 ) -> int:
@@ -598,6 +767,18 @@ def make_certificate(
     except Exception:  # pragma: no cover
         pass
 
+    # Determinism preset (CI/Release provenance) when present.
+    try:
+        det = (
+            report.get("meta", {}).get("determinism")
+            if isinstance(report.get("meta"), dict)
+            else None
+        )
+        if isinstance(det, dict) and det:
+            meta["determinism"] = det
+    except Exception:  # pragma: no cover
+        pass
+
     tokenizer_hash_meta = report["meta"].get("tokenizer_hash")
     if not tokenizer_hash_meta:
         dataset_section = report.get("data", {})
@@ -627,6 +808,13 @@ def make_certificate(
 
     # Extract dataset configuration and compute hashes
     dataset_info = _extract_dataset_info(report)
+    try:
+        if isinstance(dataset_info, dict):
+            windows = dataset_info.get("windows")
+            if isinstance(windows, dict):
+                windows.setdefault("stats", {})
+    except Exception:  # pragma: no cover
+        pass
 
     # Baseline reference (PM-only). Derive a primary_metric snapshot from baseline windows.
     # Prefer explicit baseline primary_metric when provided; otherwise compute from windows
@@ -741,15 +929,17 @@ def make_certificate(
                 tier = str(auto_cfg.get("tier")).lower()
         except Exception:  # pragma: no cover
             pass
+        tier_policies = get_tier_policies()
+        tier_defaults = tier_policies.get(tier, tier_policies.get("balanced", {}))
         metrics_policy = (
-            TIER_POLICIES.get(tier, {}).get("metrics", {})
-            if isinstance(tier, str)
-            else {}
+            tier_defaults.get("metrics", {}) if isinstance(tier_defaults, dict) else {}
         )
-        ppl_policy = (
-            metrics_policy.get("ppl", {}) if isinstance(metrics_policy, dict) else {}
+        pm_policy = (
+            metrics_policy.get("pm_ratio", {})
+            if isinstance(metrics_policy, dict)
+            else {}
         )
-        min_tokens = int(ppl_policy.get("min_tokens", 0))
+        min_tokens = int(pm_policy.get("min_tokens", 0))
         if (
             isinstance(total_tokens, int)
             and min_tokens > 0
@@ -786,6 +976,47 @@ def make_certificate(
     if paired:
         paired_run, paired_base = paired
         paired_windows = len(paired_run)
+        paired_weights: list[float] | None = None
+        try:
+            run_ids = (
+                run_windows.get("window_ids") if isinstance(run_windows, dict) else None
+            )
+            run_w = (
+                run_windows.get("token_counts")
+                if isinstance(run_windows, dict)
+                else None
+            )
+            base_ids = (
+                baseline_windows.get("window_ids")
+                if isinstance(baseline_windows, dict)
+                else None
+            )
+            if (
+                isinstance(run_ids, list)
+                and isinstance(run_w, list)
+                and isinstance(base_ids, list)
+            ):
+                base_set = {
+                    int(b_id) for b_id in base_ids if isinstance(b_id, int | float)
+                }
+                weights: list[float] = []
+                for r_id, w in zip(run_ids, run_w, strict=False):
+                    if not isinstance(r_id, int | float):
+                        continue
+                    key = int(r_id)
+                    if key not in base_set:
+                        continue
+                    try:
+                        wv = float(w)
+                    except Exception:
+                        continue
+                    if not math.isfinite(wv):
+                        continue
+                    weights.append(float(max(wv, 0.0)))
+                if weights:
+                    paired_weights = weights
+        except Exception:  # pragma: no cover
+            paired_weights = None
         method = str(metrics_bootstrap.get("method", "percentile")).lower()
         replicates = int(
             metrics_bootstrap.get(
@@ -813,6 +1044,7 @@ def make_certificate(
                 delta_ci = compute_paired_delta_log_ci(
                     paired_run,
                     paired_base,
+                    weights=paired_weights,
                     method=ci_method,
                     replicates=replicates,
                     alpha=alpha,
@@ -1053,6 +1285,115 @@ def make_certificate(
             if key in metrics_stats_source:
                 ppl_analysis["stats"][key] = metrics_stats_source[key]
 
+    # Derive requested/actual window counts for auditability when runners do not
+    # emit a metrics.stats block (normalization may also drop it).
+    try:
+        stats_obj = ppl_analysis.get("stats", {})
+        if isinstance(stats_obj, dict):
+
+            def _as_count(value: Any) -> int | None:
+                if value is None or isinstance(value, bool):
+                    return None
+                if isinstance(value, int):
+                    return int(value) if value >= 0 else None
+                if isinstance(value, float) and math.isfinite(value):
+                    if abs(value - round(value)) > 1e-9 or value < 0:
+                        return None
+                    return int(round(value))
+                return None
+
+            data_cfg = report.get("data", {}) if isinstance(report, dict) else {}
+            data_cfg = data_cfg if isinstance(data_cfg, dict) else {}
+            windows_cfg = (
+                dataset_info.get("windows", {})
+                if isinstance(dataset_info, dict)
+                else {}
+            )
+            windows_cfg = windows_cfg if isinstance(windows_cfg, dict) else {}
+
+            req_prev = _as_count(stats_obj.get("requested_preview"))
+            if req_prev is None:
+                req_prev = _as_count(data_cfg.get("preview_n"))
+            if req_prev is None:
+                req_prev = _as_count(windows_cfg.get("preview"))
+
+            req_fin = _as_count(stats_obj.get("requested_final"))
+            if req_fin is None:
+                req_fin = _as_count(data_cfg.get("final_n"))
+            if req_fin is None:
+                req_fin = _as_count(windows_cfg.get("final"))
+
+            eval_windows = (
+                report.get("evaluation_windows", {}) if isinstance(report, dict) else {}
+            )
+            eval_windows = eval_windows if isinstance(eval_windows, dict) else {}
+
+            def _len_ids(section: Any) -> int | None:
+                if not isinstance(section, dict):
+                    return None
+                ids = section.get("window_ids")
+                if isinstance(ids, list):
+                    return int(len(ids))
+                return None
+
+            act_prev = _as_count(stats_obj.get("actual_preview"))
+            if act_prev is None:
+                act_prev = _len_ids(eval_windows.get("preview"))
+            if act_prev is None:
+                cov_prev = (
+                    coverage_summary.get("preview")
+                    if isinstance(coverage_summary, dict)
+                    else None
+                )
+                if isinstance(cov_prev, dict):
+                    act_prev = _as_count(cov_prev.get("used"))
+            if act_prev is None:
+                act_prev = req_prev
+
+            act_fin = _as_count(stats_obj.get("actual_final"))
+            if act_fin is None:
+                act_fin = _len_ids(eval_windows.get("final"))
+            if act_fin is None:
+                cov_fin = (
+                    coverage_summary.get("final")
+                    if isinstance(coverage_summary, dict)
+                    else None
+                )
+                if isinstance(cov_fin, dict):
+                    act_fin = _as_count(cov_fin.get("used"))
+                elif isinstance(coverage_summary, dict):
+                    act_fin = _as_count(coverage_summary.get("used"))
+            if act_fin is None:
+                act_fin = req_fin
+
+            if req_prev is not None:
+                stats_obj["requested_preview"] = req_prev
+            if req_fin is not None:
+                stats_obj["requested_final"] = req_fin
+            if act_prev is not None:
+                stats_obj["actual_preview"] = act_prev
+            if act_fin is not None:
+                stats_obj["actual_final"] = act_fin
+
+            if "coverage_ok" not in stats_obj:
+                if (
+                    isinstance(req_prev, int)
+                    and isinstance(req_fin, int)
+                    and isinstance(act_prev, int)
+                    and isinstance(act_fin, int)
+                ):
+                    stats_obj["coverage_ok"] = (act_prev >= req_prev) and (
+                        act_fin >= req_fin
+                    )
+    except Exception:  # pragma: no cover
+        pass
+
+    _enforce_pairing_and_coverage(
+        ppl_analysis.get("stats", {}),
+        window_plan_profile,
+        auto.get("tier", "balanced"),
+    )
+
     if isinstance(window_plan_ctx, dict):
         ppl_analysis["window_plan"] = window_plan_ctx
 
@@ -1102,17 +1443,62 @@ def make_certificate(
         if variance_policy_digest:
             policies["variance"]["policy_digest"] = variance_policy_digest
 
+    # Resolve tier/profile policy (canonical) and merge observed guard policies.
+    profile = None
+    explicit_overrides = None
+    try:
+        ctx = report.get("context") if isinstance(report, dict) else None
+        if isinstance(ctx, dict) and ctx.get("profile"):
+            profile = str(ctx.get("profile"))
+    except Exception:
+        profile = None
+    try:
+        window_plan = (
+            report.get("metrics", {}).get("window_plan")
+            if isinstance(report.get("metrics"), dict)
+            else None
+        )
+        if (
+            profile is None
+            and isinstance(window_plan, dict)
+            and window_plan.get("profile")
+        ):
+            profile = str(window_plan.get("profile"))
+    except Exception:
+        profile = None
+    try:
+        meta_cfg = (
+            report.get("meta", {}).get("config")
+            if isinstance(report.get("meta"), dict)
+            else None
+        )
+        if isinstance(meta_cfg, dict) and isinstance(meta_cfg.get("guards"), dict):
+            explicit_overrides = meta_cfg.get("guards")
+        if explicit_overrides is None and isinstance(report.get("config"), dict):
+            cfg2 = report.get("config")
+            if isinstance(cfg2.get("guards"), dict):
+                explicit_overrides = cfg2.get("guards")
+    except Exception:
+        explicit_overrides = None
+
     resolved_policy = _build_resolved_policies(
-        auto.get("tier", "balanced"), spectral, rmt, variance
+        auto.get("tier", "balanced"),
+        spectral,
+        rmt,
+        variance,
+        profile=profile,
+        explicit_overrides=explicit_overrides,
+    )
+    overrides_list = _extract_policy_overrides(report)
+    resolved_digest = _compute_policy_digest(
+        {"resolved_policy": resolved_policy, "overrides": overrides_list}
     )
-    resolved_digest = _compute_policy_digest(resolved_policy)
-    policy_digest_value = variance_policy_digest or resolved_digest
     policy_provenance = {
         "tier": auto.get("tier", "balanced"),
-        "overrides": _extract_policy_overrides(report),
-        "policy_digest": policy_digest_value,
+        "overrides": overrides_list,
+        "policy_digest": resolved_digest,
     }
-    auto["policy_digest"] = policy_digest_value
+    auto["policy_digest"] = resolved_digest
 
     for guard_name in ("spectral", "rmt", "variance"):
         if guard_name in resolved_policy:
@@ -1473,16 +1859,17 @@ def make_certificate(
         or (baseline_hash != thresholds_hash)
     )
 
-    # Hysteresis knobs snapshot
-    try:
-        metrics_policy = TIER_POLICIES.get(cur_tier, {}).get("metrics", {})
-    except Exception:  # pragma: no cover
+    # Hysteresis knobs snapshot (policy-resolved)
+    metrics_policy = (
+        resolved_policy.get("metrics", {}) if isinstance(resolved_policy, dict) else {}
+    )
+    if not isinstance(metrics_policy, dict):
         metrics_policy = {}
     ppl_hys = 0.0
     acc_hys = 0.0
     try:
         ppl_hys = float(
-            (metrics_policy.get("ppl") or {}).get("hysteresis_ratio", 0.0) or 0.0
+            (metrics_policy.get("pm_ratio") or {}).get("hysteresis_ratio", 0.0) or 0.0
         )
         acc_hys = float(
             (metrics_policy.get("accuracy") or {}).get("hysteresis_delta_pp", 0.0)
@@ -1725,6 +2112,12 @@ def make_certificate(
     from .primary_metric_utils import attach_primary_metric as _attach_pm
 
     _attach_pm(certificate, report, baseline_raw, baseline_ref, ppl_analysis)
+    _enforce_display_ci_alignment(
+        ratio_ci_source,
+        certificate.get("primary_metric"),
+        logloss_delta_ci,
+        window_plan_profile,
+    )
 
     # Ensure primary_metric has display_ci populated for schema invariants
     try:
@@ -2204,11 +2597,24 @@ def _format_epsilon_map(epsilon_map: Any) -> dict[str, float]:
 
 
 def _build_resolved_policies(
-    tier: str, spectral: dict[str, Any], rmt: dict[str, Any], variance: dict[str, Any]
+    tier: str,
+    spectral: dict[str, Any],
+    rmt: dict[str, Any],
+    variance: dict[str, Any],
+    *,
+    profile: str | None = None,
+    explicit_overrides: dict[str, dict[str, Any]] | None = None,
 ) -> dict[str, Any]:
     from .policy_utils import _build_resolved_policies as _impl
 
-    return _impl(tier, spectral, rmt, variance)
+    return _impl(
+        tier,
+        spectral,
+        rmt,
+        variance,
+        profile=profile,
+        explicit_overrides=explicit_overrides,
+    )
 
 
 def _compute_policy_digest(policy: dict[str, Any]) -> str:
@@ -2279,6 +2685,23 @@ def _prepare_guard_overhead_section(
         "threshold_percent": threshold * 100,
         "source": str(payload.get("source", "report")),
     }
+    try:
+        mode = payload.get("mode")
+        if mode is None:
+            mode = payload.get("guard_overhead_mode")
+        if isinstance(mode, str) and mode.strip():
+            sanitized["mode"] = mode.strip()
+    except Exception:
+        pass
+    try:
+        skipped = bool(payload.get("skipped", False))
+        if skipped:
+            sanitized["skipped"] = True
+            reason = payload.get("skip_reason")
+            if isinstance(reason, str) and reason.strip():
+                sanitized["skip_reason"] = reason.strip()
+    except Exception:
+        pass
 
     # Prefer structured reports and reuse the validator when available
     bare_report = payload.pop("bare_report", None)
@@ -2292,8 +2715,8 @@ def _prepare_guard_overhead_section(
             {
                 "overhead_ratio": metrics.get("overhead_ratio"),
                 "overhead_percent": metrics.get("overhead_percent"),
-                "bare_final": metrics.get("bare_final"),
-                "guarded_final": metrics.get("guarded_final"),
+                "bare_ppl": metrics.get("bare_ppl"),
+                "guarded_ppl": metrics.get("guarded_ppl"),
                 "messages": list(result.messages),
                 "warnings": list(result.warnings),
                 "errors": list(result.errors),
@@ -2305,12 +2728,8 @@ def _prepare_guard_overhead_section(
         return sanitized, bool(result.passed)
 
     # Fall back to direct ratio computation when reports are not provided
-    bare_ppl = _coerce_float(payload.get("bare_final")) or _coerce_float(
-        payload.get("bare_ppl")
-    )
-    guarded_ppl = _coerce_float(payload.get("guarded_final")) or _coerce_float(
-        payload.get("guarded_ppl")
-    )
+    bare_ppl = _coerce_float(payload.get("bare_ppl"))
+    guarded_ppl = _coerce_float(payload.get("guarded_ppl"))
     ratio = _coerce_float(payload.get("overhead_ratio"))
 
     if ratio is None and bare_ppl is not None and guarded_ppl is not None:
@@ -2449,6 +2868,12 @@ def _propagate_pairing_stats(
         coverage = pa_stats.get("coverage")
         if isinstance(coverage, dict) and coverage:
             stats["coverage"] = coverage
+        bootstrap = pa_stats.get("bootstrap")
+        if isinstance(bootstrap, dict) and bootstrap:
+            stats["bootstrap"] = bootstrap
+        paired_delta_summary = pa_stats.get("paired_delta_summary")
+        if isinstance(paired_delta_summary, dict) and paired_delta_summary:
+            stats["paired_delta_summary"] = paired_delta_summary
         wmf = pa_stats.get("window_match_fraction")
         if wmf is not None:
             stats["window_match_fraction"] = wmf
@@ -2674,12 +3099,31 @@ def _compute_validation_flags(
     }
     if _tiny_relax:
         tier = "aggressive"
+
     tier_thresholds = {
         "conservative": 1.05,
         "balanced": 1.10,
         "aggressive": 1.20,
         "none": 1.10,
     }
+    tier_policies = get_tier_policies()
+    tier_policy = tier_policies.get(tier, tier_policies.get("balanced", {}))
+    metrics_policy = (
+        tier_policy.get("metrics", {}) if isinstance(tier_policy, dict) else {}
+    )
+    pm_policy = (
+        metrics_policy.get("pm_ratio", {}) if isinstance(metrics_policy, dict) else {}
+    )
+    ratio_limit_base = pm_policy.get("ratio_limit_base")
+    try:
+        if ratio_limit_base is not None:
+            ratio_limit_base = float(ratio_limit_base)
+    except Exception:
+        ratio_limit_base = None
+    if not isinstance(ratio_limit_base, (int | float)) or not math.isfinite(
+        float(ratio_limit_base)
+    ):
+        ratio_limit_base = float(tier_thresholds.get(tier, 1.10))
     acceptance = pm_acceptance_range if isinstance(pm_acceptance_range, dict) else {}
     ratio_min_bound = None
     ratio_max_bound = None
@@ -2697,7 +3141,7 @@ def _compute_validation_flags(
     ratio_limit = (
         ratio_max_bound
         if isinstance(ratio_max_bound, (int | float)) and math.isfinite(ratio_max_bound)
-        else tier_thresholds.get(tier, 1.10)
+        else float(ratio_limit_base)
     )
     if isinstance(target_ratio, int | float) and target_ratio > 0:
         ratio_limit = min(ratio_limit, float(target_ratio))
@@ -2726,13 +3170,6 @@ def _compute_validation_flags(
         except Exception:  # pragma: no cover
             pass
     # Hysteresis and sample-size floors from tier policies
-    tier_policy = TIER_POLICIES.get(tier, {}) if isinstance(tier, str) else {}
-    metrics_policy = (
-        tier_policy.get("metrics", {}) if isinstance(tier_policy, dict) else {}
-    )
-    pm_policy = (
-        metrics_policy.get("pm_ratio", {}) if isinstance(metrics_policy, dict) else {}
-    )
     hysteresis_ratio = float(pm_policy.get("hysteresis_ratio", 0.0))
     min_tokens = int(pm_policy.get("min_tokens", 0))
     # Evaluate sample-size sufficiency
@@ -2804,7 +3241,9 @@ def _compute_validation_flags(
     summary = spectral.get("summary", {}) if isinstance(spectral, dict) else {}
     max_caps = spectral.get("max_caps") or summary.get("max_caps")
     if max_caps is None:
-        default_spectral = TIER_POLICIES.get(tier, {}).get("spectral", {})
+        default_spectral = (
+            tier_policy.get("spectral", {}) if isinstance(tier_policy, dict) else {}
+        )
         max_caps = default_spectral.get("max_caps", 5)
     spectral_stable = spectral.get("caps_applied", 0) <= int(max_caps)
     if spectral.get("caps_exceeded"):
@@ -2871,14 +3310,6 @@ def _compute_validation_flags(
                 flags["primary_metric_acceptable"] = bool(ok)
             elif kind in {"accuracy", "vqa_accuracy"}:
                 # Read thresholds from tier policy if available
-                tier_policy = (
-                    TIER_POLICIES.get(tier, {}) if isinstance(tier, str) else {}
-                )
-                metrics_policy = (
-                    tier_policy.get("metrics", {})
-                    if isinstance(tier_policy, dict)
-                    else {}
-                )
                 acc_policy = (
                     metrics_policy.get("accuracy", {})
                     if isinstance(metrics_policy, dict)