Audit-confirmed fixes: matchup confidence blend + platoon unknown handling

- zone_matchup_model + matchup_model: sample_size now populated so
confidence_blend branch is reachable (was always max_fallback before)
- live_fair_simulator_v3: batter_stand/p_throws default to None →
unknown rows get multiplier 1.0 instead of false 0.92 suppression
- Supporting changes: props mapper, recommendation engine, schedule,
scores, bullpen model, pitcher adjustment/state, rolling form,
zone matchup, debug page, logger utility

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

analytics/props_mapper.py

@@ -28,6 +28,79 @@ import pandas as pd
 from analytics.no_vig_props import american_to_implied_prob, compute_edge
 from data.odds_name_map import map_odds_name_to_model_name
 from models.batter_baseline import build_batter_feature_row, compute_batter_baseline
+from models.pitcher_adjustment import build_pitcher_feature_row
+
+
+def _get_pregame_context_adjustments(
+    props_row: Any,
+    statcast_df: pd.DataFrame,
+) -> tuple[float, float, bool, str]:
+    """
+    Derive pitcher quality + park context adjustments for a pre-game props row.
+    Returns (pitcher_adj, park_adj, context_applied, source_detail_str).
+    All adjustments are no-op safe — any missing data yields 0.0.
+    """
+    pitcher_adj = 0.0
+    park_adj = 0.0
+    context_applied = False
+    source_parts: list[str] = ["baseline"]
+
+    # --- Pitcher context (only when pitcher_name is explicit in props row) ---
+    pitcher_name = None
+    for key in ("pitcher_name", "pitcher", "opposing_pitcher"):
+        val = props_row.get(key) if hasattr(props_row, "get") else None
+        if val and str(val).strip() not in ("", "nan", "None"):
+            pitcher_name = str(val).strip()
+            break
+
+    if pitcher_name and not statcast_df.empty:
+        try:
+            p_row = build_pitcher_feature_row(statcast_df, pitcher_name)
+            if p_row.get("sample_size", 0) > 0:
+                velo = p_row.get("avg_release_speed")
+                ev = p_row.get("ev_allowed")
+                barrel = p_row.get("barrel_rate_allowed")
+
+                quality_score = 0.0
+                if velo is not None:
+                    quality_score += (float(velo) - 93.0) * (-0.15)  # higher velo = better pitcher = negative for batter
+                if ev is not None:
+                    quality_score += (float(ev) - 89.0) * 0.08      # higher EV allowed = worse pitcher
+                if barrel is not None:
+                    quality_score += (float(barrel) - 0.07) * 1.0   # higher barrel = worse pitcher
+
+                pitcher_adj = max(-0.005, min(0.005, quality_score * 0.003))
+                if abs(pitcher_adj) > 0.0001:
+                    context_applied = True
+                    source_parts.append("pitcher_quality")
+        except Exception:
+            pass
+
+    # --- Park context (if venue available) ---
+    venue = None
+    for key in ("venue", "stadium", "venue_name", "park"):
+        val = props_row.get(key) if hasattr(props_row, "get") else None
+        if val and str(val).strip() not in ("", "nan", "None"):
+            venue = str(val).strip()
+            break
+
+    if venue:
+        try:
+            from models.environment_model import compute_environment_adjustment
+            env = compute_environment_adjustment(
+                game_row={"venue": venue, "stadium": venue},
+                weather_row=None,
+            )
+            raw_park = float(env.get("park_hr_boost", 0.0) or 0.0)
+            park_adj = max(-0.004, min(0.004, raw_park))
+            if abs(park_adj) > 0.0001:
+                context_applied = True
+                source_parts.append("park")
+        except Exception:
+            pass
+
+    source_detail = "+".join(source_parts)
+    return pitcher_adj, park_adj, context_applied, source_detail
 
 
 def _build_statcast_name_index(statcast_df: pd.DataFrame) -> dict[str, str]:
