Add props confidence breakdown diagnostics

analytics/props_mapper.py

@@ -29,6 +29,14 @@ def build_strikeout_probability_result(*args, **kwargs):
     return _build_strikeout_probability_result(*args, **kwargs)
 
 
+def build_strikeout_probability_result_v2(*args, **kwargs):
+    from models.strikeout_probability_engine_v2 import (
+        build_strikeout_probability_result_v2 as _build_strikeout_probability_result_v2,
+    )
+
+    return _build_strikeout_probability_result_v2(*args, **kwargs)
+
+
 def _build_statcast_name_index(statcast_df: pd.DataFrame) -> dict[str, str]:
     if statcast_df.empty or "player_name" not in statcast_df.columns:
         return {}
@@ -105,6 +113,98 @@ def _compute_verdict(
     return "pass"
 
 
+def _confidence_display_remap(raw_score: float | None) -> float | None:
+    try:
+        raw = float(raw_score)
+    except Exception:
+        return None
+    if raw <= 40.0:
+        return max(1.0, min(100.0, raw))
+    return max(1.0, min(100.0, 40.0 + ((raw - 40.0) * 1.45)))
+
+
+def _normalize_confidence_components(value: Any) -> list[dict[str, Any]]:
+    if not isinstance(value, list):
+        return []
+    normalized: list[dict[str, Any]] = []
+    for item in value:
+        if not isinstance(item, dict):
+            continue
+        label = str(item.get("label") or "").strip()
+        if not label:
+            continue
+        try:
+            component_value = float(item.get("value") or 0.0)
+        except Exception:
+            component_value = 0.0
+        normalized.append(
+            {
+                "label": label,
+                "value": round(component_value, 1),
+                "direction": str(item.get("direction") or "").strip().lower() or None,
+            }
+        )
+    return normalized
+
+
+def _select_confidence_primary_driver(
+    penalties: list[dict[str, Any]],
+    bonuses: list[dict[str, Any]],
+) -> dict[str, Any] | None:
+    penalty_candidates = [item for item in penalties if float(item.get("value") or 0.0) > 0.0]
+    bonus_candidates = [item for item in bonuses if float(item.get("value") or 0.0) > 0.0]
+    if penalty_candidates:
+        return max(penalty_candidates, key=lambda item: float(item.get("value") or 0.0))
+    if bonus_candidates:
+        return max(bonus_candidates, key=lambda item: float(item.get("value") or 0.0))
+    return None
+
+
+def _build_strikeout_confidence_payload(
+    probability_result: dict[str, Any],
+    probability_result_v2: dict[str, Any],
+) -> dict[str, Any]:
+    source = "strikeout_v2_shadow" if probability_result_v2.get("confidence_score_v2") is not None else "strikeout_v1_live"
+    if source == "strikeout_v2_shadow":
+        raw_score = probability_result_v2.get("confidence_score_raw_v2", probability_result_v2.get("confidence_score_v2"))
+        raw_bucket = probability_result_v2.get("confidence_bucket_v2")
+        reasons = list(probability_result_v2.get("confidence_reasons_v2") or [])
+        bonuses = _normalize_confidence_components(probability_result_v2.get("confidence_component_bonuses_v2"))
+        penalties = _normalize_confidence_components(probability_result_v2.get("confidence_component_penalties_v2"))
+    else:
+        raw_score = probability_result.get("confidence_score_raw", probability_result.get("confidence_score"))
+        raw_bucket = probability_result.get("confidence_bucket")
+        reasons = list(probability_result.get("confidence_reasons") or [])
+        bonuses = _normalize_confidence_components(probability_result.get("confidence_component_bonuses"))
+        penalties = _normalize_confidence_components(probability_result.get("confidence_component_penalties"))
+
+    raw_score_float = float(raw_score) if raw_score is not None else None
+    display_score = _confidence_display_remap(raw_score_float)
+    display_bucket = None
+    if display_score is not None:
+        if display_score >= 75:
+            display_bucket = "high"
+        elif display_score >= 55:
+            display_bucket = "medium"
+        else:
+            display_bucket = "low"
+    primary_driver = _select_confidence_primary_driver(penalties, bonuses)
+    summary_label = str((primary_driver or {}).get("label") or "").strip() or None
+
+    return {
+        "confidence_score_raw": round(raw_score_float, 1) if raw_score_float is not None else None,
+        "confidence_score_display": round(display_score, 1) if display_score is not None else None,
+        "confidence_source": source,
+        "confidence_component_bonuses": bonuses,
+        "confidence_component_penalties": penalties,
+        "confidence_primary_driver": primary_driver,
+        "confidence_summary_label": summary_label,
+        "confidence_bucket_raw": raw_bucket,
+        "confidence_bucket_display": display_bucket,
+        "confidence_reasons": reasons[:5],
+    }
+
+
 def _classify_hr_probability_status(
     *,
     threshold_int: int,
@@ -691,6 +791,7 @@ def map_hr_props_to_model(
                 "calibrated_hr_prob": probability_result.get("calibrated_hr_prob"),
                 "pregame_hr_prob": probability_result.get("pregame_hr_prob"),
                 "probability_mode": probability_result.get("mode"),
+                "formula_version": probability_result.get("formula_version"),
                 "is_modeled": is_modeled,
                 "threshold": threshold_int,
                 "confidence_score": probability_result.get("confidence_score"),
@@ -721,6 +822,23 @@ def map_hr_props_to_model(
                 "platoon_hr_adjustment": probability_result.get("platoon_hr_adjustment"),
                 "trajectory_hr_adjustment": probability_result.get("trajectory_hr_adjustment"),
                 "rolling_hr_adjustment": probability_result.get("rolling_hr_adjustment"),
+                "damage_zone_alignment_subscore": probability_result.get("damage_zone_alignment_subscore"),
+                "pitch_mix_exposure_subscore": probability_result.get("pitch_mix_exposure_subscore"),
+                "tunnel_damage_subscore": probability_result.get("tunnel_damage_subscore"),
+                "count_pattern_damage_subscore": probability_result.get("count_pattern_damage_subscore"),
+                "handedness_damage_subscore": probability_result.get("handedness_damage_subscore"),
+                "arsenal_fit_subscore": probability_result.get("arsenal_fit_subscore"),
+                "environment_amplification_subscore": probability_result.get("environment_amplification_subscore"),
+                "hr_opportunity_projection": probability_result.get("hr_opportunity_projection"),
+                "matchup_coverage_confidence": probability_result.get("matchup_coverage_confidence"),
+                "component_source_map": probability_result.get("component_source_map"),
+                "expected_pitch_mix_by_count": probability_result.get("expected_pitch_mix_by_count"),
+                "expected_zone_mix_by_count": probability_result.get("expected_zone_mix_by_count"),
+                "expected_pitch_zone_mix_by_count": probability_result.get("expected_pitch_zone_mix_by_count"),
+                "tunnel_pair_scores": probability_result.get("tunnel_pair_scores"),
+                "predicted_attack_regions": probability_result.get("predicted_attack_regions"),
+                "predicted_damage_regions": probability_result.get("predicted_damage_regions"),
+                "predicted_whiff_regions": probability_result.get("predicted_whiff_regions"),
                 "pitcher_reliability": probability_result.get("pitcher_reliability"),
                 "trend_reliability": probability_result.get("trend_reliability"),
                 "zone_reliability": probability_result.get("zone_reliability"),
@@ -850,6 +968,20 @@ def map_strikeout_props_to_model(
             selection_side=selection_side,
             game_row=_build_game_context_from_row(row),
         )
+        probability_result_v2 = build_strikeout_probability_result_v2(
+            pitcher_statcast_df=pitcher_df,
+            pitcher_name=pitcher_name,
+            batter_statcast_df=batter_statcast_df,
+            opponent_batters=opponent_batters,
+            opponent_team=opponent_team,
+            line=float(line) if line is not None and str(line).strip() not in {"", "nan", "None"} else None,
+            selection_side=selection_side,
+            game_row=_build_game_context_from_row(row),
+        )
+        confidence_payload = _build_strikeout_confidence_payload(
+            probability_result=probability_result,
+            probability_result_v2=probability_result_v2,
+        )
 
         fair_prob = probability_result.get("fair_prob")
         if fair_prob is not None and implied is not None:
@@ -873,10 +1005,66 @@ def map_strikeout_props_to_model(
                 "model_k_prob": fair_prob,
                 "bet_ev": bet_ev,
                 "edge": edge,
-                "confidence_score": probability_result.get("confidence_score"),
-                "confidence_bucket": probability_result.get("confidence_bucket"),
-                "confidence_reasons": probability_result.get("confidence_reasons"),
+                "confidence_score": confidence_payload.get("confidence_score_display"),
+                "confidence_bucket": confidence_payload.get("confidence_bucket_display"),
+                "confidence_reasons": confidence_payload.get("confidence_reasons"),
+                "confidence_score_raw": confidence_payload.get("confidence_score_raw"),
+                "confidence_score_display": confidence_payload.get("confidence_score_display"),
+                "confidence_source": confidence_payload.get("confidence_source"),
+                "confidence_component_bonuses": confidence_payload.get("confidence_component_bonuses"),
+                "confidence_component_penalties": confidence_payload.get("confidence_component_penalties"),
+                "confidence_primary_driver": confidence_payload.get("confidence_primary_driver"),
+                "confidence_summary_label": confidence_payload.get("confidence_summary_label"),
+                "confidence_bucket_raw": confidence_payload.get("confidence_bucket_raw"),
+                "confidence_bucket_display": confidence_payload.get("confidence_bucket_display"),
+                "confidence_score_v1": probability_result.get("confidence_score"),
+                "confidence_bucket_v1": probability_result.get("confidence_bucket"),
+                "confidence_score_raw_v1": probability_result.get("confidence_score_raw", probability_result.get("confidence_score")),
                 "expected_strikeouts": probability_result.get("expected_strikeouts"),
+                "expected_strikeouts_v2": probability_result_v2.get("expected_strikeouts_v2"),
+                "projected_pitch_count": probability_result_v2.get("projected_pitch_count"),
+                "projected_batters_faced": probability_result_v2.get("projected_batters_faced"),
+                "projected_innings": probability_result_v2.get("projected_innings"),
+                "projected_k_rate": probability_result_v2.get("projected_k_rate"),
+                "fair_prob_v2": probability_result_v2.get("fair_prob_v2"),
+                "raw_k_prob_v2": probability_result_v2.get("raw_k_prob_v2"),
+                "calibrated_k_prob_v2": probability_result_v2.get("calibrated_k_prob_v2"),
+                "confidence_score_v2": probability_result_v2.get("confidence_score_v2"),
+                "confidence_score_raw_v2": probability_result_v2.get("confidence_score_raw_v2"),
+                "confidence_score_display_v2": probability_result_v2.get("confidence_score_display_v2"),
+                "confidence_source_v2": probability_result_v2.get("confidence_source_v2"),
+                "confidence_bucket_v2": probability_result_v2.get("confidence_bucket_v2"),
+                "confidence_reasons_v2": probability_result_v2.get("confidence_reasons_v2"),
+                "confidence_component_bonuses_v2": probability_result_v2.get("confidence_component_bonuses_v2"),
+                "confidence_component_penalties_v2": probability_result_v2.get("confidence_component_penalties_v2"),
+                "confidence_primary_driver_v2": probability_result_v2.get("confidence_primary_driver_v2"),
+                "confidence_summary_label_v2": probability_result_v2.get("confidence_summary_label_v2"),
+                "k_rate_pitch_signal": probability_result_v2.get("k_rate_pitch_signal"),
+                "k_rate_anchor": probability_result_v2.get("k_rate_anchor"),
+                "bb_rate_anchor": probability_result_v2.get("bb_rate_anchor"),
+                "command_efficiency_signal": probability_result_v2.get("command_efficiency_signal"),
+                "swing_miss_subscore": probability_result_v2.get("swing_miss_subscore"),
+                "called_strike_subscore": probability_result_v2.get("called_strike_subscore"),
+                "command_efficiency_subscore": probability_result_v2.get("command_efficiency_subscore"),
+                "lineup_whiff_subscore": probability_result_v2.get("lineup_whiff_subscore"),
+                "zone_matchup_subscore": probability_result_v2.get("zone_matchup_subscore"),
+                "family_zone_matchup_subscore": probability_result_v2.get("family_zone_matchup_subscore"),
+                "arsenal_fit_subscore": probability_result_v2.get("arsenal_fit_subscore"),
+                "tunneling_subscore": probability_result_v2.get("tunneling_subscore"),
+                "release_consistency_subscore": probability_result_v2.get("release_consistency_subscore"),
+                "sequencing_subscore": probability_result_v2.get("sequencing_subscore"),
+                "count_leverage_subscore": probability_result_v2.get("count_leverage_subscore"),
+                "leash_risk_subscore": probability_result_v2.get("leash_risk_subscore"),
+                "times_through_order_penalty": probability_result_v2.get("times_through_order_penalty"),
+                "variance_band_low": probability_result_v2.get("variance_band_low"),
+                "variance_band_high": probability_result_v2.get("variance_band_high"),
+                "matchup_coverage_confidence": probability_result_v2.get("matchup_coverage_confidence"),
+                "component_source_map": probability_result_v2.get("component_source_map"),
+                "predicted_whiff_regions": probability_result_v2.get("predicted_whiff_regions"),
+                "predicted_attack_regions": probability_result_v2.get("predicted_attack_regions"),
+                "predicted_damage_regions": probability_result_v2.get("predicted_damage_regions"),
+                "tunnel_pair_scores": probability_result_v2.get("tunnel_pair_scores"),
+                "formula_version": probability_result_v2.get("formula_version"),
                 "pitcher_swstr_rate": probability_result.get("pitcher_swstr_rate"),
                 "pitcher_csw_rate": probability_result.get("pitcher_csw_rate"),
                 "pitcher_ball_rate": probability_result.get("pitcher_ball_rate"),

models/hr_probability_engine.py

@@ -14,6 +14,7 @@ from models.rolling_form_model import (
     build_pitcher_rolling_form_row,
     compute_upcoming_rolling_adjustment,
 )
+from models.shared_matchup_engine import compose_shared_matchup_context
 from models.trajectory_model import build_trajectory_features, compute_trajectory_adjustment
 
 
@@ -46,6 +47,7 @@ def _empty_result(player_name: str, mode: str) -> dict[str, Any]:
         "player_name": player_name,
         "pitcher_name": "",
         "mode": mode,
+        "formula_version": "hr_v1_shared_matchup",
         "baseline_hr_prob": None,
         "adjusted_hr_prob": None,
         "raw_hr_prob": None,
@@ -103,6 +105,23 @@ def _empty_result(player_name: str, mode: str) -> dict[str, Any]:
         "trajectory_reliability": 0.0,
         "rolling_reliability": 0.0,
         "opportunity_reliability": 0.0,
+        "damage_zone_alignment_subscore": None,
+        "pitch_mix_exposure_subscore": None,
+        "tunnel_damage_subscore": None,
+        "count_pattern_damage_subscore": None,
+        "handedness_damage_subscore": None,
+        "arsenal_fit_subscore": None,
+        "environment_amplification_subscore": None,
+        "hr_opportunity_projection": None,
+        "matchup_coverage_confidence": None,
+        "component_source_map": {},
+        "expected_pitch_mix_by_count": {},
+        "expected_zone_mix_by_count": {},
+        "expected_pitch_zone_mix_by_count": {},
+        "tunnel_pair_scores": [],
+        "predicted_attack_regions": [],
+        "predicted_damage_regions": [],
+        "predicted_whiff_regions": [],
         "model_voice_reason_candidates": [],
         "model_voice_tags": [],
         "reason_candidate_count": 0,
@@ -451,6 +470,24 @@ def build_hr_probability_result(
             _sample_reliability(batter_pa, 180.0),
             _sample_reliability(pitcher_row.get("sample_size"), 180.0),
         )
+        shared_matchup = compose_shared_matchup_context(
+            batter_name=batter_name,
+            pitcher_name=result["pitcher_name"],
+            batter_statcast_df=batter_df,
+            pitcher_statcast_df=pitcher_df,
+            batter_features=batter_features,
+            pitcher_row=pitcher_row,
+            game_row=game_row,
+        )
+        result["expected_pitch_mix_by_count"] = shared_matchup.get("expected_pitch_mix_by_count") or {}
+        result["expected_zone_mix_by_count"] = shared_matchup.get("expected_zone_mix_by_count") or {}
+        result["expected_pitch_zone_mix_by_count"] = shared_matchup.get("expected_pitch_zone_mix_by_count") or {}
+        result["tunnel_pair_scores"] = shared_matchup.get("tunnel_pair_scores") or []
+        result["predicted_attack_regions"] = shared_matchup.get("predicted_attack_regions") or []
+        result["predicted_damage_regions"] = shared_matchup.get("predicted_damage_regions") or []
+        result["predicted_whiff_regions"] = shared_matchup.get("predicted_whiff_regions") or []
+        result["matchup_coverage_confidence"] = shared_matchup.get("matchup_coverage_confidence")
+        result["component_source_map"] = shared_matchup.get("component_source_map") or {}
         zone_eff = 0.0
         batter_zone_row: dict[str, Any] = {}
         pitcher_zone_row: dict[str, Any] = {}
@@ -515,6 +552,7 @@ def build_hr_probability_result(
             "missing_pitcher_zone_profile" if int(_safe_float(pitcher_zone_row.get("zone_sample_size"), 0.0) or 0.0) <= 0 else
             "available_zero_effect"
         )
+        result["damage_zone_alignment_subscore"] = round(_safe_float(zone_matchup_adj.get("hr_zone_boost"), 0.0), 4) if "zone_matchup_adj" in locals() else 0.0
         result["family_zone_status"] = (
             "applied" if abs(result["family_zone_hr_adjustment"]) > 1e-6 else
             "missing_batter_family_zone_profile" if int(_safe_float(batter_family_zone_row.get("family_zone_sample_size"), 0.0) or 0.0) <= 0 else
@@ -573,6 +611,15 @@ def build_hr_probability_result(
             "missing_pitcher_arsenal_profile" if int(_safe_float(pitcher_arsenal_row.get("arsenal_sample_size"), 0.0) or 0.0) <= 0 else
             "available_zero_effect"
         )
+        result["pitch_mix_exposure_subscore"] = round(
+            _safe_float(shared_matchup.get("arsenal_matchup", {}).get("arsenal_hr_boost"), 0.0),
+            4,
+        )
+        result["count_pattern_damage_subscore"] = round(
+            sum(float(item.get("score") or 0.0) for item in (result["predicted_damage_regions"] or [])[:3]),
+            4,
+        )
+        result["arsenal_fit_subscore"] = round(_safe_float(arsenal_matchup_adj.get("arsenal_hr_boost"), 0.0), 4) if "arsenal_matchup_adj" in locals() else 0.0
         hr_prob = _clamp(hr_prob + result["arsenal_hr_adjustment"], 0.005, 0.25)
         if abs(result["arsenal_hr_adjustment"]) > 1e-6:
             applied_layers.append("arsenal")
@@ -585,6 +632,7 @@ def build_hr_probability_result(
             )
 
         result["platoon_hr_adjustment"] = platoon_adj
+        result["handedness_damage_subscore"] = round(_safe_float(platoon_adj, 0.0), 4)
         hr_prob = _clamp(hr_prob + platoon_adj, 0.005, 0.25)
         if abs(platoon_adj) > 1e-6:
             applied_layers.append("platoon")
@@ -659,6 +707,7 @@ def build_hr_probability_result(
         _safe_float(traj_adj.get("hr_adj")),
         result["trajectory_reliability"],
     )
+    result["tunnel_damage_subscore"] = round(_safe_float(trajectory_row.get("tunnel_score"), 0.0), 4)
     hr_prob = _clamp(hr_prob + result["trajectory_hr_adjustment"], 0.005, 0.25)
     if abs(result["trajectory_hr_adjustment"]) > 1e-6:
         applied_layers.append("trajectory")
@@ -731,6 +780,7 @@ def build_hr_probability_result(
     result["pa_multiplier"] = opportunity.get("pa_multiplier")
     result["opportunity_mode"] = opportunity.get("opportunity_mode")
     result["opportunity_reason"] = opportunity.get("opportunity_reason")
+    result["hr_opportunity_projection"] = round(_safe_float(opportunity.get("expected_pa"), 0.0), 3)
     if lineup_slot is not None and team_total is not None:
         result["opportunity_reliability"] = 1.0 if result["lineup_slot_source"] == "confirmed" else 0.82
     elif lineup_slot is not None:
@@ -765,6 +815,7 @@ def build_hr_probability_result(
         raw_prob=hr_prob,
         baseline_prob=result.get("baseline_hr_prob"),
     )
+    result["environment_amplification_subscore"] = round(_safe_float(result["env_hr_adjustment"], 0.0), 4)
     if mode == "pregame":
         result["pregame_hr_prob"] = result["calibrated_hr_prob"]
     else:

models/shared_matchup_engine.py

@@ -0,0 +1,267 @@
+from __future__ import annotations
+
+from typing import Any
+
+import pandas as pd
+
+from models.arsenal_matchup_model import compute_arsenal_matchup_adjustment
+from models.batter_arsenal_model import build_batter_arsenal_feature_row
+from models.batter_zone_model import build_batter_zone_feature_row
+from models.family_zone_profile_store import (
+    build_batter_family_zone_feature_row,
+    build_pitcher_family_zone_feature_row,
+)
+from models.matchup_model import compute_family_zone_matchup_adjustment
+from models.pitch_sequence_model import build_sequence_features, predict_next_pitch_distribution
+from models.pitcher_arsenal_model import build_pitcher_arsenal_feature_row
+from models.pitcher_zone_model import build_pitcher_zone_feature_row
+from models.trajectory_model import build_trajectory_features
+from models.zone_matchup_model import compute_zone_matchup_adjustment
+
+_COUNT_STATES: tuple[tuple[int, int], ...] = (
+    (0, 0),
+    (1, 0),
+    (0, 1),
+    (1, 1),
+    (0, 2),
+    (1, 2),
+    (2, 2),
+    (3, 2),
+)
+_PITCH_FAMILIES: tuple[str, ...] = ("fastball", "breaking", "offspeed")
+_ZONES: tuple[str, ...] = ("heart", "shadow", "chase", "waste")
+
+
+def _safe_float(value: Any, default: float = 0.0) -> float:
+    try:
+        if value is None:
+            return default
+        text = str(value).strip().lower()
+        if text in {"", "nan", "none"}:
+            return default
+        return float(value)
+    except Exception:
+        return default
+
+
+def _clamp(value: float, lo: float, hi: float) -> float:
+    return max(lo, min(hi, value))
+
+
+def _reliability(sample_size: Any, k: float) -> float:
+    sample = max(0.0, _safe_float(sample_size, 0.0))
+    return _clamp(sample / (sample + max(1.0, float(k))), 0.0, 1.0)
+
+
+def _component_source_map() -> dict[str, dict[str, str]]:
+    return {
+        "zone_matchup": {"classification": "reuse_as_is", "source_module": "models.zone_matchup_model"},
+        "family_zone_matchup": {"classification": "reuse_as_is", "source_module": "models.matchup_model"},
+        "arsenal_matchup": {"classification": "reuse_as_is", "source_module": "models.arsenal_matchup_model"},
+        "trajectory": {"classification": "reuse_as_is", "source_module": "models.trajectory_model"},
+        "sequencing": {"classification": "upgrade_existing_module", "source_module": "models.pitch_sequence_model"},
+        "count_context": {"classification": "upgrade_existing_module", "source_module": "models.pitch_sequence_model"},
+        "shared_composer": {"classification": "new_source_of_truth_component", "source_module": "models.shared_matchup_engine"},
+    }
+
+
+def _build_pitch_zone_mix(
+    sequence_profiles: dict[str, dict[str, Any]],
+) -> dict[str, float]:
+    combined: dict[str, float] = {}
+    if not sequence_profiles:
+        return combined
+
+    count_weight = 1.0 / float(len(sequence_profiles))
+    for payload in sequence_profiles.values():
+        fb = _safe_float(payload.get("fastball_prob"))
+        br = _safe_float(payload.get("breaking_prob"))
+        os = _safe_float(payload.get("offspeed_prob"))
+        zone_probs = payload.get("zone_probs", {}) or {}
+        family_probs = {
+            "fastball": fb,
+            "breaking": br,
+            "offspeed": os,
+        }
+        for family, family_prob in family_probs.items():
+            for zone in _ZONES:
+                zone_prob = _safe_float(zone_probs.get(zone))
+                combined[f"{family}_{zone}"] = combined.get(f"{family}_{zone}", 0.0) + (
+                    family_prob * zone_prob * count_weight
+                )
+
+    total = sum(combined.values())
+    if total > 0:
+        for key in list(combined.keys()):
+            combined[key] = combined[key] / total
+    return combined
+
+
+def _top_regions(weighted_map: dict[str, float], limit: int = 4) -> list[dict[str, Any]]:
+    rows = [
+        {"region": key, "score": round(float(val), 6)}
+        for key, val in weighted_map.items()
+        if float(val) > 0
+    ]
+    rows.sort(key=lambda item: item["score"], reverse=True)
+    return rows[:limit]
+
+
+def compose_shared_matchup_context(
+    *,
+    batter_name: str,
+    pitcher_name: str,
+    batter_statcast_df: pd.DataFrame | None,
+    pitcher_statcast_df: pd.DataFrame | None,
+    batter_features: dict[str, Any] | None = None,
+    pitcher_row: dict[str, Any] | None = None,
+    game_row: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    empty = {
+        "expected_pitch_mix_by_count": {},
+        "expected_zone_mix_by_count": {},
+        "expected_pitch_zone_mix_by_count": {},
+        "tunnel_pair_scores": [],
+        "predicted_attack_regions": [],
+        "predicted_damage_regions": [],
+        "predicted_whiff_regions": [],
+        "handedness_context": {},
+        "count_context_profile": {},
+        "matchup_coverage_confidence": 0.0,
+        "component_source_map": _component_source_map(),
+        "zone_matchup": {},
+        "family_zone_matchup": {},
+        "arsenal_matchup": {},
+        "trajectory": {},
+        "sequence_profiles": {},
+    }
+
+    batter_df = batter_statcast_df if batter_statcast_df is not None else pd.DataFrame()
+    pitcher_df = pitcher_statcast_df if pitcher_statcast_df is not None else batter_df
+    if batter_df.empty or pitcher_df.empty or not batter_name or not pitcher_name:
+        return empty
+
+    batter_features = dict(batter_features or {})
+    pitcher_row = dict(pitcher_row or {})
+    game_row = dict(game_row or {})
+
+    batter_zone_row = build_batter_zone_feature_row(batter_df, batter_name)
+    pitcher_zone_row = build_pitcher_zone_feature_row(pitcher_df, pitcher_name)
+    zone_matchup = compute_zone_matchup_adjustment(batter_zone_row, pitcher_zone_row)
+
+    batter_family_zone_row = build_batter_family_zone_feature_row(batter_df, batter_name)
+    pitcher_family_zone_row = build_pitcher_family_zone_feature_row(pitcher_df, pitcher_name)
+    family_zone_matchup = compute_family_zone_matchup_adjustment(
+        batter_family_zone_row=batter_family_zone_row,
+        pitcher_family_zone_row=pitcher_family_zone_row,
+    )
+
+    batter_arsenal_row = build_batter_arsenal_feature_row(batter_df, batter_name)
+    pitcher_arsenal_row = build_pitcher_arsenal_feature_row(pitcher_df, pitcher_name)
+    arsenal_matchup = compute_arsenal_matchup_adjustment(
+        batter_arsenal_row=batter_arsenal_row,
+        pitcher_arsenal_row=pitcher_arsenal_row,
+    )
+
+    trajectory = build_trajectory_features(
+        statcast_df=pitcher_df,
+        pitcher_name=pitcher_name,
+        pitcher_id=game_row.get("pitcher_id"),
+    )
+
+    handedness_context = {
+        "batter_stand": str(batter_features.get("batter_stand", "") or "").strip().upper(),
+        "pitcher_hand": str(pitcher_row.get("p_throws", "") or "").strip().upper(),
+    }
+
+    count_context_profile: dict[str, dict[str, Any]] = {}
+    expected_pitch_mix_by_count: dict[str, dict[str, float]] = {}
+    expected_zone_mix_by_count: dict[str, dict[str, float]] = {}
+    sequence_profiles: dict[str, dict[str, Any]] = {}
+    for balls, strikes in _COUNT_STATES:
+        count_key = f"{balls}-{strikes}"
+        seq_features = build_sequence_features(
+            game_row={**game_row, "balls": balls, "strikes": strikes},
+            pitcher_row=pitcher_row,
+            batter_row=batter_features,
+            pitcher_family_zone_row=pitcher_family_zone_row,
+        )
+        seq_profile = predict_next_pitch_distribution(seq_features)
+        sequence_profiles[count_key] = seq_profile
+        expected_pitch_mix_by_count[count_key] = {
+            family: round(_safe_float(seq_profile.get(f"{family}_prob")), 6)
+            for family in _PITCH_FAMILIES
+        }
+        expected_zone_mix_by_count[count_key] = {
+            zone: round(_safe_float((seq_profile.get("zone_probs") or {}).get(zone)), 6)
+            for zone in _ZONES
+        }
+        leverage = "neutral"
+        if strikes >= 2:
+            leverage = "putaway"
+        elif balls >= 2:
+            leverage = "hitter_ahead"
+        count_context_profile[count_key] = {
+            "balls": balls,
+            "strikes": strikes,
+            "count_leverage": leverage,
+        }
+
+    expected_pitch_zone_mix_by_count = _build_pitch_zone_mix(sequence_profiles)
+
+    attack_regions = _top_regions(expected_pitch_zone_mix_by_count, limit=5)
+
+    damage_region_map: dict[str, float] = {}
+    whiff_region_map: dict[str, float] = {}
+    for key, attack_weight in expected_pitch_zone_mix_by_count.items():
+        try:
+            family, zone = key.split("_", 1)
+        except ValueError:
+            continue
+        batter_damage = _safe_float(batter_family_zone_row.get(f"damage_rate_{family}_{zone}"))
+        pitcher_damage = _safe_float(pitcher_family_zone_row.get(f"damage_allowed_rate_{family}_{zone}"))
+        batter_whiff = _safe_float(batter_family_zone_row.get(f"whiff_rate_{family}_{zone}"))
+        pitcher_whiff = _safe_float(pitcher_family_zone_row.get(f"whiff_rate_{family}_{zone}"))
+        damage_region_map[key] = attack_weight * ((batter_damage * 0.6) + (pitcher_damage * 0.4))
+        whiff_region_map[key] = attack_weight * ((batter_whiff * 0.55) + (pitcher_whiff * 0.45))
+
+    tunnel_score = _safe_float(trajectory.get("tunnel_score"))
+    release_score = _safe_float(trajectory.get("release_consistency_score"))
+    tunnel_pair_scores = [
+        {
+            "pair": "arsenal_tunnel_profile",
+            "tunnel_score": round(tunnel_score, 6),
+            "release_consistency_score": round(release_score, 6),
+            "deception_score": round(_safe_float(trajectory.get("deception_score")), 6),
+        }
+    ] if (tunnel_score or release_score) else []
+
+    coverage_signals = [
+        _reliability(batter_zone_row.get("zone_sample_size"), 200.0),
+        _reliability(pitcher_zone_row.get("zone_sample_size"), 200.0),
+        _reliability(batter_family_zone_row.get("family_zone_sample_size"), 220.0),
+        _reliability(pitcher_family_zone_row.get("family_zone_sample_size"), 220.0),
+        _reliability(batter_arsenal_row.get("arsenal_sample_size"), 180.0),
+        _reliability(pitcher_arsenal_row.get("arsenal_sample_size"), 180.0),
+        _reliability(trajectory.get("trajectory_sample_size"), 240.0),
+    ]
+    matchup_coverage_confidence = round(sum(coverage_signals) / len(coverage_signals), 4)
+
+    return {
+        "expected_pitch_mix_by_count": expected_pitch_mix_by_count,
+        "expected_zone_mix_by_count": expected_zone_mix_by_count,
+        "expected_pitch_zone_mix_by_count": expected_pitch_zone_mix_by_count,
+        "tunnel_pair_scores": tunnel_pair_scores,
+        "predicted_attack_regions": attack_regions,
+        "predicted_damage_regions": _top_regions(damage_region_map, limit=5),
+        "predicted_whiff_regions": _top_regions(whiff_region_map, limit=5),
+        "handedness_context": handedness_context,
+        "count_context_profile": count_context_profile,
+        "matchup_coverage_confidence": matchup_coverage_confidence,
+        "component_source_map": _component_source_map(),
+        "zone_matchup": zone_matchup,
+        "family_zone_matchup": family_zone_matchup,
+        "arsenal_matchup": arsenal_matchup,
+        "trajectory": trajectory,
+        "sequence_profiles": sequence_profiles,
+    }

models/strikeout_probability_engine.py

@@ -68,6 +68,14 @@ def _bucket(score: float) -> str:
     return "low"
 
 
+def _confidence_component(label: str, value: float, direction: str) -> dict[str, Any]:
+    return {
+        "label": label,
+        "value": round(float(value), 1),
+        "direction": direction,
+    }
+
+
 def _normalize_name(value: Any) -> str:
     return " ".join(str(value or "").strip().lower().split())
 
@@ -225,8 +233,15 @@ def build_strikeout_probability_result(
         "trajectory_release_consistency_score": None,
         "sequencing_score": None,
         "confidence_score": None,
+        "confidence_score_raw": None,
+        "confidence_score_display": None,
+        "confidence_source": "strikeout_v1_live",
         "confidence_bucket": None,
         "confidence_reasons": [],
+        "confidence_component_bonuses": [],
+        "confidence_component_penalties": [],
+        "confidence_primary_driver": None,
+        "confidence_summary_label": None,
         "applied_layers": "",
         "skipped_layers": "",
         "reason_tags_for": [],
@@ -380,27 +395,52 @@ def build_strikeout_probability_result(
 
     confidence = 52.0
     confidence_reasons: list[str] = []
+    confidence_component_bonuses: list[dict[str, Any]] = []
+    confidence_component_penalties: list[dict[str, Any]] = []
     if sample_size >= 400:
         confidence += 10
+        confidence_component_bonuses.append(_confidence_component("Strong pitcher sample", 10, "bonus"))
     elif sample_size < 150:
         confidence -= 12
         confidence_reasons.append("Limited pitcher pitch sample")
+        confidence_component_penalties.append(_confidence_component("Limited pitcher pitch sample", 12, "penalty"))
     if opponent_overlay.get("lineup_sample_size", 0) >= 7:
         confidence += 8
+        confidence_component_bonuses.append(_confidence_component("Projected lineup mostly complete", 8, "bonus"))
     else:
         confidence -= 6
         confidence_reasons.append("Projected opponent lineup is incomplete")
+        confidence_component_penalties.append(_confidence_component("Projected opponent lineup is incomplete", 6, "penalty"))
     if traj_reliability >= 0.45:
         confidence += 5
+        confidence_component_bonuses.append(_confidence_component("Strong telemetry coverage", 5, "bonus"))
     else:
         confidence_reasons.append("Trajectory/tunneling sample is thin")
+        confidence_component_penalties.append(_confidence_component("Trajectory/tunneling sample is thin", 0, "penalty"))
     if seq_reliability >= 0.40:
         confidence += 4
+        confidence_component_bonuses.append(_confidence_component("Sequencing sample is stable", 4, "bonus"))
     else:
         confidence_reasons.append("Sequencing signal is still noisy")
+        confidence_component_penalties.append(_confidence_component("Sequencing signal is still noisy", 0, "penalty"))
     if abs(calibrated_prob - 0.50) > 0.28:
         confidence -= 5
         confidence_reasons.append("Fair probability is still high-variance")
+        confidence_component_penalties.append(_confidence_component("Fair probability is still high-variance", 5, "penalty"))
+
+    confidence_raw = _clamp(confidence, 1.0, 100.0)
+    primary_penalty = max(
+        [item for item in confidence_component_penalties if float(item.get("value") or 0.0) > 0.0],
+        key=lambda item: float(item.get("value") or 0.0),
+        default=None,
+    )
+    primary_bonus = max(
+        [item for item in confidence_component_bonuses if float(item.get("value") or 0.0) > 0.0],
+        key=lambda item: float(item.get("value") or 0.0),
+        default=None,
+    )
+    primary_driver = primary_penalty or primary_bonus
+    summary_label = str((primary_driver or {}).get("label") or "").strip() or None
 
     result.update(
         {
@@ -417,9 +457,15 @@ def build_strikeout_probability_result(
             "trajectory_tunnel_score": tunnel,
             "trajectory_release_consistency_score": release_consistency,
             "sequencing_score": sequencing_score,
-            "confidence_score": _clamp(confidence, 1.0, 100.0),
-            "confidence_bucket": _bucket(_clamp(confidence, 1.0, 100.0)),
+            "confidence_score": confidence_raw,
+            "confidence_score_raw": confidence_raw,
+            "confidence_score_display": confidence_raw,
+            "confidence_bucket": _bucket(confidence_raw),
             "confidence_reasons": confidence_reasons[:5],
+            "confidence_component_bonuses": confidence_component_bonuses,
+            "confidence_component_penalties": confidence_component_penalties,
+            "confidence_primary_driver": primary_driver,
+            "confidence_summary_label": summary_label,
             "applied_layers": "|".join(applied_layers),
             "reason_tags_for": reasons_for[:4],
             "reason_tags_against": reasons_against[:4],

models/strikeout_probability_engine_v2.py

@@ -0,0 +1,363 @@
+from __future__ import annotations
+
+import math
+from typing import Any
+
+import pandas as pd
+
+from models.pitcher_adjustment import build_pitcher_feature_row
+from models.shared_matchup_engine import compose_shared_matchup_context
+
+
+def _safe_float(value: Any, default: float | None = None) -> float | None:
+    try:
+        if value is None:
+            return default
+        text = str(value).strip().lower()
+        if text in {"", "nan", "none"}:
+            return default
+        return float(value)
+    except Exception:
+        return default
+
+
+def _clamp(value: float, lo: float, hi: float) -> float:
+    return max(lo, min(hi, value))
+
+
+def _reliability(sample_size: Any, k: float = 120.0) -> float:
+    sample = max(0.0, float(_safe_float(sample_size, 0.0) or 0.0))
+    return _clamp(sample / (sample + max(1.0, k)), 0.0, 1.0)
+
+
+def _confidence_component(label: str, value: float, direction: str) -> dict[str, Any]:
+    return {
+        "label": label,
+        "value": round(float(value), 1),
+        "direction": direction,
+    }
+
+
+def _poisson_prob_over(expected_value: float, line: float) -> float:
+    if expected_value <= 0:
+        return 0.0
+    target = int(math.floor(line))
+    cumulative = 0.0
+    for k in range(0, target + 1):
+        cumulative += math.exp(-expected_value) * (expected_value ** k) / math.factorial(k)
+    return _clamp(1.0 - cumulative, 0.0, 1.0)
+
+
+def _poisson_prob_under(expected_value: float, line: float) -> float:
+    return _clamp(1.0 - _poisson_prob_over(expected_value, line), 0.0, 1.0)
+
+
+def _calibrate(probability: float) -> float:
+    centered = probability - 0.50
+    return _clamp(0.50 + (centered * 0.92), 0.02, 0.98)
+
+
+def build_strikeout_probability_result_v2(
+    pitcher_statcast_df: pd.DataFrame,
+    pitcher_name: str,
+    batter_statcast_df: pd.DataFrame | None = None,
+    opponent_batters: list[str] | None = None,
+    opponent_team: str | None = None,
+    line: float | None = None,
+    selection_side: str | None = None,
+    game_row: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    result: dict[str, Any] = {
+        "formula_version": "strikeout_v2_shadow",
+        "raw_k_prob_v2": None,
+        "calibrated_k_prob_v2": None,
+        "fair_prob_v2": None,
+        "expected_strikeouts_v2": None,
+        "projected_pitch_count": None,
+        "projected_batters_faced": None,
+        "projected_innings": None,
+        "projected_k_rate": None,
+        "k_rate_pitch_signal": None,
+        "k_rate_anchor": None,
+        "bb_rate_anchor": None,
+        "command_efficiency_signal": None,
+        "swing_miss_subscore": None,
+        "called_strike_subscore": None,
+        "command_efficiency_subscore": None,
+        "lineup_whiff_subscore": None,
+        "zone_matchup_subscore": None,
+        "family_zone_matchup_subscore": None,
+        "arsenal_fit_subscore": None,
+        "tunneling_subscore": None,
+        "release_consistency_subscore": None,
+        "sequencing_subscore": None,
+        "count_leverage_subscore": None,
+        "leash_risk_subscore": None,
+        "times_through_order_penalty": None,
+        "variance_band_low": None,
+        "variance_band_high": None,
+        "matchup_coverage_confidence": None,
+        "component_source_map": {},
+        "predicted_whiff_regions": [],
+        "predicted_attack_regions": [],
+        "predicted_damage_regions": [],
+        "tunnel_pair_scores": [],
+        "applied_layers_v2": "",
+        "skipped_layers_v2": "",
+        "confidence_score_v2": None,
+        "confidence_score_raw_v2": None,
+        "confidence_score_display_v2": None,
+        "confidence_source_v2": "strikeout_v2_shadow",
+        "confidence_bucket_v2": None,
+        "confidence_reasons_v2": [],
+        "confidence_component_bonuses_v2": [],
+        "confidence_component_penalties_v2": [],
+        "confidence_primary_driver_v2": None,
+        "confidence_summary_label_v2": None,
+    }
+
+    if (
+        pitcher_statcast_df is None
+        or pitcher_statcast_df.empty
+        or not pitcher_name
+        or line is None
+        or selection_side not in {"over", "under"}
+    ):
+        result["skipped_layers_v2"] = "missing_pitcher_or_line"
+        return result
+
+    pitcher_row = build_pitcher_feature_row(pitcher_statcast_df, pitcher_name)
+    sample_size = int(pitcher_row.get("sample_size") or 0)
+    reliability = _reliability(sample_size, k=180.0)
+    swstr = _safe_float(pitcher_row.get("swstr_rate"))
+    csw = _safe_float(pitcher_row.get("csw_rate"))
+    ball = _safe_float(pitcher_row.get("ball_rate"))
+
+    strike_anchor = None
+    walk_anchor = None
+    if swstr is not None:
+        strike_anchor = _clamp(0.12 + ((swstr - 0.11) * 1.15), 0.12, 0.42)
+    if ball is not None:
+        walk_anchor = _clamp(0.05 + ((ball - 0.36) * 0.75), 0.02, 0.14)
+
+    matchup_rows: list[dict[str, Any]] = []
+    if batter_statcast_df is not None and not batter_statcast_df.empty and opponent_batters:
+        for batter_name in opponent_batters[:9]:
+            matchup_rows.append(
+                compose_shared_matchup_context(
+                    batter_name=batter_name,
+                    pitcher_name=pitcher_name,
+                    batter_statcast_df=batter_statcast_df,
+                    pitcher_statcast_df=pitcher_statcast_df,
+                    pitcher_row=pitcher_row,
+                    game_row=game_row,
+                    batter_features={"batter_stand": "L"},
+                )
+            )
+
+    if matchup_rows:
+        def _avg(path: tuple[str, ...], default: float = 0.0) -> float:
+            vals: list[float] = []
+            for row in matchup_rows:
+                cur: Any = row
+                for key in path:
+                    if not isinstance(cur, dict):
+                        cur = default
+                        break
+                    cur = cur.get(key)
+                if cur is not None:
+                    vals.append(float(_safe_float(cur, default) or default))
+            return sum(vals) / len(vals) if vals else default
+
+        matchup = {
+            "predicted_whiff_regions": matchup_rows[0].get("predicted_whiff_regions") or [],
+            "predicted_attack_regions": matchup_rows[0].get("predicted_attack_regions") or [],
+            "predicted_damage_regions": matchup_rows[0].get("predicted_damage_regions") or [],
+            "tunnel_pair_scores": matchup_rows[0].get("tunnel_pair_scores") or [],
+            "matchup_coverage_confidence": _avg(("matchup_coverage_confidence",), 0.0),
+            "component_source_map": matchup_rows[0].get("component_source_map") or {},
+            "zone_matchup": {"hit_zone_boost": _avg(("zone_matchup", "hit_zone_boost"), 0.0)},
+            "family_zone_matchup": {"family_zone_whiff_risk": _avg(("family_zone_matchup", "family_zone_whiff_risk"), 0.0)},
+            "arsenal_matchup": {"arsenal_whiff_risk": _avg(("arsenal_matchup", "arsenal_whiff_risk"), 0.0)},
+            "trajectory": matchup_rows[0].get("trajectory") or {},
+            "count_context_profile": matchup_rows[0].get("count_context_profile") or {},
+        }
+    else:
+        matchup = {
+        "predicted_whiff_regions": [],
+        "predicted_attack_regions": [],
+        "predicted_damage_regions": [],
+        "tunnel_pair_scores": [],
+        "matchup_coverage_confidence": 0.0,
+        "component_source_map": {},
+        "zone_matchup": {},
+        "family_zone_matchup": {},
+        "arsenal_matchup": {},
+        "trajectory": {},
+        "count_context_profile": {},
+    }
+
+    zone_matchup_subscore = _safe_float((matchup.get("zone_matchup") or {}).get("hit_zone_boost"), 0.0) or 0.0
+    family_zone_matchup_subscore = _safe_float((matchup.get("family_zone_matchup") or {}).get("family_zone_whiff_risk"), 0.0) or 0.0
+    arsenal_fit_subscore = _safe_float((matchup.get("arsenal_matchup") or {}).get("arsenal_whiff_risk"), 0.0) or 0.0
+    trajectory = matchup.get("trajectory") or {}
+    tunneling_subscore = _safe_float(trajectory.get("tunnel_score"), 0.5) or 0.5
+    release_consistency_subscore = _safe_float(trajectory.get("release_consistency_score"), 0.5) or 0.5
+    sequencing_profiles = matchup.get("count_context_profile") or {}
+    putaway_states = [v for k, v in sequencing_profiles.items() if str(k).endswith("-2")]
+    count_leverage_subscore = 0.58 if putaway_states else 0.50
+    sequencing_subscore = _clamp(0.5 + ((count_leverage_subscore - 0.5) * 0.6), 0.0, 1.0)
+
+    swing_miss_subscore = _clamp((swstr or 0.11) / 0.18, 0.0, 1.0)
+    called_strike_subscore = _clamp((csw or 0.28) / 0.36, 0.0, 1.0)
+    command_efficiency_signal = _clamp(1.0 - ((ball or 0.36) - 0.30) / 0.12, 0.0, 1.0)
+    command_efficiency_subscore = command_efficiency_signal
+    lineup_whiff_subscore = _clamp(
+        (
+            family_zone_matchup_subscore * 0.55
+            + arsenal_fit_subscore * 0.45
+        ) / 0.35 if (family_zone_matchup_subscore or arsenal_fit_subscore) else 0.5,
+        0.0,
+        1.0,
+    )
+
+    # Opportunity layer: explicit but conservative until richer workload data is added.
+    pitch_count = 88.0
+    if swstr is not None:
+        pitch_count += (swstr - 0.11) * 18.0
+    if csw is not None:
+        pitch_count += (csw - 0.28) * 12.0
+    if ball is not None:
+        pitch_count -= (ball - 0.36) * 28.0
+    if opponent_batters and len(opponent_batters) >= 7:
+        pitch_count += 1.5
+    leash_risk_score = _clamp(1.0 - command_efficiency_signal, 0.0, 1.0)
+    pitch_count -= leash_risk_score * 8.0
+    pitch_count = _clamp(pitch_count, 64.0, 108.0)
+
+    pitches_per_bf = 3.85
+    if ball is not None:
+        pitches_per_bf += (ball - 0.36) * 2.4
+    projected_batters_faced = _clamp(pitch_count / max(3.1, pitches_per_bf), 16.0, 31.0)
+    projected_innings = _clamp(projected_batters_faced / 4.35, 3.8, 7.8)
+    times_through_order_penalty = _clamp(max(0.0, projected_batters_faced - 24.0) * 0.004, 0.0, 0.06)
+
+    pitch_signal = (
+        swing_miss_subscore * 0.34
+        + called_strike_subscore * 0.18
+        + command_efficiency_subscore * 0.14
+        + lineup_whiff_subscore * 0.10
+        + _clamp(zone_matchup_subscore / 0.40, 0.0, 1.0) * 0.08
+        + _clamp(family_zone_matchup_subscore / 0.40, 0.0, 1.0) * 0.06
+        + _clamp(arsenal_fit_subscore / 0.35, 0.0, 1.0) * 0.05
+        + tunneling_subscore * 0.03
+        + release_consistency_subscore * 0.01
+        + sequencing_subscore * 0.01
+    )
+    k_rate_pitch_signal = _clamp(0.12 + (pitch_signal * 0.26), 0.14, 0.42)
+    k_rate_anchor = strike_anchor if strike_anchor is not None else k_rate_pitch_signal
+    projected_k_rate = (
+        k_rate_pitch_signal * (1.0 - reliability)
+        + k_rate_anchor * reliability
+    )
+    projected_k_rate = _clamp(projected_k_rate - times_through_order_penalty, 0.12, 0.40)
+
+    expected_strikeouts = _clamp(projected_batters_faced * projected_k_rate, 1.5, 11.5)
+    raw_prob = _poisson_prob_over(expected_strikeouts, float(line)) if selection_side == "over" else _poisson_prob_under(expected_strikeouts, float(line))
+    calibrated_prob = _calibrate(raw_prob)
+    variance = _clamp(0.35 + leash_risk_score * 0.9 + (1.0 - reliability) * 0.8, 0.35, 1.8)
+
+    confidence = 56.0
+    reasons: list[str] = []
+    bonuses: list[dict[str, Any]] = []
+    penalties: list[dict[str, Any]] = []
+    if sample_size >= 400:
+        confidence += 10.0
+        bonuses.append(_confidence_component("Strong pitcher sample", 10.0, "bonus"))
+    elif sample_size < 150:
+        confidence -= 10.0
+        reasons.append("Limited pitcher pitch sample")
+        penalties.append(_confidence_component("Limited pitcher pitch sample", 10.0, "penalty"))
+    if matchup.get("matchup_coverage_confidence", 0.0) >= 0.45:
+        confidence += 8.0
+        bonuses.append(_confidence_component("Strong telemetry and zone coverage", 8.0, "bonus"))
+    else:
+        confidence -= 6.0
+        reasons.append("Thin telemetry and zone-coverage sample")
+        penalties.append(_confidence_component("Thin telemetry and zone-coverage sample", 6.0, "penalty"))
+    if opponent_batters and len(opponent_batters) >= 7:
+        confidence += 5.0
+        bonuses.append(_confidence_component("Projected lineup mostly complete", 5.0, "bonus"))
+    else:
+        confidence -= 5.0
+        reasons.append("Projected opponent lineup is incomplete")
+        penalties.append(_confidence_component("Projected opponent lineup is incomplete", 5.0, "penalty"))
+    if leash_risk_score >= 0.55:
+        confidence -= 7.0
+        reasons.append("Pitch-count and leash risk remain elevated")
+        penalties.append(_confidence_component("Pitch-count and leash risk remain elevated", 7.0, "penalty"))
+
+    confidence_raw = _clamp(confidence, 1.0, 100.0)
+    bucket = "high" if confidence_raw >= 75 else "medium" if confidence_raw >= 55 else "low"
+    primary_penalty = max(
+        [item for item in penalties if float(item.get("value") or 0.0) > 0.0],
+        key=lambda item: float(item.get("value") or 0.0),
+        default=None,
+    )
+    primary_bonus = max(
+        [item for item in bonuses if float(item.get("value") or 0.0) > 0.0],
+        key=lambda item: float(item.get("value") or 0.0),
+        default=None,
+    )
+    primary_driver = primary_penalty or primary_bonus
+    summary_label = str((primary_driver or {}).get("label") or "").strip() or None
+
+    result.update(
+        {
+            "raw_k_prob_v2": raw_prob,
+            "calibrated_k_prob_v2": calibrated_prob,
+            "fair_prob_v2": calibrated_prob,
+            "expected_strikeouts_v2": expected_strikeouts,
+            "projected_pitch_count": round(pitch_count, 2),
+            "projected_batters_faced": round(projected_batters_faced, 2),
+            "projected_innings": round(projected_innings, 2),
+            "projected_k_rate": round(projected_k_rate, 4),
+            "k_rate_pitch_signal": round(k_rate_pitch_signal, 4),
+            "k_rate_anchor": round(k_rate_anchor, 4) if k_rate_anchor is not None else None,
+            "bb_rate_anchor": round(walk_anchor, 4) if walk_anchor is not None else None,
+            "command_efficiency_signal": round(command_efficiency_signal, 4),
+            "swing_miss_subscore": round(swing_miss_subscore, 4),
+            "called_strike_subscore": round(called_strike_subscore, 4),
+            "command_efficiency_subscore": round(command_efficiency_subscore, 4),
+            "lineup_whiff_subscore": round(lineup_whiff_subscore, 4),
+            "zone_matchup_subscore": round(zone_matchup_subscore, 4),
+            "family_zone_matchup_subscore": round(family_zone_matchup_subscore, 4),
+            "arsenal_fit_subscore": round(arsenal_fit_subscore, 4),
+            "tunneling_subscore": round(tunneling_subscore, 4),
+            "release_consistency_subscore": round(release_consistency_subscore, 4),
+            "sequencing_subscore": round(sequencing_subscore, 4),
+            "count_leverage_subscore": round(count_leverage_subscore, 4),
+            "leash_risk_subscore": round(leash_risk_score, 4),
+            "times_through_order_penalty": round(times_through_order_penalty, 4),
+            "variance_band_low": round(_clamp(expected_strikeouts - variance, 0.5, 12.0), 2),
+            "variance_band_high": round(_clamp(expected_strikeouts + variance, 0.5, 12.5), 2),
+            "matchup_coverage_confidence": matchup.get("matchup_coverage_confidence"),
+            "component_source_map": matchup.get("component_source_map") or {},
+            "predicted_whiff_regions": matchup.get("predicted_whiff_regions") or [],
+            "predicted_attack_regions": matchup.get("predicted_attack_regions") or [],
+            "predicted_damage_regions": matchup.get("predicted_damage_regions") or [],
+            "tunnel_pair_scores": matchup.get("tunnel_pair_scores") or [],
+            "applied_layers_v2": "opportunity|pitch_win|probability|uncertainty",
+            "skipped_layers_v2": "",
+            "confidence_score_v2": round(confidence_raw, 1),
+            "confidence_score_raw_v2": round(confidence_raw, 1),
+            "confidence_score_display_v2": round(confidence_raw, 1),
+            "confidence_bucket_v2": bucket,
+            "confidence_reasons_v2": reasons[:5],
+            "confidence_component_bonuses_v2": bonuses,
+            "confidence_component_penalties_v2": penalties,
+            "confidence_primary_driver_v2": primary_driver,
+            "confidence_summary_label_v2": summary_label,
+        }
+    )
+    return result

tests/test_props_mapper.py

@@ -663,8 +663,11 @@ class TestPropsMapper(unittest.TestCase):
                 "fair_prob": 0.58,
                 "expected_strikeouts": 7.2,
                 "confidence_score": 72.0,
+                "confidence_score_raw": 72.0,
                 "confidence_bucket": "medium",
                 "confidence_reasons": ["Projected opponent lineup is incomplete"],
+                "confidence_component_bonuses": [{"label": "Strong pitcher sample", "value": 10, "direction": "bonus"}],
+                "confidence_component_penalties": [{"label": "Projected opponent lineup is incomplete", "value": 6, "direction": "penalty"}],
                 "pitcher_swstr_rate": 0.14,
                 "pitcher_csw_rate": 0.31,
                 "pitcher_ball_rate": 0.34,
@@ -679,6 +682,54 @@ class TestPropsMapper(unittest.TestCase):
                 "reason_tags_for": ["Misses bats consistently", "Strong pitch tunneling"],
                 "reason_tags_against": ["Projected opponent lineup is incomplete"],
             },
+        ), patch(
+            "analytics.props_mapper.build_strikeout_probability_result_v2",
+            return_value={
+                "formula_version": "strikeout_v2_shadow",
+                "fair_prob_v2": 0.61,
+                "expected_strikeouts_v2": 7.0,
+                "projected_pitch_count": 94.0,
+                "projected_batters_faced": 25.0,
+                "projected_innings": 5.7,
+                "projected_k_rate": 0.28,
+                "raw_k_prob_v2": 0.61,
+                "calibrated_k_prob_v2": 0.61,
+                "confidence_score_v2": 64.0,
+                "confidence_score_raw_v2": 64.0,
+                "confidence_score_display_v2": 64.0,
+                "confidence_source_v2": "strikeout_v2_shadow",
+                "confidence_bucket_v2": "medium",
+                "confidence_reasons_v2": ["Projected opponent lineup is incomplete"],
+                "confidence_component_bonuses_v2": [{"label": "Strong pitcher sample", "value": 10, "direction": "bonus"}],
+                "confidence_component_penalties_v2": [{"label": "Projected opponent lineup is incomplete", "value": 5, "direction": "penalty"}],
+                "confidence_primary_driver_v2": {"label": "Projected opponent lineup is incomplete", "value": 5, "direction": "penalty"},
+                "confidence_summary_label_v2": "Projected opponent lineup is incomplete",
+                "k_rate_pitch_signal": 0.28,
+                "k_rate_anchor": 0.27,
+                "bb_rate_anchor": 0.06,
+                "command_efficiency_signal": 0.69,
+                "swing_miss_subscore": 0.77,
+                "called_strike_subscore": 0.73,
+                "command_efficiency_subscore": 0.69,
+                "lineup_whiff_subscore": 0.58,
+                "zone_matchup_subscore": 0.19,
+                "family_zone_matchup_subscore": 0.22,
+                "arsenal_fit_subscore": 0.24,
+                "tunneling_subscore": 0.64,
+                "release_consistency_subscore": 0.62,
+                "sequencing_subscore": 0.66,
+                "count_leverage_subscore": 0.58,
+                "leash_risk_subscore": 0.34,
+                "times_through_order_penalty": 0.01,
+                "variance_band_low": 6.0,
+                "variance_band_high": 8.0,
+                "matchup_coverage_confidence": 0.48,
+                "component_source_map": {"shared_composer": "ok"},
+                "predicted_whiff_regions": ["shadow"],
+                "predicted_attack_regions": ["shadow"],
+                "predicted_damage_regions": ["heart"],
+                "tunnel_pair_scores": [{"pair": "FF/CH", "score": 0.62}],
+            },
         ):
             result = map_props_to_models(
                 props_df,
@@ -693,6 +744,11 @@ class TestPropsMapper(unittest.TestCase):
         self.assertEqual(row["selection_scope"], "pitcher")
         self.assertIn(row["verdict"], {"bet", "watch", "pass"})
         self.assertTrue(bool(str(row["model_voice_for"])))
+        self.assertEqual(row["confidence_source"], "strikeout_v2_shadow")
+        self.assertGreater(float(row["confidence_score"]), 64.0)
+        self.assertEqual(row["confidence_summary_label"], "Projected opponent lineup is incomplete")
+        self.assertTrue(bool(row["confidence_component_bonuses"]))
+        self.assertTrue(bool(row["confidence_component_penalties"]))
 
 
 if __name__ == "__main__":

tests/test_shared_matchup_engine.py

@@ -0,0 +1,17 @@
+import pandas as pd
+
+from models.shared_matchup_engine import compose_shared_matchup_context
+
+
+def test_compose_shared_matchup_context_empty_inputs():
+    result = compose_shared_matchup_context(
+        batter_name="",
+        pitcher_name="",
+        batter_statcast_df=pd.DataFrame(),
+        pitcher_statcast_df=pd.DataFrame(),
+    )
+
+    assert result["expected_pitch_mix_by_count"] == {}
+    assert result["predicted_attack_regions"] == []
+    assert "shared_composer" in result["component_source_map"]
+

tests/test_strikeout_probability_engine_v2.py

@@ -0,0 +1,19 @@
+import pandas as pd
+
+from models.strikeout_probability_engine_v2 import build_strikeout_probability_result_v2
+
+
+def test_strikeout_probability_result_v2_missing_inputs():
+    result = build_strikeout_probability_result_v2(
+        pitcher_statcast_df=pd.DataFrame(),
+        pitcher_name="",
+        line=None,
+        selection_side=None,
+    )
+
+    assert result["formula_version"] == "strikeout_v2_shadow"
+    assert result["expected_strikeouts_v2"] is None
+    assert result["skipped_layers_v2"] == "missing_pitcher_or_line"
+    assert result["confidence_score_v2"] is None
+    assert result["confidence_component_bonuses_v2"] == []
+    assert result["confidence_component_penalties_v2"] == []

visualization/debug_page.py

@@ -110,6 +110,142 @@ _LADDER_TB2P_FIELDS = [
     ("Final (simulated)",       "tb2p_prob"),
 ]
 
+_MODEL_RUBRIC_WEIGHTS = {
+    "shared_telemetry": 18,
+    "explicit_opportunity": 16,
+    "explicit_components": 18,
+    "pitch_level_backbone": 12,
+    "hr_damage_modeling": 12,
+    "k_shadow_v2": 10,
+    "provenance_debug": 8,
+    "uncertainty_outputs": 6,
+}
+
+
+def _build_model_upgrade_rubric(
+    props_hr_health_debug: dict[str, Any] | None,
+    shared_component_debug: dict[str, Any] | None,
+) -> tuple[pd.DataFrame, dict[str, Any]]:
+    shared_component_debug = shared_component_debug or {}
+    props_hr_health_debug = props_hr_health_debug or {}
+    rows = pd.DataFrame(shared_component_debug.get("rows") or [])
+
+    has_shared = not rows.empty
+    has_hr_components = has_shared and any(
+        col in rows.columns
+        for col in [
+            "damage_zone_alignment_subscore",
+            "pitch_mix_exposure_subscore",
+            "tunnel_damage_subscore",
+            "count_pattern_damage_subscore",
+        ]
+    )
+    has_k_v2 = has_shared and "expected_strikeouts_v2" in rows.columns
+    has_opportunity = has_shared and any(
+        col in rows.columns
+        for col in ["projected_pitch_count", "projected_batters_faced", "projected_innings"]
+    )
+    has_uncertainty = has_shared and any(
+        col in rows.columns
+        for col in ["variance_band_low", "variance_band_high", "matchup_coverage_confidence"]
+    )
+    has_provenance = has_shared and "component_source_map" in rows.columns
+    has_pitch_backbone = has_shared and any(
+        col in rows.columns
+        for col in [
+            "zone_matchup_subscore",
+            "family_zone_matchup_subscore",
+            "arsenal_fit_subscore",
+            "tunneling_subscore",
+            "sequencing_subscore",
+        ]
+    )
+    has_explicit_components = has_shared and any(
+        col in rows.columns
+        for col in [
+            "damage_zone_alignment_subscore",
+            "arsenal_fit_subscore",
+            "zone_matchup_subscore",
+            "count_leverage_subscore",
+        ]
+    )
+
+    grade_rows = [
+        {
+            "category": "Shared telemetry framework",
+            "weight": _MODEL_RUBRIC_WEIGHTS["shared_telemetry"],
+            "old_system": 2,
+            "current_system": _MODEL_RUBRIC_WEIGHTS["shared_telemetry"] if has_shared else 0,
+            "status": "active" if has_shared else "missing",
+            "evidence": "shared_matchup_engine + shared diagnostics" if has_shared else "not captured yet",
+        },
+        {
+            "category": "Explicit opportunity modeling",
+            "weight": _MODEL_RUBRIC_WEIGHTS["explicit_opportunity"],
+            "old_system": 3,
+            "current_system": _MODEL_RUBRIC_WEIGHTS["explicit_opportunity"] if has_opportunity else 0,
+            "status": "active" if has_opportunity else "missing",
+            "evidence": "projected pitch count / BF / innings" if has_opportunity else "old heuristic only",
+        },
+        {
+            "category": "Explicit modeled components",
+            "weight": _MODEL_RUBRIC_WEIGHTS["explicit_components"],
+            "old_system": 8,
+            "current_system": _MODEL_RUBRIC_WEIGHTS["explicit_components"] if has_explicit_components else 0,
+            "status": "active" if has_explicit_components else "partial",
+            "evidence": "named subscores emitted" if has_explicit_components else "implicit heuristics",
+        },
+        {
+            "category": "Pitch-level backbone",
+            "weight": _MODEL_RUBRIC_WEIGHTS["pitch_level_backbone"],
+            "old_system": 8,
+            "current_system": _MODEL_RUBRIC_WEIGHTS["pitch_level_backbone"] if has_pitch_backbone else 0,
+            "status": "active" if has_pitch_backbone else "missing",
+            "evidence": "zone/family-zone/arsenal/tunnel/sequencing present" if has_pitch_backbone else "not surfaced",
+        },
+        {
+            "category": "HR damage-zone modeling",
+            "weight": _MODEL_RUBRIC_WEIGHTS["hr_damage_modeling"],
+            "old_system": 8,
+            "current_system": _MODEL_RUBRIC_WEIGHTS["hr_damage_modeling"] if has_hr_components else 0,
+            "status": "active" if has_hr_components else "missing",
+            "evidence": "damage-zone and pitch-mix exposure subscores" if has_hr_components else "legacy HR layers only",
+        },
+        {
+            "category": "K shadow v2 readiness",
+            "weight": _MODEL_RUBRIC_WEIGHTS["k_shadow_v2"],
+            "old_system": 0,
+            "current_system": _MODEL_RUBRIC_WEIGHTS["k_shadow_v2"] if has_k_v2 else 0,
+            "status": "active" if has_k_v2 else "missing",
+            "evidence": "strikeout v2 outputs captured" if has_k_v2 else "current K engine only",
+        },
+        {
+            "category": "Provenance and debug traceability",
+            "weight": _MODEL_RUBRIC_WEIGHTS["provenance_debug"],
+            "old_system": 4,
+            "current_system": _MODEL_RUBRIC_WEIGHTS["provenance_debug"] if has_provenance else 0,
+            "status": "active" if has_provenance else "missing",
+            "evidence": "component_source_map exposed" if has_provenance else "limited traceability",
+        },
+        {
+            "category": "Uncertainty outputs",
+            "weight": _MODEL_RUBRIC_WEIGHTS["uncertainty_outputs"],
+            "old_system": 3,
+            "current_system": _MODEL_RUBRIC_WEIGHTS["uncertainty_outputs"] if has_uncertainty else 0,
+            "status": "active" if has_uncertainty else "missing",
+            "evidence": "variance bands / coverage confidence" if has_uncertainty else "point estimate only",
+        },
+    ]
+
+    rubric_df = pd.DataFrame(grade_rows)
+    summary = {
+        "old_architecture_score": int(rubric_df["old_system"].sum()),
+        "current_architecture_score": int(rubric_df["current_system"].sum()),
+        "max_score": int(rubric_df["weight"].sum()),
+        "modeled_hr_rows_total": int(props_hr_health_debug.get("modeled_hr_rows_total") or 0),
+    }
+    return rubric_df, summary
+
 
 # ---------------------------------------------------------------------------
 # Private diagnostic helpers
@@ -887,6 +1023,83 @@ def render_debug(
                     hide_index=True,
                 )
 
+            with st.expander("Strikeout Confidence Diagnostics", expanded=False):
+                strikeout_df = exec_df[
+                    exec_df.get("market_family", pd.Series(index=exec_df.index, dtype="object"))
+                    .astype(str)
+                    .str.lower()
+                    .eq("k")
+                ].copy()
+                if strikeout_df.empty:
+                    st.info("No strikeout props are currently available.")
+                else:
+                    summary_cols = [
+                        "player_name_raw",
+                        "sportsbook",
+                        "display_label",
+                        "selection_side",
+                        "fair_prob",
+                        "confidence_score",
+                        "confidence_score_raw",
+                        "confidence_score_display",
+                        "confidence_source",
+                        "confidence_bucket",
+                        "confidence_bucket_raw",
+                        "confidence_bucket_display",
+                        "confidence_summary_label",
+                        "confidence_reasons",
+                        "confidence_score_v1",
+                        "confidence_bucket_v1",
+                        "confidence_score_v2",
+                        "confidence_score_raw_v2",
+                        "confidence_score_display_v2",
+                        "confidence_bucket_v2",
+                        "confidence_reasons_v2",
+                        "projected_pitch_count",
+                        "projected_batters_faced",
+                        "projected_innings",
+                        "expected_strikeouts",
+                        "expected_strikeouts_v2",
+                    ]
+                    st.write("Card-facing strikeout confidence rows")
+                    st.dataframe(
+                        strikeout_df[[c for c in summary_cols if c in strikeout_df.columns]],
+                        use_container_width=True,
+                        hide_index=True,
+                    )
+
+                    component_rows: list[dict[str, Any]] = []
+                    for _, row in strikeout_df.iterrows():
+                        player_name = row.get("player_name_raw") or row.get("player_name")
+                        display_label = row.get("display_label")
+                        for item in row.get("confidence_component_bonuses") or []:
+                            component_rows.append(
+                                {
+                                    "player_name": player_name,
+                                    "display_label": display_label,
+                                    "component_type": "bonus",
+                                    "label": item.get("label"),
+                                    "value": item.get("value"),
+                                    "source": row.get("confidence_source"),
+                                }
+                            )
+                        for item in row.get("confidence_component_penalties") or []:
+                            component_rows.append(
+                                {
+                                    "player_name": player_name,
+                                    "display_label": display_label,
+                                    "component_type": "penalty",
+                                    "label": item.get("label"),
+                                    "value": item.get("value"),
+                                    "source": row.get("confidence_source"),
+                                }
+                            )
+                    if component_rows:
+                        st.write("Confidence component math")
+                        st.dataframe(pd.DataFrame(component_rows), use_container_width=True, hide_index=True)
+                    else:
+                        st.info("No confidence component rows are present yet.")
+
             with st.expander("Shared Baseline Diagnostics", expanded=False):
                 baseline_summary_frames: list[pd.DataFrame] = []
                 batter_meta = (baseline_bundle or {}).get("batter_baseline_meta", pd.DataFrame())
@@ -1079,6 +1292,46 @@ def render_debug(
                 else:
                     st.info("Open the Props page in this session to capture HR health diagnostics.")
 
+            with st.expander("Shared Matchup Component Diagnostics", expanded=False):
+                shared_component_debug = st.session_state.get("props_shared_component_debug") or {}
+                if shared_component_debug:
+                    st.caption(
+                        f"Captured from Props market: {str(shared_component_debug.get('market_type') or 'unknown').upper()}"
+                    )
+                    rows_df = pd.DataFrame(shared_component_debug.get("rows") or [])
+                    if not rows_df.empty:
+                        st.dataframe(rows_df, use_container_width=True, hide_index=True)
+                    else:
+                        st.info("No shared-component rows captured in this session.")
+                else:
+                    st.info("Open the Props page in this session to capture shared matchup diagnostics.")
+
+            with st.expander("Model Grading Rubric", expanded=False):
+                props_hr_health_debug = st.session_state.get("props_hr_health_debug") or {}
+                shared_component_debug = st.session_state.get("props_shared_component_debug") or {}
+                rubric_df, rubric_summary = _build_model_upgrade_rubric(
+                    props_hr_health_debug=props_hr_health_debug,
+                    shared_component_debug=shared_component_debug,
+                )
+                c1, c2, c3 = st.columns(3)
+                c1.metric(
+                    "Old Architecture Grade",
+                    f"{int(rubric_summary.get('old_architecture_score') or 0)}/{int(rubric_summary.get('max_score') or 100)}",
+                )
+                c2.metric(
+                    "Current Architecture Grade",
+                    f"{int(rubric_summary.get('current_architecture_score') or 0)}/{int(rubric_summary.get('max_score') or 100)}",
+                )
+                c3.metric(
+                    "Modeled 1+ HR Rows",
+                    int(rubric_summary.get("modeled_hr_rows_total") or 0),
+                )
+                st.caption(
+                    "This is an architecture and model-readiness rubric, not a live ROI or hit-rate grade. "
+                    "Replace or augment it with rolling backtest metrics as the evaluation layer is built."
+                )
+                st.dataframe(rubric_df, use_container_width=True, hide_index=True)
+
             with st.expander("Debug Event Row Read Status", expanded=False):
                 read_status = debug_event_row_status or {}
                 if read_status:

visualization/props_page.py

@@ -223,6 +223,13 @@ def _render_props_ui_styles() -> None:
         .props-metric-value.bad {
             color: #ff7f7f;
         }
+        .props-metric-subvalue {
+            color: #88a0bb;
+            font-size: 0.72rem;
+            line-height: 1.25;
+            margin-top: 0.12rem;
+            min-height: 1rem;
+        }
         .props-verdict {
             display: inline-block;
             border-radius: 999px;
@@ -341,6 +348,71 @@ def _format_confidence(val: float | None) -> str:
         return "-"
 
 
+def _confidence_summary_label(value: Any) -> str:
+    text = str(value or "").strip()
+    return text if text else "-"
+
+
+def _build_confidence_metric_html(row: pd.Series | dict[str, Any]) -> str:
+    score = _format_confidence(row.get("confidence_score"))
+    summary = _confidence_summary_label(row.get("confidence_summary_label"))
+    if summary == "-":
+        summary = " "
+    return (
+        f"<div class=\"props-metric-value\">{score}</div>"
+        f"<div class=\"props-metric-subvalue\">{summary}</div>"
+    )
+
+
+def _render_confidence_breakdown(details_row: dict[str, Any]) -> None:
+    raw_score = details_row.get("confidence_score_raw")
+    display_score = details_row.get("confidence_score_display", details_row.get("confidence_score"))
+    confidence_source = str(details_row.get("confidence_source") or "").strip() or "-"
+    final_bucket = str(details_row.get("confidence_bucket") or details_row.get("confidence_bucket_display") or "-").strip()
+    summary_label = str(details_row.get("confidence_summary_label") or "").strip()
+    bonuses = details_row.get("confidence_component_bonuses") or []
+    penalties = details_row.get("confidence_component_penalties") or []
+
+    if (
+        raw_score is None
+        and display_score is None
+        and confidence_source == "-"
+        and not bonuses
+        and not penalties
+    ):
+        return
+
+    st.caption("Confidence Breakdown")
+    metric_cols = st.columns(4)
+    metric_cols[0].metric("Raw/Base", _format_confidence(raw_score))
+    metric_cols[1].metric("Display", _format_confidence(display_score))
+    metric_cols[2].metric("Source", confidence_source.replace("_", " ").title())
+    metric_cols[3].metric("Bucket", final_bucket.title() if final_bucket else "-")
+
+    if bonuses:
+        st.write("Bonuses")
+        for bonus in bonuses:
+            st.write(f"- +{float(bonus.get('value') or 0.0):.0f} {str(bonus.get('label') or '-').strip()}")
+
+    if penalties:
+        st.write("Penalties")
+        for penalty in penalties:
+            value = float(penalty.get("value") or 0.0)
+            prefix = f"-{value:.0f}" if value > 0 else "0"
+            st.write(f"- {prefix} {str(penalty.get('label') or '-').strip()}")
+
+    why_lines: list[str] = []
+    if summary_label:
+        why_lines.append(f"Primary driver: {summary_label}")
+    for reason in details_row.get("confidence_reasons") or []:
+        if str(reason).strip():
+            why_lines.append(str(reason).strip())
+    if why_lines:
+        st.write("Why It Landed Here")
+        for line in why_lines:
+            st.write(f"- {line}")
+
+
 def _market_label(value: Any) -> str:
     text = str(value or "").strip().lower()
     labels = {
@@ -638,6 +710,10 @@ def _build_market_modeling_payload(
             )
         else:
             st.session_state.pop("props_hr_health_debug", None)
+        st.session_state["props_shared_component_debug"] = _build_shared_component_debug(
+            mapped,
+            market_type=market_type,
+        )
 
     return {
         "baseline_request": baseline_request,
@@ -1038,6 +1114,51 @@ def _build_hr_health_debug(display: pd.DataFrame, extra_context: dict[str, Any]
     return out
 
 
+def _build_shared_component_debug(display: pd.DataFrame, market_type: str) -> dict[str, Any]:
+    if display is None or display.empty:
+        return {"market_type": market_type, "rows": []}
+
+    cols = [
+        "player_name",
+        "player_name_raw",
+        "display_label",
+        "resolved_pitcher_name",
+        "formula_version",
+        "matchup_coverage_confidence",
+        "damage_zone_alignment_subscore",
+        "pitch_mix_exposure_subscore",
+        "tunnel_damage_subscore",
+        "count_pattern_damage_subscore",
+        "handedness_damage_subscore",
+        "arsenal_fit_subscore",
+        "environment_amplification_subscore",
+        "hr_opportunity_projection",
+        "projected_pitch_count",
+        "projected_batters_faced",
+        "projected_innings",
+        "projected_k_rate",
+        "expected_strikeouts_v2",
+        "zone_matchup_subscore",
+        "family_zone_matchup_subscore",
+        "tunneling_subscore",
+        "release_consistency_subscore",
+        "sequencing_subscore",
+        "count_leverage_subscore",
+        "leash_risk_subscore",
+        "times_through_order_penalty",
+        "variance_band_low",
+        "variance_band_high",
+        "predicted_attack_regions",
+        "predicted_damage_regions",
+        "predicted_whiff_regions",
+        "component_source_map",
+    ]
+    return {
+        "market_type": market_type,
+        "rows": display[[c for c in cols if c in display.columns]].head(30).to_dict("records"),
+    }
+
+
 def render_props_hero(display_df: pd.DataFrame, view_model: dict[str, Any] | None = None) -> None:
     st.markdown(
         """
@@ -1136,7 +1257,7 @@ def render_featured_hr_cards(featured_df: pd.DataFrame) -> None:
                         </div>
                         <div>
                             <div class="props-metric-label">Confidence</div>
-                            <div class="props-metric-value">{_format_confidence(row.get('confidence_score'))}</div>
+                            {_build_confidence_metric_html(row)}
                         </div>
                     </div>
                     <div class="props-voice">
@@ -1216,7 +1337,7 @@ def render_best_on_slate_cards(best_df: pd.DataFrame, summary: dict[str, Any] |
                         </div>
                         <div>
                             <div class="props-metric-label">Confidence</div>
-                            <div class="props-metric-value">{_format_confidence(row.get('confidence_score'))}</div>
+                            {_build_confidence_metric_html(row)}
                         </div>
                     </div>
                     <div class="props-voice">
@@ -1291,8 +1412,15 @@ def render_player_hr_details(player_details: dict[str, Any]) -> None:
         "model_voice_for",
         "model_voice_against",
         "confidence_score",
+        "confidence_score_raw",
+        "confidence_score_display",
+        "confidence_source",
         "confidence_bucket",
         "confidence_reasons",
+        "confidence_component_bonuses",
+        "confidence_component_penalties",
+        "confidence_primary_driver",
+        "confidence_summary_label",
         "opportunity_hr_adjustment",
         "expected_pa",
         "lineup_slot_used",
@@ -1380,6 +1508,7 @@ def render_player_hr_row(player_entry: dict[str, Any]) -> None:
                 st.caption("Why this rating")
                 for line in why_lines:
                     st.write(f"- {line}")
+            _render_confidence_breakdown(details.get("best_primary_row") or {})
             render_player_hr_details(details)
         st.divider()