Stabilize props baseline and starter resolution

analytics/props_mapper.py

@@ -84,6 +84,16 @@ def _to_display_name(value: Any) -> str:
     return str(value or "").strip()
 
 
+def _normalize_person_name(value: Any) -> str:
+    return normalize_for_matching(to_canonical_name(str(value or "").strip()))
+
+
+def _names_match(left: Any, right: Any) -> bool:
+    left_norm = _normalize_person_name(left)
+    right_norm = _normalize_person_name(right)
+    return bool(left_norm and right_norm and left_norm == right_norm)
+
+
 def _compute_verdict(
     bet_ev: float | None,
     edge: float | None,
@@ -257,8 +267,9 @@ def _infer_batter_team(
     ):
         return ""
 
+    normalized_target = _normalize_person_name(batter_name)
     player_rows = batter_statcast_df[
-        batter_statcast_df["player_name"].astype(str).str.casefold() == batter_name.casefold()
+        batter_statcast_df["player_name"].astype(str).map(_normalize_person_name) == normalized_target
     ].copy()
     if player_rows.empty:
         return ""
@@ -289,6 +300,60 @@ def _infer_batter_team(
     return pd.Series(normalized).mode().iloc[0]
 
 
+def _resolve_batter_team(
+    row: Any,
+    batter_name: str,
+    projected_lineups: dict[str, dict[str, Any]] | None,
+    batter_statcast_df: pd.DataFrame,
+) -> tuple[str, str]:
+    row_team, row_source = _resolve_batter_team_from_row_context(
+        row=row,
+        batter_name=batter_name,
+        projected_lineups=projected_lineups,
+    )
+    if row_team:
+        return (row_team, row_source)
+
+    away_team = _to_display_name(row.get("away_team"))
+    home_team = _to_display_name(row.get("home_team"))
+    away_norm = _normalize_team_name(away_team)
+    home_norm = _normalize_team_name(home_team)
+
+    if (
+        batter_statcast_df is None
+        or batter_statcast_df.empty
+        or not batter_name
+        or "player_name" not in batter_statcast_df.columns
+    ):
+        return ("", "unresolved")
+
+    normalized_target = _normalize_person_name(batter_name)
+    player_rows = batter_statcast_df[
+        batter_statcast_df["player_name"].astype(str).map(_normalize_person_name) == normalized_target
+    ].copy()
+    if player_rows.empty:
+        return ("", "unresolved")
+
+    if "source_season" in player_rows.columns:
+        current_rows = player_rows[pd.to_numeric(player_rows["source_season"], errors="coerce") == 2026].copy()
+        current_team = _infer_batter_team(batter_name=batter_name, batter_statcast_df=current_rows)
+        if current_team:
+            if current_team == away_norm and away_team:
+                return (away_team, "current_season_statcast")
+            if current_team == home_norm and home_team:
+                return (home_team, "current_season_statcast")
+
+    historical_team = _infer_batter_team(batter_name=batter_name, batter_statcast_df=player_rows)
+    if historical_team:
+        if historical_team == away_norm and away_team:
+            return (away_team, "historical_statcast")
+        if historical_team == home_norm and home_team:
+            return (home_team, "historical_statcast")
+        return (historical_team, "historical_statcast")
+
+    return ("", "unresolved")
+
+
 def _resolve_batter_team_from_row_context(
     row: Any,
     batter_name: str,
@@ -313,7 +378,7 @@ def _resolve_batter_team_from_row_context(
             for lineup_key in ("lineup_vs_rhp", "lineup_vs_lhp"):
                 for entry in payload.get(lineup_key) or []:
                     player_name = _to_display_name(entry.get("player_name"))
-                    if player_name and player_name.casefold() == batter_name.casefold():
+                    if _names_match(player_name, batter_name):
                         return True
             return False
 
@@ -365,7 +430,7 @@ def _resolve_pitcher_hand(
         return ("", "unavailable")
     if {"player_name", "p_throws"}.issubset(pitcher_statcast_df.columns):
         direct_rows = pitcher_statcast_df[
-            pitcher_statcast_df["player_name"].astype(str).str.casefold() == str(pitcher_name).casefold()
+            pitcher_statcast_df["player_name"].astype(str).map(_normalize_person_name) == _normalize_person_name(pitcher_name)
         ].copy()
         if not direct_rows.empty:
             direct_hand = str(direct_rows.iloc[0].get("p_throws") or "").strip().upper()
@@ -458,8 +523,7 @@ def _resolve_pitcher_name(
     away_pitcher = str(starters.get("away_pitcher") or "").strip()
 
     if explicit_pitcher:
-        explicit_norm = explicit_pitcher.casefold()
-        if (home_pitcher and home_pitcher.casefold() == explicit_norm) or (away_pitcher and away_pitcher.casefold() == explicit_norm):
+        if _names_match(home_pitcher, explicit_pitcher) or _names_match(away_pitcher, explicit_pitcher):
             return (explicit_pitcher, "row_explicit_validated", "resolved")
 
     if batter_team_norm and batter_team_norm == away_norm:
@@ -531,10 +595,9 @@ def _projected_starter_match_status(
         return "projected_starter_unavailable"
     if not resolved:
         return "projected_starter_available_but_unresolved"
-    resolved_norm = resolved.casefold()
-    if projected_home_pitcher and projected_home_pitcher.casefold() == resolved_norm:
+    if _names_match(projected_home_pitcher, resolved):
         return "matched_projected_home"
-    if projected_away_pitcher and projected_away_pitcher.casefold() == resolved_norm:
+    if _names_match(projected_away_pitcher, resolved):
         return "matched_projected_away"
     return "resolved_pitcher_mismatch"
 
@@ -559,9 +622,9 @@ def _resolve_pitcher_team_and_opponent(
 
     away_pitcher = str(starters.get("away_pitcher") or "").strip()
     home_pitcher = str(starters.get("home_pitcher") or "").strip()
-    if away_pitcher and away_pitcher.casefold() == pitcher_name.casefold():
+    if _names_match(away_pitcher, pitcher_name):
         return (away_team, home_team)
-    if home_pitcher and home_pitcher.casefold() == pitcher_name.casefold():
+    if _names_match(home_pitcher, pitcher_name):
         return (home_team, away_team)
     return ("", "")
 
@@ -588,10 +651,9 @@ def _resolve_strikeout_pitcher_name(
 
     projected_home = str(starters.get("home_pitcher") or "").strip()
     projected_away = str(starters.get("away_pitcher") or "").strip()
-    explicit_norm = explicit_pitcher.casefold()
     if explicit_pitcher and (
-        (projected_home and projected_home.casefold() == explicit_norm)
-        or (projected_away and projected_away.casefold() == explicit_norm)
+        _names_match(projected_home, explicit_pitcher)
+        or _names_match(projected_away, explicit_pitcher)
     ):
         return (explicit_pitcher, "row_explicit_validated", "resolved")
     if projected_home and not projected_away:
@@ -645,11 +707,11 @@ def _lookup_baseline_metadata(
     ):
         return default
 
-    normalized_target = normalize_for_matching(player_name)
+    normalized_target = _normalize_person_name(player_name)
     if not normalized_target:
         return default
 
-    normalized_series = statcast_df["player_name"].astype(str).map(normalize_for_matching)
+    normalized_series = statcast_df["player_name"].astype(str).map(_normalize_person_name)
     rows = statcast_df[normalized_series == normalized_target].copy()
     if rows.empty:
         return default
@@ -750,10 +812,11 @@ def map_hr_props_to_model(
             str(row.get("event_id") or "").strip(),
         )
         if batter_team_key not in batter_team_cache:
-            batter_team_cache[batter_team_key] = _resolve_batter_team_from_row_context(
+            batter_team_cache[batter_team_key] = _resolve_batter_team(
                 row=row,
                 batter_name=batter_name,
                 projected_lineups=projected_lineups,
+                batter_statcast_df=statcast_df,
             )
         batter_team, batter_team_source = batter_team_cache[batter_team_key]
 
@@ -768,12 +831,6 @@ def map_hr_props_to_model(
                 probable_starters=probable_starters,
             )
         projected_starter_context = projected_starter_cache[starter_key]
-        if not batter_team:
-            inferred_team = _infer_batter_team(batter_name=batter_name, batter_statcast_df=statcast_df)
-            if inferred_team:
-                batter_team = inferred_team
-                batter_team_source = "historical_statcast"
-
         pitcher_resolution_key = (
             starter_key[0],
             starter_key[1],

app.py

@@ -651,10 +651,29 @@ def load_probable_starters() -> dict:
     try:
         cached_meta = read_cached_probable_starters_meta(conn)
         if not cached_meta.empty:
+            fetched_at = cached_meta.iloc[0]["fetched_at"]
+            fetched_ts = pd.to_datetime(fetched_at, errors="coerce", utc=True)
+            cache_age_seconds = None
+            if pd.notna(fetched_ts):
+                cache_age_seconds = max(
+                    0,
+                    int((pd.Timestamp.now(tz="UTC") - fetched_ts).total_seconds()),
+                )
             cached = read_cached_probable_starters(conn)
             if cached:
-                if _is_fetched_at_fresh(cached_meta.iloc[0]["fetched_at"], 60 * 60):
+                if _is_fetched_at_fresh(fetched_at, 60 * 60):
+                    st.session_state["probable_starters_refresh_mode"] = "cache_fresh"
+                    st.session_state["probable_starters_cache_age_seconds"] = cache_age_seconds
                     return cached
+                try:
+                    fresh = fetch_probable_starters_for_props()
+                    if fresh:
+                        replace_cached_probable_starters(conn, fresh)
+                        st.session_state["probable_starters_refresh_mode"] = "stale_sync_refresh"
+                        st.session_state["probable_starters_cache_age_seconds"] = cache_age_seconds
+                        return fresh
+                except Exception as exc:
+                    logger.warning("[load_probable_starters] synchronous stale refresh failed: %s", exc)
                 _queue_async_refresh(
                     "probable_starters",
                     lambda: _run_with_fresh_conn(
@@ -664,6 +683,8 @@ def load_probable_starters() -> dict:
                         )
                     ),
                 )
+                st.session_state["probable_starters_refresh_mode"] = "stale_cache_served_async_refresh"
+                st.session_state["probable_starters_cache_age_seconds"] = cache_age_seconds
                 return cached
     except Exception:
         pass
@@ -673,6 +694,8 @@ def load_probable_starters() -> dict:
         replace_cached_probable_starters(conn, fresh)
     except Exception as exc:
         logger.warning("[load_probable_starters] cache persist failure: %s", exc)
+    st.session_state["probable_starters_refresh_mode"] = "fresh_network_load"
+    st.session_state["probable_starters_cache_age_seconds"] = 0
     return fresh
 
 

data/shared_baseline.py

@@ -15,7 +15,7 @@ from models.rolling_form_model import (
     build_pitcher_rolling_form_row,
 )
 from utils.helpers import utc_now_iso
-from visualization.cards.player_identity import load_identity_map, normalize_for_matching
+from visualization.cards.player_identity import load_identity_map, normalize_for_matching, to_canonical_name
 
 PRIOR_SEASONS = (2021, 2022, 2023, 2024, 2025)
 CURRENT_SEASON = 2026
@@ -207,7 +207,131 @@ def _coerce_bool(value: Any) -> bool:
 
 
 def _normalize_name(value: Any) -> str:
-    return normalize_for_matching(str(value or "").strip())
+    return normalize_for_matching(to_canonical_name(str(value or "").strip()))
+
+
+def _normalized_name_set(values: list[Any] | tuple[Any, ...] | set[Any] | pd.Series | None) -> set[str]:
+    if values is None:
+        return set()
+    return {
+        _normalize_name(value)
+        for value in list(values)
+        if _normalize_name(value)
+    }
+
+
+def _compute_missing_requested_names(
+    requested_names: tuple[str, ...] | list[str] | None,
+    available_names: set[str],
+) -> list[str]:
+    if not requested_names:
+        return []
+    out: list[str] = []
+    for raw_name in requested_names:
+        cleaned = str(raw_name or "").strip()
+        if not cleaned:
+            continue
+        if _normalize_name(cleaned) not in available_names:
+            out.append(cleaned)
+    return out
+
+
+def _annotate_request_coverage(
+    bundle: dict[str, pd.DataFrame],
+    *,
+    requested_hitter_names: tuple[str, ...],
+    requested_pitcher_names: tuple[str, ...],
+    coverage_mode: str,
+    background_refresh_queued: bool,
+) -> dict[str, pd.DataFrame]:
+    available_hitters = _normalized_name_set(
+        bundle.get("batter_baseline_meta", pd.DataFrame()).get("player_name", pd.Series(dtype="object")).dropna().astype(str).tolist()
+        if isinstance(bundle.get("batter_baseline_meta", pd.DataFrame()), pd.DataFrame)
+        else []
+    )
+    available_pitchers = _normalized_name_set(
+        bundle.get("pitcher_baseline_meta", pd.DataFrame()).get("player_name", pd.Series(dtype="object")).dropna().astype(str).tolist()
+        if isinstance(bundle.get("pitcher_baseline_meta", pd.DataFrame()), pd.DataFrame)
+        else []
+    )
+    missing_hitter_names = _compute_missing_requested_names(requested_hitter_names, available_hitters)
+    missing_pitcher_names = _compute_missing_requested_names(requested_pitcher_names, available_pitchers)
+    bundle["requested_hitter_count"] = int(len(requested_hitter_names))
+    bundle["requested_pitcher_count"] = int(len(requested_pitcher_names))
+    bundle["resolved_hitter_count"] = int(len(requested_hitter_names) - len(missing_hitter_names))
+    bundle["resolved_pitcher_count"] = int(len(requested_pitcher_names) - len(missing_pitcher_names))
+    bundle["missing_hitter_names"] = missing_hitter_names
+    bundle["missing_pitcher_names"] = missing_pitcher_names
+    bundle["snapshot_coverage_mode"] = coverage_mode
+    bundle["background_refresh_queued"] = background_refresh_queued
+    return bundle
+
+
+def _merge_bundle_frames(
+    left: pd.DataFrame | None,
+    right: pd.DataFrame | None,
+    *,
+    subset_candidates: list[str],
+) -> pd.DataFrame:
+    left_df = left if isinstance(left, pd.DataFrame) else pd.DataFrame()
+    right_df = right if isinstance(right, pd.DataFrame) else pd.DataFrame()
+    if left_df.empty:
+        return right_df.copy()
+    if right_df.empty:
+        return left_df.copy()
+    merged = pd.concat([left_df, right_df], ignore_index=True, sort=False)
+    subset = [col for col in subset_candidates if col in merged.columns]
+    if subset:
+        merged = merged.drop_duplicates(subset=subset, keep="last")
+    else:
+        merged = merged.drop_duplicates(keep="last")
+    return merged.reset_index(drop=True)
+
+
+def _merge_shared_baseline_bundles(
+    snapshot_bundle: dict[str, pd.DataFrame],
+    patch_bundle: dict[str, pd.DataFrame],
+) -> dict[str, pd.DataFrame]:
+    merged = dict(snapshot_bundle)
+    merged["blended_batter_df"] = _merge_bundle_frames(
+        snapshot_bundle.get("blended_batter_df"),
+        patch_bundle.get("blended_batter_df"),
+        subset_candidates=["player_name", "event_key", "game_pk", "at_bat_number", "pitch_number"],
+    )
+    merged["blended_pitcher_df"] = _merge_bundle_frames(
+        snapshot_bundle.get("blended_pitcher_df"),
+        patch_bundle.get("blended_pitcher_df"),
+        subset_candidates=["player_name", "event_key", "game_pk", "at_bat_number", "pitch_number"],
+    )
+    merged["batter_baseline_meta"] = _merge_bundle_frames(
+        snapshot_bundle.get("batter_baseline_meta"),
+        patch_bundle.get("batter_baseline_meta"),
+        subset_candidates=["player_name"],
+    )
+    merged["pitcher_baseline_meta"] = _merge_bundle_frames(
+        snapshot_bundle.get("pitcher_baseline_meta"),
+        patch_bundle.get("pitcher_baseline_meta"),
+        subset_candidates=["player_name"],
+    )
+    merged["hitter_rolling_snapshot"] = _merge_bundle_frames(
+        snapshot_bundle.get("hitter_rolling_snapshot"),
+        patch_bundle.get("hitter_rolling_snapshot"),
+        subset_candidates=["player_name"],
+    )
+    merged["pitcher_rolling_snapshot"] = _merge_bundle_frames(
+        snapshot_bundle.get("pitcher_rolling_snapshot"),
+        patch_bundle.get("pitcher_rolling_snapshot"),
+        subset_candidates=["player_name"],
+    )
+    merged["snapshot_status"] = _merge_bundle_frames(
+        snapshot_bundle.get("snapshot_status"),
+        patch_bundle.get("snapshot_status"),
+        subset_candidates=["table_name"],
+    )
+    merged["snapshot_source_status"] = "snapshot_request_patched"
+    merged["runtime_fallback_used"] = False
+    merged["request_patch_used"] = True
+    return merged
 
 
 def _clamp(value: float, lo: float, hi: float) -> float:
@@ -357,10 +481,10 @@ def _normalize_names_tuple(values: tuple[str, ...] | None) -> tuple[str, ...]:
         cleaned = str(value or "").strip()
         if not cleaned:
             continue
-        lowered = cleaned.lower()
-        if lowered in seen:
+        normalized = _normalize_name(cleaned)
+        if normalized in seen:
             continue
-        seen.add(lowered)
+        seen.add(normalized)
         out.append(cleaned)
     return tuple(sorted(out))
 
@@ -1386,36 +1510,27 @@ def load_or_build_shared_baseline_bundle(
     )
     snapshot_status = snapshot_bundle.get("snapshot_status", pd.DataFrame())
 
-    available_hitters: set[str] = set()
-    if isinstance(snapshot_bundle.get("batter_baseline_meta", pd.DataFrame()), pd.DataFrame):
-        available_hitters = {
-            str(name).strip().lower()
-            for name in snapshot_bundle.get("batter_baseline_meta", pd.DataFrame())
-            .get("player_name", pd.Series(dtype="object"))
-            .dropna()
-            .astype(str)
-            .tolist()
-        }
-
-    available_pitchers: set[str] = set()
-    if isinstance(snapshot_bundle.get("pitcher_baseline_meta", pd.DataFrame()), pd.DataFrame):
-        available_pitchers = {
-            str(name).strip().lower()
-            for name in snapshot_bundle.get("pitcher_baseline_meta", pd.DataFrame())
-            .get("player_name", pd.Series(dtype="object"))
-            .dropna()
-            .astype(str)
-            .tolist()
-        }
+    available_hitters = _normalized_name_set(
+        snapshot_bundle.get("batter_baseline_meta", pd.DataFrame())
+        .get("player_name", pd.Series(dtype="object"))
+        .dropna()
+        .astype(str)
+        .tolist()
+        if isinstance(snapshot_bundle.get("batter_baseline_meta", pd.DataFrame()), pd.DataFrame)
+        else []
+    )
+    available_pitchers = _normalized_name_set(
+        snapshot_bundle.get("pitcher_baseline_meta", pd.DataFrame())
+        .get("player_name", pd.Series(dtype="object"))
+        .dropna()
+        .astype(str)
+        .tolist()
+        if isinstance(snapshot_bundle.get("pitcher_baseline_meta", pd.DataFrame()), pd.DataFrame)
+        else []
+    )
 
-    missing_hitter_names = [
-        name for name in snapshot_batter_names
-        if str(name).strip().lower() not in available_hitters
-    ]
-    missing_pitcher_names = [
-        name for name in snapshot_pitcher_names
-        if str(name).strip().lower() not in available_pitchers
-    ]
+    missing_hitter_names = _compute_missing_requested_names(snapshot_batter_names, available_hitters)
+    missing_pitcher_names = _compute_missing_requested_names(snapshot_pitcher_names, available_pitchers)
 
     requested_hitter_covered = True
     if snapshot_batter_names:
@@ -1439,15 +1554,13 @@ def load_or_build_shared_baseline_bundle(
     background_refresh_queued = False
 
     if snapshot_has_data and requested_hitter_covered and requested_pitcher_covered and not snapshot_stale:
-        snapshot_bundle["requested_hitter_count"] = int(len(snapshot_batter_names))
-        snapshot_bundle["requested_pitcher_count"] = int(len(snapshot_pitcher_names))
-        snapshot_bundle["resolved_hitter_count"] = int(len(snapshot_batter_names) - len(missing_hitter_names))
-        snapshot_bundle["resolved_pitcher_count"] = int(len(snapshot_pitcher_names) - len(missing_pitcher_names))
-        snapshot_bundle["missing_hitter_names"] = missing_hitter_names
-        snapshot_bundle["missing_pitcher_names"] = missing_pitcher_names
-        snapshot_bundle["snapshot_coverage_mode"] = coverage_mode
-        snapshot_bundle["background_refresh_queued"] = background_refresh_queued
-        return snapshot_bundle
+        return _annotate_request_coverage(
+            snapshot_bundle,
+            requested_hitter_names=snapshot_batter_names,
+            requested_pitcher_names=snapshot_pitcher_names,
+            coverage_mode=coverage_mode,
+            background_refresh_queued=background_refresh_queued,
+        )
 
     if snapshot_has_data and (
         (requested_hitter_covered and requested_pitcher_covered and snapshot_stale)
@@ -1460,15 +1573,13 @@ def load_or_build_shared_baseline_bundle(
         )
         snapshot_bundle["snapshot_source_status"] = "snapshot_partial_served" if coverage_mode == "partial" else "snapshot_stale_served"
         snapshot_bundle["runtime_fallback_used"] = False
-        snapshot_bundle["requested_hitter_count"] = int(len(snapshot_batter_names))
-        snapshot_bundle["requested_pitcher_count"] = int(len(snapshot_pitcher_names))
-        snapshot_bundle["resolved_hitter_count"] = int(len(snapshot_batter_names) - len(missing_hitter_names))
-        snapshot_bundle["resolved_pitcher_count"] = int(len(snapshot_pitcher_names) - len(missing_pitcher_names))
-        snapshot_bundle["missing_hitter_names"] = missing_hitter_names
-        snapshot_bundle["missing_pitcher_names"] = missing_pitcher_names
-        snapshot_bundle["snapshot_coverage_mode"] = coverage_mode
-        snapshot_bundle["background_refresh_queued"] = background_refresh_queued
-        return snapshot_bundle
+        return _annotate_request_coverage(
+            snapshot_bundle,
+            requested_hitter_names=snapshot_batter_names,
+            requested_pitcher_names=snapshot_pitcher_names,
+            coverage_mode=coverage_mode,
+            background_refresh_queued=background_refresh_queued,
+        )
 
     runtime_bundle = build_shared_baseline_bundle(
         batter_names=snapshot_batter_names,
@@ -1482,40 +1593,127 @@ def load_or_build_shared_baseline_bundle(
             runtime_bundle,
             source_status="runtime_refreshed",
         )
+        runtime_bundle["runtime_fallback_used"] = True
 
     if "snapshot_status" not in runtime_bundle:
         runtime_bundle["snapshot_status"] = snapshot_status
-    runtime_available_hitters = {
-        str(name).strip().lower()
-        for name in runtime_bundle.get("batter_baseline_meta", pd.DataFrame())
+    return _annotate_request_coverage(
+        runtime_bundle,
+        requested_hitter_names=snapshot_batter_names,
+        requested_pitcher_names=snapshot_pitcher_names,
+        coverage_mode="runtime_fallback",
+        background_refresh_queued=background_refresh_queued,
+    )
+
+
+def load_or_build_shared_baseline_bundle_complete_for_request(
+    batter_names: tuple[str, ...] = (),
+    pitcher_names: tuple[str, ...] = (),
+    max_age_seconds: int = _DEFAULT_SNAPSHOT_MAX_AGE_SECONDS,
+    persist_runtime_refresh: bool = True,
+) -> dict[str, pd.DataFrame]:
+    batter_names = _normalize_names_tuple(batter_names)
+    pitcher_names = _normalize_names_tuple(pitcher_names)
+    snapshot_batter_names = _resolve_snapshot_player_names(batter_names, role="batter")
+    snapshot_pitcher_names = _resolve_snapshot_player_names(pitcher_names, role="pitcher")
+
+    snapshot_bundle = load_shared_baseline_bundle_from_snapshots(
+        batter_names=snapshot_batter_names,
+        pitcher_names=snapshot_pitcher_names,
+        max_age_seconds=max_age_seconds,
+    )
+    snapshot_status = snapshot_bundle.get("snapshot_status", pd.DataFrame())
+    snapshot_has_data = not snapshot_bundle.get("blended_batter_df", pd.DataFrame()).empty or not snapshot_bundle.get("blended_pitcher_df", pd.DataFrame()).empty
+    snapshot_stale = bool(
+        isinstance(snapshot_status, pd.DataFrame)
+        and not snapshot_status.empty
+        and snapshot_status["stale"].fillna(False).any()
+    )
+
+    available_hitters = _normalized_name_set(
+        snapshot_bundle.get("batter_baseline_meta", pd.DataFrame())
         .get("player_name", pd.Series(dtype="object"))
         .dropna()
         .astype(str)
         .tolist()
-    }
-    runtime_available_pitchers = {
-        str(name).strip().lower()
-        for name in runtime_bundle.get("pitcher_baseline_meta", pd.DataFrame())
+        if isinstance(snapshot_bundle.get("batter_baseline_meta", pd.DataFrame()), pd.DataFrame)
+        else []
+    )
+    available_pitchers = _normalized_name_set(
+        snapshot_bundle.get("pitcher_baseline_meta", pd.DataFrame())
         .get("player_name", pd.Series(dtype="object"))
         .dropna()
         .astype(str)
         .tolist()
-    }
-    runtime_missing_hitter_names = [
-        name for name in snapshot_batter_names if str(name).strip().lower() not in runtime_available_hitters
-    ]
-    runtime_missing_pitcher_names = [
-        name for name in snapshot_pitcher_names if str(name).strip().lower() not in runtime_available_pitchers
-    ]
-    runtime_bundle["requested_hitter_count"] = int(len(snapshot_batter_names))
-    runtime_bundle["requested_pitcher_count"] = int(len(snapshot_pitcher_names))
-    runtime_bundle["resolved_hitter_count"] = int(len(snapshot_batter_names) - len(runtime_missing_hitter_names))
-    runtime_bundle["resolved_pitcher_count"] = int(len(snapshot_pitcher_names) - len(runtime_missing_pitcher_names))
-    runtime_bundle["missing_hitter_names"] = runtime_missing_hitter_names
-    runtime_bundle["missing_pitcher_names"] = runtime_missing_pitcher_names
-    runtime_bundle["snapshot_coverage_mode"] = "runtime_fallback"
-    runtime_bundle["background_refresh_queued"] = background_refresh_queued
-    return runtime_bundle
+        if isinstance(snapshot_bundle.get("pitcher_baseline_meta", pd.DataFrame()), pd.DataFrame)
+        else []
+    )
+    missing_hitter_names = _compute_missing_requested_names(snapshot_batter_names, available_hitters)
+    missing_pitcher_names = _compute_missing_requested_names(snapshot_pitcher_names, available_pitchers)
+
+    if snapshot_has_data and not missing_hitter_names and not missing_pitcher_names:
+        coverage_mode = "full" if not snapshot_stale else "stale_full"
+        background_refresh_queued = False
+        if snapshot_stale:
+            background_refresh_queued = queue_shared_baseline_refresh(
+                batter_names=snapshot_batter_names,
+                pitcher_names=snapshot_pitcher_names,
+            )
+            snapshot_bundle["snapshot_source_status"] = "snapshot_stale_served"
+        return _annotate_request_coverage(
+            snapshot_bundle,
+            requested_hitter_names=snapshot_batter_names,
+            requested_pitcher_names=snapshot_pitcher_names,
+            coverage_mode=coverage_mode,
+            background_refresh_queued=background_refresh_queued,
+        )
+
+    if snapshot_has_data and (missing_hitter_names or missing_pitcher_names):
+        patch_bundle = build_shared_baseline_bundle(
+            batter_names=tuple(sorted(missing_hitter_names)),
+            pitcher_names=tuple(sorted(missing_pitcher_names)),
+        )
+        if persist_runtime_refresh:
+            patch_bundle = persist_shared_baseline_snapshots(
+                patch_bundle,
+                source_status="runtime_request_patch",
+            )
+        merged_bundle = _merge_shared_baseline_bundles(snapshot_bundle, patch_bundle)
+        if snapshot_stale:
+            merged_bundle["background_refresh_queued"] = queue_shared_baseline_refresh(
+                batter_names=snapshot_batter_names,
+                pitcher_names=snapshot_pitcher_names,
+            )
+        return _annotate_request_coverage(
+            merged_bundle,
+            requested_hitter_names=snapshot_batter_names,
+            requested_pitcher_names=snapshot_pitcher_names,
+            coverage_mode="request_completed_patch",
+            background_refresh_queued=bool(merged_bundle.get("background_refresh_queued")),
+        )
+
+    runtime_bundle = build_shared_baseline_bundle(
+        batter_names=snapshot_batter_names,
+        pitcher_names=snapshot_pitcher_names,
+    )
+    runtime_bundle["snapshot_source_status"] = "runtime_fallback"
+    runtime_bundle["runtime_fallback_used"] = True
+    runtime_bundle["request_patch_used"] = False
+    if persist_runtime_refresh:
+        runtime_bundle = persist_shared_baseline_snapshots(
+            runtime_bundle,
+            source_status="runtime_refreshed",
+        )
+        runtime_bundle["runtime_fallback_used"] = True
+    if "snapshot_status" not in runtime_bundle:
+        runtime_bundle["snapshot_status"] = snapshot_status
+    return _annotate_request_coverage(
+        runtime_bundle,
+        requested_hitter_names=snapshot_batter_names,
+        requested_pitcher_names=snapshot_pitcher_names,
+        coverage_mode="runtime_fallback",
+        background_refresh_queued=False,
+    )
 
 
 def build_shared_baseline_bundle(

tests/test_props_mapper.py

@@ -603,6 +603,218 @@ class TestPropsMapper(unittest.TestCase):
         self.assertEqual(row["model_voice_tags"], ["arsenal_favorable"])
         self.assertIn("arsenal", str(row["model_voice"]).lower())
 
+    def test_props_mapper_matches_pitcher_aliases_across_starters_and_baseline(self) -> None:
+        props_df = pd.DataFrame(
+            [
+                {
+                    "market": "hr",
+                    "player_name": "alek thomas",
+                    "player_name_raw": "Alek Thomas",
+                    "odds_american": 450,
+                    "sportsbook": "Caesars",
+                    "away_team": "Arizona Diamondbacks",
+                    "home_team": "Los Angeles Dodgers",
+                    "commence_time": "2026-03-25T00:10:00Z",
+                }
+            ]
+        )
+        statcast_df = pd.DataFrame(
+            [
+                {
+                    "player_name": "Alek Thomas",
+                    "inning_topbot": "Top",
+                    "away_team": "Arizona Diamondbacks",
+                    "home_team": "Los Angeles Dodgers",
+                    "baseline_mode": "blended",
+                }
+            ]
+        )
+        pitcher_statcast_df = pd.DataFrame(
+            [
+                {
+                    "player_name": "Rodriguez, Eduardo",
+                    "baseline_mode": "prior_only",
+                    "prior_sample_size": 5000,
+                    "season_2026_sample_size": 0,
+                    "prior_weight": 1.0,
+                    "season_2026_weight": 0.0,
+                    "baseline_driver": "prior_led",
+                    "rolling_overlay_active": False,
+                    "p_throws": "L",
+                }
+            ]
+        )
+        probable_starters = {
+            ("arizona diamondbacks", "los angeles dodgers"): {
+                "home_pitcher": "Eduardo Rodriguez",
+                "away_pitcher": "Someone Else",
+            }
+        }
+
+        with patch(
+            "analytics.props_mapper.build_hr_probability_result",
+            return_value={
+                "adjusted_hr_prob": 0.04,
+                "raw_hr_prob": 0.04,
+                "calibrated_hr_prob": 0.04,
+                "baseline_hr_prob": 0.03,
+                "pregame_hr_prob": 0.04,
+                "mode": "pregame",
+                "applied_layers": "pitcher",
+                "skipped_layers": "",
+                "confidence_score": 70.0,
+                "confidence_bucket": "medium",
+                "confidence_reasons": [],
+                "opportunity_hr_adjustment": 0.0,
+                "expected_pa": 4.3,
+                "pa_multiplier": 1.0,
+                "lineup_slot_used": None,
+                "lineup_slot_source": "unknown",
+                "team_total_used": None,
+                "team_total_source": "unknown",
+                "opportunity_mode": None,
+                "opportunity_reason": None,
+                "pregame_pitcher_context_adj": 0.0,
+                "pregame_park_context_adj": 0.0,
+                "pregame_weather_context_adj": 0.0,
+                "pregame_context_applied": True,
+                "pitcher_hr_adjustment": 0.0,
+                "trend_hr_adjustment": 0.0,
+                "zone_hr_adjustment": 0.0,
+                "family_zone_hr_adjustment": 0.0,
+                "arsenal_hr_adjustment": 0.0,
+                "pulled_contact_hr_adjustment": 0.0,
+                "env_hr_adjustment": 0.0,
+                "park_hr_adjustment": 0.0,
+                "weather_hr_adjustment": 0.0,
+                "platoon_hr_adjustment": 0.0,
+                "trajectory_hr_adjustment": 0.0,
+                "rolling_hr_adjustment": 0.0,
+                "pitcher_reliability": 0.8,
+                "pitcher_resolution_status": "resolved",
+                "trend_reliability": 0.0,
+                "zone_reliability": 0.0,
+                "family_zone_reliability": 0.0,
+                "arsenal_reliability": 0.0,
+                "pulled_contact_reliability": 0.0,
+                "environment_reliability": 0.0,
+                "trajectory_reliability": 0.0,
+                "rolling_reliability": 0.0,
+                "opportunity_reliability": 0.0,
+                "matchup_platoon_multiplier": 1.0,
+                "matchup_platoon_reason": "unknown",
+            },
+        ):
+            result = map_hr_props_to_model(
+                props_df,
+                statcast_df,
+                pitcher_statcast_df=pitcher_statcast_df,
+                probable_starters=probable_starters,
+            )
+
+        row = result.iloc[0]
+        self.assertEqual(row["resolved_pitcher_name"], "Eduardo Rodriguez")
+        self.assertEqual(row["pitcher_baseline_mode"], "prior_only")
+        self.assertEqual(row["projected_starter_match_status"], "matched_projected_home")
+
+    def test_props_mapper_uses_current_season_statcast_team_when_row_team_is_missing(self) -> None:
+        props_df = pd.DataFrame(
+            [
+                {
+                    "market": "hr",
+                    "player_name": "andrew benintendi",
+                    "player_name_raw": "Andrew Benintendi",
+                    "odds_american": 500,
+                    "sportsbook": "BetMGM",
+                    "away_team": "Chicago White Sox",
+                    "home_team": "Toronto Blue Jays",
+                    "commence_time": "2026-03-25T00:10:00Z",
+                }
+            ]
+        )
+        statcast_df = pd.DataFrame(
+            [
+                {
+                    "player_name": "Andrew Benintendi",
+                    "inning_topbot": "Top",
+                    "away_team": "Chicago White Sox",
+                    "home_team": "Toronto Blue Jays",
+                    "source_season": 2026,
+                }
+            ]
+        )
+        probable_starters = {
+            ("chicago white sox", "toronto blue jays"): {
+                "home_pitcher": "Anthony Kay",
+                "away_pitcher": "Brandon Sproat",
+            }
+        }
+
+        with patch(
+            "analytics.props_mapper.build_hr_probability_result",
+            return_value={
+                "adjusted_hr_prob": 0.03,
+                "raw_hr_prob": 0.03,
+                "calibrated_hr_prob": 0.03,
+                "baseline_hr_prob": 0.02,
+                "pregame_hr_prob": 0.03,
+                "mode": "pregame",
+                "applied_layers": "pitcher",
+                "skipped_layers": "",
+                "confidence_score": 68.0,
+                "confidence_bucket": "medium",
+                "confidence_reasons": [],
+                "opportunity_hr_adjustment": 0.0,
+                "expected_pa": 4.2,
+                "pa_multiplier": 1.0,
+                "lineup_slot_used": None,
+                "lineup_slot_source": "unknown",
+                "team_total_used": None,
+                "team_total_source": "unknown",
+                "opportunity_mode": None,
+                "opportunity_reason": None,
+                "pregame_pitcher_context_adj": 0.0,
+                "pregame_park_context_adj": 0.0,
+                "pregame_weather_context_adj": 0.0,
+                "pregame_context_applied": True,
+                "pitcher_hr_adjustment": 0.0,
+                "trend_hr_adjustment": 0.0,
+                "zone_hr_adjustment": 0.0,
+                "family_zone_hr_adjustment": 0.0,
+                "arsenal_hr_adjustment": 0.0,
+                "pulled_contact_hr_adjustment": 0.0,
+                "env_hr_adjustment": 0.0,
+                "park_hr_adjustment": 0.0,
+                "weather_hr_adjustment": 0.0,
+                "platoon_hr_adjustment": 0.0,
+                "trajectory_hr_adjustment": 0.0,
+                "rolling_hr_adjustment": 0.0,
+                "pitcher_reliability": 0.8,
+                "pitcher_resolution_status": "resolved",
+                "trend_reliability": 0.0,
+                "zone_reliability": 0.0,
+                "family_zone_reliability": 0.0,
+                "arsenal_reliability": 0.0,
+                "pulled_contact_reliability": 0.0,
+                "environment_reliability": 0.0,
+                "trajectory_reliability": 0.0,
+                "rolling_reliability": 0.0,
+                "opportunity_reliability": 0.0,
+                "matchup_platoon_multiplier": 1.0,
+                "matchup_platoon_reason": "unknown",
+            },
+        ):
+            result = map_hr_props_to_model(
+                props_df,
+                statcast_df,
+                probable_starters=probable_starters,
+            )
+
+        row = result.iloc[0]
+        self.assertEqual(row["batter_team"], "Chicago White Sox")
+        self.assertEqual(row["batter_team_source"], "current_season_statcast")
+        self.assertEqual(row["resolved_pitcher_name"], "Anthony Kay")
+
     def test_unmodeled_hr_ladders_do_not_get_model_probability(self) -> None:
         props_df = pd.DataFrame(
             [

tests/test_shared_baseline.py

@@ -8,10 +8,13 @@ import pandas as pd
 
 sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
 
-from data.shared_baseline import _blend_entity_frames
+from data.shared_baseline import _blend_entity_frames, _normalize_name
 
 
 class TestSharedBaseline(unittest.TestCase):
+    def test_normalize_name_matches_first_last_and_last_first(self) -> None:
+        self.assertEqual(_normalize_name("Eduardo Rodriguez"), _normalize_name("Rodriguez, Eduardo"))
+
     def test_blend_entity_frames_prefers_prior_when_current_sample_is_small(self) -> None:
         prior_df = pd.DataFrame(
             [

visualization/debug_page.py

@@ -177,7 +177,11 @@ def _build_model_upgrade_rubric(
             "count_pattern_damage_subscore",
         ]
     )
-    has_k_v2 = has_shared and "expected_strikeouts_v2" in rows.columns
+    has_k_v2 = has_shared and (
+        ("market_family" in rows.columns and rows["market_family"].astype(str).str.lower().eq("k").any())
+        or "expected_strikeouts_v2" in rows.columns
+        or "expected_strikeouts" in rows.columns
+    )
     has_opportunity = has_shared and any(
         col in rows.columns
         for col in ["projected_pitch_count", "projected_batters_faced", "projected_innings"]
@@ -780,7 +784,19 @@ def render_debug(
     # ------------------------------------------------------------------
     # SECTION 5c — Execution Layer
     # ------------------------------------------------------------------
-    exec_df = st.session_state.get("props_exec_df")
+    active_exec_df = st.session_state.get("props_exec_df")
+    props_modeled_market_bundle = st.session_state.get("props_modeled_market_bundle") or {}
+    props_market_debug_bundle = st.session_state.get("props_market_debug_bundle") or {}
+    combined_exec_frames: list[pd.DataFrame] = []
+    for payload in props_modeled_market_bundle.values():
+        mapped = payload.get("mapped", pd.DataFrame()) if isinstance(payload, dict) else pd.DataFrame()
+        if isinstance(mapped, pd.DataFrame) and not mapped.empty:
+            combined_exec_frames.append(mapped.copy())
+    exec_df = (
+        pd.concat(combined_exec_frames, ignore_index=True, sort=False)
+        if combined_exec_frames
+        else active_exec_df
+    )
     with st.expander("Execution Layer (Props)", expanded=False):
         if exec_df is None or (isinstance(exec_df, pd.DataFrame) and exec_df.empty):
             st.info("No execution layer data. Visit the Props tab first.")
@@ -885,7 +901,7 @@ def render_debug(
                 "model_hr_prob_source",
             ]
             with vm_tab_normalized:
-                st.write("Normalized HR rows")
+                st.write("Normalized props rows")
                 st.dataframe(
                     exec_df[[c for c in normalized_cols if c in exec_df.columns]],
                     use_container_width=True,
@@ -1285,51 +1301,40 @@ def render_debug(
                     )
 
             with st.expander("Props Baseline Diagnostics", expanded=False):
-                props_baseline_debug = st.session_state.get("props_baseline_debug") or {}
-                if props_baseline_debug:
-                    c1, c2, c3 = st.columns(3)
-                    c1.metric(
-                        "Coverage Mode",
-                        str(props_baseline_debug.get("snapshot_coverage_mode") or "unknown").replace("_", " ").title(),
-                    )
-                    c2.metric(
-                        "Runtime Fallback Used",
-                        "Yes" if bool(props_baseline_debug.get("runtime_fallback_used")) else "No",
-                    )
-                    c3.metric(
-                        "Background Refresh Queued",
-                        "Yes" if bool(props_baseline_debug.get("background_refresh_queued")) else "No",
-                    )
-
-                    counts_df = pd.DataFrame(
-                        [
+                baseline_debug_rows = []
+                for market_key, payload in props_market_debug_bundle.items():
+                    baseline_debug = (payload or {}).get("baseline_debug") or {}
+                    if baseline_debug:
+                        baseline_debug_rows.append(
                             {
-                                "market_type": props_baseline_debug.get("market_type"),
-                                "baseline_source": props_baseline_debug.get("baseline_source"),
-                                "requested_hitter_count": props_baseline_debug.get("requested_hitter_count"),
-                                "resolved_hitter_count": props_baseline_debug.get("resolved_hitter_count"),
-                                "requested_pitcher_count": props_baseline_debug.get("requested_pitcher_count"),
-                                "resolved_pitcher_count": props_baseline_debug.get("resolved_pitcher_count"),
-                                "slate_team_scope": ", ".join(props_baseline_debug.get("slate_team_scope") or []),
+                                "market_type": market_key,
+                                "baseline_source": baseline_debug.get("baseline_source"),
+                                "coverage_mode": baseline_debug.get("snapshot_coverage_mode"),
+                                "runtime_fallback_used": baseline_debug.get("runtime_fallback_used"),
+                                "request_patch_used": baseline_debug.get("request_patch_used"),
+                                "background_refresh_queued": baseline_debug.get("background_refresh_queued"),
+                                "requested_hitter_count": baseline_debug.get("requested_hitter_count"),
+                                "resolved_hitter_count": baseline_debug.get("resolved_hitter_count"),
+                                "requested_pitcher_count": baseline_debug.get("requested_pitcher_count"),
+                                "resolved_pitcher_count": baseline_debug.get("resolved_pitcher_count"),
+                                "slate_team_scope": ", ".join(baseline_debug.get("slate_team_scope") or []),
+                                "missing_hitter_names": ", ".join(baseline_debug.get("missing_hitter_names") or []),
+                                "missing_pitcher_names": ", ".join(baseline_debug.get("missing_pitcher_names") or []),
                             }
-                        ]
-                    )
-                    st.dataframe(counts_df, use_container_width=True, hide_index=True)
-
-                    missing_rows = pd.DataFrame(
-                        [
-                            {
-                                "missing_hitter_names": ", ".join(props_baseline_debug.get("missing_hitter_names") or []),
-                                "missing_pitcher_names": ", ".join(props_baseline_debug.get("missing_pitcher_names") or []),
-                            }
-                        ]
-                    )
-                    st.dataframe(missing_rows, use_container_width=True, hide_index=True)
+                        )
+                if baseline_debug_rows:
+                    baseline_debug_df = pd.DataFrame(baseline_debug_rows)
+                    c1, c2, c3, c4 = st.columns(4)
+                    c1.metric("Markets Captured", len(baseline_debug_rows))
+                    c2.metric("Any Runtime Fallback", "Yes" if baseline_debug_df["runtime_fallback_used"].fillna(False).astype(bool).any() else "No")
+                    c3.metric("Any Request Patch", "Yes" if baseline_debug_df["request_patch_used"].fillna(False).astype(bool).any() else "No")
+                    c4.metric("Any Refresh Queued", "Yes" if baseline_debug_df["background_refresh_queued"].fillna(False).astype(bool).any() else "No")
+                    st.dataframe(baseline_debug_df, use_container_width=True, hide_index=True)
                 else:
                     st.info("Open the Props page in this session to capture Props baseline diagnostics.")
 
             with st.expander("Props HR Health Diagnostics", expanded=False):
-                props_hr_health_debug = st.session_state.get("props_hr_health_debug") or {}
+                props_hr_health_debug = ((props_market_debug_bundle.get("hr") or {}).get("hr_health_debug")) or {}
                 if props_hr_health_debug:
                     c1, c2, c3, c4, c5 = st.columns(5)
                     c1.metric("Modeled 1+ HR Rows", int(props_hr_health_debug.get("modeled_hr_rows_total") or 0))
@@ -1359,25 +1364,48 @@ def render_debug(
                     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)
+                shared_component_rows = []
+                executed_rows = []
+                gating_rows = []
+                failure_summary_rows = []
+                for market_key, payload in props_market_debug_bundle.items():
+                    shared_component_debug = (payload or {}).get("shared_component_debug") or {}
+                    for row in shared_component_debug.get("rows") or []:
+                        shared_component_rows.append({"market_type": market_key, **row})
+                    for row in shared_component_debug.get("executed_rows") or []:
+                        executed_rows.append({"market_type": market_key, **row})
+                    for row in shared_component_debug.get("gating_rows") or []:
+                        gating_rows.append({"market_type": market_key, **row})
+                    for row in shared_component_debug.get("failure_summary") or []:
+                        failure_summary_rows.append({"market_type": market_key, **row})
+                if shared_component_rows:
+                    summary_df = pd.DataFrame(failure_summary_rows)
+                    if not summary_df.empty:
+                        st.write("Failure Summary")
+                        st.dataframe(summary_df, use_container_width=True, hide_index=True)
+                    if gating_rows:
+                        st.write("Upstream Gating Failures")
+                        st.dataframe(pd.DataFrame(gating_rows), use_container_width=True, hide_index=True)
+                    if executed_rows:
+                        st.write("Executed Matchup Components")
+                        st.dataframe(pd.DataFrame(executed_rows), use_container_width=True, hide_index=True)
                     else:
-                        st.info("No shared-component rows captured in this session.")
+                        st.info("No shared-component execution 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 {}
+                props_hr_health_debug = ((props_market_debug_bundle.get("hr") or {}).get("hr_health_debug")) or {}
+                combined_shared_component_debug = {
+                    "rows": [
+                        row
+                        for payload in props_market_debug_bundle.values()
+                        for row in ((payload or {}).get("shared_component_debug") or {}).get("executed_rows", [])
+                    ]
+                }
                 rubric_df, rubric_summary = _build_model_upgrade_rubric(
                     props_hr_health_debug=props_hr_health_debug,
-                    shared_component_debug=shared_component_debug,
+                    shared_component_debug=combined_shared_component_debug,
                 )
                 c1, c2, c3 = st.columns(3)
                 c1.metric(
@@ -1462,6 +1490,8 @@ def render_debug(
                             "source": "cached_probable_starters",
                             "row_count": int(starters_meta.iloc[0]["matchup_count"]) if not starters_meta.empty else 0,
                             "latest_fetched_at": starters_meta.iloc[0]["fetched_at"] if not starters_meta.empty else None,
+                            "refresh_mode": st.session_state.get("probable_starters_refresh_mode"),
+                            "cache_age_seconds": st.session_state.get("probable_starters_cache_age_seconds"),
                         }
                     )
                 except Exception:

visualization/props_page.py

@@ -24,7 +24,7 @@ from analytics.props_view_model import (
     build_hr_props_view_model,
     select_best_lines_per_prop,
 )
-from data.shared_baseline import load_or_build_shared_baseline_bundle
+from data.shared_baseline import load_or_build_shared_baseline_bundle_complete_for_request
 from data.live_prop_odds import fetch_all_upcoming_hr_props
 from database.db import (
     ensure_upcoming_hr_props_table,
@@ -635,7 +635,7 @@ def _load_props_market_baseline_bundle(
     hitter_names: tuple[str, ...],
     pitcher_names: tuple[str, ...],
 ) -> dict[str, Any]:
-    bundle = load_or_build_shared_baseline_bundle(
+    bundle = load_or_build_shared_baseline_bundle_complete_for_request(
         batter_names=hitter_names,
         pitcher_names=pitcher_names,
         max_age_seconds=60 * 60,
@@ -657,6 +657,7 @@ def _load_props_market_baseline_bundle(
         "missing_pitcher_names": bundle.get("missing_pitcher_names", []),
         "snapshot_coverage_mode": bundle.get("snapshot_coverage_mode"),
         "background_refresh_queued": bundle.get("background_refresh_queued"),
+        "request_patch_used": bundle.get("request_patch_used"),
     }
 
 
@@ -742,6 +743,49 @@ def _build_market_modeling_payload(
     }
 
 
+def _build_props_market_debug_payload(
+    *,
+    market_type: str,
+    payload: dict[str, Any],
+) -> dict[str, Any]:
+    baseline_request = payload.get("baseline_request") or {}
+    baseline_bundle = payload.get("baseline_bundle") or {}
+    mapped = payload.get("mapped", pd.DataFrame())
+    baseline_debug = {
+        "market_type": market_type,
+        "slate_team_scope": list(baseline_request.get("slate_team_scope") or []),
+        "requested_hitter_count": int(baseline_bundle.get("requested_hitter_count", len(baseline_request.get("hitter_names") or ()))),
+        "requested_pitcher_count": int(baseline_bundle.get("requested_pitcher_count", len(baseline_request.get("pitcher_names") or ()))),
+        "resolved_hitter_count": int(baseline_bundle.get("resolved_hitter_count", 0)),
+        "resolved_pitcher_count": int(baseline_bundle.get("resolved_pitcher_count", 0)),
+        "missing_hitter_names": list(baseline_bundle.get("missing_hitter_names", [])),
+        "missing_pitcher_names": list(baseline_bundle.get("missing_pitcher_names", [])),
+        "snapshot_coverage_mode": str(baseline_bundle.get("snapshot_coverage_mode") or "unknown"),
+        "runtime_fallback_used": bool(baseline_bundle.get("runtime_fallback_used")),
+        "background_refresh_queued": bool(baseline_bundle.get("background_refresh_queued")),
+        "request_patch_used": bool(baseline_bundle.get("request_patch_used")),
+        "baseline_source": str(baseline_bundle.get("snapshot_source_status") or "unknown"),
+    }
+    hr_health = None
+    if market_type == "hr":
+        hr_health = _build_hr_health_debug(
+            mapped,
+            extra_context={
+                "requested_hitter_count": baseline_debug.get("requested_hitter_count"),
+                "resolved_hitter_count": baseline_debug.get("resolved_hitter_count"),
+                "requested_pitcher_count": baseline_debug.get("requested_pitcher_count"),
+                "resolved_pitcher_count": baseline_debug.get("resolved_pitcher_count"),
+            },
+        )
+    return {
+        "market_type": market_type,
+        "baseline_debug": baseline_debug,
+        "hr_health_debug": hr_health,
+        "shared_component_debug": _build_shared_component_debug(mapped, market_type=market_type),
+        "mapped": mapped,
+    }
+
+
 @st.cache_data(ttl=60 * 10, show_spinner=False)
 def _build_modeled_market_bundle(
     raw: pd.DataFrame,
@@ -774,42 +818,13 @@ def _hydrate_props_debug_state(
     market_type: str,
     payload: dict[str, Any],
 ) -> None:
-    baseline_request = payload.get("baseline_request") or {}
-    baseline_bundle = payload.get("baseline_bundle") or {}
-    mapped = payload.get("mapped", pd.DataFrame())
-
-    st.session_state["props_baseline_debug"] = {
-        "market_type": market_type,
-        "slate_team_scope": list(baseline_request.get("slate_team_scope") or []),
-        "requested_hitter_count": int(baseline_bundle.get("requested_hitter_count", len(baseline_request.get("hitter_names") or ()))),
-        "requested_pitcher_count": int(baseline_bundle.get("requested_pitcher_count", len(baseline_request.get("pitcher_names") or ()))),
-        "resolved_hitter_count": int(baseline_bundle.get("resolved_hitter_count", 0)),
-        "resolved_pitcher_count": int(baseline_bundle.get("resolved_pitcher_count", 0)),
-        "missing_hitter_names": list(baseline_bundle.get("missing_hitter_names", [])),
-        "missing_pitcher_names": list(baseline_bundle.get("missing_pitcher_names", [])),
-        "snapshot_coverage_mode": str(baseline_bundle.get("snapshot_coverage_mode") or "unknown"),
-        "runtime_fallback_used": bool(baseline_bundle.get("runtime_fallback_used")),
-        "background_refresh_queued": bool(baseline_bundle.get("background_refresh_queued")),
-        "baseline_source": str(baseline_bundle.get("snapshot_source_status") or "unknown"),
-    }
-
+    debug_payload = _build_props_market_debug_payload(market_type=market_type, payload=payload)
+    st.session_state["props_baseline_debug"] = debug_payload.get("baseline_debug") or {}
     if market_type == "hr":
-        st.session_state["props_hr_health_debug"] = _build_hr_health_debug(
-            mapped,
-            extra_context={
-                "requested_hitter_count": st.session_state.get("props_baseline_debug", {}).get("requested_hitter_count"),
-                "resolved_hitter_count": st.session_state.get("props_baseline_debug", {}).get("resolved_hitter_count"),
-                "requested_pitcher_count": st.session_state.get("props_baseline_debug", {}).get("requested_pitcher_count"),
-                "resolved_pitcher_count": st.session_state.get("props_baseline_debug", {}).get("resolved_pitcher_count"),
-            },
-        )
+        st.session_state["props_hr_health_debug"] = debug_payload.get("hr_health_debug") or {}
     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,
-    )
+    st.session_state["props_shared_component_debug"] = debug_payload.get("shared_component_debug") or {}
 
 
 def _build_best_on_slate_source(
@@ -1197,9 +1212,10 @@ def _build_hr_health_debug(display: pd.DataFrame, extra_context: dict[str, Any]
 
 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": []}
+        return {"market_type": market_type, "rows": [], "executed_rows": [], "gating_rows": [], "failure_summary": []}
 
     cols = [
+        "market_family",
         "player_name",
         "player_name_raw",
         "display_label",
@@ -1245,10 +1261,65 @@ def _build_shared_component_debug(display: pd.DataFrame, market_type: str) -> di
         "predicted_whiff_regions",
         "component_source_map",
         "expected_pitch_family_mix",
+        "baseline_mode",
+        "pitcher_resolution_status",
+        "modeled_row_available",
+        "modeled_row_missing_reason",
     ]
+    working = display[[c for c in cols if c in display.columns]].copy()
+
+    def _status(row: pd.Series) -> str:
+        baseline_mode = str(row.get("baseline_mode") or "").strip().lower()
+        starter_status = str(row.get("projected_starter_match_status") or "").strip().lower()
+        pitcher_status = str(row.get("pitcher_resolution_status") or "").strip().lower()
+        shared_available = str(row.get("shared_matchup_available") or "").strip().lower()
+        telemetry_status = str(row.get("telemetry_path_status") or "").strip().lower()
+        if not baseline_mode or baseline_mode in {"none", "nan", "unavailable"}:
+            return "missing_baseline"
+        if starter_status == "projected_starter_unavailable":
+            return "projected_starter_unavailable"
+        if starter_status == "projected_starter_available_but_unresolved":
+            return "projected_starter_available_but_unresolved"
+        if pitcher_status in {"pitcher_missing", "unresolved", "matchup_incomplete", "resolved_no_pitcher_statcast"}:
+            return pitcher_status or "pitcher_resolution_failure"
+        if shared_available in {"1", "true", "yes"} or telemetry_status in {
+            "full_telemetry",
+            "partial_telemetry",
+            "core_baseline_plus_projected_pitcher",
+            "baseline_only_degraded",
+        }:
+            return "executed"
+        component_cols = [
+            "damage_zone_alignment_subscore",
+            "pitch_mix_exposure_subscore",
+            "tunnel_damage_subscore",
+            "count_pattern_damage_subscore",
+            "handedness_damage_subscore",
+            "arsenal_fit_subscore",
+            "zone_matchup_subscore",
+            "family_zone_matchup_subscore",
+            "tunneling_subscore",
+            "sequencing_subscore",
+        ]
+        if any(pd.notna(row.get(col)) for col in component_cols):
+            return "executed"
+        return "prerequisites_not_met"
+
+    working["component_execution_status"] = working.apply(_status, axis=1)
+    executed = working[working["component_execution_status"] == "executed"].copy()
+    gating = working[working["component_execution_status"] != "executed"].copy()
+    failure_summary = (
+        working["component_execution_status"]
+        .value_counts(dropna=False)
+        .rename_axis("failure_reason")
+        .reset_index(name="row_count")
+    )
     return {
         "market_type": market_type,
-        "rows": display[[c for c in cols if c in display.columns]].head(30).to_dict("records"),
+        "rows": working.head(30).to_dict("records"),
+        "executed_rows": executed.head(30).to_dict("records"),
+        "gating_rows": gating.head(30).to_dict("records"),
+        "failure_summary": failure_summary.to_dict("records"),
     }
 
 
@@ -1290,9 +1361,9 @@ def render_props_hero(display_df: pd.DataFrame, view_model: dict[str, Any] | Non
         hero_cols = st.columns(6)
         hero_cols[0].metric("Games", int(len(games_summary_df)) if not games_summary_df.empty else int(display_df["event_id"].nunique() if "event_id" in display_df.columns else 0))
         hero_cols[1].metric("Books", len(available_books))
-        hero_cols[2].metric("Modeled 1+ HR", int(len(modeled_display)) if not modeled_display.empty else 0)
-        hero_cols[3].metric("Best Edge", _format_edge(float(best_edge)) if best_edge is not None else "-")
-        hero_cols[4].metric("Best EV", _format_ev(float(best_ev)) if best_ev is not None else "-")
+        hero_cols[2].metric("Modeled 1+ HR Rows", int(len(modeled_display)) if not modeled_display.empty else 0)
+        hero_cols[3].metric("Best Edge (modeled)", _format_edge(float(best_edge)) if best_edge is not None else "-")
+        hero_cols[4].metric("Best EV (modeled)", _format_ev(float(best_ev)) if best_ev is not None else "-")
         hero_cols[5].metric("Avg Featured EV", _format_ev(float(avg_featured_ev)) if avg_featured_ev is not None else "-")
 
 
@@ -1719,10 +1790,10 @@ def _render_summary_metrics(display: pd.DataFrame, market_type: str) -> None:
     if market_type == "hr":
         col1, col2, col3 = st.columns(3)
         modeled_display = _modeled_hr_primary_subset(display)
-        col1.metric("Props shown", len(modeled_display))
+        col1.metric("Shown modeled 1+ HR", len(modeled_display))
         with_edge = modeled_display["edge"].dropna() if "edge" in modeled_display.columns else pd.Series(dtype=float)
         with_ev = modeled_display["bet_ev"].dropna() if "bet_ev" in modeled_display.columns else pd.Series(dtype=float)
-        col2.metric("With model edge", len(with_edge))
+        col2.metric("Shown rows with priced edge", len(with_edge))
         col3.metric("Best EV", _format_ev(float(with_ev.max())) if not with_ev.empty else "-")
     else:
         col1, col2, col3 = st.columns(3)
@@ -1842,6 +1913,10 @@ def render_props(
         probable_starters=probable_starters,
     )
     st.session_state["props_modeled_market_bundle"] = modeled_market_bundle
+    st.session_state["props_market_debug_bundle"] = {
+        market: _build_props_market_debug_payload(market_type=market, payload=payload)
+        for market, payload in modeled_market_bundle.items()
+    }
 
     available_markets = sorted(raw["market"].dropna().unique().tolist())
     default_idx = available_markets.index("hr") if "hr" in available_markets else 0