@@ -79,6 +152,7 @@ def map_hr_props_to_model(
     props_df: pd.DataFrame,
     statcast_df: pd.DataFrame,
     prob_fn: Callable[[str, pd.DataFrame, dict[str, str] | None], tuple[float | None, str]] | None = None,
+    pitcher_stats_df: pd.DataFrame | None = None,
 ) -> pd.DataFrame:
     """
     Join HR prop rows to model HR probabilities and compute edge.
@@ -105,10 +179,17 @@ def map_hr_props_to_model(
     # Build name index once for all players
     name_index = _build_statcast_name_index(statcast_df)
 
+    # Use pitcher_stats_df if provided, else fall back to statcast_df for pitcher lookups
+    _pitcher_df = pitcher_stats_df if pitcher_stats_df is not None else statcast_df
+
     implied_probs: list[float] = []
     model_probs: list[float | None] = []
     sources: list[str] = []
     edges: list[float | None] = []
+    pitcher_context_adjs: list[float | None] = []
+    park_context_adjs: list[float | None] = []
+    context_applied_flags: list[bool] = []
+    source_details: list[str] = []
 
     for _, row in hr_df.iterrows():
         odds = row.get("odds_american")
@@ -120,28 +201,50 @@ def map_hr_props_to_model(
         except Exception:
             implied = None
 
-        # Model HR probability
+        # Model HR probability (baseline only)
         if player_name:
             model_prob, source = _prob_fn(player_name, statcast_df, name_index)
         else:
             model_prob, source = None, "unavailable"
 
-        # Edge
-        if model_prob is not None and implied is not None:
-            edge = compute_edge(model_prob, implied)
+        # Pregame context adjustments (pitcher quality + park)
+        try:
+            pitcher_adj, park_adj, ctx_applied, src_detail = _get_pregame_context_adjustments(
+                row, _pitcher_df
+            )
+        except Exception:
+            pitcher_adj, park_adj, ctx_applied, src_detail = 0.0, 0.0, False, "baseline"
+
+        # Apply context to model prob
+        if model_prob is not None and ctx_applied:
+            model_prob_adj: float | None = max(0.01, min(0.40, model_prob + pitcher_adj + park_adj))
+        else:
+            model_prob_adj = model_prob
+
+        # Edge (uses context-adjusted prob)
+        if model_prob_adj is not None and implied is not None:
+            edge = compute_edge(model_prob_adj, implied)
         else:
             edge = None
 
         implied_probs.append(implied)  # type: ignore[arg-type]
-        model_probs.append(model_prob)
+        model_probs.append(model_prob_adj)
         sources.append(source)
         edges.append(edge)
+        pitcher_context_adjs.append(pitcher_adj if ctx_applied else None)
+        park_context_adjs.append(park_adj if ctx_applied else None)
+        context_applied_flags.append(ctx_applied)
+        source_details.append(src_detail)
 
     hr_df = hr_df.copy()
     hr_df["implied_prob"] = implied_probs
     hr_df["model_hr_prob"] = model_probs
     hr_df["model_hr_prob_source"] = sources
     hr_df["edge"] = edges
+    hr_df["pregame_pitcher_context_adj"] = pitcher_context_adjs
+    hr_df["pregame_park_context_adj"] = park_context_adjs
+    hr_df["pregame_context_applied"] = context_applied_flags
+    hr_df["model_hr_prob_source_detail"] = source_details
 
     # Sort: rows with edge first (highest edge first), then no-edge rows
     has_edge = hr_df["edge"].notna()

analytics/recommendation_engine.py

@@ -4,10 +4,11 @@ import pandas as pd
 
 from analytics.confidence import compute_confidence
 from analytics.recommendation_rules import apply_recommendation_rules
-from analytics.no_vig_props import compute_bet_ev, compute_edge
+from analytics.no_vig_props import american_to_implied_prob, compute_bet_ev, compute_edge
 from models.fair_odds import probability_to_american
 from models.live_fair_simulator_v3 import build_upcoming_simulated_rows
 from models.opportunity_model import estimate_plate_appearance_probability
+from utils.logger import logger
 
 def _lineup_distance_from_slot(slot: str) -> int:
     s = str(slot or "").strip().lower()
@@ -127,8 +128,8 @@ def build_upcoming_hitter_recommendations(
                 try:
                     raw_prob = float(row.get(prob_col))
                     row[prob_col] = min(0.95, max(0.001, raw_prob * expected_pa))
-                except Exception:
-                    pass
+                except Exception as e:
+                    logger.warning(f"[prob_opportunity_adjust] failure: {e}", exc_info=True)
 
         # Recalculate fair odds and edges after probability adjustment
         if row.get("hit_prob") is not None:
@@ -140,24 +141,24 @@ def build_upcoming_hitter_recommendations(
 
         try:
             book_hit_odds = float(row.get("book_hit_odds"))
-            row["hit_edge"] = compute_edge(row["hit_prob"], 100 / (book_hit_odds + 100))
+            row["hit_edge"] = compute_edge(row["hit_prob"], american_to_implied_prob(book_hit_odds))
             row["hit_bet_ev"] = compute_bet_ev(row["hit_prob"], int(book_hit_odds))
-        except Exception:
-            pass
+        except Exception as e:
+            logger.warning(f"[hit_edge_compute] failure: {e}", exc_info=True)
 
         try:
             book_hr_odds = float(row.get("book_hr_odds"))
-            row["hr_edge"] = compute_edge(row["hr_prob"], 100 / (book_hr_odds + 100))
+            row["hr_edge"] = compute_edge(row["hr_prob"], american_to_implied_prob(book_hr_odds))
             row["hr_bet_ev"] = compute_bet_ev(row["hr_prob"], int(book_hr_odds))
-        except Exception:
-            pass
+        except Exception as e:
+            logger.warning(f"[hr_edge_compute] failure: {e}", exc_info=True)
 
         try:
             book_tb2p_odds = float(row.get("book_tb2p_odds"))
-            row["tb2p_edge"] = compute_edge(row["tb2p_prob"], 100 / (book_tb2p_odds + 100))
+            row["tb2p_edge"] = compute_edge(row["tb2p_prob"], american_to_implied_prob(book_tb2p_odds))
             row["tb2p_bet_ev"] = compute_bet_ev(row["tb2p_prob"], int(book_tb2p_odds))
-        except Exception:
-            pass
+        except Exception as e:
+            logger.warning(f"[tb2p_edge_compute] failure: {e}", exc_info=True)
 
         # Carry diagnostics forward
         row["lineup_distance"] = lineup_distance

app.py

@@ -28,6 +28,7 @@ from analytics.batter_audit_metrics import (
 )
 from analytics.batter_realization import build_batter_realization_rows
 from analytics.batter_prop_grader import build_batter_prop_outcome_rows_from_audit
+from utils.logger import logger
 from analytics.outcome_grader import build_game_outcome_rows_from_scores
 from analytics.bankroll import bankroll_curve, grade_profit, summary_metrics
 from analytics.edge import (
@@ -571,8 +572,8 @@ def load_scores_for_today() -> pd.DataFrame:
                 out = df.copy()
                 out["scores_source_date"] = candidate_date
                 candidates.append(out)
-        except Exception:
-            pass
+        except Exception as e:
+            logger.warning(f"[scores_source_date_enrich] failure: {e}", exc_info=True)
 
     for df in candidates:
         if _scores_df_has_live_or_final_content(df):
@@ -1067,8 +1068,8 @@ def split_games_for_scoreboard(
     if not scores.empty:
         try:
             scores = enrich_live_games_from_feeds(scores)
-        except Exception:
-            pass
+        except Exception as e:
+            logger.warning(f"[live_feed_enrich] failure: {e}", exc_info=True)
 
     if scores is None or scores.empty:
         scores = pd.DataFrame()
@@ -1418,8 +1419,8 @@ def prepare_live_game_for_ui(game: dict) -> dict:
         try:
             enriched = enrich_game_from_live_feed(prepared, feed)
             prepared = merge_live_game_row(prepared, enriched)
-        except Exception:
-            pass
+        except Exception as e:
+            logger.warning(f"[live_feed_merge] failure: {e}", exc_info=True)
 
         # Second: direct fallback extraction from feed so UI fields are guaranteed
         live_data = feed.get("liveData", {}) or {}
@@ -1446,8 +1447,8 @@ def prepare_live_game_for_ui(game: dict) -> dict:
             lineup = offense.get("battingOrder", []) or []
             if isinstance(lineup, list) and len(lineup) >= 3:
                 three_away_name = _extract_person_name(lineup[2])
-        except Exception:
-            pass
+        except Exception as e:
+            logger.warning(f"[lineup_slot_extract] failure: {e}", exc_info=True)
 
         prepared = merge_live_game_row(
             prepared,
@@ -1471,6 +1472,29 @@ def prepare_live_game_for_ui(game: dict) -> dict:
             },
         )
 
+        # Task 3: Extract batting order lineup slots (fully fallback-safe)
+        try:
+            batting_order = offense.get("battingOrder") or []
+
+            def _find_slot(player_id: object, bo_list: list) -> int | None:
+                if not player_id or not bo_list:
+                    return None
+                for i, p in enumerate(bo_list):
+                    pid = p.get("id") if isinstance(p, dict) else p
+                    if str(pid) == str(player_id):
+                        return i + 1  # 1-based slot
+                return None
+
+            on_deck_id = offense.get("onDeck", {}).get("id")
+            in_hole_id = offense.get("inHole", {}).get("id")
+            prepared["on_deck_lineup_slot"]    = _find_slot(on_deck_id, batting_order)
+            prepared["in_hole_lineup_slot"]    = _find_slot(in_hole_id, batting_order)
+            prepared["three_away_lineup_slot"] = None
+        except Exception:
+            prepared["on_deck_lineup_slot"]    = None
+            prepared["in_hole_lineup_slot"]    = None
+            prepared["three_away_lineup_slot"] = None
+
         # Prefer the most recent pitch event that actually has RPM/EXT.
         # If none exists, fall back to the most recent event with any pitchData.
         play_events = current_play.get("playEvents", []) or []
@@ -1938,8 +1962,8 @@ def prepare_live_game_for_ui(game: dict) -> dict:
         except Exception as e:
             st.session_state["batter_zone_store_error"] = str(e)
 
-    except Exception:
-        pass
+    except Exception as e:
+        logger.warning(f"[batter_zone_store_init] failure: {e}", exc_info=True)
 
     return prepared
 
@@ -2013,8 +2037,8 @@ def render_live_games_with_edge_strips(
                         graded_at=timestamp,
                     )
                     insert_recommendation_outcomes(conn, outcome_df)
-                except Exception:
-                    pass
+                except Exception as e:
+                    logger.warning(f"[recommendation_outcome_insert] failure: {e}", exc_info=True)
 
 def normalize_game_pk(value: object) -> str:
     try:
@@ -2199,8 +2223,8 @@ def build_scores_from_schedule_via_live_feeds(schedule_df: pd.DataFrame) -> pd.D
             if isinstance(feed, dict) and feed:
                 game["game_pk"] = game_pk
                 game = enrich_game_from_live_feed(game, feed)
-        except Exception:
-            pass
+        except Exception as e:
+            logger.warning(f"[feed_cache_load] failure: {e}", exc_info=True)
 
         rows.append(game)
 
@@ -2253,8 +2277,8 @@ def enrich_live_games_from_feeds(scores_df: pd.DataFrame) -> pd.DataFrame:
                     # Preserve original completed-game status text
                     if is_final_candidate:
                         game["status"] = original_status if original_status else "Final"
-            except Exception:
-                pass
+            except Exception as e:
+                logger.warning(f"[game_status_preserve] failure: {e}", exc_info=True)
 
         rows.append(game)
 
@@ -2594,31 +2618,16 @@ def render_dashboard() -> None:
             live_games = recovered_live_games
             final_games = recovered_final_games
 
-    col1, col2 = st.columns([2, 1])
-    
-    with col1:
-        filter_option = st.radio(
-            "Game Status",
-            ["All", "Live", "Final", "Scheduled"],
-            horizontal=True,
-            key="dashboard_filter",
-        )
-        
-    with col2:
-        competition_filter = st.radio(
-            "Competition",
-            ["All", "WBC", "MLB"],
-            horizontal=True,
-            key="competition_filter",
-        )
-        
+    filter_option = st.radio(
+        "Game Status",
+        ["All", "Live", "Final", "Scheduled"],
+        horizontal=True,
+        key="dashboard_filter",
+    )
+
     live_games = sort_scoreboard_games(normalize_game_cards_df(live_games))
     final_games = sort_scoreboard_games(normalize_game_cards_df(final_games))
     scheduled_games = sort_scoreboard_games(normalize_game_cards_df(scheduled_games))
-    # Apply competition filter to the actual scoreboard buckets
-    live_games = filter_games_for_competition(live_games, competition_filter)
-    final_games = filter_games_for_competition(final_games, competition_filter)
-    scheduled_games = filter_games_for_competition(scheduled_games, competition_filter)
 
     auto_refresh_live = st.sidebar.checkbox(
         "Full Page Auto Refresh Toggle",

config/settings.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import os
 
-APP_TITLE = "WBC Analytics Assistant"
+APP_TITLE = "Kasper"
 REFRESH_TTL_SECONDS = 30
 
 LIVE_FEED_TTL_SECONDS = 5

data/live_prop_odds.py

@@ -5,6 +5,7 @@ import pandas as pd
 from config.settings import ENABLE_ENTERPRISE_PROVIDER
 from data.provider_enterprise import EnterpriseMarketProvider
 from data.provider_theoddsapi import TheOddsAPIProvider
+from utils.logger import logger
 
 
 def normalize_prop_odds(raw_df: pd.DataFrame) -> pd.DataFrame:
@@ -85,7 +86,8 @@ def fetch_all_upcoming_hr_props(
             df = fetch_fn(sportsbooks=sportsbooks)
             if not df.empty:
                 frames.append(df)
-        except Exception:
+        except Exception as e:
+            logger.warning(f"[odds_provider_fetch] failure: {e}", exc_info=True)
             continue
 
     if not frames:

data/schedule.py

@@ -7,6 +7,8 @@ from typing import Any
 import pandas as pd
 import requests
 
+from utils.logger import logger
+
 WBC_SCHEDULE_URL_TEMPLATE = "https://www.mlb.com/world-baseball-classic/schedule/{date_str}"
 SCHEDULE_API_URL = "https://statsapi.mlb.com/api/v1/schedule"
 
@@ -282,25 +284,10 @@ def _fetch_mlb_schedule_for_date(date_str: str) -> pd.DataFrame:
 
 
 def fetch_schedule_for_date(date_str: str) -> pd.DataFrame:
-    parts: list[pd.DataFrame] = []
-
-    try:
-        wbc_df = _fetch_wbc_schedule_for_date(date_str)
-        if wbc_df is not None and not wbc_df.empty:
-            parts.append(wbc_df)
-    except Exception:
-        pass
-
     try:
         mlb_df = _fetch_mlb_schedule_for_date(date_str)
         if mlb_df is not None and not mlb_df.empty:
-            parts.append(mlb_df)
-    except Exception:
-        pass
-
-    if not parts:
-        return pd.DataFrame()
-
-    df = pd.concat(parts, ignore_index=True)
-    df = df.drop_duplicates(subset=["game_pk", "away_team", "home_team"], keep="last")
-    return df.reset_index(drop=True)
+            return mlb_df
+    except Exception as e:
+        logger.warning(f"[schedule_fetch] failure: {e}", exc_info=True)
+    return pd.DataFrame()

data/scores.py

@@ -13,9 +13,7 @@ HEADERS = {
 
 SCORES_API_URL = "https://statsapi.mlb.com/api/v1/schedule"
 
-# 51 = WBC in your current usage
-# 1 = MLB
-SPORT_IDS = [51, 1]
+SPORT_IDS = [1]  # MLB only
 
 TEAM_NORMALIZATION = {
     "Chinese Taipei": "Chinese Taipei",

models/bullpen_model.py

@@ -1,9 +1,32 @@
 from __future__ import annotations
 
+from datetime import datetime, timedelta
 from typing import Any
 
+import pandas as pd
 
-def build_bullpen_context(game_row: dict[str, Any], pitcher_row: dict[str, Any]) -> dict[str, Any]:
+
+def _parse_game_date(game_row: dict[str, Any]) -> datetime | None:
+    for key in ("game_datetime_utc", "game_date", "game_datetime"):
+        val = game_row.get(key)
+        if val is None:
+            continue
+        try:
+            if isinstance(val, datetime):
+                return val
+            s = str(val).strip()[:10]
+            return datetime.strptime(s, "%Y-%m-%d")
+        except Exception:
+            continue
+    return None
+
+
+def build_bullpen_context(
+    game_row: dict[str, Any],
+    pitcher_row: dict[str, Any],
+    statcast_df: pd.DataFrame | None = None,
+    upcoming_batter_stands: list[str] | None = None,
+) -> dict[str, Any]:
     def _safe_int(value: Any, default: int = 0) -> int:
         try:
             if value is None:
@@ -42,6 +65,41 @@ def build_bullpen_context(game_row: dict[str, Any], pitcher_row: dict[str, Any])
     score_diff_abs = abs(away_score - home_score)
     high_leverage = inning >= 7 and score_diff_abs <= 3
 
+    # --- Candidate scoring (Tasks 1A-1E) ---
+    candidates: list[dict[str, Any]] = []
+    bullpen_selection_mode = "fallback"
+    bullpen_availability_applied = False
+
+    _ref_date = _parse_game_date(game_row)
+    if (
+        statcast_df is not None
+        and not statcast_df.empty
+        and "player_name" in statcast_df.columns
+        and "game_date" in statcast_df.columns
+        and _ref_date is not None
+    ):
+        try:
+            candidates, bullpen_selection_mode, bullpen_availability_applied = _score_bullpen_candidates(
+                statcast_df=statcast_df,
+                game_row=game_row,
+                pitcher_name=pitcher_name,
+                ref_date=_ref_date,
+                inning=inning,
+                score_diff_abs=score_diff_abs,
+                upcoming_batter_stands=upcoming_batter_stands or [],
+            )
+        except Exception:
+            candidates = []
+            bullpen_selection_mode = "fallback"
+            bullpen_availability_applied = False
+
+    top = candidates[0] if candidates else None
+    second = candidates[1] if len(candidates) > 1 else None
+    third = candidates[2] if len(candidates) > 2 else None
+
+    summary_parts = [f"{c['name']}({c['availability']:.2f})" for c in candidates[:5]]
+    bullpen_candidate_summary = "|".join(summary_parts) if summary_parts else ""
+
     return {
         "pitcher_name": pitcher_name,
         "inning": inning,
@@ -55,9 +113,253 @@ def build_bullpen_context(game_row: dict[str, Any], pitcher_row: dict[str, Any])
         "hard_hit_rate_allowed": hard_hit_rate_allowed,
         "score_diff_abs": score_diff_abs,
         "high_leverage": high_leverage,
+        # Candidate fields for compute_bullpen_adjustment modulation
+        "bullpen_candidates": candidates,
+        "bullpen_top_candidate":                top["name"] if top else None,
+        "bullpen_top_candidate_availability":   top["availability"] if top else None,
+        "bullpen_top_candidate_handedness_fit": top["handedness_boost"] if top else None,
+        "bullpen_top_candidate_role_fit":       top["role_fit"] if top else None,
+        "bullpen_candidate_summary":            bullpen_candidate_summary,
+        "bullpen_availability_applied":         bullpen_availability_applied,
+        "bullpen_candidate_1":                  top["name"] if top else None,
+        "bullpen_candidate_2":                  second["name"] if second else None,
+        "bullpen_candidate_3":                  third["name"] if third else None,
+        "bullpen_selection_mode":               bullpen_selection_mode,
     }
 
 
+def _score_bullpen_candidates(
+    statcast_df: pd.DataFrame,
+    game_row: dict[str, Any],
+    pitcher_name: str,
+    ref_date: datetime,
+    inning: int,
+    score_diff_abs: int,
+    upcoming_batter_stands: list[str],
+) -> tuple[list[dict[str, Any]], str, bool]:
+    """Score reliever candidates. Returns (candidates_sorted, mode, applied)."""
+    try:
+        game_dates = pd.to_datetime(statcast_df["game_date"], errors="coerce")
+        cutoff = pd.Timestamp(ref_date - timedelta(days=3))
+        recent_mask = game_dates >= cutoff
+        recent_df = statcast_df[recent_mask].copy()
+    except Exception:
+        return [], "fallback", False
+
+    if recent_df.empty:
+        return [], "fallback", False
+
+    # Attempt team-based filtering
+    pool_df, selection_mode = _filter_to_pitching_team(recent_df, game_row, pitcher_name)
+
+    # Exclude current starter
+    pitcher_name_lower = pitcher_name.strip().lower()
+
+    def _is_current_starter(name: str) -> bool:
+        n = name.strip().lower()
+        if n == pitcher_name_lower:
+            return True
+        parts = pitcher_name_lower.split()
+        if len(parts) >= 2 and parts[-1] in n and parts[0] in n:
+            return True
+        return False
+
+    all_pitchers = pool_df["player_name"].astype(str).unique().tolist()
+    candidates_pool = [p for p in all_pitchers if not _is_current_starter(p)]
+
+    if not candidates_pool:
+        return [], selection_mode, False
+
+    # 1B: Handedness boost direction
+    stands = [s for s in upcoming_batter_stands if s in ("L", "R")]
+    handedness_boost_lhp = 0.0
+    handedness_boost_rhp = 0.0
+    if len(stands) >= 2:
+        lhb_frac = stands.count("L") / len(stands)
+        rhb_frac = stands.count("R") / len(stands)
+        if lhb_frac >= 2 / 3:
+            handedness_boost_lhp = 0.10
+        elif rhb_frac >= 2 / 3:
+            handedness_boost_rhp = 0.10
+
+    # Pull p_throws per pitcher
+    pitcher_throws: dict[str, str] = {}
+    if "p_throws" in pool_df.columns:
+        for pname in candidates_pool:
+            prows = pool_df[pool_df["player_name"].astype(str) == pname]
+            mode_t = prows["p_throws"].dropna().mode()
+            pitcher_throws[pname] = str(mode_t.iloc[0]) if not mode_t.empty else "R"
+    else:
+        for pname in candidates_pool:
+            pitcher_throws[pname] = "R"
+
+    ref_norm = pd.Timestamp(ref_date).normalize()
+
+    def _availability_score(pname: str) -> float:
+        prows = pool_df[pool_df["player_name"].astype(str) == pname].copy()
+        if prows.empty:
+            return 0.75
+        try:
+            pdates = pd.to_datetime(prows["game_date"], errors="coerce").dt.normalize().dropna()
+        except Exception:
+            return 0.75
+        if pdates.empty:
+            return 0.75
+
+        appeared_yesterday = any((ref_norm - d).days == 1 for d in pdates.unique())
+        appeared_2ago = any((ref_norm - d).days == 2 for d in pdates.unique())
+        appeared_3ago = any((ref_norm - d).days == 3 for d in pdates.unique())
+
+        if not appeared_yesterday and not appeared_2ago and not appeared_3ago:
+            return 1.00  # fresh — no appearance in last 3 days
+        if appeared_3ago and not appeared_2ago and not appeared_yesterday:
+            return 0.85
+        if appeared_2ago and not appeared_yesterday:
+            return 0.70
+        if appeared_yesterday:
+            if appeared_2ago:
+                return 0.35  # two straight days
+            # Estimate pitch count via row count yesterday
+            yesterday_rows = prows[
+                (ref_norm - pd.to_datetime(prows["game_date"], errors="coerce").dt.normalize()).abs()
+                <= pd.Timedelta(days=1)
+            ]
+            pitch_proxy = len(yesterday_rows)
+            return 0.65 if pitch_proxy < 20 else 0.45
+        return 0.75
+
+    def _infer_role(pname: str) -> str:
+        prows = pool_df[pool_df["player_name"].astype(str) == pname]
+        if prows.empty:
+            return "middle_tier"
+        try:
+            if "inning" not in prows.columns:
+                return "middle_tier"
+            innings = pd.to_numeric(prows["inning"], errors="coerce").dropna()
+            if innings.empty:
+                return "middle_tier"
+            avg_inning = float(innings.mean())
+            if "game_date" in prows.columns:
+                avg_rows_per_game = float(prows.groupby("game_date").size().mean())
+            else:
+                avg_rows_per_game = float(len(prows))
+            if avg_inning >= 7.5 and avg_rows_per_game <= 20:
+                return "closer_tier"
+            elif avg_inning >= 5.5 and avg_rows_per_game <= 40:
+                return "setup_tier"
+            elif avg_rows_per_game >= 60:
+                return "long_relief"
+            else:
+                return "middle_tier"
+        except Exception:
+            return "middle_tier"
+
+    def _role_fit_score(role: str) -> float:
+        if inning >= 8 and score_diff_abs <= 2:
+            return 1.0 if role == "closer_tier" else (0.7 if role == "setup_tier" else 0.5)
+        elif inning >= 6 and score_diff_abs <= 4:
+            return 1.0 if role == "setup_tier" else (0.7 if role in ("middle_tier", "closer_tier") else 0.5)
+        else:
+            return 1.0 if role in ("middle_tier", "long_relief") else 0.7
+
+    scored: list[dict[str, Any]] = []
+    for pname in candidates_pool:
+        avail = _availability_score(pname)
+        throws = pitcher_throws.get(pname, "R")
+        h_boost = (
+            handedness_boost_lhp if throws == "L"
+            else (handedness_boost_rhp if throws == "R" else 0.0)
+        )
+        role = _infer_role(pname)
+        r_fit = _role_fit_score(role)
+        raw_score = avail * (1.0 + h_boost) * r_fit
+        scored.append({
+            "name": pname,
+            "availability": avail,
+            "p_throws": throws,
+            "handedness_boost": h_boost,
+            "role": role,
+            "role_fit": r_fit,
+            "raw_score": raw_score,
+        })
+
+    if not scored:
+        return [], selection_mode, False
+
+    total_raw = sum(c["raw_score"] for c in scored)
+    for c in scored:
+        c["usage_prob"] = c["raw_score"] / total_raw if total_raw > 0 else (1.0 / len(scored))
+
+    scored.sort(key=lambda c: c["raw_score"], reverse=True)
+    return scored, selection_mode, True
+
+
+def _filter_to_pitching_team(
+    recent_df: pd.DataFrame,
+    game_row: dict[str, Any],
+    pitcher_name: str,
+) -> tuple[pd.DataFrame, str]:
+    """
+    Try to return rows from the same team as the current pitcher.
+    Falls back to full recent_df (heuristic mode) on any failure.
+    """
+    home_team = str(game_row.get("home_team", "") or "").strip().upper()
+    away_team = str(game_row.get("away_team", "") or "").strip().upper()
+
+    if not home_team and not away_team:
+        return recent_df, "heuristic"
+    if "home_team" not in recent_df.columns or "away_team" not in recent_df.columns:
+        return recent_df, "heuristic"
+
+    try:
+        pitcher_name_lower = pitcher_name.strip().lower()
+        pitcher_rows = recent_df[
+            recent_df["player_name"].astype(str).str.lower() == pitcher_name_lower
+        ]
+        if pitcher_rows.empty:
+            parts = pitcher_name_lower.split()
+            if len(parts) >= 2:
+                pitcher_rows = recent_df[
+                    recent_df["player_name"].astype(str).str.lower().str.contains(parts[-1], na=False)
+                ]
+        if pitcher_rows.empty:
+            return recent_df, "heuristic"
+
+        pitcher_home_teams = pitcher_rows["home_team"].astype(str).str.upper().mode()
+        pitcher_away_teams = pitcher_rows["away_team"].astype(str).str.upper().mode()
+
+        pitcher_team = None
+        if not pitcher_home_teams.empty and not pitcher_away_teams.empty:
+            ht_val = pitcher_home_teams.iloc[0]
+            at_val = pitcher_away_teams.iloc[0]
+            if ht_val in (home_team, away_team):
+                # Pitcher appeared as home team pitcher (they're on that team or pitched against it)
+                # Use game_row teams to narrow — prefer the matching team
+                if ht_val == home_team:
+                    pitcher_team = home_team
+                elif ht_val == away_team:
+                    pitcher_team = away_team
+            elif at_val in (home_team, away_team):
+                if at_val == home_team:
+                    pitcher_team = home_team
+                elif at_val == away_team:
+                    pitcher_team = away_team
+
+        if pitcher_team is None:
+            return recent_df, "heuristic"
+
+        team_mask = (
+            (recent_df["home_team"].astype(str).str.upper() == pitcher_team)
+            | (recent_df["away_team"].astype(str).str.upper() == pitcher_team)
+        )
+        team_df = recent_df[team_mask]
+        if team_df.empty or len(team_df["player_name"].unique()) < 2:
+            return recent_df, "heuristic"
+        return team_df, "data_driven"
+    except Exception:
+        return recent_df, "heuristic"
+
+
 def compute_bullpen_adjustment(context: dict[str, Any]) -> dict[str, Any]:
     """
     Bullpen model v2:
@@ -143,10 +445,6 @@ def compute_bullpen_adjustment(context: dict[str, Any]) -> dict[str, Any]:
 
     bullpen_entry_prob = 1.0 - starter_stays_next_batter_prob
 
-    # v2 assumption:
-    # bullpen entry reduces certainty and can modestly improve or worsen outcomes.
-    # For v1-v2, we bias toward a slight suppression of power in true late leverage
-    # because quality relievers are more likely, but increase variance for hits/TB.
     bullpen_risk_adj_hit = 0.0
     bullpen_risk_adj_hr = 0.0
     bullpen_risk_adj_tb2p = 0.0
@@ -168,6 +466,25 @@ def compute_bullpen_adjustment(context: dict[str, Any]) -> dict[str, Any]:
         bullpen_risk_adj_tb2p += bullpen_entry_prob * 0.006
         bullpen_risk_adj_hr += bullpen_entry_prob * 0.002
 
+    # 1E: Modest risk adj modulation from top candidate quality (±10% max)
+    top_avail = context.get("bullpen_top_candidate_availability")
+    top_role_fit = context.get("bullpen_top_candidate_role_fit")
+    if top_avail is not None:
+        try:
+            top_avail_f = float(top_avail)
+            top_role_f = float(top_role_fit) if top_role_fit is not None else 0.7
+            if top_avail_f < 0.50:
+                scale = 1.10  # tired relievers — slightly more risk
+            elif top_avail_f >= 0.85 and top_role_f >= 1.0:
+                scale = 0.90  # fresh quality reliever — slightly less risk
+            else:
+                scale = 1.0
+            bullpen_risk_adj_hit  *= scale
+            bullpen_risk_adj_hr   *= scale
+            bullpen_risk_adj_tb2p *= scale
+        except Exception:
+            pass
+
     return {
         "starter_stays_next_batter_prob": starter_stays_next_batter_prob,
         "starter_stays_next_inning_prob": starter_stays_next_inning_prob,
@@ -176,4 +493,15 @@ def compute_bullpen_adjustment(context: dict[str, Any]) -> dict[str, Any]:
         "bullpen_risk_adj_hr": bullpen_risk_adj_hr,
         "bullpen_risk_adj_tb2p": bullpen_risk_adj_tb2p,
         "reason_tags": reason_tags,
-    }
+        # Pass through candidate fields for output row
+        "bullpen_top_candidate":                context.get("bullpen_top_candidate"),
+        "bullpen_top_candidate_availability":   context.get("bullpen_top_candidate_availability"),
+        "bullpen_top_candidate_handedness_fit": context.get("bullpen_top_candidate_handedness_fit"),
+        "bullpen_top_candidate_role_fit":       context.get("bullpen_top_candidate_role_fit"),
+        "bullpen_candidate_summary":            context.get("bullpen_candidate_summary"),
+        "bullpen_availability_applied":         context.get("bullpen_availability_applied", False),
+        "bullpen_candidate_1":                  context.get("bullpen_candidate_1"),
+        "bullpen_candidate_2":                  context.get("bullpen_candidate_2"),
+        "bullpen_candidate_3":                  context.get("bullpen_candidate_3"),
+        "bullpen_selection_mode":               context.get("bullpen_selection_mode", "fallback"),
+    }

models/live_fair_simulator_v3.py

@@ -78,7 +78,23 @@ def build_upcoming_simulated_rows(
     live_context["game_row"] = game_row
     context_adj = compute_context_adjustment(live_context)
 
-    bullpen_context = build_bullpen_context(game_row, pitcher_row)
+    # Pre-compute upcoming batter stands for bullpen handedness context (Task 1)
+    _upcoming_stands: list[str | None] = []
+    for _s_lbl, _s_name in slots:
+        if _s_name:
+            try:
+                _s_feats = build_batter_feature_row(statcast_df, _s_name)
+                _upcoming_stands.append(_s_feats.get("batter_stand"))
+            except Exception:
+                _upcoming_stands.append(None)
+        else:
+            _upcoming_stands.append(None)
+
+    bullpen_context = build_bullpen_context(
+        game_row, pitcher_row,
+        statcast_df=statcast_df,
+        upcoming_batter_stands=[s for s in _upcoming_stands if s],
+    )
     bullpen_adj = compute_bullpen_adjustment(bullpen_context)
 
     # Batch 11: Environment overlay — computed once per game (venue/datetime don't change per batter)
@@ -364,10 +380,43 @@ def build_upcoming_simulated_rows(
         fz_hit_eff  = (family_zone_hit_boost * 0.06) - (family_zone_whiff_risk * 0.02)
         fz_tb2p_eff = (family_zone_tb2p_boost * 0.06) + (family_zone_hit_boost * 0.02)
 
-        # Apply whichever signal is stronger per dimension (no double-counting)
-        primary_hr   = zone_hr_eff   if abs(zone_hr_eff)   >= abs(fz_hr_eff)   else fz_hr_eff
-        primary_hit  = zone_hit_eff  if abs(zone_hit_eff)  >= abs(fz_hit_eff)  else fz_hit_eff
-        primary_tb2p = zone_tb2p_eff if abs(zone_tb2p_eff) >= abs(fz_tb2p_eff) else fz_tb2p_eff
+        # Task 2: Matchup platoon multiplier — modulate zone/fz eff inside matchup scaling
+        batter_stand = batter_features.get("batter_stand")
+        p_throws = pitcher_row.get("p_throws")
+        if batter_stand is None or p_throws is None:
+            matchup_platoon_multiplier = 1.0
+            matchup_platoon_reason = "unknown"
+        elif (batter_stand == "L" and p_throws == "L") or (batter_stand == "R" and p_throws == "R"):
+            matchup_platoon_multiplier = 0.92
+            matchup_platoon_reason = "same_hand_suppressed"
+        else:
+            matchup_platoon_multiplier = 1.08
+            matchup_platoon_reason = "opposite_hand_enhanced"
+
+        zone_hr_eff   *= matchup_platoon_multiplier
+        zone_hit_eff  *= matchup_platoon_multiplier
+        zone_tb2p_eff *= matchup_platoon_multiplier
+        fz_hr_eff     *= matchup_platoon_multiplier
+        fz_hit_eff    *= matchup_platoon_multiplier
+        fz_tb2p_eff   *= matchup_platoon_multiplier
+
+        # Task 9: Confidence-weighted blend (uses sample_size from adj dicts when available)
+        zone_sample_size = float(zone_matchup_adj.get("sample_size", 0) or 0)
+        fz_sample_size   = float(family_zone_matchup_adj.get("sample_size", 0) or 0)
+        zone_conf  = min(1.0, zone_sample_size / 30.0)
+        fz_conf    = min(1.0, fz_sample_size   / 30.0)
+        total_conf = zone_conf + fz_conf
+
+        if total_conf < 0.05 or (zone_sample_size == 0 and fz_sample_size == 0):
+            blend_mode = "max_fallback"
+            primary_hr   = zone_hr_eff   if abs(zone_hr_eff)   >= abs(fz_hr_eff)   else fz_hr_eff
+            primary_hit  = zone_hit_eff  if abs(zone_hit_eff)  >= abs(fz_hit_eff)  else fz_hit_eff
+            primary_tb2p = zone_tb2p_eff if abs(zone_tb2p_eff) >= abs(fz_tb2p_eff) else fz_tb2p_eff
+        else:
+            blend_mode = "confidence_blend"
+            primary_hr   = (zone_hr_eff   * zone_conf + fz_hr_eff   * fz_conf) / total_conf
+            primary_hit  = (zone_hit_eff  * zone_conf + fz_hit_eff  * fz_conf) / total_conf
+            primary_tb2p = (zone_tb2p_eff * zone_conf + fz_tb2p_eff * fz_conf) / total_conf
 
         batter_baseline["hr_prob_base"]   = min(0.25, max(0.005,
             float(batter_baseline.get("hr_prob_base",   0.03) or 0.03) + primary_hr))
@@ -394,18 +443,22 @@ def build_upcoming_simulated_rows(
         arsenal_tb2p_boost = float(arsenal_matchup_adj.get("arsenal_tb2p_boost", 0.0) or 0.0)
         arsenal_whiff_risk = float(arsenal_matchup_adj.get("arsenal_whiff_risk", 0.0) or 0.0)
 
+        # Task 2: Apply matchup_platoon_multiplier to arsenal effective values
+        arsenal_hit_eff  = (arsenal_hit_boost  * 0.04 - arsenal_whiff_risk * 0.02) * matchup_platoon_multiplier
+        arsenal_hr_eff   = (arsenal_hr_boost   * 0.05) * matchup_platoon_multiplier
+        arsenal_tb2p_eff = (arsenal_tb2p_boost * 0.04) * matchup_platoon_multiplier
+
         batter_baseline["hit_prob_base"]  = min(0.55, max(0.05,
             float(batter_baseline.get("hit_prob_base",  0.15) or 0.15)
-            + (arsenal_hit_boost * 0.04)
-            - (arsenal_whiff_risk * 0.02)))
+            + arsenal_hit_eff))
 
         batter_baseline["hr_prob_base"]   = min(0.25, max(0.005,
             float(batter_baseline.get("hr_prob_base",   0.03) or 0.03)
-            + (arsenal_hr_boost * 0.05)))
+            + arsenal_hr_eff))
 
         batter_baseline["tb2p_prob_base"] = min(0.45, max(0.03,
             float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
-            + (arsenal_tb2p_boost * 0.04)))
+            + arsenal_tb2p_eff))
 
         _snap_after_arsenal_hr   = float(batter_baseline.get("hr_prob_base",   0.03) or 0.03)
         _snap_after_arsenal_hit  = float(batter_baseline.get("hit_prob_base",  0.15) or 0.15)
@@ -589,8 +642,15 @@ def build_upcoming_simulated_rows(
 
         # Batch 13: Opportunity adjustment (multiplicative, upcoming-only)
         try:
+            # Task 3: Map slot label to lineup slot field in game_row
+            _slot_key_map = {
+                "On Deck":  "on_deck_lineup_slot",
+                "In Hole":  "in_hole_lineup_slot",
+                "3 Away":   "three_away_lineup_slot",
+            }
+            _lineup_slot = game_row.get(_slot_key_map.get(slot))
             opp_adj = compute_opportunity_adjustment(
-                lineup_slot=None,          # batting order not available in game_row currently
+                lineup_slot=_lineup_slot,
                 team_total=game_row.get("team_total"),
                 pitcher_row=pitcher_row,
             )
@@ -725,7 +785,21 @@ def build_upcoming_simulated_rows(
                 "starter_stays_next_batter_prob": bullpen_adj["starter_stays_next_batter_prob"],
                 "starter_stays_next_inning_prob": bullpen_adj["starter_stays_next_inning_prob"],
                 "bullpen_entry_prob": bullpen_adj["bullpen_entry_prob"],
+                # Task 1 — bullpen candidate debug fields
+                "bullpen_top_candidate":                bullpen_adj.get("bullpen_top_candidate"),
+                "bullpen_top_candidate_availability":   bullpen_adj.get("bullpen_top_candidate_availability"),
+                "bullpen_top_candidate_handedness_fit": bullpen_adj.get("bullpen_top_candidate_handedness_fit"),
+                "bullpen_top_candidate_role_fit":       bullpen_adj.get("bullpen_top_candidate_role_fit"),
+                "bullpen_candidate_summary":            bullpen_adj.get("bullpen_candidate_summary"),
+                "bullpen_availability_applied":         bullpen_adj.get("bullpen_availability_applied", False),
+                "bullpen_candidate_1":                  bullpen_adj.get("bullpen_candidate_1"),
+                "bullpen_candidate_2":                  bullpen_adj.get("bullpen_candidate_2"),
+                "bullpen_candidate_3":                  bullpen_adj.get("bullpen_candidate_3"),
+                "bullpen_selection_mode":               bullpen_adj.get("bullpen_selection_mode", "fallback"),
                 "reason_tags": reason_tags,
+                # Task 2 — matchup platoon multiplier
+                "matchup_platoon_multiplier": matchup_platoon_multiplier,
+                "matchup_platoon_reason":     matchup_platoon_reason,
                 "fatigue_score": pitcher_adj.get("fatigue_score"),
                 "degradation_score": pitcher_adj.get("degradation_score"),
                 "trust_live_score": pitcher_adj.get("trust_live_score"),
@@ -737,6 +811,11 @@ def build_upcoming_simulated_rows(
                 "pitch_count": pitcher_adj.get("pitch_count"),
                 "times_through_order": pitcher_adj.get("times_through_order"),
 
+                # Task 9 — zone/fz confidence blend
+                "zone_confidence":        zone_conf,
+                "family_zone_confidence": fz_conf,
+                "zone_family_blend_mode": blend_mode,
+
                 "zone_hr_boost": zone_matchup_adj.get("hr_zone_boost"),
                 "zone_hit_boost": zone_matchup_adj.get("hit_zone_boost"),
                 "zone_tb2p_boost": zone_matchup_adj.get("tb2p_zone_boost"),
@@ -762,6 +841,14 @@ def build_upcoming_simulated_rows(
                 "rolling_pitch_pfx_x_sample_size": pitcher_adj.get("rolling_pitch_pfx_x_sample_size"),
                 "rolling_pitch_pfx_z_sample_size": pitcher_adj.get("rolling_pitch_pfx_z_sample_size"),
 
+                # Task 5 — movement signal debug
+                "movement_signal_debug": pitcher_adj.get("movement_signal_debug"),
+
+                # Task 6 — pitcher adjustment pre-clamp debug
+                "pitcher_net_adj_pre_clamp_hit":  pitcher_adj.get("pitcher_net_adj_pre_clamp_hit"),
+                "pitcher_net_adj_pre_clamp_hr":   pitcher_adj.get("pitcher_net_adj_pre_clamp_hr"),
+                "pitcher_net_adj_pre_clamp_tb2p": pitcher_adj.get("pitcher_net_adj_pre_clamp_tb2p"),
+
                 "deception_score": trajectory_row.get("deception_score"),
                 "tunnel_score": trajectory_row.get("tunnel_score"),
                 "release_consistency_score": trajectory_row.get("release_consistency_score"),
@@ -907,6 +994,37 @@ def build_upcoming_simulated_rows(
                 "arsenal_drift_score":          drift_adj.get("arsenal_drift_score"),
                 "arsenal_reason_tags":          drift_adj.get("arsenal_reason_tags"),
                 "arsenal_drift_applied_scale":  drift_adj.get("arsenal_drift_applied_scale"),
+
+                # Task 10 — model version metadata
+                "model_version":   "v3.2",
+                "feature_version": "v1.0",
+                "weighting_mode":  "static_rule_based",
+
+                # Task 10 — layer contribution deltas (derived from snap ladder)
+                "contrib_trend_hr":    _snap_after_trend_hr      - _snap_baseline_hr,
+                "contrib_matchup_hr":  _snap_after_arsenal_hr    - _snap_after_trend_hr,
+                "contrib_env_hr":      _snap_after_env_hr        - _snap_after_arsenal_hr,
+                "contrib_platoon_hr":  _snap_after_platoon_hr    - _snap_after_env_hr,
+                "contrib_traj_hr":     _snap_after_traj_hr       - _snap_after_platoon_hr,
+                "contrib_rolling_hr":  _snap_after_rolling_hr    - _snap_after_traj_hr,
+                "contrib_opp_hr":      _snap_after_opportunity_hr - _snap_after_rolling_hr,
+                "contrib_drift_hr":    _snap_after_drift_hr      - _snap_after_opportunity_hr,
+                "contrib_trend_hit":   _snap_after_trend_hit     - _snap_baseline_hit,
+                "contrib_matchup_hit": _snap_after_arsenal_hit   - _snap_after_trend_hit,
+                "contrib_env_hit":     _snap_after_env_hit       - _snap_after_arsenal_hit,
+                "contrib_platoon_hit": _snap_after_platoon_hit   - _snap_after_env_hit,
+                "contrib_traj_hit":    _snap_after_traj_hit      - _snap_after_platoon_hit,
+                "contrib_rolling_hit": _snap_after_rolling_hit   - _snap_after_traj_hit,
+                "contrib_opp_hit":     _snap_after_opportunity_hit - _snap_after_rolling_hit,
+                "contrib_drift_hit":   _snap_after_drift_hit     - _snap_after_opportunity_hit,
+                "contrib_trend_tb2p":   _snap_after_trend_tb2p    - _snap_baseline_tb2p,
+                "contrib_matchup_tb2p": _snap_after_arsenal_tb2p  - _snap_after_trend_tb2p,
+                "contrib_env_tb2p":     _snap_after_env_tb2p      - _snap_after_arsenal_tb2p,
+                "contrib_platoon_tb2p": _snap_after_platoon_tb2p  - _snap_after_env_tb2p,
+                "contrib_traj_tb2p":    _snap_after_traj_tb2p     - _snap_after_platoon_tb2p,
+                "contrib_rolling_tb2p": _snap_after_rolling_tb2p  - _snap_after_traj_tb2p,
+                "contrib_opp_tb2p":     _snap_after_opportunity_tb2p - _snap_after_rolling_tb2p,
+                "contrib_drift_tb2p":   _snap_after_drift_tb2p    - _snap_after_opportunity_tb2p,
             }
         )
 

models/matchup_model.py

@@ -410,4 +410,5 @@ def compute_family_zone_matchup_adjustment(
         adjustment["family_zone_tb2p_boost"] /= total_weight
         adjustment["family_zone_whiff_risk"] /= total_weight
 
+    adjustment["sample_size"] = total_weight
     return adjustment

models/pitcher_adjustment.py

@@ -315,23 +315,31 @@ def compute_pitcher_adjustment(
             tb2p_adj += 0.002
             reason_tags.append("Short release extension")
 
+    movement_fired = False
+    _pfx_x_str = f"{avg_pfx_x:.3f}" if avg_pfx_x is not None else "N/A"
+    _pfx_z_str = f"{avg_pfx_z:.3f}" if avg_pfx_z is not None else "N/A"
+
     try:
-        if avg_pfx_x is not None and abs(float(avg_pfx_x)) >= 9:
-            hit_adj -= 0.002
-            tb2p_adj -= 0.002
-            reason_tags.append("Strong horizontal movement")
+        if avg_pfx_x is not None and abs(float(avg_pfx_x)) >= 0.75:  # ~9 inches in feet
+            hit_adj  -= 0.003
+            tb2p_adj -= 0.003
+            reason_tags.append("strong_horizontal_break")
+            movement_fired = True
     except Exception as e:
         logger.debug(f"[pitcher_adjustment] pfx_x movement block skipped: {e}")
 
     try:
-        if avg_pfx_z is not None and abs(float(avg_pfx_z)) >= 14:
-            hit_adj -= 0.002
-            hr_adj -= 0.002
-            tb2p_adj -= 0.002
-            reason_tags.append("Strong vertical movement")
+        if avg_pfx_z is not None and abs(float(avg_pfx_z)) >= 1.17:  # ~14 inches in feet
+            hit_adj  -= 0.003
+            hr_adj   -= 0.003
+            tb2p_adj -= 0.003
+            reason_tags.append("strong_vertical_break")
+            movement_fired = True
     except Exception as e:
         logger.debug(f"[pitcher_adjustment] pfx_z movement block skipped: {e}")
 
+    movement_signal_debug = f"pfx_x={_pfx_x_str} pfx_z={_pfx_z_str} fired={'Y' if movement_fired else 'N'}"
+
     # G1: Velocity-band precision segmentation
     if avg_release_speed is not None:
         avg_velo = float(avg_release_speed)
@@ -380,6 +388,16 @@ def compute_pitcher_adjustment(
 
     reason_tags.extend(live_state.get("reason_tags", []))
 
+    # Capture pre-clamp values for debug
+    _hit_adj_pre  = hit_adj
+    _hr_adj_pre   = hr_adj
+    _tb2p_adj_pre = tb2p_adj
+
+    # Final net clamp — prevents extreme multi-signal stacking
+    hit_adj  = max(-0.030, min(0.030, hit_adj))
+    hr_adj   = max(-0.025, min(0.025, hr_adj))
+    tb2p_adj = max(-0.025, min(0.025, tb2p_adj))
+
     return {
         "hit_adj": hit_adj,
         "hr_adj": hr_adj,
@@ -406,4 +424,12 @@ def compute_pitcher_adjustment(
         "rolling_pitch_extension_sample_size": live_state.get("rolling_pitch_extension_sample_size"),
         "rolling_pitch_pfx_x_sample_size": live_state.get("rolling_pitch_pfx_x_sample_size"),
         "rolling_pitch_pfx_z_sample_size": live_state.get("rolling_pitch_pfx_z_sample_size"),
+
+        # Task 5 — movement signal debug
+        "movement_signal_debug": movement_signal_debug,
+
+        # Task 6 — pre-clamp values for transparency
+        "pitcher_net_adj_pre_clamp_hit":  _hit_adj_pre,
+        "pitcher_net_adj_pre_clamp_hr":   _hr_adj_pre,
+        "pitcher_net_adj_pre_clamp_tb2p": _tb2p_adj_pre,
     }

models/pitcher_live_state.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from typing import Any
 
+from utils.logger import logger
+
 
 def _safe_float(value: Any, default: float | None = None) -> float | None:
     try:
@@ -75,8 +77,8 @@ def build_pitcher_live_state(
         elif velo_delta is not None and velo_delta >= 1.0:
             fatigue_score -= 0.10
             reason_tags.append("velo_up")
-    except Exception:
-        pass
+    except Exception as e:
+        logger.warning(f"[fatigue_velo_delta] failure: {e}", exc_info=True)
 
     try:
         if spin_delta is not None and spin_delta <= -120:
@@ -85,8 +87,8 @@ def build_pitcher_live_state(
         elif spin_delta is not None and spin_delta >= 120:
             fatigue_score -= 0.05
             reason_tags.append("spin_up")
-    except Exception:
-        pass
+    except Exception as e:
+        logger.warning(f"[fatigue_spin_delta] failure: {e}", exc_info=True)
 
     try:
         if extension_delta is not None and extension_delta <= -0.25:
@@ -95,8 +97,8 @@ def build_pitcher_live_state(
         elif extension_delta is not None and extension_delta >= 0.25:
             fatigue_score -= 0.03
             reason_tags.append("extension_up")
-    except Exception:
-        pass
+    except Exception as e:
+        logger.warning(f"[fatigue_extension_delta] failure: {e}", exc_info=True)
 
     fatigue_score = max(0.0, min(1.0, fatigue_score))
 

models/rolling_form_model.py

@@ -316,7 +316,7 @@ def build_batter_rolling_form_row(
         "batter_pulled_barrel_rate_5g": None,
         "batter_games_in_window_5g": n5,
         "batter_games_in_window_10g": n10,
-        "batter_recent_form_available": 1 if n5 >= 2 else 0,
+        "batter_recent_form_available": 1 if n5 >= 4 else 0,
     }
 
 
@@ -445,7 +445,7 @@ def build_pitcher_rolling_form_row(
         "pitcher_hr_allowed_rate_10g": _hr_rate_allowed(df10),
         "pitcher_games_in_window_5g": n5,
         "pitcher_games_in_window_10g": n10,
-        "pitcher_recent_form_available": 1 if n5 >= 2 else 0,
+        "pitcher_recent_form_available": 1 if n5 >= 4 else 0,
         "pitcher_rolling_confidence": confidence,
     }
 
@@ -481,12 +481,8 @@ def _10g_confirmation_scale(delta_5g: float | None, delta_10g: float | None, thr
 
 
 def _sample_scale(n_games: int) -> float:
-    if n_games < 2:
-        return 0.0
-    if n_games <= 3:
-        return 0.4
-    if n_games == 4:
-        return 0.7
+    if n_games < 4:   return 0.0   # raised gate to match recent_form_available (n >= 4)
+    if n_games == 4:  return 0.7
     return 1.0
 
 

models/zone_matchup_model.py

@@ -56,4 +56,5 @@ def compute_zone_matchup_adjustment(
         for k in adjustment:
             adjustment[k] = adjustment[k] / total_weight
 
+    adjustment["sample_size"] = total_weight
     return adjustment

utils/logger.py

@@ -0,0 +1,10 @@
+import logging
+
+logger = logging.getLogger("kasper")
+if not logger.handlers:
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(
+        "[%(asctime)s] [%(levelname)s] %(message)s"
+    ))
+    logger.addHandler(handler)
+    logger.setLevel(logging.INFO)

visualization/debug_page.py

@@ -49,48 +49,48 @@ from utils.dates import current_wbc_date_str
 # ---------------------------------------------------------------------------
 
 _LADDER_HR_FIELDS = [
-    ("Baseline",             "snap_baseline_hr"),
-    ("After Zone",           "snap_after_zone_hr"),
-    ("After Family Zone",    "snap_after_family_zone_hr"),
-    ("After Arsenal",        "snap_after_arsenal_hr"),
-    ("After Pulled Contact", "snap_after_pulled_contact_hr"),
-    ("After Env",            "snap_after_env_hr"),
-    ("After Platoon",        "snap_after_platoon_hr"),
-    ("After Trajectory",     "snap_after_traj_hr"),
-    ("After Rolling",        "snap_after_rolling_hr"),
-    ("After Opportunity",    "snap_after_opportunity_hr"),
-    ("After Drift",          "snap_after_drift_hr"),
-    ("Final (simulated)",    "hr_prob"),
+    ("Baseline",                "snap_baseline_hr"),
+    ("After Trend",             "snap_after_trend_hr"),
+    ("After Zone/Family Dedup", "snap_after_zone_dedup_hr"),
+    ("After Arsenal",           "snap_after_arsenal_hr"),
+    ("After Pulled Contact",    "snap_after_pulled_contact_hr"),
+    ("After Env",               "snap_after_env_hr"),
+    ("After Platoon",           "snap_after_platoon_hr"),
+    ("After Trajectory",        "snap_after_traj_hr"),
+    ("After Rolling",           "snap_after_rolling_hr"),
+    ("After Opportunity",       "snap_after_opportunity_hr"),
+    ("After Drift",             "snap_after_drift_hr"),
+    ("Final (simulated)",       "hr_prob"),
 ]
 
 _LADDER_HIT_FIELDS = [
-    ("Baseline",             "snap_baseline_hit"),
-    ("After Zone",           "snap_after_zone_hit"),
-    ("After Family Zone",    "snap_after_family_zone_hit"),
-    ("After Arsenal",        "snap_after_arsenal_hit"),
-    ("After Pulled Contact", "snap_after_pulled_contact_hit"),
-    ("After Env",            "snap_after_env_hit"),
-    ("After Platoon",        "snap_after_platoon_hit"),
-    ("After Trajectory",     "snap_after_traj_hit"),
-    ("After Rolling",        "snap_after_rolling_hit"),
-    ("After Opportunity",    "snap_after_opportunity_hit"),
-    ("After Drift",          "snap_after_drift_hit"),
-    ("Final (simulated)",    "hit_prob"),
+    ("Baseline",                "snap_baseline_hit"),
+    ("After Trend",             "snap_after_trend_hit"),
+    ("After Zone/Family Dedup", "snap_after_zone_dedup_hit"),
+    ("After Arsenal",           "snap_after_arsenal_hit"),
+    ("After Pulled Contact",    "snap_after_pulled_contact_hit"),
+    ("After Env",               "snap_after_env_hit"),
+    ("After Platoon",           "snap_after_platoon_hit"),
+    ("After Trajectory",        "snap_after_traj_hit"),
+    ("After Rolling",           "snap_after_rolling_hit"),
+    ("After Opportunity",       "snap_after_opportunity_hit"),
+    ("After Drift",             "snap_after_drift_hit"),
+    ("Final (simulated)",       "hit_prob"),
 ]
 
 _LADDER_TB2P_FIELDS = [
-    ("Baseline",             "snap_baseline_tb2p"),
-    ("After Zone",           "snap_after_zone_tb2p"),
-    ("After Family Zone",    "snap_after_family_zone_tb2p"),
-    ("After Arsenal",        "snap_after_arsenal_tb2p"),
-    ("After Pulled Contact", "snap_after_pulled_contact_tb2p"),
-    ("After Env",            "snap_after_env_tb2p"),
-    ("After Platoon",        "snap_after_platoon_tb2p"),
-    ("After Trajectory",     "snap_after_traj_tb2p"),
-    ("After Rolling",        "snap_after_rolling_tb2p"),
-    ("After Opportunity",    "snap_after_opportunity_tb2p"),
-    ("After Drift",          "snap_after_drift_tb2p"),
-    ("Final (simulated)",    "tb2p_prob"),
+    ("Baseline",                "snap_baseline_tb2p"),
+    ("After Trend",             "snap_after_trend_tb2p"),
+    ("After Zone/Family Dedup", "snap_after_zone_dedup_tb2p"),
+    ("After Arsenal",           "snap_after_arsenal_tb2p"),
+    ("After Pulled Contact",    "snap_after_pulled_contact_tb2p"),
+    ("After Env",               "snap_after_env_tb2p"),
+    ("After Platoon",           "snap_after_platoon_tb2p"),
+    ("After Trajectory",        "snap_after_traj_tb2p"),
+    ("After Rolling",           "snap_after_rolling_tb2p"),
+    ("After Opportunity",       "snap_after_opportunity_tb2p"),
+    ("After Drift",             "snap_after_drift_tb2p"),
+    ("Final (simulated)",       "tb2p_prob"),
 ]
 
 
@@ -223,6 +223,7 @@ def render_debug(
                 "fair_hr_odds", "book_hr_odds", "hr_edge",
                 "pa_multiplier", "pitcher_quality_score", "opportunity_mode",
                 "rolling_combined_form_score", "arsenal_drift_score",
+                "bullpen_top_candidate", "bullpen_entry_prob",
             ] if c in sim_df.columns
         ]
 
@@ -369,6 +370,26 @@ def render_debug(
         else:
             st.info("No active signal tags for filtered batters.")
 
+    # ------------------------------------------------------------------
+    # SECTION 5b — Bullpen Candidates
+    # ------------------------------------------------------------------
+    if not sim_df.empty:
+        with st.expander("Bullpen Candidates", expanded=False):
+            bullpen_cols = [
+                "batter_name", "pitcher_name",
+                "bullpen_top_candidate", "bullpen_top_candidate_availability",
+                "bullpen_top_candidate_handedness_fit", "bullpen_top_candidate_role_fit",
+                "bullpen_candidate_1", "bullpen_candidate_2", "bullpen_candidate_3",
+                "bullpen_candidate_summary", "bullpen_selection_mode",
+                "bullpen_availability_applied", "bullpen_entry_prob",
+                "starter_stays_next_batter_prob",
+            ]
+            available_cols = [c for c in bullpen_cols if c in sim_df.columns]
+            if available_cols:
+                st.dataframe(sim_df[available_cols], use_container_width=True)
+            else:
+                st.info("Bullpen candidate data not available.")
+
     # ------------------------------------------------------------------
     # SECTION 6 — Admin Tools
     # ------------------------------------------------------------------