Feedback tab + Batch 13 debug refinements + rebrand to Kasper

- Add Feedback nav tab (CockroachDB-backed submit + display)
- Add missing snap_after_family_zone_* and snap_after_pulled_contact_* checkpoints to simulator
- Add arsenal_drift_applied_scale to drift model output and simulator passthrough
- Expand debug ladder to 12 steps with HR/Hit/TB2P toggle
- Rebrand dashboard header to Kasper with updated product description
- Add arsenal_drift_model.py and rolling_form_model.py (Batch 13 models)
- Add debug_page.py (Batch 13 full debug dashboard)
- Opportunity model and pitcher adjustment updates

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

app.py

@@ -127,6 +127,8 @@ from visualization.pitcher import create_pitch_movement_chart
 from visualization.props_page import render_props
 from visualization.simulation import create_hr_distribution, create_total_bases_distribution
 from visualization.game_cards import render_game_card
+from visualization.debug_page import render_debug
+from visualization.feedback_page import render_feedback
 
 st.set_page_config(
     page_title=APP_TITLE,
@@ -504,10 +506,11 @@ def load_weather(venue_name: str) -> pd.DataFrame:
 
 
 def render_header() -> None:
-    st.title("⚾ World Baseball Classic Analytics Assistant")
+    st.title("⚾ Kasper")
     st.caption(
-        "WBC-first app using official WBC schedule pages, WBC Statcast from Baseball Savant, "
-        "The Odds API, weather overlays, CockroachDB persistence, and a modern Streamlit UI."
+        "All-in-One Baseball Assistant. Excellent for finding Home Run True +EV. "
+        "Full pitch telemetry with XGBoost Machine Learning model trained on a 3.8M pitch-event "
+        "data set + live data with custom anchors."
     )
     secret_status = []
     secret_status.append("ODDS_API_KEY ✓" if ODDS_API_KEY else "ODDS_API_KEY missing")
@@ -2654,1032 +2657,6 @@ def render_dashboard() -> None:
     if live_games.empty and final_games.empty and scheduled_games.empty:
         st.warning("No games available from either schedule or scores feed.")
 
-    with st.expander("Debug: raw schedule, scores"):
-        if st.button("Grade Final Game Outcomes From Scores", key="grade_final_games_debug"):
-            grade_final_game_outcomes_from_scores(scores_df)
-            st.success("Attempted final game grading from scores feed.")
-        if st.button("Build Batter Prop Outcome Rows From Audit", key="grade_batter_props_debug"):
-            grade_batter_prop_outcomes_from_audit()
-            st.success("Attempted batter-prop outcome scaffolding from audit rows.")
-        if st.button("Fill Batter Prop Realized Outcomes From Statcast", key="fill_batter_realized_debug"):
-            fill_batter_prop_realized_outcomes(statcast_df)
-            st.success("Attempted realized batter outcome fill from loaded Statcast.")
-        st.write("Current WBC date")
-        st.write(current_wbc_date_str())
-        st.write("Scores rows count")
-        st.write(len(scores_df))
-        game_outcomes_df = read_game_outcomes(conn)
-        st.write("Game outcome rows")
-        st.write(len(game_outcomes_df))
-
-        if not game_outcomes_df.empty:
-            st.dataframe(
-                game_outcomes_df.tail(20),
-                use_container_width=True,
-                hide_index=True,
-            )
-        batter_prop_outcomes_df = read_batter_prop_outcomes(conn)
-        st.write("Batter prop outcome rows")
-        st.write(len(batter_prop_outcomes_df))
-
-        if not batter_prop_outcomes_df.empty:
-            display_cols = [
-                col for col in [
-                    "created_at",
-                    "graded_at",
-                    "game_pk",
-                    "slot",
-                    "batter_name",
-                    "fair_hr_odds",
-                    "book_hr_odds",
-                    "adjusted_edge",
-                    "confidence",
-                    "recommendation_tier",
-                    "realized_hit",
-                    "realized_hr",
-                    "realized_tb2p",
-                    "grade_status",
-                    "outcome_source",
-                    "play_events_debug",
-                ] if col in batter_prop_outcomes_df.columns
-            ]
-
-            st.dataframe(
-                batter_prop_outcomes_df[display_cols].tail(20),
-                use_container_width=True,
-                hide_index=True,
-            )
-        st.write("Raw score statuses")
-        st.write(sorted(scores_df["status"].fillna("").astype(str).unique().tolist()))
-        st.write("Schedule rows")
-        st.dataframe(schedule_df.head(20), use_container_width=True, hide_index=True)
-
-        st.write("Scores rows")
-        st.dataframe(scores_df.head(20), use_container_width=True, hide_index=True)
-
-        if not scores_df.empty and "status" in scores_df.columns:
-            st.write("Statuses from scores feed")
-            st.write(scores_df["status"].value_counts(dropna=False))
-
-            st.write("Scores columns")
-            st.write(list(scores_df.columns))
-
-        st.write("Live games extracted")
-        st.dataframe(live_games.head(20), use_container_width=True, hide_index=True)
-
-        if not live_games.empty:
-            st.write("Live games detail")
-
-            debug_cols = [
-                col for col in [
-                    "away_team",
-                    "home_team",
-                    "status",
-                    "batter_name",
-                    "pitcher_name",
-                    "last_pitch",
-                    "pitch_type",
-                    "pitch_velocity",
-                    "pitch_spin_rate",
-                    "pitch_extension",
-                    "pitch_break_angle",
-                    "pitch_break_length",
-                    "pitch_pfx_x",
-                    "pitch_pfx_z",
-                    "pitch_data_debug",
-                    "play_events_debug",
-                    "savant_pitch_debut",
-                    "savant_feed_debug",
-                ]
-                if col in live_games.columns
-            ]
-
-            st.dataframe(
-                live_games[debug_cols].head(20),
-                use_container_width=True,
-                hide_index=True,
-            )
-
-        st.write("Final games extracted")
-        st.dataframe(final_games.head(20), use_container_width=True, hide_index=True)
-
-        if not final_games.empty:
-            st.write("Final games score hydration debug")
-            debug_cols = [
-                col for col in [
-                    "away_team",
-                    "home_team",
-                    "status",
-                    "game_pk",
-                    "away_score",
-                    "home_score",
-                    "away_hits",
-                    "home_hits",
-                    "away_errors",
-                    "home_errors",
-                ] if col in final_games.columns
-            ]
-            st.dataframe(final_games[debug_cols], use_container_width=True, hide_index=True)
-
-        st.write("Scores fallback from schedule feeds used")
-        st.write(scores_df.empty and not schedule_df.empty)
-
-        st.write("Scores have live/final content")
-        st.write(_scores_df_has_live_or_final_content(scores_df))
-
-        st.write("Fallback schedule->live-feed path eligible")
-        st.write((scores_df.empty or not _scores_df_has_live_or_final_content(scores_df)) and not schedule_df.empty)
-
-        st.write("Recovery live rows")
-        st.write(len(live_games))
-        st.write("Recovery final rows")
-        st.write(len(final_games))
-
-        if not scores_df.empty and "status" in scores_df.columns:
-            st.write("Raw score statuses")
-            st.write(sorted(scores_df["status"].fillna("").astype(str).unique().tolist()))
-
-        if not scores_df.empty and "status" in scores_df.columns:
-            st.write("Raw score statuses")
-            st.write(sorted(scores_df["status"].fillna("").astype(str).unique().tolist()))
-
-        st.write("Scheduled games extracted")
-        st.dataframe(scheduled_games.head(20), use_container_width=True, hide_index=True)
-
-        st.write("Schedule source date")
-        st.write(schedule_date_str)
-
-        st.write("Using sticky last-good scores")
-        st.write("last_good_scores_df" in st.session_state)
-
-        if not scores_df.empty and "scores_source_date" in scores_df.columns:
-            st.write("Scores source date")
-            st.write(scores_df["scores_source_date"].iloc[0])
-
-        if not live_games.empty and "status" in live_games.columns:
-            st.write("Live game statuses")
-            st.write(live_games["status"].fillna("").astype(str).tolist())
-
-        if not live_games.empty:
-            st.write("Recovered live game_pk values")
-            st.write(live_games.get("game_pk", pd.Series(dtype=str)).tolist() if "game_pk" in live_games.columns else [])
-
-        st.write("LIVE GAME PK DEBUG")
-        if not live_games.empty:
-            st.dataframe(
-            live_games[["away_team", "home_team", "status", "game_pk"]],
-            use_container_width=True,
-            hide_index=True,
-        )
-
-        from utils.import_savant_csvs import (
-        import_batter_savant_csv,
-        import_pitcher_savant_csv,
-        )
-        st.markdown("### Savant CSV Import")
-        clear_first = st.checkbox("Clear Savant tables before import")
-        if st.button("Import batter Savant CSV"):
-            try:
-                with st.spinner("Importing batter Savant CSV..."):
-                    result = import_batter_savant_csv(clear_first=clear_first)
-                st.success(
-                    f"Imported {result['inserted_rows']} / {result['total_rows']} batter rows into {result['table_name']}"
-                )
-            except Exception as e:
-                st.error(f"Batter import failed: {e}")
-                
-        if st.button("Import pitcher Savant CSV"):
-            try:
-                with st.spinner("Importing pitcher Savant CSV..."):
-                    result = import_pitcher_savant_csv(clear_first=clear_first)
-                st.success(
-                    f"Imported {result['inserted_rows']} / {result['total_rows']} pitcher rows into {result['table_name']}"
-                )
-            except Exception as e:
-                st.error(f"Pitcher import failed: {e}")
-                
-        from sqlalchemy import text
-        from database.remote_db import get_connection
-        from models.batter_zone_store import load_batter_zone_store_metrics
-        
-        if st.checkbox("Show single batter zone store summary"):
-            batter_name_debug = st.text_input(
-                "Batter name for zone store summary",
-                value="Bryce Harper"
-            )
-            
-            if batter_name_debug:
-                try:
-                    summary = load_batter_zone_store_metrics(batter_name_debug)
-                    st.write(summary)
-                except Exception as e:
-                    st.error(f"Error loading batter zone store summary: {e}")
-                    
-        if st.checkbox("Show pitcher baseline store status"):
-            try:
-                pitcher_store_conn = get_connection()
-                pitcher_table_exists = pitcher_store_conn.execute(
-                    text(
-                        """
-                        SELECT EXISTS (
-                            SELECT 1
-                            FROM information_schema.tables
-                            WHERE table_schema = 'public'
-                              AND table_name = 'pitcher_inning_first_seed_events'
-                        )
-                        """
-                    )
-                ).scalar()
-                
-                st.write("Pitcher baseline DB exists:", bool(pitcher_table_exists))
-                
-                if pitcher_table_exists:
-                    count = pitcher_store_conn.execute(
-                        text("SELECT COUNT(*) FROM pitcher_inning_first_seed_events")
-                    ).scalar()
-                    
-                    st.write("Stored pitcher inning-first seed rows:", int(count or 0))
-                    
-                    preview_rows = pitcher_store_conn.execute(
-                        text(
-                            """
-                            SELECT
-                                pitcher_name,
-                                game_date,
-                                inning,
-                                pitch_type_key,
-                                velocity,
-                                spin_rate,
-                                extension,
-                                pfx_x,
-                                pfx_z,
-                                created_at
-                            FROM pitcher_inning_first_seed_events
-                            ORDER BY created_at DESC
-                            LIMIT 25
-                            """
-                        )
-                    ).fetchall()
-
-                    if preview_rows:
-                        preview = pd.DataFrame(
-                            preview_rows,
-                            columns=[
-                                "pitcher_name",
-                                "game_date",
-                                "inning",
-                                "pitch_type_key",
-                                "velocity",
-                                "spin_rate",
-                                "extension",
-                                "pfx_x",
-                                "pfx_z",
-                                "created_at",
-                            ],
-                        )
-                        st.dataframe(preview, use_container_width=True, hide_index=True)
-                pitcher_store_conn.close()
-
-            except Exception as e:
-                st.error(f"Error reading pitcher baseline store: {e}")
-
-        if st.checkbox("Show batter zone store status"):
-            try:
-                batter_store_conn = get_connection()
-                
-                batter_table_exists = batter_store_conn.execute(
-                    text(
-                        """
-                        SELECT EXISTS (
-                            SELECT 1
-                            FROM information_schema.tables
-                            WHERE table_schema = 'public'
-                              AND table_name = 'batter_zone_events'
-                        )
-                        """
-                    )
-                ).scalar()
-
-                st.write("Batter zone DB exists:", bool(batter_table_exists))
-
-                if batter_table_exists:
-                    count = batter_store_conn.execute(
-                        text("SELECT COUNT(*) FROM batter_zone_events")
-                    ).scalar()
-
-                    st.write("Stored batter zone event rows:", int(count or 0))
-
-                    preview_rows = batter_store_conn.execute(
-                        text(
-                            """
-                            SELECT
-                                batter_name,
-                                game_date,
-                                pitch_family,
-                                zone_bucket,
-                                plate_x,
-                                plate_z,
-                                pfx_x,
-                                pfx_z,
-                                ax,
-                                ay,
-                                az,
-                                hit_flag,
-                                hr_flag,
-                                tb2p_flag,
-                                whiff_flag,
-                                damage_flag,
-                                created_at
-                            FROM batter_zone_events
-                            ORDER BY created_at DESC
-                            LIMIT 25
-                            """
-                        )
-                    ).fetchall()
-
-                    if preview_rows:
-                        preview = pd.DataFrame(
-                            preview_rows,
-                            columns=[
-                                "batter_name",
-                                "game_date",
-                                "pitch_family",
-                                "zone_bucket",
-                                "plate_x",
-                                "plate_z",
-                                "pfx_x",
-                                "pfx_z",
-                                "ax",
-                                "ay",
-                                "az",
-                                "hit_flag",
-                                "hr_flag",
-                                "tb2p_flag",
-                                "whiff_flag",
-                                "damage_flag",
-                                "created_at",
-                            ],
-                        )
-                        st.dataframe(preview, use_container_width=True, hide_index=True)
-                batter_store_conn.close()
-
-            except Exception as e:
-                st.error(f"Error reading batter zone store: {e}")
-
-        if st.checkbox("Show zone and pulled-barrel debug table"):
-            if phase6_debug_rows:
-                debug_df = pd.DataFrame(phase6_debug_rows)
-
-                preferred_cols = [
-                    "away_team",
-                    "home_team",
-                    "slot",
-                    "batter_name",
-                    "pitcher_name",
-                    "hr_prob",
-                    "zone_hr_boost",
-                    "zone_hit_boost",
-                    "zone_tb2p_boost",
-                    "zone_sample_size",
-                    "pull_rate",
-                    "air_ball_rate",
-                    "pull_air_rate",
-                    "pulled_hard_air_rate",
-                    "pulled_barrel_rate",
-                    "pre_pull_hr_prob_base",
-                    "post_pull_hr_prob_base",
-                ]
-
-                available_cols = [col for col in preferred_cols if col in debug_df.columns]
-
-                st.dataframe(
-                    debug_df[available_cols],
-                    use_container_width=True,
-                    hide_index=True,
-                )
-            else:
-                st.info("No debug rows available.")
-
-        if "pitcher_store_error" in st.session_state:
-            st.error(f"Pitcher store error: {st.session_state['pitcher_store_error']}")
-
-        if "batter_zone_store_error" in st.session_state:
-            st.error(f"Batter zone store error: {st.session_state['batter_zone_store_error']}")
-        
-        st.write("Live pitch metrics debug")
-
-        pitch_debug_df = build_live_pitch_metrics_debug_df(live_games)
-
-        if pitch_debug_df.empty:
-            st.info("No live games available for pitch metrics debug.")
-        else:
-            st.dataframe(
-                pitch_debug_df,
-                use_container_width=True,
-                hide_index=True,
-            )
-
-        st.write("Prepared live games debug")
-
-        prepared_live_games_df = build_prepared_live_games_df(live_games)
-
-        prepared_live_games_df = filter_games_for_display(
-            prepared_live_games_df,
-            filter_option,
-        )
-        
-        prepared_live_games_df = filter_games_for_competition(
-            prepared_live_games_df,
-            competition_filter,
-        )
-
-        if prepared_live_games_df.empty:
-            st.info("No prepared live games available.")
-        else:
-            debug_cols = [
-                col for col in [
-                    "away_team",
-                    "home_team",
-                    "status",
-                    "game_pk",
-                    "batter_name",
-                    "pitcher_name",
-                    "balls",
-                    "strikes",
-                    "outs",
-                    "runner_on_1b",
-                    "runner_on_2b",
-                    "runner_on_3b",
-                    "last_play",
-                    "last_pitch",
-                    "pitch_velocity",
-                    "pitch_spin_rate",
-                    "pitch_extension",
-                ] if col in prepared_live_games_df.columns
-            ]
-            st.dataframe(
-                prepared_live_games_df[debug_cols],
-                use_container_width=True,
-                hide_index=True,
-            )
-
-        st.write("Opportunity model source inputs")
-
-        prepared_live_games_df = build_prepared_live_games_df(live_games)
-
-        if prepared_live_games_df is None or prepared_live_games_df.empty:
-            st.info("No prepared live games available for opportunity source debug.")
-        else:
-            source_cols = [
-                col for col in [
-                    "away_team",
-                    "home_team",
-                    "status",
-                    "pitcher_name",
-                    "on_deck_name",
-                    "in_hole_name",
-                    "three_away_name",
-                    "outs",
-                ]
-                if col in prepared_live_games_df.columns
-            ]
-
-            if source_cols:
-                st.dataframe(
-                    prepared_live_games_df[source_cols],
-                    use_container_width=True,
-                    hide_index=True,
-                )
-            else:
-                st.info("Opportunity source columns are not present on prepared live games.")
-
-        st.write("Upcoming simulator raw rows")
-
-        prepared_live_games_df = build_prepared_live_games_df(live_games)
-
-        if prepared_live_games_df is None or prepared_live_games_df.empty:
-            st.info("No prepared live games available for simulator debug.")
-        else:
-            simulator_debug_rows: list[dict] = []
-
-            for _, live_row in prepared_live_games_df.iterrows():
-                game = live_row.to_dict()
-
-                pitcher_name_debug = str(game.get("pitcher_name", "") or "").strip()
-                pitcher_row_debug = build_pitcher_feature_row(statcast_df, pitcher_name_debug)
-                
-                try:
-                    simulated_rows = build_upcoming_simulated_rows(
-                        game_row=game,
-                        statcast_df=statcast_df,
-                        weather_row=None,
-                    )
-                except Exception as e:
-                    simulated_rows = []
-                    simulator_debug_rows.append(
-                        {
-                            "away_team": game.get("away_team"),
-                            "home_team": game.get("home_team"),
-                            "slot": "ERROR",
-                            "batter_name": None,
-                            "pitcher_name": game.get("pitcher_name"),
-                            "on_deck_name": game.get("on_deck_name"),
-                            "in_hole_name": game.get("in_hole_name"),
-                            "three_away_name": game.get("three_away_name"),
-                            "debug_note": str(e),
-                        }
-                    )
-
-                if isinstance(simulated_rows, list) and not simulated_rows:
-                    simulator_debug_rows.append(
-                        {
-                            "away_team": game.get("away_team"),
-                            "home_team": game.get("home_team"),
-                            "slot": "EMPTY",
-                            "batter_name": None,
-                            "pitcher_name": game.get("pitcher_name"),
-                            "on_deck_name": game.get("on_deck_name"),
-                            "in_hole_name": game.get("in_hole_name"),
-                            "three_away_name": game.get("three_away_name"),
-                            "debug_note": "build_upcoming_simulated_rows returned []",
-                        }
-                    )
-
-                if isinstance(simulated_rows, list):
-                    for sim_row in simulated_rows:
-                        if isinstance(sim_row, dict):
-                            simulator_debug_rows.append(
-                                {
-                                    "away_team": game.get("away_team"),
-                                    "home_team": game.get("home_team"),
-                                    "slot": sim_row.get("slot"),
-                                    "batter_name": sim_row.get("batter_name"),
-                                    "pitcher_name": sim_row.get("pitcher_name"),
-                                    "on_deck_name": game.get("on_deck_name"),
-                                    "in_hole_name": game.get("in_hole_name"),
-                                    "three_away_name": game.get("three_away_name"),
-                                    "hit_prob": sim_row.get("hit_prob"),
-                                    "hr_prob": sim_row.get("hr_prob"),
-                                    "tb2p_prob": sim_row.get("tb2p_prob"),
-                                    "debug_note": None,
-                                }
-                            )
-
-            if not simulator_debug_rows:
-                st.info("No simulator debug rows available.")
-            else:
-                simulator_debug_df = pd.DataFrame(simulator_debug_rows)
-                st.dataframe(
-                    simulator_debug_df,
-                    use_container_width=True,
-                    hide_index=True,
-                )
-
-        st.write("Opportunity model debug")
-
-        prepared_live_games_df = build_prepared_live_games_df(live_games)
-
-        if prepared_live_games_df is None or prepared_live_games_df.empty:
-            st.info("No prepared live games available for opportunity-model debug.")
-        else:
-            opportunity_debug_rows: list[dict] = []
-
-            for _, live_row in prepared_live_games_df.iterrows():
-                game = live_row.to_dict()
-
-                try:
-                    recommendations_debug = build_upcoming_hitter_recommendations(
-                        game_row=game,
-                        statcast_df=statcast_df,
-                        odds_df=odds_df,
-                        weather_row=None,
-                    )
-                except Exception as e:
-                    recommendations_debug = []
-                    opportunity_debug_rows.append(
-                        {
-                            "away_team": game.get("away_team"),
-                            "home_team": game.get("home_team"),
-                            "batter_name": None,
-                            "slot": "ERROR",
-                            "lineup_distance": None,
-                            "pa_prob_this_inning": None,
-                            "pa_prob_next_two_innings": None,
-                            "expected_pa": None,
-                            "hit_prob": None,
-                            "hr_prob": None,
-                            "tb2p_prob": None,
-                            "fair_hr_odds": None,
-                            "book_hr_odds": None,
-                            "hr_edge": str(e),
-                        }
-                    )
-
-                if isinstance(recommendations_debug, list) and not recommendations_debug:
-                    opportunity_debug_rows.append(
-                        {
-                            "away_team": game.get("away_team"),
-                            "home_team": game.get("home_team"),
-                            "batter_name": None,
-                            "slot": "EMPTY",
-                            "lineup_distance": None,
-                            "pa_prob_this_inning": None,
-                            "pa_prob_next_two_innings": None,
-                            "expected_pa": None,
-                            "hit_prob": None,
-                            "hr_prob": None,
-                            "tb2p_prob": None,
-                            "fair_hr_odds": None,
-                            "book_hr_odds": None,
-                            "hr_edge": "build_upcoming_hitter_recommendations returned []",
-                        }
-                    )
-
-                if isinstance(recommendations_debug, list):
-                    for rec in recommendations_debug:
-                        if isinstance(rec, dict):
-                            opportunity_debug_rows.append(
-                                {
-                                    "away_team": game.get("away_team"),
-                                    "home_team": game.get("home_team"),
-                                    "batter_name": rec.get("batter_name"),
-                                    "slot": rec.get("slot"),
-                                    "lineup_distance": rec.get("lineup_distance"),
-                                    "pa_prob_this_inning": rec.get("pa_prob_this_inning"),
-                                    "pa_prob_next_two_innings": rec.get("pa_prob_next_two_innings"),
-                                    "expected_pa": rec.get("expected_pa"),
-                                    "hit_prob": rec.get("hit_prob"),
-                                    "hr_prob": rec.get("hr_prob"),
-                                    "tb2p_prob": rec.get("tb2p_prob"),
-                                    "fair_hr_odds": rec.get("fair_hr_odds"),
-                                    "book_hr_odds": rec.get("book_hr_odds"),
-                                    "hr_edge": rec.get("hr_edge"),
-                                }
-                            )
-
-            if not opportunity_debug_rows:
-                st.info("No opportunity-model debug rows available.")
-            else:
-                opportunity_debug_df = pd.DataFrame(opportunity_debug_rows)
-                st.dataframe(
-                    opportunity_debug_df,
-                    use_container_width=True,
-                    hide_index=True,
-                )
-
-        st.write("Phase 6 live-state debug")
-
-        prepared_live_games_df = build_prepared_live_games_df(live_games)
-
-        if prepared_live_games_df is None or prepared_live_games_df.empty:
-            st.info("No prepared live games available for Phase 6 debug.")
-        else:
-            phase6_debug_rows: list[dict] = []
-
-            for _, live_row in prepared_live_games_df.iterrows():
-                game = live_row.to_dict()
-
-                pitcher_name_debug = str(game.get("pitcher_name", "") or "").strip()
-                pitcher_id_debug = game.get("pitcher_id")
-                pitcher_row_debug = build_pitcher_feature_row(
-                    statcast_df=statcast_df,
-                    pitcher_name=pitcher_name_debug,
-                    pitcher_id=pitcher_id_debug,
-                )
-
-                try:
-                    recommendations_debug = build_upcoming_hitter_recommendations(
-                        game_row=game,
-                        statcast_df=statcast_df,
-                        odds_df=odds_df,
-                        weather_row=None,
-                    )
-                except Exception as e:
-                    recommendations_debug = []
-                    phase6_debug_rows.append(
-                        {
-                            "away_team": game.get("away_team"),
-                            "home_team": game.get("home_team"),
-                            "pitcher_name": pitcher_name_debug,
-                            "batter_name": None,
-                            "slot": "ERROR",
-
-                            "fatigue_score": None,
-                            "degradation_score": None,
-                            "trust_live_score": None,
-                            "baseline_weight": None,
-                            "live_weight": None,
-                            "velo_delta": None,
-                            "spin_delta": None,
-                            "extension_delta": None,
-                            "pitch_count": None,
-                            "times_through_order": None,
-
-                            "live_velocity": game.get("pitch_velocity"),
-                            "rolling_velocity": game.get("rolling_pitch_velocity"),
-                            "baseline_velocity": pitcher_row_debug.get("avg_release_speed"),
-                            "baseline_spin_rate": pitcher_row_debug.get("avg_release_spin_rate"),
-                            "baseline_extension": pitcher_row_debug.get("avg_release_extension"),
-
-                            "rolling_pitch_sample_size": game.get("rolling_pitch_sample_size"),
-                            "rolling_pitch_velocity_sample_size": game.get("rolling_pitch_velocity_sample_size"),
-                            "rolling_pitch_spin_sample_size": game.get("rolling_pitch_spin_sample_size"),
-                            "rolling_pitch_extension_sample_size": game.get("rolling_pitch_extension_sample_size"),
-
-                            "rolling_pitch_velocity": game.get("rolling_pitch_velocity"),
-                            "rolling_pitch_spin_rate": game.get("rolling_pitch_spin_rate"),
-                            "rolling_pitch_extension": game.get("rolling_pitch_extension"),
-
-                            "seed_baseline_velocity": game.get("seed_baseline_velocity"),
-                            "seed_baseline_spin_rate": game.get("seed_baseline_spin_rate"),
-                            "seed_baseline_extension": game.get("seed_baseline_extension"),
-                            "seed_baseline_velocity_sample_size": game.get("seed_baseline_velocity_sample_size"),
-                            "seed_baseline_spin_sample_size": game.get("seed_baseline_spin_sample_size"),
-                            "seed_baseline_extension_sample_size": game.get("seed_baseline_extension_sample_size"),
-
-                            "pitch_type_key": game.get("pitch_type_key"),
-                            "rolling_pitch_type_key": game.get("rolling_pitch_type_key"),
-
-                            "rolling_pitch_type_velocity": game.get("rolling_pitch_type_velocity"),
-                            "rolling_pitch_type_spin_rate": game.get("rolling_pitch_type_spin_rate"),
-                            "rolling_pitch_type_extension": game.get("rolling_pitch_type_extension"),
-
-                            "rolling_pitch_type_velocity_sample_size": game.get("rolling_pitch_type_velocity_sample_size"),
-                            "rolling_pitch_type_spin_sample_size": game.get("rolling_pitch_type_spin_sample_size"),
-                            "rolling_pitch_type_extension_sample_size": game.get("rolling_pitch_type_extension_sample_size"),
-
-                            "seed_pitch_type_key": game.get("seed_pitch_type_key"),
-                            "seed_pitch_type_baseline_velocity": game.get("seed_pitch_type_baseline_velocity"),
-                            "seed_pitch_type_baseline_spin_rate": game.get("seed_pitch_type_baseline_spin_rate"),
-                            "seed_pitch_type_baseline_extension": game.get("seed_pitch_type_baseline_extension"),
-
-                            "seed_pitch_type_baseline_velocity_sample_size": game.get("seed_pitch_type_baseline_velocity_sample_size"),
-                            "seed_pitch_type_baseline_spin_sample_size": game.get("seed_pitch_type_baseline_spin_sample_size"),
-                            "seed_pitch_type_baseline_extension_sample_size": game.get("seed_pitch_type_baseline_extension_sample_size"),
-
-                            "stored_baseline_velocity": game.get("stored_baseline_velocity"),
-                            "stored_baseline_spin_rate": game.get("stored_baseline_spin_rate"),
-                            "stored_baseline_extension": game.get("stored_baseline_extension"),
-                            "stored_baseline_velocity_sample_size": game.get("stored_baseline_velocity_sample_size"),
-                            "stored_baseline_spin_sample_size": game.get("stored_baseline_spin_sample_size"),
-                            "stored_baseline_extension_sample_size": game.get("stored_baseline_extension_sample_size"),
-
-                            "stored_pitch_type_baseline_velocity": game.get("stored_pitch_type_baseline_velocity"),
-                            "stored_pitch_type_baseline_spin_rate": game.get("stored_pitch_type_baseline_spin_rate"),
-                            "stored_pitch_type_baseline_extension": game.get("stored_pitch_type_baseline_extension"),
-                            "stored_pitch_type_baseline_velocity_sample_size": game.get("stored_pitch_type_baseline_velocity_sample_size"),
-                            "stored_pitch_type_baseline_spin_sample_size": game.get("stored_pitch_type_baseline_spin_sample_size"),
-                            "stored_pitch_type_baseline_extension_sample_size": game.get("stored_pitch_type_baseline_extension_sample_size"),
-
-                            "arsenal_hr_boost": arsenal_matchup_adj.get("arsenal_hr_boost"),
-                            "arsenal_hit_boost": arsenal_matchup_adj.get("arsenal_hit_boost"),
-                            "arsenal_tb2p_boost": arsenal_matchup_adj.get("arsenal_tb2p_boost"),
-                            "arsenal_whiff_risk": arsenal_matchup_adj.get("arsenal_whiff_risk"),
-                            "arsenal_sample_size": batter_arsenal_row.get("arsenal_sample_size"),
-
-                            "family_zone_hr_boost": family_zone_matchup_adj.get("family_zone_hr_boost"),
-                            "family_zone_hit_boost": family_zone_matchup_adj.get("family_zone_hit_boost"),
-                            "family_zone_tb2p_boost": family_zone_matchup_adj.get("family_zone_tb2p_boost"),
-                            "family_zone_whiff_risk": family_zone_matchup_adj.get("family_zone_whiff_risk"),
-                            "family_zone_sample_size": batter_family_zone_row.get("family_zone_sample_size"),
-                            
-                            "debug_note": str(e),
-                        }
-                    )
-
-                if isinstance(recommendations_debug, list):
-                    for rec in recommendations_debug:
-                        if isinstance(rec, dict):
-                            phase6_debug_rows.append(
-                                {
-                                    "away_team": game.get("away_team"),
-                                    "home_team": game.get("home_team"),
-                                    "pitcher_name": pitcher_name_debug,
-                                    "batter_name": rec.get("batter_name"),
-                                    "slot": rec.get("slot"),
-
-                                    "fatigue_score": rec.get("fatigue_score"),
-                                    "degradation_score": rec.get("degradation_score"),
-                                    "trust_live_score": rec.get("trust_live_score"),
-                                    "baseline_weight": rec.get("baseline_weight"),
-                                    "live_weight": rec.get("live_weight"),
-                                    "velo_delta": rec.get("velo_delta"),
-                                    "spin_delta": rec.get("spin_delta"),
-                                    "extension_delta": rec.get("extension_delta"),
-                                    "pitch_count": rec.get("pitch_count"),
-                                    "times_through_order": rec.get("times_through_order"),
-                                    "zone_hr_boost": rec.get("zone_hr_boost"),
-                                    "zone_hit_boost": rec.get("zone_hit_boost"),
-                                    "zone_tb2p_boost": rec.get("zone_tb2p_boost"),
-                                    "zone_sample_size": rec.get("zone_sample_size"),
-                                    "pull_rate": rec.get("pull_rate"),
-                                    "air_ball_rate": rec.get("air_ball_rate"),
-                                    "pull_air_rate": rec.get("pull_air_rate"),
-                                    "pulled_hard_air_rate": rec.get("pulled_hard_air_rate"),
-                                    "pulled_barrel_rate": rec.get("pulled_barrel_rate"),
-                                    "pre_pull_hr_prob_base": rec.get("pre_pull_hr_prob_base"),
-                                    "post_pull_hr_prob_base": rec.get("post_pull_hr_prob_base"),
-
-                                    "live_velocity": game.get("pitch_velocity"),
-                                    "rolling_velocity": game.get("rolling_pitch_velocity"),
-                                    "baseline_velocity": pitcher_row_debug.get("avg_release_speed"),
-                                    "baseline_spin_rate": pitcher_row_debug.get("avg_release_spin_rate"),
-                                    "baseline_extension": pitcher_row_debug.get("avg_release_extension"),
-
-                                    "rolling_pitch_sample_size": rec.get("rolling_pitch_sample_size"),
-                                    "rolling_pitch_velocity_sample_size": rec.get("rolling_pitch_velocity_sample_size"),
-                                    "rolling_pitch_spin_sample_size": rec.get("rolling_pitch_spin_sample_size"),
-                                    "rolling_pitch_extension_sample_size": rec.get("rolling_pitch_extension_sample_size"),
-
-                                    "rolling_pitch_velocity": game.get("rolling_pitch_velocity"),
-                                    "rolling_pitch_spin_rate": game.get("rolling_pitch_spin_rate"),
-                                    "rolling_pitch_extension": game.get("rolling_pitch_extension"),
-
-                                    "seed_baseline_velocity": game.get("seed_baseline_velocity"),
-                                    "seed_baseline_spin_rate": game.get("seed_baseline_spin_rate"),
-                                    "seed_baseline_extension": game.get("seed_baseline_extension"),
-
-                                    "debug_note": None,
-                                }
-                            )
-
-            if not phase6_debug_rows:
-                st.info("No Phase 6 live-state debug rows available.")
-            else:
-                phase6_debug_df = pd.DataFrame(phase6_debug_rows)
-                st.dataframe(
-                    phase6_debug_df,
-                    use_container_width=True,
-                    hide_index=True,
-                )
-        
-        batter_audit_df = read_batter_prop_audit_view(conn)
-        st.write("Batter prop audit rows")
-        st.write(len(batter_audit_df))
-
-        if not batter_audit_df.empty:
-            st.dataframe(
-                batter_audit_df.tail(20),
-                use_container_width=True,
-                hide_index=True,
-            )
-
-            st.markdown("### Batter HR Audit Metrics")
-
-            batter_tier_table = build_batter_hr_tier_table(batter_audit_df)
-            batter_conf_table = build_batter_hr_confidence_table(batter_audit_df)
-            batter_edge_table = build_batter_hr_edge_table(batter_audit_df)
-
-            if not batter_tier_table.empty:
-                st.write("Batter HR Rate by Recommendation Tier")
-                st.dataframe(batter_tier_table, use_container_width=True, hide_index=True)
-
-            if not batter_conf_table.empty:
-                st.write("Batter HR Rate by Confidence Bucket")
-                st.dataframe(batter_conf_table, use_container_width=True, hide_index=True)
-
-            if not batter_edge_table.empty:
-                st.write("Batter HR Rate by Adjusted Edge Bucket")
-                st.dataframe(batter_edge_table, use_container_width=True, hide_index=True)
-
-        rec_logs_df = read_table(conn, "recommendation_logs")
-        st.write("Recommendation log rows")
-        st.write(len(rec_logs_df))
-
-        if not rec_logs_df.empty:
-            st.dataframe(
-                rec_logs_df.tail(20),
-                use_container_width=True,
-                hide_index=True,
-            )
-
-        audit_df = read_recommendation_audit_view(conn)
-        st.write("Recommendation audit rows")
-        st.write(len(audit_df))
-
-        if not audit_df.empty:
-            audit_display_cols = [
-                col for col in [
-                    "created_at",
-                    "game_pk",
-                    "away_team",
-                    "home_team",
-                    "slot",
-                    "batter_name",
-                    "fair_hr_odds",
-                    "book_hr_odds",
-                    "adjusted_edge",
-                    "confidence",
-                    "recommendation_tier",
-                    "realized_hr",
-                    "graded_at",
-                    "outcome_source",
-                ] if col in audit_df.columns
-            ]
-
-            st.dataframe(
-                audit_df[audit_display_cols].tail(20),
-                use_container_width=True,
-                hide_index=True,
-            )
-
-        st.markdown("### Model Evaluation Metrics")
-
-        audit_df = read_recommendation_audit_view(conn)
-
-        cal_table = build_hr_calibration_table(audit_df)
-        edge_table = build_edge_bucket_table(audit_df)
-        conf_table = build_confidence_table(audit_df)
-        tier_table = build_tier_performance_table(audit_df)
-
-        if not cal_table.empty:
-            st.write("HR Probability Calibration")
-            st.dataframe(cal_table, use_container_width=True, hide_index=True)
-
-        if not edge_table.empty:
-            st.write("Edge Bucket Performance")
-            st.dataframe(edge_table, use_container_width=True, hide_index=True)
-
-        if not conf_table.empty:
-            st.write("Confidence Bucket Performance")
-            st.dataframe(conf_table, use_container_width=True, hide_index=True)
-
-        if not tier_table.empty:
-            st.write("Recommendation Tier Performance")
-            st.dataframe(tier_table, use_container_width=True, hide_index=True)
-
-
-        if not scores_df.empty and "status" in scores_df.columns:
-            st.write("Raw score statuses")
-            st.write(sorted(scores_df["status"].fillna("").astype(str).unique().tolist()))
-
-
-        st.markdown("### Batch 7: ERE and CLV")
-
-        ere_table = build_ere_table(audit_df)
-        ere_edge_table = build_ere_by_edge_bucket_table(audit_df)
-        ere_conf_table = build_ere_by_confidence_bucket_table(audit_df)
-        ere_tier_table = build_ere_by_tier_table(audit_df)
-
-        clv_table = build_clv_table(audit_df)
-        clv_tier_table = build_clv_by_tier_table(audit_df)
-
-        if not ere_table.empty:
-            st.write("Global Edge Realization Efficiency (ERE)")
-            st.dataframe(ere_table, use_container_width=True, hide_index=True)
-        else:
-            st.info("No graded audit data available yet.")
-
-        if not ere_edge_table.empty:
-            st.write("ERE by Edge Bucket")
-            st.dataframe(ere_edge_table, use_container_width=True, hide_index=True)
-        else:
-            st.info("No graded audit data available yet.")
-            
-        if not ere_conf_table.empty:
-            st.write("ERE by Confidence Bucket")
-            st.dataframe(ere_conf_table, use_container_width=True, hide_index=True)
-        else:
-            st.info("No graded audit data available yet.")
-            
-        if not ere_tier_table.empty:
-            st.write("ERE by Recommendation Tier")
-            st.dataframe(ere_tier_table, use_container_width=True, hide_index=True)
-        else:
-            st.info("No graded audit data available yet.")
-            
-        if not clv_table.empty:
-            st.write("Closing Line Value (CLV) Summary")
-            st.dataframe(clv_table, use_container_width=True, hide_index=True)
-        else:
-            st.info("No graded audit data available yet.")
-            
-        if not clv_tier_table.empty:
-            st.write("CLV by Recommendation Tier")
-            st.dataframe(clv_tier_table, use_container_width=True, hide_index=True)
-        else:
-            st.info("No graded audit data available yet.")
-
-        st.markdown("### Batch 7 Readiness Check")
-
-        st.write("Recommendation logging function restored")
-        st.write(True)
-
-        st.write("Recommendation log rows")
-        rec_logs_df = read_table(conn, "recommendation_logs")
-        st.write(len(rec_logs_df))
-
-        st.write("Recommendation outcome rows")
-        rec_outcomes_df = read_table(conn, "recommendation_outcomes")
-        st.write(len(rec_outcomes_df))
-
-        st.write("Batter prop outcome rows")
-        batter_prop_outcomes_df = read_batter_prop_outcomes(conn)
-        st.write(len(batter_prop_outcomes_df))
-
-        st.write("Recommendation audit rows")
-        audit_df = read_recommendation_audit_view(conn)
-        st.write(len(audit_df))
     render_live_prop_odds_debug_panel(live_games)
     
     if statcast_df.empty:
@@ -3970,6 +2947,8 @@ def main() -> None:
             "Betting",
             "Bet Tracker",
             "Algorithm Breakdown",
+            "Feedback",
+            "Debug",
         ],
     )
 
@@ -3986,8 +2965,22 @@ def main() -> None:
         render_betting()
     elif page == "Bet Tracker":
         render_bet_tracker()
-    else:
+    elif page == "Algorithm Breakdown":
         render_algorithm_breakdown()
+    elif page == "Feedback":
+        render_feedback(conn)
+    elif page == "Debug":
+        _debug_scores = get_stable_scores_for_dashboard_date(current_wbc_date_str())
+        render_debug(
+            statcast_df=load_statcast_recent(),
+            odds_df=load_odds(),
+            conn=conn,
+            live_games=pd.DataFrame(),
+            scores_df=_debug_scores,
+            grade_outcomes_fn=grade_final_game_outcomes_from_scores,
+            grade_props_fn=grade_batter_prop_outcomes_from_audit,
+            fill_realized_fn=fill_batter_prop_realized_outcomes,
+        )
 
 
 if __name__ == "__main__":

database/db.py

@@ -28,6 +28,7 @@ import pandas as pd
 from sqlalchemy import text
 
 from database import remote_db
+from utils.helpers import utc_now_iso
 
 
 # ---------------------------------------------------------------------------
@@ -584,3 +585,37 @@ def read_batter_prop_audit_view(conn) -> pd.DataFrame:
     ORDER BY graded_at DESC, created_at DESC
     """
     return pd.read_sql(text(query), conn)
+
+
+# ---------------------------------------------------------------------------
+# Feedback submissions
+# ---------------------------------------------------------------------------
+
+def ensure_feedback_submissions_table(conn) -> None:
+    conn.execute(text(
+        """
+        CREATE TABLE IF NOT EXISTS feedback_submissions (
+            created_at TEXT NOT NULL,
+            message    TEXT NOT NULL
+        )
+        """
+    ))
+
+
+def insert_feedback_submission(conn, message: str) -> None:
+    ensure_feedback_submissions_table(conn)
+    conn.execute(
+        text(
+            "INSERT INTO feedback_submissions (created_at, message) "
+            "VALUES (:created_at, :message)"
+        ),
+        {"created_at": utc_now_iso(), "message": message},
+    )
+
+
+def read_feedback_submissions(conn) -> pd.DataFrame:
+    ensure_feedback_submissions_table(conn)
+    return pd.read_sql(
+        text("SELECT * FROM feedback_submissions ORDER BY created_at DESC"),
+        conn,
+    )

models/arsenal_drift_model.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+"""
+Batch 13 — Arsenal Drift Layer
+
+Short-term pitcher form adjustment derived from existing rolling pitcher signals.
+No new statcast queries — reuses pitcher_rolling_row and pitcher_row already
+computed in the simulator.
+
+Anti-double-counting: signals that the Rolling Form Layer (Batch 12E) already
+fired are reduced by 50% or zeroed out based on rolling_reason_tags.
+
+Returns additive HR and hit adjustments bounded at ±0.003 (HR) and ±0.0025 (hit).
+"""
+
+from typing import Any
+
+
+# ---------------------------------------------------------------------------
+# Shared helpers (self-contained — do not import from rolling_form_model)
+# ---------------------------------------------------------------------------
+
+
+def _safe_delta(rolling_val: Any, baseline_val: Any) -> float | None:
+    """rolling - baseline; returns None if either is None."""
+    if rolling_val is None or baseline_val is None:
+        return None
+    try:
+        return float(rolling_val) - float(baseline_val)
+    except (TypeError, ValueError):
+        return None
+
+
+def _clamp(value: float, lo: float, hi: float) -> float:
+    return max(lo, min(hi, value))
+
+
+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
+    return 1.0
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def compute_arsenal_drift_adjustment(
+    pitcher_roll: dict[str, Any],
+    pitcher_row: dict[str, Any],
+    rolling_reason_tags: str = "",
+) -> dict[str, Any]:
+    """
+    Compute short-term pitcher drift signals from rolling data vs. season baseline.
+
+    pitcher_roll: output of build_pitcher_rolling_form_row() — absolute rolling values
+    pitcher_row:  output of build_pitcher_feature_row() — season baseline
+    rolling_reason_tags: pipe-delimited tag string from compute_upcoming_rolling_adjustment()
+                         used to detect and reduce overlapping signals
+
+    Returns arsenal_hr_adjustment, arsenal_hit_adjustment (additive, bounded).
+    """
+    # ------------------------------------------------------------------
+    # Sample dampening (same pattern as rolling_form_model)
+    # Confidence already includes match quality × n5_scale from build_pitcher_rolling_form_row.
+    # Apply _sample_scale once more here — but use n5 directly to avoid double-squaring:
+    # scale = confidence (match × n5_scale_from_row) is already a dampened measure.
+    # We use it directly without multiplying by sample_scale again.
+    # ------------------------------------------------------------------
+    n5 = int(pitcher_roll.get("pitcher_games_in_window_5g") or 0)
+    confidence = float(pitcher_roll.get("pitcher_rolling_confidence") or 0.0)
+    # confidence = match_scale × n5_scale (from rolling_form_model)
+    # Do NOT multiply by _sample_scale(n5) again — that would double-apply n5 dampening.
+    scale = confidence  # already accounts for both match quality and sample size
+
+    if scale == 0.0:
+        return {
+            "arsenal_hr_adjustment":       0.0,
+            "arsenal_hit_adjustment":      0.0,
+            "arsenal_drift_score":         0.0,
+            "arsenal_reason_tags":         "",
+            "arsenal_drift_applied_scale": 0.0,
+        }
+
+    # ------------------------------------------------------------------
+    # Compute deltas vs season baseline
+    # ------------------------------------------------------------------
+    velo_delta   = _safe_delta(
+        pitcher_roll.get("pitcher_avg_release_speed_5g"),
+        pitcher_row.get("avg_release_speed"),
+    )
+    spin_delta   = _safe_delta(
+        pitcher_roll.get("pitcher_avg_release_spin_rate_5g"),
+        pitcher_row.get("avg_release_spin_rate"),
+    )
+    ev_delta     = _safe_delta(
+        pitcher_roll.get("pitcher_ev_allowed_5g"),
+        pitcher_row.get("ev_allowed"),
+    )
+    barrel_delta = _safe_delta(
+        pitcher_roll.get("pitcher_barrel_rate_allowed_5g"),
+        pitcher_row.get("barrel_rate_allowed"),
+    )
+
+    # ------------------------------------------------------------------
+    # Anti-double-count: identify which signals rolling already fired
+    # ------------------------------------------------------------------
+    rolling_tags: set[str] = set()
+    if rolling_reason_tags:
+        rolling_tags = {t.strip() for t in rolling_reason_tags.split("|") if t.strip()}
+
+    velo_overlap   = bool(
+        "pitcher_velo_decline_hard" in rolling_tags
+        or "pitcher_velo_decline" in rolling_tags
+    )
+    ev_overlap     = "pitcher_ev_allowed_spiking" in rolling_tags
+    barrel_overlap = "pitcher_barrel_allowed_spiking" in rolling_tags
+
+    # ------------------------------------------------------------------
+    # Drift scoring
+    # ------------------------------------------------------------------
+    raw_score = 0.0
+    active_tags: list[str] = []
+
+    # Velo signals
+    if velo_delta is not None and not velo_overlap:
+        if velo_delta < -3.0:
+            raw_score += 0.25
+            active_tags.append("drift_velo_hard_decline")
+        elif velo_delta < -1.5:
+            raw_score += 0.15
+            active_tags.append("drift_velo_soft_decline")
+
+    # Spin signals (new — not in rolling layer)
+    if spin_delta is not None:
+        if spin_delta < -100.0:
+            raw_score += 0.20
+            active_tags.append("drift_spin_decline")
+        elif spin_delta > 100.0:
+            raw_score -= 0.15
+            active_tags.append("drift_spin_surge")
+
+    # EV allowed signal (reduce if rolling already caught it)
+    if ev_delta is not None and ev_delta > 2.0:
+        contribution = 0.20 * (0.5 if ev_overlap else 1.0)
+        raw_score += contribution
+        active_tags.append("drift_ev_allowed_spike")
+
+    # Barrel allowed signal (reduce if rolling already caught it)
+    if barrel_delta is not None and barrel_delta > 0.03:
+        contribution = 0.25 * (0.5 if barrel_overlap else 1.0)
+        raw_score += contribution
+        active_tags.append("drift_barrel_allowed_spike")
+
+    # ------------------------------------------------------------------
+    # Apply scale and bounds
+    # ------------------------------------------------------------------
+    drift_score = _clamp(raw_score * scale, -0.5, 0.5)
+    hr_adj  = round(_clamp(drift_score * 0.006, -0.003, 0.003), 5)
+    hit_adj = round(_clamp(drift_score * 0.005, -0.0025, 0.0025), 5)
+
+    return {
+        "arsenal_hr_adjustment":       hr_adj,
+        "arsenal_hit_adjustment":      hit_adj,
+        "arsenal_drift_score":         round(drift_score, 4),
+        "arsenal_reason_tags":         "|".join(active_tags),
+        "arsenal_drift_applied_scale": round(scale, 4),
+    }

models/live_fair_simulator_v3.py

@@ -28,6 +28,13 @@ from models.arsenal_matchup_model import compute_arsenal_matchup_adjustment
 from models.trajectory_model import build_trajectory_features, compute_trajectory_adjustment
 from models.batter_trend_model import build_batter_trend_row
 from models.batter_archetype import classify_batter_archetype
+from models.rolling_form_model import (
+    build_batter_rolling_form_row,
+    build_pitcher_rolling_form_row,
+    compute_upcoming_rolling_adjustment,
+)
+from models.opportunity_model import compute_opportunity_adjustment
+from models.arsenal_drift_model import compute_arsenal_drift_adjustment
 from config.settings import ENABLE_XGB_SHADOW
 
 if ENABLE_XGB_SHADOW:
@@ -83,6 +90,37 @@ def build_upcoming_simulated_rows(
     rows: list[dict] = []
     _game_ref_date = game_row.get("game_datetime_utc") or game_row.get("game_date")
 
+    # Batch 12E: Rolling form — pitcher slice computed once per game
+    try:
+        pitcher_rolling_row = build_pitcher_rolling_form_row(
+            statcast_df=statcast_df,
+            pitcher_name=pitcher_name,
+            pitcher_id=pitcher_id,
+            reference_date=_game_ref_date,
+        )
+    except Exception:
+        pitcher_rolling_row = {
+            "pitcher_avg_release_speed_5g": None,
+            "pitcher_avg_release_speed_10g": None,
+            "pitcher_avg_release_spin_rate_5g": None,
+            "pitcher_ev_allowed_5g": None,
+            "pitcher_ev_allowed_10g": None,
+            "pitcher_hard_hit_rate_allowed_5g": None,
+            "pitcher_hard_hit_rate_allowed_10g": None,
+            "pitcher_barrel_rate_allowed_5g": None,
+            "pitcher_barrel_rate_allowed_10g": None,
+            "pitcher_avg_launch_angle_allowed_5g": None,
+            "pitcher_fb_rate_allowed_5g": None,
+            "pitcher_ld_rate_allowed_5g": None,
+            "pitcher_gb_rate_allowed_5g": None,
+            "pitcher_hr_allowed_rate_5g": None,
+            "pitcher_hr_allowed_rate_10g": None,
+            "pitcher_games_in_window_5g": 0,
+            "pitcher_games_in_window_10g": 0,
+            "pitcher_recent_form_available": 0,
+            "pitcher_rolling_confidence": 0.0,
+        }
+
     for slot, batter_name in slots:
         if not batter_name:
             continue
@@ -204,6 +242,11 @@ def build_upcoming_simulated_rows(
         # Strongest Phase 6: use blended pitch outcome probabilities
         # to lightly influence batter baseline before simulation.
         batter_baseline = dict(batter_baseline)
+
+        # Batch 13: Baseline snapshot for exact debug ladder
+        _snap_baseline_hr   = float(batter_baseline.get("hr_prob_base",   0.03) or 0.03)
+        _snap_baseline_hit  = float(batter_baseline.get("hit_prob_base",  0.15) or 0.15)
+        _snap_baseline_tb2p = float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
         batter_baseline["hit_prob_base"] = min(
             0.55,
             max(
@@ -265,6 +308,10 @@ def build_upcoming_simulated_rows(
             ),
         )
 
+        _snap_after_zone_hr   = float(batter_baseline.get("hr_prob_base",   0.03) or 0.03)
+        _snap_after_zone_hit  = float(batter_baseline.get("hit_prob_base",  0.15) or 0.15)
+        _snap_after_zone_tb2p = float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
+
                 # Family + zone conditional arsenal overlay
         family_zone_hr_boost = float(
             family_zone_matchup_adj.get("family_zone_hr_boost", 0.0) or 0.0
@@ -308,7 +355,11 @@ def build_upcoming_simulated_rows(
                 + (family_zone_hit_boost * 0.02),
             ),
         )
-                
+
+        _snap_after_family_zone_hr   = float(batter_baseline.get("hr_prob_base",   0.03) or 0.03)
+        _snap_after_family_zone_hit  = float(batter_baseline.get("hit_prob_base",  0.15) or 0.15)
+        _snap_after_family_zone_tb2p = float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
+
         # Arsenal matchup overlay
         arsenal_hr_boost = float(arsenal_matchup_adj.get("arsenal_hr_boost", 0.0) or 0.0)
         arsenal_hit_boost = float(arsenal_matchup_adj.get("arsenal_hit_boost", 0.0) or 0.0)
@@ -342,7 +393,11 @@ def build_upcoming_simulated_rows(
                 + (arsenal_tb2p_boost * 0.08),
             ),
         )
-        
+
+        _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)
+        _snap_after_arsenal_tb2p = float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
+
         # HR-specific pulled-contact-shape overlay
         pre_pull_hr_prob_base = batter_baseline.get("hr_prob_base")
 
@@ -392,6 +447,10 @@ def build_upcoming_simulated_rows(
             except Exception as e:
                 logger.debug(f"[simulator] pull_air_rate adjustment skipped: {e}")
 
+        _snap_after_pulled_contact_hr   = float(batter_baseline.get("hr_prob_base",   0.03) or 0.03)
+        _snap_after_pulled_contact_hit  = float(batter_baseline.get("hit_prob_base",  0.15) or 0.15)
+        _snap_after_pulled_contact_tb2p = float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
+
         # Batch 11: Apply environment overlay (env_adj computed once per game before loop)
         batter_baseline["hit_prob_base"] = min(0.55, max(0.05,
             float(batter_baseline.get("hit_prob_base", 0.15) or 0.15) + env_hit_boost))
@@ -401,6 +460,10 @@ def build_upcoming_simulated_rows(
         batter_baseline["tb2p_prob_base"] = min(0.45, max(0.03,
             float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10) * tb2p_fac))
 
+        _snap_after_env_hr   = float(batter_baseline.get("hr_prob_base",   0.03) or 0.03)
+        _snap_after_env_hit  = float(batter_baseline.get("hit_prob_base",  0.15) or 0.15)
+        _snap_after_env_tb2p = float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
+
         # Phase E4: Platoon (handedness) adjustment
         batter_stand = batter_features.get("batter_stand", "R")
         p_throws = pitcher_row.get("p_throws", "R")
@@ -429,6 +492,10 @@ def build_upcoming_simulated_rows(
                 0.45, float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10) + 0.005
             )
 
+        _snap_after_platoon_hr   = float(batter_baseline.get("hr_prob_base",   0.03) or 0.03)
+        _snap_after_platoon_hit  = float(batter_baseline.get("hit_prob_base",  0.15) or 0.15)
+        _snap_after_platoon_tb2p = float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
+
         # Batch 10 physics layer: trajectory deception adjustment
         traj_adj = compute_trajectory_adjustment(trajectory_row)
         traj_hit = float(traj_adj.get("hit_adj", 0.0) or 0.0)
@@ -457,6 +524,107 @@ def build_upcoming_simulated_rows(
             ),
         )
 
+        _snap_after_traj_hr   = float(batter_baseline.get("hr_prob_base",   0.03) or 0.03)
+        _snap_after_traj_hit  = float(batter_baseline.get("hit_prob_base",  0.15) or 0.15)
+        _snap_after_traj_tb2p = float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
+
+        # Batch 12E: Rolling form adjustment (upcoming-only path).
+        # batter_baseline is a local dict (copied at line ~206 above); mutating it
+        # here does NOT affect any live-game code path.
+        try:
+            batter_rolling_row = build_batter_rolling_form_row(
+                statcast_df=statcast_df,
+                player_name=batter_name,
+                reference_date=_game_ref_date,
+            )
+            rolling_adj = compute_upcoming_rolling_adjustment(
+                batter_roll=batter_rolling_row,
+                pitcher_roll=pitcher_rolling_row,
+                batter_features=batter_features,
+                pitcher_row=pitcher_row,
+            )
+        except Exception:
+            batter_rolling_row = {
+                "batter_ev90_5g": None, "batter_ev90_10g": None,
+                "batter_barrel_rate_5g": None, "batter_barrel_rate_10g": None,
+                "batter_hard_hit_rate_5g": None, "batter_avg_launch_angle_5g": None,
+                "batter_games_in_window_5g": 0, "batter_games_in_window_10g": 0,
+                "batter_recent_form_available": 0,
+            }
+            rolling_adj = {
+                "rolling_hit_adjustment": 0.0, "rolling_hr_adjustment": 0.0,
+                "rolling_tb2p_adjustment": 0.0, "rolling_batter_form_score": 0.0,
+                "rolling_pitcher_form_score": 0.0, "rolling_combined_form_score": 0.0,
+                "rolling_adjustment_applied": False, "rolling_adjustment_reason_tags": "",
+                "pitcher_rolling_confidence": 0.0,
+            }
+
+        rolling_hit  = float(rolling_adj.get("rolling_hit_adjustment",  0.0) or 0.0)
+        rolling_hr   = float(rolling_adj.get("rolling_hr_adjustment",   0.0) or 0.0)
+        rolling_tb2p = float(rolling_adj.get("rolling_tb2p_adjustment", 0.0) or 0.0)
+
+        batter_baseline["hit_prob_base"] = min(0.55, max(0.05,
+            float(batter_baseline.get("hit_prob_base",  0.15) or 0.15) + rolling_hit))
+        batter_baseline["hr_prob_base"]  = min(0.30, max(0.005,
+            float(batter_baseline.get("hr_prob_base",   0.03) or 0.03) + rolling_hr))
+        batter_baseline["tb2p_prob_base"] = min(0.45, max(0.03,
+            float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10) + rolling_tb2p))
+
+        _snap_after_rolling_hr   = float(batter_baseline.get("hr_prob_base",   0.03) or 0.03)
+        _snap_after_rolling_hit  = float(batter_baseline.get("hit_prob_base",  0.15) or 0.15)
+        _snap_after_rolling_tb2p = float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
+
+        # Batch 13: Opportunity adjustment (multiplicative, upcoming-only)
+        try:
+            opp_adj = compute_opportunity_adjustment(
+                lineup_slot=None,          # batting order not available in game_row currently
+                team_total=game_row.get("team_total"),
+                pitcher_row=pitcher_row,
+            )
+        except Exception:
+            opp_adj = {
+                "expected_pa": 4.3, "pa_multiplier": 1.0,
+                "pitcher_quality_score": 0.0, "opportunity_reason": "error",
+                "lineup_slot_used": None, "team_total_used": None,
+                "opportunity_mode": "error",
+            }
+
+        pa_mult = float(opp_adj.get("pa_multiplier", 1.0) or 1.0)
+        batter_baseline["hit_prob_base"]  = min(0.55, max(0.05,
+            float(batter_baseline.get("hit_prob_base",  0.15) or 0.15) * pa_mult))
+        batter_baseline["hr_prob_base"]   = min(0.30, max(0.005,
+            float(batter_baseline.get("hr_prob_base",   0.03) or 0.03) * pa_mult))
+        batter_baseline["tb2p_prob_base"] = min(0.45, max(0.03,
+            float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10) * pa_mult))
+
+        _snap_after_opportunity_hr   = float(batter_baseline.get("hr_prob_base",   0.03) or 0.03)
+        _snap_after_opportunity_hit  = float(batter_baseline.get("hit_prob_base",  0.15) or 0.15)
+        _snap_after_opportunity_tb2p = float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
+
+        # Batch 13: Arsenal drift adjustment (additive, upcoming-only)
+        try:
+            drift_adj = compute_arsenal_drift_adjustment(
+                pitcher_roll=pitcher_rolling_row,
+                pitcher_row=pitcher_row,
+                rolling_reason_tags=rolling_adj.get("rolling_adjustment_reason_tags", ""),
+            )
+        except Exception:
+            drift_adj = {
+                "arsenal_hr_adjustment": 0.0, "arsenal_hit_adjustment": 0.0,
+                "arsenal_drift_score": 0.0, "arsenal_reason_tags": "",
+            }
+
+        drift_hit = float(drift_adj.get("arsenal_hit_adjustment", 0.0) or 0.0)
+        drift_hr  = float(drift_adj.get("arsenal_hr_adjustment",  0.0) or 0.0)
+        batter_baseline["hit_prob_base"]  = min(0.55, max(0.05,
+            float(batter_baseline.get("hit_prob_base",  0.15) or 0.15) + drift_hit))
+        batter_baseline["hr_prob_base"]   = min(0.30, max(0.005,
+            float(batter_baseline.get("hr_prob_base",   0.03) or 0.03) + drift_hr))
+
+        _snap_after_drift_hr   = float(batter_baseline.get("hr_prob_base",   0.03) or 0.03)
+        _snap_after_drift_hit  = float(batter_baseline.get("hit_prob_base",  0.15) or 0.15)
+        _snap_after_drift_tb2p = float(batter_baseline.get("tb2p_prob_base", 0.10) or 0.10)
+
         sim = simulate_upcoming_hitter(
             game_row=game_row,
             batter_row=batter_features,
@@ -644,6 +812,82 @@ def build_upcoming_simulated_rows(
                 "xgb_hr_delta":      _shadow.get("xgb_hr_delta"),
                 "xgb_hr_adjusted":   _shadow.get("xgb_hr_adjusted"),
                 "xgb_shadow_active": _shadow.get("xgb_shadow_active", False),
+
+                # Batch 12E — rolling form adjustments
+                "rolling_hit_adjustment":       rolling_adj.get("rolling_hit_adjustment"),
+                "rolling_hr_adjustment":        rolling_adj.get("rolling_hr_adjustment"),
+                "rolling_tb2p_adjustment":      rolling_adj.get("rolling_tb2p_adjustment"),
+                "rolling_batter_form_score":    rolling_adj.get("rolling_batter_form_score"),
+                "rolling_pitcher_form_score":   rolling_adj.get("rolling_pitcher_form_score"),
+                "rolling_combined_form_score":  rolling_adj.get("rolling_combined_form_score"),
+                "rolling_adjustment_applied":   rolling_adj.get("rolling_adjustment_applied", False),
+                "rolling_adjustment_reason_tags": rolling_adj.get("rolling_adjustment_reason_tags", ""),
+                "pitcher_rolling_confidence":   rolling_adj.get("pitcher_rolling_confidence"),
+                # Key batter rolling metrics for debug
+                "batter_ev90_5g":               batter_rolling_row.get("batter_ev90_5g"),
+                "batter_ev90_10g":              batter_rolling_row.get("batter_ev90_10g"),
+                "batter_barrel_rate_5g":        batter_rolling_row.get("batter_barrel_rate_5g"),
+                "batter_barrel_rate_10g":       batter_rolling_row.get("batter_barrel_rate_10g"),
+                "batter_avg_la_5g":             batter_rolling_row.get("batter_avg_launch_angle_5g"),
+                "batter_hard_hit_rate_5g":      batter_rolling_row.get("batter_hard_hit_rate_5g"),
+                "batter_games_in_window_5g":    batter_rolling_row.get("batter_games_in_window_5g"),
+                "batter_games_in_window_10g":   batter_rolling_row.get("batter_games_in_window_10g"),
+                # Key pitcher rolling metrics for debug
+                "pitcher_velo_5g":              pitcher_rolling_row.get("pitcher_avg_release_speed_5g"),
+                "pitcher_ev_allowed_5g":        pitcher_rolling_row.get("pitcher_ev_allowed_5g"),
+                "pitcher_ev_allowed_10g":       pitcher_rolling_row.get("pitcher_ev_allowed_10g"),
+                "pitcher_barrel_allowed_5g":    pitcher_rolling_row.get("pitcher_barrel_rate_allowed_5g"),
+                "pitcher_barrel_allowed_10g":   pitcher_rolling_row.get("pitcher_barrel_rate_allowed_10g"),
+                "pitcher_games_in_window_5g":   pitcher_rolling_row.get("pitcher_games_in_window_5g"),
+
+                # Batch 13 — exact intermediate probability checkpoints (debug ladder)
+                "snap_baseline_hr":           _snap_baseline_hr,
+                "snap_baseline_hit":          _snap_baseline_hit,
+                "snap_baseline_tb2p":         _snap_baseline_tb2p,
+                "snap_after_zone_hr":              _snap_after_zone_hr,
+                "snap_after_zone_hit":             _snap_after_zone_hit,
+                "snap_after_zone_tb2p":            _snap_after_zone_tb2p,
+                "snap_after_family_zone_hr":       _snap_after_family_zone_hr,
+                "snap_after_family_zone_hit":      _snap_after_family_zone_hit,
+                "snap_after_family_zone_tb2p":     _snap_after_family_zone_tb2p,
+                "snap_after_arsenal_hr":           _snap_after_arsenal_hr,
+                "snap_after_arsenal_hit":          _snap_after_arsenal_hit,
+                "snap_after_arsenal_tb2p":         _snap_after_arsenal_tb2p,
+                "snap_after_pulled_contact_hr":    _snap_after_pulled_contact_hr,
+                "snap_after_pulled_contact_hit":   _snap_after_pulled_contact_hit,
+                "snap_after_pulled_contact_tb2p":  _snap_after_pulled_contact_tb2p,
+                "snap_after_env_hr":          _snap_after_env_hr,
+                "snap_after_env_hit":         _snap_after_env_hit,
+                "snap_after_env_tb2p":        _snap_after_env_tb2p,
+                "snap_after_platoon_hr":      _snap_after_platoon_hr,
+                "snap_after_platoon_hit":     _snap_after_platoon_hit,
+                "snap_after_platoon_tb2p":    _snap_after_platoon_tb2p,
+                "snap_after_traj_hr":         _snap_after_traj_hr,
+                "snap_after_traj_hit":        _snap_after_traj_hit,
+                "snap_after_traj_tb2p":       _snap_after_traj_tb2p,
+                "snap_after_rolling_hr":      _snap_after_rolling_hr,
+                "snap_after_rolling_hit":     _snap_after_rolling_hit,
+                "snap_after_rolling_tb2p":    _snap_after_rolling_tb2p,
+                "snap_after_opportunity_hr":  _snap_after_opportunity_hr,
+                "snap_after_opportunity_hit": _snap_after_opportunity_hit,
+                "snap_after_opportunity_tb2p":_snap_after_opportunity_tb2p,
+                "snap_after_drift_hr":        _snap_after_drift_hr,
+                "snap_after_drift_hit":       _snap_after_drift_hit,
+                "snap_after_drift_tb2p":      _snap_after_drift_tb2p,
+                # Batch 13 — opportunity adjustment
+                "expected_pa":             opp_adj.get("expected_pa"),
+                "pa_multiplier":           opp_adj.get("pa_multiplier"),
+                "pitcher_quality_score":   opp_adj.get("pitcher_quality_score"),
+                "opportunity_reason":      opp_adj.get("opportunity_reason"),
+                "lineup_slot_used":        opp_adj.get("lineup_slot_used"),
+                "team_total_used":         opp_adj.get("team_total_used"),
+                "opportunity_mode":        opp_adj.get("opportunity_mode"),
+                # Batch 13 — arsenal drift adjustment
+                "arsenal_hr_adjustment":   drift_adj.get("arsenal_hr_adjustment"),
+                "arsenal_hit_adjustment":  drift_adj.get("arsenal_hit_adjustment"),
+                "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"),
             }
         )
 

models/opportunity_model.py

@@ -1,5 +1,11 @@
 from __future__ import annotations
 
+from typing import Any
+
+
+def _clamp(value: float, lo: float, hi: float) -> float:
+    return max(lo, min(hi, value))
+
 
 def estimate_plate_appearance_probability(
     outs: int,
@@ -40,4 +46,125 @@ def estimate_plate_appearance_probability(
         "pa_prob_this_inning": pa_prob_this_inning,
         "pa_prob_next_two_innings": pa_prob_next_two,
         "expected_pa": expected_pa,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Batch 13 — Full-game PA scaling (upcoming simulator path only)
+# ---------------------------------------------------------------------------
+
+_PA_MAP = {1: 4.7, 2: 4.6, 3: 4.5, 4: 4.4, 5: 4.3, 6: 4.2, 7: 4.1, 8: 4.0, 9: 3.9}
+_PA_BASELINE = 4.3
+
+
+def compute_opportunity_adjustment(
+    lineup_slot: int | None,
+    team_total: float | None,
+    pitcher_row: dict[str, Any] | None,
+) -> dict[str, Any]:
+    """
+    Compute a PA-volume-based probability multiplier for the upcoming simulator.
+
+    lineup_slot: batting order position 1–9 (None = unavailable, uses baseline 4.3 PA)
+    team_total:  implied team run total from odds (None = unavailable, skips adjustment)
+    pitcher_row: season pitcher features dict (uses swstr_rate, csw_rate, ball_rate)
+
+    Returns pa_multiplier ∈ [0.85, 1.15] plus traceability fields.
+    """
+    # Step 1 — Base PA by lineup slot
+    if lineup_slot is not None:
+        try:
+            pa = _PA_MAP.get(int(lineup_slot), _PA_BASELINE)
+        except (TypeError, ValueError):
+            pa = _PA_BASELINE
+    else:
+        pa = _PA_BASELINE
+
+    # Step 2 — Team total adjustment
+    if team_total is not None:
+        try:
+            tt = float(team_total)
+            if tt > 5.5:
+                pa += 0.15
+            elif tt < 3.5:
+                pa -= 0.15
+        except (TypeError, ValueError):
+            pass
+
+    # Step 3 — Pitcher quality model (SwStr / CSW / Ball)
+    swstr = pitcher_row.get("swstr_rate") if pitcher_row else None
+    csw   = pitcher_row.get("csw_rate")   if pitcher_row else None
+    ball  = pitcher_row.get("ball_rate")  if pitcher_row else None
+
+    if swstr is not None and csw is not None and ball is not None:
+        try:
+            swstr = float(swstr)
+            csw   = float(csw)
+            ball  = float(ball)
+
+            # 3A SwStr score
+            if swstr < 0.08:   swstr_score = +0.4
+            elif swstr < 0.10: swstr_score = +0.2
+            elif swstr < 0.12: swstr_score =  0.0
+            elif swstr < 0.14: swstr_score = -0.3
+            else:               swstr_score = -0.5
+
+            # 3B CSW score
+            if csw < 0.26:     csw_score = +0.3
+            elif csw < 0.28:   csw_score = +0.1
+            elif csw < 0.30:   csw_score =  0.0
+            elif csw < 0.32:   csw_score = -0.2
+            else:               csw_score = -0.4
+
+            # 3C Ball score
+            if ball < 0.32:    ball_score = -0.3
+            elif ball < 0.35:  ball_score = -0.1
+            elif ball < 0.38:  ball_score =  0.0
+            elif ball < 0.41:  ball_score = +0.2
+            else:               ball_score = +0.4
+
+            # 3D Ratio (SwStr / Ball)
+            ratio = swstr / max(ball, 0.01)
+            if ratio > 0.40:   ratio_score = -0.4
+            elif ratio > 0.30: ratio_score = -0.2
+            elif ratio > 0.22: ratio_score =  0.0
+            elif ratio > 0.15: ratio_score = +0.2
+            else:               ratio_score = +0.4
+
+            # 3E Combine
+            quality_score = _clamp(
+                swstr_score * 0.35 + csw_score * 0.30 + ball_score * 0.20 + ratio_score * 0.15,
+                -1.0, 1.0,
+            )
+            pa_multiplier = _clamp(1.0 + quality_score * 0.25, 0.85, 1.15)
+            opportunity_reason = f"swstr={swstr:.3f}|csw={csw:.3f}|ball={ball:.3f}"
+        except Exception:
+            quality_score = 0.0
+            pa_multiplier = 1.0
+            opportunity_reason = "pitcher_quality_error"
+    else:
+        quality_score = 0.0
+        pa_multiplier = 1.0
+        opportunity_reason = "pitcher_quality_missing"
+
+    # opportunity_mode for traceability
+    if lineup_slot is not None and team_total is not None and quality_score != 0.0:
+        opportunity_mode = "full"
+    elif lineup_slot is not None and team_total is not None:
+        opportunity_mode = "slot_and_total"
+    elif quality_score != 0.0:
+        opportunity_mode = "pitcher_quality_only"
+    elif lineup_slot is not None:
+        opportunity_mode = "slot_only"
+    else:
+        opportunity_mode = "baseline_only"
+
+    return {
+        "expected_pa": round(float(pa), 3),
+        "pa_multiplier": round(pa_multiplier, 4),
+        "pitcher_quality_score": round(quality_score, 4),
+        "opportunity_reason": opportunity_reason,
+        "lineup_slot_used": lineup_slot,
+        "team_total_used": team_total,
+        "opportunity_mode": opportunity_mode,
     }

models/pitcher_adjustment.py

@@ -73,6 +73,9 @@ def build_pitcher_feature_row(
             "la_sweet_spot_allowed_rate": 0.0,
             "la_optimal_hr_allowed_rate": 0.0,
             "avg_launch_angle_allowed": None,
+            "swstr_rate": None,
+            "csw_rate": None,
+            "ball_rate": None,
         }
 
     df = pd.DataFrame()
@@ -129,6 +132,9 @@ def build_pitcher_feature_row(
             "la_sweet_spot_allowed_rate": 0.0,
             "la_optimal_hr_allowed_rate": 0.0,
             "avg_launch_angle_allowed": None,
+            "swstr_rate": None,
+            "csw_rate": None,
+            "ball_rate": None,
         }
 
     launch_speed = pd.to_numeric(df.get("launch_speed"), errors="coerce")
@@ -200,6 +206,20 @@ def build_pitcher_feature_row(
 
     avg_launch_angle_allowed = _safe_mean(launch_angle)
 
+    # Batch 13: Pitch-level command rates from description column
+    swstr_rate = None
+    csw_rate = None
+    ball_rate = None
+    if "description" in df.columns and len(df) >= 10:
+        desc = df["description"].astype(str).str.strip().str.lower()
+        total = len(desc)
+        swstr_mask = desc.isin({"swinging_strike", "swinging_strike_blocked"})
+        cs_mask = desc == "called_strike"
+        ball_mask = desc.isin({"ball", "blocked_ball", "intent_ball", "pitchout"})
+        swstr_rate = float(swstr_mask.sum() / total)
+        csw_rate = float((swstr_mask | cs_mask).sum() / total)
+        ball_rate = float(ball_mask.sum() / total)
+
     return {
         "pitcher_name": pitcher_name,
         "ev_allowed": ev_allowed,
@@ -219,6 +239,9 @@ def build_pitcher_feature_row(
         "la_sweet_spot_allowed_rate": la_sweet_spot_allowed_rate,
         "la_optimal_hr_allowed_rate": la_optimal_hr_allowed_rate,
         "avg_launch_angle_allowed": avg_launch_angle_allowed,
+        "swstr_rate": swstr_rate,
+        "csw_rate": csw_rate,
+        "ball_rate": ball_rate,
     }
 
 

models/rolling_form_model.py

@@ -0,0 +1,660 @@
+from __future__ import annotations
+
+"""
+Batch 12E — Rolling Upcoming Form Layer
+
+Computes game-based (5g / 10g) rolling batter and pitcher form metrics and
+translates them into bounded additive probability adjustments for the UPCOMING
+game engine only.
+
+Design principles:
+- Returns absolute rolling values; deltas are computed in the adjustment function
+  against stable batter_features / pitcher_row baselines (NOT recomputed from the
+  same narrow window).
+- Sample-aware: weak windows (< 2 games) produce zero adjustment.
+- 10g window used as confirmation/dampening of 5g signal.
+- Pitcher-side adjustments scaled by pitcher_rolling_confidence (match quality
+  × sample availability).
+- Hard-capped adjustments; no runaway boosts.
+- Pull/direction metrics SKIPPED (spray_angle not in normalized statcast).
+- Zone/heart-rate metrics SKIPPED (not in normalized statcast).
+"""
+
+import logging
+import re
+import unicodedata
+from datetime import date, datetime
+from typing import Any
+
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Shared helpers (same barrel definition and utils as batter_trend_model)
+# ---------------------------------------------------------------------------
+
+
+def _parse_reference_date(reference_date: Any) -> date | None:
+    if reference_date is None:
+        return None
+    if isinstance(reference_date, datetime):
+        return reference_date.date()
+    if isinstance(reference_date, date):
+        return reference_date
+    if isinstance(reference_date, str):
+        for fmt in ("%Y-%m-%d", "%Y-%m-%dT%H:%M:%SZ", "%Y-%m-%dT%H:%M:%S"):
+            try:
+                return datetime.strptime(reference_date[:19], fmt).date()
+            except ValueError:
+                continue
+    return None
+
+
+def _percentile(series: pd.Series, q: float) -> float | None:
+    numeric = pd.to_numeric(series, errors="coerce").dropna()
+    if len(numeric) < 5:
+        return None
+    return float(numeric.quantile(q))
+
+
+def _safe_mean(series: pd.Series) -> float | None:
+    numeric = pd.to_numeric(series, errors="coerce").dropna()
+    if len(numeric) < 5:
+        return None
+    return float(numeric.mean())
+
+
+def _barrel_rate(launch_speed: pd.Series, launch_angle: pd.Series) -> float | None:
+    valid = pd.DataFrame(
+        {
+            "ls": pd.to_numeric(launch_speed, errors="coerce"),
+            "la": pd.to_numeric(launch_angle, errors="coerce"),
+        }
+    ).dropna()
+    if len(valid) < 5:
+        return None
+    mask = (
+        ((valid["ls"] >= 98) & (valid["la"].between(26, 30)))
+        | ((valid["ls"] >= 99) & (valid["la"].between(25, 31)))
+        | ((valid["ls"] >= 100) & (valid["la"].between(23, 33)))
+        | ((valid["ls"] >= 102) & (valid["la"].between(20, 35)))
+    )
+    return float(mask.mean())
+
+
+def _safe_rate_from_la(
+    launch_angle: pd.Series,
+    lo: float,
+    hi: float | None = None,
+) -> float | None:
+    """Fraction of non-null LA rows where lo <= la < hi (or la >= lo if hi is None)."""
+    la = pd.to_numeric(launch_angle, errors="coerce").dropna()
+    if len(la) < 5:
+        return None
+    if hi is None:
+        return float((la >= lo).mean())
+    return float(((la >= lo) & (la < hi)).mean())
+
+
+def _n_games(df: pd.DataFrame) -> int:
+    """Count unique game_pk values in a slice; fall back to row-count heuristic."""
+    if "game_pk" in df.columns:
+        return int(df["game_pk"].nunique())
+    return len(df)
+
+
+# ---------------------------------------------------------------------------
+# Game-window helper
+# ---------------------------------------------------------------------------
+
+
+def _game_window_df(player_df: pd.DataFrame, ref: date, n_games: int) -> pd.DataFrame:
+    """
+    Return rows for the last `n_games` unique games before `ref` (exclusive).
+
+    Sorting is by `game_date` descending; unique `game_pk` values are taken in
+    that order.  Falls back to the last N×25 rows (rough PA estimate) if
+    `game_pk` is unavailable.
+    """
+    if player_df.empty:
+        return player_df.iloc[0:0]
+
+    if "game_date" not in player_df.columns:
+        return player_df.iloc[0:0]
+
+    game_dates = pd.to_datetime(player_df["game_date"], errors="coerce")
+    cutoff = pd.Timestamp(ref)
+    before_ref = player_df[game_dates < cutoff].copy()
+
+    if before_ref.empty:
+        return before_ref
+
+    before_ref["_gd"] = pd.to_datetime(before_ref["game_date"], errors="coerce")
+
+    if "game_pk" in before_ref.columns:
+        before_ref["_gpk"] = pd.to_numeric(before_ref["game_pk"], errors="coerce")
+        sorted_games = (
+            before_ref.groupby("_gpk")["_gd"]
+            .max()
+            .sort_values(ascending=False)
+            .head(n_games)
+            .index.tolist()
+        )
+        result = before_ref[before_ref["_gpk"].isin(sorted_games)].drop(
+            columns=["_gd", "_gpk"], errors="ignore"
+        )
+        return result
+
+    # Fallback: no game_pk — take last n_games*25 rows sorted by date
+    fallback = before_ref.sort_values("_gd", ascending=False).head(n_games * 25)
+    return fallback.drop(columns=["_gd"], errors="ignore")
+
+
+# ---------------------------------------------------------------------------
+# Pitcher name normalization (mirrors pitcher_adjustment.py)
+# ---------------------------------------------------------------------------
+
+
+def _normalize_name(name: str) -> str:
+    text = str(name or "").strip().lower()
+    text = unicodedata.normalize("NFKD", text)
+    text = "".join(ch for ch in text if not unicodedata.combining(ch))
+    text = text.replace(",", " ")
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
+
+def _name_variants(name: str) -> set[str]:
+    normalized = _normalize_name(name)
+    if not normalized:
+        return set()
+    parts = normalized.split()
+    variants = {normalized}
+    if len(parts) >= 2:
+        first, last = parts[0], parts[-1]
+        middle = " ".join(parts[1:-1]).strip()
+        variants.add(f"{last} {first}".strip())
+        if middle:
+            variants.add(f"{last} {first} {middle}".strip())
+    return variants
+
+
+# ---------------------------------------------------------------------------
+# Empty skeletons
+# ---------------------------------------------------------------------------
+
+_EMPTY_BATTER_ROLL: dict[str, Any] = {
+    "batter_ev_5g": None,
+    "batter_ev_10g": None,
+    "batter_ev90_5g": None,
+    "batter_ev90_10g": None,
+    "batter_hard_hit_rate_5g": None,
+    "batter_hard_hit_rate_10g": None,
+    "batter_barrel_rate_5g": None,
+    "batter_barrel_rate_10g": None,
+    "batter_avg_launch_angle_5g": None,
+    "batter_avg_launch_angle_10g": None,
+    "batter_fb_rate_5g": None,
+    "batter_fb_rate_10g": None,
+    "batter_ld_rate_5g": None,
+    "batter_gb_rate_5g": None,
+    "batter_air_ball_rate_5g": None,
+    "batter_hr_rate_5g": None,
+    "batter_hr_rate_10g": None,
+    # direction metrics deferred (spray_angle not in normalized statcast)
+    "batter_pull_air_rate_5g": None,
+    "batter_pulled_hard_air_rate_5g": None,
+    "batter_pulled_barrel_rate_5g": None,
+    "batter_games_in_window_5g": 0,
+    "batter_games_in_window_10g": 0,
+    "batter_recent_form_available": 0,
+}
+
+_EMPTY_PITCHER_ROLL: dict[str, Any] = {
+    "pitcher_avg_release_speed_5g": None,
+    "pitcher_avg_release_speed_10g": None,
+    "pitcher_avg_release_spin_rate_5g": None,
+    "pitcher_ev_allowed_5g": None,
+    "pitcher_ev_allowed_10g": None,
+    "pitcher_hard_hit_rate_allowed_5g": None,
+    "pitcher_hard_hit_rate_allowed_10g": None,
+    "pitcher_barrel_rate_allowed_5g": None,
+    "pitcher_barrel_rate_allowed_10g": None,
+    "pitcher_avg_launch_angle_allowed_5g": None,
+    "pitcher_fb_rate_allowed_5g": None,
+    "pitcher_ld_rate_allowed_5g": None,
+    "pitcher_gb_rate_allowed_5g": None,
+    "pitcher_hr_allowed_rate_5g": None,
+    "pitcher_hr_allowed_rate_10g": None,
+    "pitcher_games_in_window_5g": 0,
+    "pitcher_games_in_window_10g": 0,
+    "pitcher_recent_form_available": 0,
+    "pitcher_rolling_confidence": 0.0,
+}
+
+
+# ---------------------------------------------------------------------------
+# Public API — batter rolling form
+# ---------------------------------------------------------------------------
+
+
+def build_batter_rolling_form_row(
+    statcast_df: pd.DataFrame,
+    player_name: str,
+    reference_date: Any = None,
+) -> dict[str, Any]:
+    """
+    Compute game-based 5g / 10g rolling form metrics for *player_name*.
+
+    Returns absolute rolling values only; delta vs. baseline is handled in
+    compute_upcoming_rolling_adjustment() against stable batter_features values.
+    """
+    if statcast_df is None or statcast_df.empty:
+        return dict(_EMPTY_BATTER_ROLL)
+
+    ref = _parse_reference_date(reference_date)
+    if ref is None:
+        return dict(_EMPTY_BATTER_ROLL)
+
+    try:
+        player_df = statcast_df[
+            statcast_df["player_name"].astype(str) == str(player_name)
+        ].copy()
+    except Exception:
+        return dict(_EMPTY_BATTER_ROLL)
+
+    if player_df.empty:
+        return dict(_EMPTY_BATTER_ROLL)
+
+    df5 = _game_window_df(player_df, ref, 5)
+    df10 = _game_window_df(player_df, ref, 10)
+
+    n5 = _n_games(df5)
+    n10 = _n_games(df10)
+
+    def _hr_rate(df: pd.DataFrame) -> float | None:
+        if "events" not in df.columns or len(df) < 5:
+            return None
+        events = df["events"].dropna().astype(str)
+        if events.empty:
+            return None
+        return float((events == "home_run").mean())
+
+    def _hh_rate(df: pd.DataFrame) -> float | None:
+        ls = pd.to_numeric(df.get("launch_speed", pd.Series(dtype=float)), errors="coerce").dropna()
+        if len(ls) < 5:
+            return None
+        return float((ls >= 95).mean())
+
+    ls5 = df5.get("launch_speed", pd.Series(dtype=float)) if not df5.empty else pd.Series(dtype=float)
+    la5 = df5.get("launch_angle", pd.Series(dtype=float)) if not df5.empty else pd.Series(dtype=float)
+    ls10 = df10.get("launch_speed", pd.Series(dtype=float)) if not df10.empty else pd.Series(dtype=float)
+    la10 = df10.get("launch_angle", pd.Series(dtype=float)) if not df10.empty else pd.Series(dtype=float)
+
+    return {
+        "batter_ev_5g": _safe_mean(ls5),
+        "batter_ev_10g": _safe_mean(ls10),
+        "batter_ev90_5g": _percentile(ls5, 0.90),
+        "batter_ev90_10g": _percentile(ls10, 0.90),
+        "batter_hard_hit_rate_5g": _hh_rate(df5),
+        "batter_hard_hit_rate_10g": _hh_rate(df10),
+        "batter_barrel_rate_5g": _barrel_rate(ls5, la5),
+        "batter_barrel_rate_10g": _barrel_rate(ls10, la10),
+        "batter_avg_launch_angle_5g": _safe_mean(la5),
+        "batter_avg_launch_angle_10g": _safe_mean(la10),
+        "batter_fb_rate_5g": _safe_rate_from_la(la5, 25.0),
+        "batter_fb_rate_10g": _safe_rate_from_la(la10, 25.0),
+        "batter_ld_rate_5g": _safe_rate_from_la(la5, 10.0, 25.0),
+        "batter_gb_rate_5g": _safe_rate_from_la(la5, -90.0, 10.0),
+        "batter_air_ball_rate_5g": _safe_rate_from_la(la5, 10.0),
+        "batter_hr_rate_5g": _hr_rate(df5),
+        "batter_hr_rate_10g": _hr_rate(df10),
+        # direction metrics deferred
+        "batter_pull_air_rate_5g": None,
+        "batter_pulled_hard_air_rate_5g": None,
+        "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,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Public API — pitcher rolling form
+# ---------------------------------------------------------------------------
+
+
+def build_pitcher_rolling_form_row(
+    statcast_df: pd.DataFrame,
+    pitcher_name: str | None = None,
+    pitcher_id: int | None = None,
+    reference_date: Any = None,
+) -> dict[str, Any]:
+    """
+    Compute game-based 5g / 10g rolling form metrics for a pitcher.
+
+    Follows the same fuzzy-name-match pattern as pitcher_adjustment.py.
+    pitcher_rolling_confidence reflects match quality × sample availability.
+    """
+    if statcast_df is None or statcast_df.empty:
+        return dict(_EMPTY_PITCHER_ROLL)
+
+    ref = _parse_reference_date(reference_date)
+    if ref is None:
+        return dict(_EMPTY_PITCHER_ROLL)
+
+    pitcher_name = str(pitcher_name or "").strip()
+
+    df = pd.DataFrame()
+    match_quality = "none"
+
+    # Attempt 1: pitcher ID column (present in some CSVs)
+    if pitcher_id is not None and "pitcher" in statcast_df.columns:
+        try:
+            numeric_ids = pd.to_numeric(statcast_df["pitcher"], errors="coerce")
+            df = statcast_df[numeric_ids == int(pitcher_id)].copy()
+            if not df.empty:
+                match_quality = "id"
+        except Exception:
+            df = pd.DataFrame()
+
+    # Attempt 2: exact / variant name match on player_name
+    if df.empty and pitcher_name and "player_name" in statcast_df.columns:
+        variants = _name_variants(pitcher_name)
+        normalized_series = statcast_df["player_name"].astype(str).map(_normalize_name)
+        mask = normalized_series.isin(variants)
+        df = statcast_df[mask].copy()
+        if not df.empty:
+            match_quality = "exact"
+
+    # Attempt 3: loose contains-style match
+    if df.empty and pitcher_name and "player_name" in statcast_df.columns:
+        parts = _normalize_name(pitcher_name).split()
+        if len(parts) >= 2:
+            first, last = parts[0], parts[-1]
+            normalized_series = statcast_df["player_name"].astype(str).map(_normalize_name)
+            loose_mask = normalized_series.apply(
+                lambda n: isinstance(n, str) and first in n and last in n
+            )
+            df = statcast_df[loose_mask].copy()
+            if not df.empty:
+                match_quality = "loose"
+
+    if df.empty:
+        return dict(_EMPTY_PITCHER_ROLL)
+
+    df5 = _game_window_df(df, ref, 5)
+    df10 = _game_window_df(df, ref, 10)
+
+    n5 = _n_games(df5)
+    n10 = _n_games(df10)
+
+    # pitcher_rolling_confidence: match quality × sample scale
+    sample_scale_5g = (
+        0.0 if n5 < 2
+        else 0.4 if n5 <= 3
+        else 0.7 if n5 == 4
+        else 1.0
+    )
+    match_scale = {
+        "id": 1.0,
+        "exact": 1.0,
+        "loose": 0.4,
+        "none": 0.0,
+    }.get(match_quality, 0.0)
+    confidence = round(match_scale * sample_scale_5g, 3)
+
+    def _hh_rate(df: pd.DataFrame) -> float | None:
+        ls = pd.to_numeric(df.get("launch_speed", pd.Series(dtype=float)), errors="coerce").dropna()
+        if len(ls) < 5:
+            return None
+        return float((ls >= 95).mean())
+
+    def _hr_rate_allowed(df: pd.DataFrame) -> float | None:
+        if "events" not in df.columns or len(df) < 5:
+            return None
+        events = df["events"].dropna().astype(str)
+        if events.empty:
+            return None
+        return float((events == "home_run").mean())
+
+    ls5 = df5.get("launch_speed", pd.Series(dtype=float)) if not df5.empty else pd.Series(dtype=float)
+    la5 = df5.get("launch_angle", pd.Series(dtype=float)) if not df5.empty else pd.Series(dtype=float)
+    ls10 = df10.get("launch_speed", pd.Series(dtype=float)) if not df10.empty else pd.Series(dtype=float)
+    la10 = df10.get("launch_angle", pd.Series(dtype=float)) if not df10.empty else pd.Series(dtype=float)
+    rs5 = df5.get("release_speed", pd.Series(dtype=float)) if not df5.empty else pd.Series(dtype=float)
+    rs10 = df10.get("release_speed", pd.Series(dtype=float)) if not df10.empty else pd.Series(dtype=float)
+    spin5 = df5.get("release_spin_rate", pd.Series(dtype=float)) if not df5.empty else pd.Series(dtype=float)
+
+    return {
+        "pitcher_avg_release_speed_5g": _safe_mean(rs5),
+        "pitcher_avg_release_speed_10g": _safe_mean(rs10),
+        "pitcher_avg_release_spin_rate_5g": _safe_mean(spin5),
+        "pitcher_ev_allowed_5g": _safe_mean(ls5),
+        "pitcher_ev_allowed_10g": _safe_mean(ls10),
+        "pitcher_hard_hit_rate_allowed_5g": _hh_rate(df5),
+        "pitcher_hard_hit_rate_allowed_10g": _hh_rate(df10),
+        "pitcher_barrel_rate_allowed_5g": _barrel_rate(ls5, la5),
+        "pitcher_barrel_rate_allowed_10g": _barrel_rate(ls10, la10),
+        "pitcher_avg_launch_angle_allowed_5g": _safe_mean(la5),
+        "pitcher_fb_rate_allowed_5g": _safe_rate_from_la(la5, 25.0),
+        "pitcher_ld_rate_allowed_5g": _safe_rate_from_la(la5, 10.0, 25.0),
+        "pitcher_gb_rate_allowed_5g": _safe_rate_from_la(la5, -90.0, 10.0),
+        "pitcher_hr_allowed_rate_5g": _hr_rate_allowed(df5),
+        "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_rolling_confidence": confidence,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Helpers for adjustment function
+# ---------------------------------------------------------------------------
+
+
+def _safe_delta(rolling_val: Any, baseline_val: Any) -> float | None:
+    """rolling - baseline; returns None if either is None."""
+    if rolling_val is None or baseline_val is None:
+        return None
+    try:
+        return float(rolling_val) - float(baseline_val)
+    except (TypeError, ValueError):
+        return None
+
+
+def _clamp(value: float, lo: float, hi: float) -> float:
+    return max(lo, min(hi, value))
+
+
+def _10g_confirmation_scale(delta_5g: float | None, delta_10g: float | None, threshold: float) -> float:
+    """
+    1.0 if 10g confirms 5g direction or is None (neutral).
+    0.5 if 10g conflicts with 5g direction.
+    """
+    if delta_5g is None or delta_10g is None:
+        return 1.0
+    aligned = (delta_5g > threshold) == (delta_10g > threshold)
+    return 1.0 if aligned else 0.5
+
+
+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
+    return 1.0
+
+
+# ---------------------------------------------------------------------------
+# Public API — rolling adjustment
+# ---------------------------------------------------------------------------
+
+
+def compute_upcoming_rolling_adjustment(
+    batter_roll: dict[str, Any],
+    pitcher_roll: dict[str, Any],
+    batter_features: dict[str, Any],
+    pitcher_row: dict[str, Any],
+) -> dict[str, Any]:
+    """
+    Compute bounded additive probability adjustments from rolling form.
+
+    Deltas are computed against the stable batter_features / pitcher_row
+    baselines (not recomputed from the narrow rolling window).
+
+    Returns a dict with rolling_hit_adjustment, rolling_hr_adjustment,
+    rolling_tb2p_adjustment, scores, tags (pipe-delimited string), and
+    pitcher_rolling_confidence.
+    """
+    batter_n5 = int(batter_roll.get("batter_games_in_window_5g") or 0)
+    pitcher_n5 = int(pitcher_roll.get("pitcher_games_in_window_5g") or 0)
+    pitcher_confidence = float(pitcher_roll.get("pitcher_rolling_confidence") or 0.0)
+
+    batter_scale = _sample_scale(batter_n5)
+    pitcher_n5_scale = _sample_scale(pitcher_n5)
+    pitcher_scale = pitcher_confidence * pitcher_n5_scale
+
+    # ------------------------------------------------------------------
+    # Compute deltas vs stable engine baselines
+    # ------------------------------------------------------------------
+
+    # Batter deltas
+    ev90_delta_5g = _safe_delta(batter_roll.get("batter_ev90_5g"), batter_features.get("ev90"))
+    ev90_delta_10g = _safe_delta(batter_roll.get("batter_ev90_10g"), batter_features.get("ev90"))
+    barrel_delta_5g = _safe_delta(batter_roll.get("batter_barrel_rate_5g"), batter_features.get("barrel_rate"))
+    barrel_delta_10g = _safe_delta(batter_roll.get("batter_barrel_rate_10g"), batter_features.get("barrel_rate"))
+    hh_delta_5g = _safe_delta(batter_roll.get("batter_hard_hit_rate_5g"), batter_features.get("hard_hit_rate"))
+    la_delta_5g = _safe_delta(batter_roll.get("batter_avg_launch_angle_5g"), batter_features.get("avg_launch_angle"))
+    air_ball_5g = batter_roll.get("batter_air_ball_rate_5g")
+    air_ball_baseline = batter_features.get("air_ball_rate")
+    air_ball_delta_5g = _safe_delta(air_ball_5g, air_ball_baseline)
+
+    # Pitcher deltas vs stable pitcher_row baselines
+    velo_delta_5g = _safe_delta(pitcher_roll.get("pitcher_avg_release_speed_5g"), pitcher_row.get("avg_release_speed"))
+    ev_allowed_delta_5g = _safe_delta(pitcher_roll.get("pitcher_ev_allowed_5g"), pitcher_row.get("ev_allowed"))
+    ev_allowed_delta_10g = _safe_delta(pitcher_roll.get("pitcher_ev_allowed_10g"), pitcher_row.get("ev_allowed"))
+    barrel_allowed_delta_5g = _safe_delta(pitcher_roll.get("pitcher_barrel_rate_allowed_5g"), pitcher_row.get("barrel_rate_allowed"))
+    barrel_allowed_delta_10g = _safe_delta(pitcher_roll.get("pitcher_barrel_rate_allowed_10g"), pitcher_row.get("barrel_rate_allowed"))
+    hh_allowed_delta_5g = _safe_delta(pitcher_roll.get("pitcher_hard_hit_rate_allowed_5g"), pitcher_row.get("hard_hit_rate_allowed"))
+
+    # ------------------------------------------------------------------
+    # Batter form score
+    # ------------------------------------------------------------------
+    batter_score = 0.0
+    active_batter_tags: list[str] = []
+
+    if ev90_delta_5g is not None:
+        conf_10g = _10g_confirmation_scale(ev90_delta_5g, ev90_delta_10g, 2.0)
+        if ev90_delta_5g > 2.0:
+            batter_score += 0.25 * conf_10g
+            active_batter_tags.append("batter_ev90_surge")
+        elif ev90_delta_5g < -2.0:
+            batter_score -= 0.25 * conf_10g
+            active_batter_tags.append("batter_ev90_decline")
+
+    if barrel_delta_5g is not None:
+        conf_10g = _10g_confirmation_scale(barrel_delta_5g, barrel_delta_10g, 0.03)
+        if barrel_delta_5g > 0.03:
+            batter_score += 0.40 * conf_10g
+            active_batter_tags.append("batter_barrel_spike")
+        elif barrel_delta_5g < -0.03:
+            batter_score -= 0.40 * conf_10g
+            active_batter_tags.append("batter_barrel_drop")
+
+    if hh_delta_5g is not None and hh_delta_5g > 0.05:
+        batter_score += 0.20
+        active_batter_tags.append("batter_hard_hit_rising")
+
+    if (
+        la_delta_5g is not None
+        and batter_roll.get("batter_avg_launch_angle_5g") is not None
+        and 20.0 < float(batter_roll["batter_avg_launch_angle_5g"]) < 30.0
+        and la_delta_5g > 3.0
+    ):
+        batter_score += 0.20
+        active_batter_tags.append("batter_la_optimizing")
+
+    if (
+        air_ball_5g is not None
+        and air_ball_delta_5g is not None
+        and float(air_ball_5g) > 0.45
+        and air_ball_delta_5g > 0.05
+    ):
+        batter_score += 0.15
+        active_batter_tags.append("batter_air_ball_spike")
+
+    batter_score = _clamp(batter_score * batter_scale, -1.0, 1.0)
+
+    # ------------------------------------------------------------------
+    # Pitcher form score
+    # ------------------------------------------------------------------
+    pitcher_score = 0.0
+    active_pitcher_tags: list[str] = []
+
+    if velo_delta_5g is not None:
+        if velo_delta_5g < -3.0:
+            pitcher_score += 0.50  # -1.5 and -3.0 contributions combined
+            active_pitcher_tags.append("pitcher_velo_decline_hard")
+        elif velo_delta_5g < -1.5:
+            pitcher_score += 0.30
+            active_pitcher_tags.append("pitcher_velo_decline")
+
+    if ev_allowed_delta_5g is not None:
+        conf_10g = _10g_confirmation_scale(ev_allowed_delta_5g, ev_allowed_delta_10g, 2.0)
+        if ev_allowed_delta_5g > 2.0:
+            pitcher_score += 0.30 * conf_10g
+            active_pitcher_tags.append("pitcher_ev_allowed_spiking")
+
+    if barrel_allowed_delta_5g is not None:
+        conf_10g = _10g_confirmation_scale(barrel_allowed_delta_5g, barrel_allowed_delta_10g, 0.03)
+        if barrel_allowed_delta_5g > 0.03:
+            pitcher_score += 0.40 * conf_10g
+            active_pitcher_tags.append("pitcher_barrel_allowed_spiking")
+
+    if hh_allowed_delta_5g is not None and hh_allowed_delta_5g > 0.05:
+        pitcher_score += 0.20
+        active_pitcher_tags.append("pitcher_hard_hit_allowed_rising")
+
+    # Pitcher sharp: velo up + EV allowed down + barrel allowed down
+    pitcher_sharp = (
+        velo_delta_5g is not None and velo_delta_5g > 1.5
+        and ev_allowed_delta_5g is not None and ev_allowed_delta_5g < -2.0
+        and barrel_allowed_delta_5g is not None and barrel_allowed_delta_5g < -0.03
+    )
+    if pitcher_sharp:
+        pitcher_score -= 0.35
+        active_pitcher_tags.append("pitcher_sharp_recently")
+
+    pitcher_score = _clamp(pitcher_score * pitcher_scale, -1.0, 1.0)
+
+    # ------------------------------------------------------------------
+    # Combined score and adjustments
+    # ------------------------------------------------------------------
+    combined = _clamp(batter_score + pitcher_score, -1.0, 1.0)
+
+    rolling_hr_adjustment   = _clamp(combined * 0.012, -0.012, 0.012)
+    rolling_hit_adjustment  = _clamp(combined * 0.010, -0.010, 0.010)
+    rolling_tb2p_adjustment = _clamp(combined * 0.011, -0.011, 0.011)
+
+    adjustment_applied = abs(combined) > 0.05
+
+    # Compact pipe-delimited reason tags (up to 3 most active)
+    all_tags = (active_batter_tags + active_pitcher_tags)[:3]
+    reason_tags_str = "|".join(all_tags)
+
+    return {
+        "rolling_hit_adjustment": round(rolling_hit_adjustment, 5),
+        "rolling_hr_adjustment": round(rolling_hr_adjustment, 5),
+        "rolling_tb2p_adjustment": round(rolling_tb2p_adjustment, 5),
+        "rolling_batter_form_score": round(batter_score, 4),
+        "rolling_pitcher_form_score": round(pitcher_score, 4),
+        "rolling_combined_form_score": round(combined, 4),
+        "rolling_adjustment_applied": adjustment_applied,
+        "rolling_adjustment_reason_tags": reason_tags_str,
+        "pitcher_rolling_confidence": pitcher_confidence,
+    }

visualization/debug_page.py

@@ -0,0 +1,576 @@
+from __future__ import annotations
+
+"""
+Batch 13 — Full Debug Dashboard
+
+Renders the Debug navigation page.  All model-layer diagnostics,
+adjustment ladders, signal attribution, admin tools, and audit
+metrics are consolidated here, replacing the Debug expander that
+previously lived inside render_dashboard().
+"""
+
+import json
+from typing import Any, Callable
+
+import pandas as pd
+import streamlit as st
+
+from analytics.evaluation_metrics import (
+    build_clv_by_tier_table,
+    build_clv_table,
+    build_confidence_table,
+    build_edge_bucket_table,
+    build_ere_by_confidence_bucket_table,
+    build_ere_by_edge_bucket_table,
+    build_ere_by_tier_table,
+    build_ere_table,
+    build_hr_calibration_table,
+    build_tier_performance_table,
+)
+from analytics.batter_audit_metrics import (
+    build_batter_hr_tier_table,
+    build_batter_hr_confidence_table,
+    build_batter_hr_edge_table,
+)
+from analytics.recommendation_engine import build_upcoming_hitter_recommendations
+from database.db import (
+    read_batter_prop_audit_view,
+    read_batter_prop_outcomes,
+    read_game_outcomes,
+    read_recommendation_audit_view,
+    read_table,
+)
+from models.live_fair_simulator_v3 import build_upcoming_simulated_rows
+from models.pitcher_adjustment import build_pitcher_feature_row
+from utils.dates import current_wbc_date_str
+
+# ---------------------------------------------------------------------------
+# Ladder definition — HR prob checkpoint fields in output dict order
+# ---------------------------------------------------------------------------
+
+_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"),
+]
+
+_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"),
+]
+
+_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"),
+]
+
+
+# ---------------------------------------------------------------------------
+# Public entry point
+# ---------------------------------------------------------------------------
+
+
+def render_debug(
+    statcast_df: pd.DataFrame,
+    odds_df: pd.DataFrame | None,
+    conn: Any,
+    live_games: pd.DataFrame,
+    scores_df: pd.DataFrame,
+    prepared_live_games_df: pd.DataFrame | None = None,
+    grade_outcomes_fn: Callable | None = None,
+    grade_props_fn: Callable | None = None,
+    fill_realized_fn: Callable | None = None,
+) -> None:
+    """
+    Full Debug Dashboard page.
+
+    Parameters
+    ----------
+    statcast_df : normalized statcast data (from load_statcast_recent)
+    odds_df     : odds dataframe (may be None / empty)
+    conn        : active DB connection
+    live_games  : raw live games DataFrame
+    scores_df   : scores feed DataFrame
+    prepared_live_games_df : optional pre-enriched live games (avoids re-enrichment)
+    grade_outcomes_fn  : callable(scores_df) → grade final game outcomes
+    grade_props_fn     : callable() → grade batter prop outcomes from audit
+    fill_realized_fn   : callable(statcast_df) → fill realized batter outcomes
+    """
+    st.header("Debug Dashboard")
+    st.caption("Model diagnostics, adjustment ladders, signal attribution, and admin tools.")
+
+    # ------------------------------------------------------------------
+    # Resolve prepared live games
+    # ------------------------------------------------------------------
+    if prepared_live_games_df is None or prepared_live_games_df.empty:
+        prep_df = pd.DataFrame()
+    else:
+        prep_df = prepared_live_games_df
+
+    # ------------------------------------------------------------------
+    # SECTION 1 — Filters
+    # ------------------------------------------------------------------
+    st.subheader("Filters")
+    col_game, col_player, col_team, col_edge = st.columns(4)
+
+    with col_game:
+        game_options: list[str] = []
+        if not prep_df.empty and "away_team" in prep_df.columns and "home_team" in prep_df.columns:
+            game_options = [
+                f"{row.get('away_team','?')} @ {row.get('home_team','?')}"
+                for _, row in prep_df.iterrows()
+            ]
+        selected_games = st.multiselect("Games", options=game_options, default=[])
+
+    with col_player:
+        player_filter = st.text_input("Player filter", value="")
+
+    with col_team:
+        team_options: list[str] = []
+        if not prep_df.empty:
+            for col in ("away_team", "home_team"):
+                if col in prep_df.columns:
+                    team_options += prep_df[col].dropna().astype(str).unique().tolist()
+            team_options = sorted(set(team_options))
+        selected_teams = st.multiselect("Teams", options=team_options, default=[])
+
+    with col_edge:
+        edge_threshold = st.slider("Min HR edge (%)", min_value=0, max_value=30, value=0, step=1)
+
+    # ------------------------------------------------------------------
+    # Run simulator for selected games
+    # ------------------------------------------------------------------
+    all_sim_rows: list[dict] = []
+
+    if not prep_df.empty:
+        for _, live_row in prep_df.iterrows():
+            game = live_row.to_dict()
+            game_label = f"{game.get('away_team','?')} @ {game.get('home_team','?')}"
+
+            # Apply game filter
+            if selected_games and game_label not in selected_games:
+                continue
+
+            try:
+                sim_rows = build_upcoming_simulated_rows(
+                    game_row=game,
+                    statcast_df=statcast_df,
+                    weather_row=None,
+                )
+            except Exception as e:
+                all_sim_rows.append({"game": game_label, "batter_name": "ERROR", "debug_note": str(e)})
+                continue
+
+            for row in (sim_rows or []):
+                if isinstance(row, dict):
+                    row["_game_label"] = game_label
+                    all_sim_rows.append(row)
+
+    # Apply player / team filters
+    filtered_rows = all_sim_rows
+    if player_filter.strip():
+        pf = player_filter.strip().lower()
+        filtered_rows = [r for r in filtered_rows if pf in str(r.get("batter_name", "")).lower()]
+    if selected_teams:
+        filtered_rows = [
+            r for r in filtered_rows
+            if any(t in r.get("_game_label", "") for t in selected_teams)
+        ]
+
+    sim_df = pd.DataFrame(filtered_rows) if filtered_rows else pd.DataFrame()
+
+    # ------------------------------------------------------------------
+    # SECTION 2 — Model Snapshot Table
+    # ------------------------------------------------------------------
+    st.subheader("Model Snapshot")
+
+    if sim_df.empty:
+        st.info("No simulation rows available. Load live games and statcast data first.")
+    else:
+        snapshot_cols = [
+            c for c in [
+                "_game_label", "slot", "batter_name", "pitcher_name",
+                "hit_prob", "hr_prob", "tb2p_prob",
+                "fair_hr_odds", "book_hr_odds", "hr_edge",
+                "pa_multiplier", "pitcher_quality_score", "opportunity_mode",
+                "rolling_combined_form_score", "arsenal_drift_score",
+            ] if c in sim_df.columns
+        ]
+
+        display_df = sim_df[snapshot_cols].copy()
+
+        # Apply edge threshold filter
+        if edge_threshold > 0 and "hr_edge" in display_df.columns:
+            display_df = display_df[
+                pd.to_numeric(display_df["hr_edge"], errors="coerce").fillna(0) >= edge_threshold / 100.0
+            ]
+
+        st.dataframe(display_df, use_container_width=True, hide_index=True)
+
+    # ------------------------------------------------------------------
+    # SECTION 3 — Adjustment Ladder (per batter, exact checkpoints)
+    # ------------------------------------------------------------------
+    st.subheader("Adjustment Ladder (HR probability)")
+
+    if sim_df.empty:
+        st.info("No simulation data loaded.")
+    else:
+        for _, brow in sim_df.iterrows():
+            batter = str(brow.get("batter_name", "?"))
+            game   = str(brow.get("_game_label", ""))
+            label  = f"{batter} — {game}"
+
+            with st.expander(label, expanded=False):
+                ladder_metric = st.selectbox(
+                    "Ladder metric",
+                    options=["HR", "Hit", "TB2P"],
+                    index=0,
+                    key=f"ladder_metric_{batter}",
+                )
+                ladder_fields = (
+                    _LADDER_HR_FIELDS if ladder_metric == "HR"
+                    else _LADDER_HIT_FIELDS if ladder_metric == "Hit"
+                    else _LADDER_TB2P_FIELDS
+                )
+
+                ladder_rows = []
+                prev_val: float | None = None
+
+                for layer_name, field in ladder_fields:
+                    val = brow.get(field)
+                    if val is not None:
+                        try:
+                            val_f = float(val)
+                        except (TypeError, ValueError):
+                            val_f = None
+                    else:
+                        val_f = None
+
+                    delta_str = ""
+                    if val_f is not None and prev_val is not None:
+                        delta = val_f - prev_val
+                        delta_str = f"{delta:+.4f}"
+                    elif val_f is not None and prev_val is None:
+                        delta_str = "—"
+
+                    ladder_rows.append({
+                        "Layer": layer_name,
+                        "Delta": delta_str,
+                        f"Cumulative {ladder_metric} prob": f"{val_f:.4f}" if val_f is not None else "—",
+                    })
+                    if val_f is not None:
+                        prev_val = val_f
+
+                st.dataframe(
+                    pd.DataFrame(ladder_rows),
+                    use_container_width=True,
+                    hide_index=True,
+                )
+
+                # Opportunity mode display
+                opp_mode = brow.get("opportunity_mode")
+                if opp_mode:
+                    st.caption(
+                        f"Opportunity mode: **{opp_mode}** | "
+                        f"pa_multiplier={brow.get('pa_multiplier', '?')} | "
+                        f"lineup_slot_used={brow.get('lineup_slot_used', 'None')} | "
+                        f"team_total_used={brow.get('team_total_used', 'None')}"
+                    )
+
+    # ------------------------------------------------------------------
+    # SECTION 4 — Full Feature Snapshot
+    # ------------------------------------------------------------------
+    st.subheader("Feature Snapshot (per batter)")
+
+    if not prep_df.empty and not sim_df.empty:
+        batter_names = sim_df["batter_name"].dropna().unique().tolist() if "batter_name" in sim_df.columns else []
+        selected_batter = st.selectbox("Select batter", options=["—"] + batter_names)
+
+        if selected_batter and selected_batter != "—":
+            from models.batter_baseline import build_batter_feature_row  # local import to avoid circular
+            try:
+                batter_features = build_batter_feature_row(statcast_df, selected_batter)
+            except Exception:
+                batter_features = {}
+
+            # Get pitcher from first sim row for this batter
+            batter_rows = sim_df[sim_df["batter_name"] == selected_batter]
+            pitcher_name = batter_rows.iloc[0].get("pitcher_name", "") if not batter_rows.empty else ""
+
+            try:
+                pitcher_row = build_pitcher_feature_row(statcast_df, pitcher_name)
+            except Exception:
+                pitcher_row = {}
+
+            col_b, col_p = st.columns(2)
+            with col_b:
+                with st.expander("Batter features", expanded=True):
+                    st.json({k: (v if v is not None else None) for k, v in batter_features.items()})
+            with col_p:
+                with st.expander("Pitcher row", expanded=True):
+                    st.json({k: (v if v is not None else None) for k, v in pitcher_row.items()})
+
+    # ------------------------------------------------------------------
+    # SECTION 5 — Signal Attribution
+    # ------------------------------------------------------------------
+    st.subheader("Signal Attribution")
+
+    if not sim_df.empty:
+        tag_rows = []
+        for _, srow in sim_df.iterrows():
+            batter = srow.get("batter_name", "?")
+            game   = srow.get("_game_label", "")
+            for tag_field, source in [
+                ("rolling_adjustment_reason_tags", "Rolling"),
+                ("arsenal_reason_tags", "Drift"),
+                ("reason_tags", "Pitcher Live"),
+            ]:
+                tags_val = srow.get(tag_field, "")
+                if isinstance(tags_val, list):
+                    tags = tags_val
+                elif isinstance(tags_val, str) and tags_val:
+                    tags = [t.strip() for t in tags_val.split("|") if t.strip()]
+                else:
+                    tags = []
+                for tag in tags:
+                    tag_rows.append({"Game": game, "Batter": batter, "Source": source, "Tag": tag})
+
+        if tag_rows:
+            st.dataframe(pd.DataFrame(tag_rows), use_container_width=True, hide_index=True)
+        else:
+            st.info("No active signal tags for filtered batters.")
+
+    # ------------------------------------------------------------------
+    # SECTION 6 — Admin Tools
+    # ------------------------------------------------------------------
+    st.subheader("Admin Tools")
+
+    col_a, col_b2, col_c = st.columns(3)
+    with col_a:
+        if grade_outcomes_fn is not None:
+            if st.button("Grade Final Game Outcomes", key="dbg_grade_final"):
+                grade_outcomes_fn(scores_df)
+                st.success("Grading attempted.")
+        else:
+            st.caption("grade_outcomes_fn not provided.")
+    with col_b2:
+        if grade_props_fn is not None:
+            if st.button("Build Batter Prop Outcomes", key="dbg_grade_props"):
+                grade_props_fn()
+                st.success("Prop outcome build attempted.")
+        else:
+            st.caption("grade_props_fn not provided.")
+    with col_c:
+        if fill_realized_fn is not None:
+            if st.button("Fill Realized Outcomes (Statcast)", key="dbg_fill_realized"):
+                fill_realized_fn(statcast_df)
+                st.success("Realized outcome fill attempted.")
+        else:
+            st.caption("fill_realized_fn not provided.")
+
+    st.caption(f"Current WBC date: {current_wbc_date_str()}")
+
+    # --- Simulator raw rows ---
+    with st.expander("Simulator raw rows", expanded=False):
+        if not prep_df.empty:
+            sim_debug_rows: list[dict] = []
+            for _, live_row in prep_df.iterrows():
+                game = live_row.to_dict()
+                try:
+                    sim_rows = build_upcoming_simulated_rows(
+                        game_row=game, statcast_df=statcast_df, weather_row=None,
+                    )
+                except Exception as e:
+                    sim_debug_rows.append({
+                        "away_team": game.get("away_team"), "home_team": game.get("home_team"),
+                        "slot": "ERROR", "batter_name": None, "pitcher_name": game.get("pitcher_name"),
+                        "hit_prob": None, "hr_prob": None, "tb2p_prob": None, "debug_note": str(e),
+                    })
+                    continue
+                for row in (sim_rows or []):
+                    if isinstance(row, dict):
+                        sim_debug_rows.append({
+                            "away_team": game.get("away_team"),
+                            "home_team": game.get("home_team"),
+                            "slot": row.get("slot"),
+                            "batter_name": row.get("batter_name"),
+                            "pitcher_name": row.get("pitcher_name"),
+                            "hit_prob": row.get("hit_prob"),
+                            "hr_prob": row.get("hr_prob"),
+                            "tb2p_prob": row.get("tb2p_prob"),
+                            "debug_note": None,
+                        })
+            if sim_debug_rows:
+                st.dataframe(pd.DataFrame(sim_debug_rows), use_container_width=True, hide_index=True)
+            else:
+                st.info("No simulator rows available.")
+        else:
+            st.info("No prepared live games.")
+
+    # --- Batter prop outcomes ---
+    with st.expander("Batter prop outcomes", expanded=False):
+        batter_prop_outcomes_df = read_batter_prop_outcomes(conn)
+        st.write(f"Rows: {len(batter_prop_outcomes_df)}")
+        if not batter_prop_outcomes_df.empty:
+            display_cols = [c for c in [
+                "created_at", "graded_at", "game_pk", "slot", "batter_name",
+                "fair_hr_odds", "book_hr_odds", "adjusted_edge", "confidence",
+                "recommendation_tier", "realized_hit", "realized_hr", "realized_tb2p",
+                "grade_status", "outcome_source",
+            ] if c in batter_prop_outcomes_df.columns]
+            st.dataframe(batter_prop_outcomes_df[display_cols].tail(30), use_container_width=True, hide_index=True)
+
+    # --- Game outcomes ---
+    with st.expander("Game outcomes", expanded=False):
+        game_outcomes_df = read_game_outcomes(conn)
+        st.write(f"Rows: {len(game_outcomes_df)}")
+        if not game_outcomes_df.empty:
+            st.dataframe(game_outcomes_df.tail(20), use_container_width=True, hide_index=True)
+
+    # --- Recommendation logs ---
+    with st.expander("Recommendation logs", expanded=False):
+        rec_logs_df = read_table(conn, "recommendation_logs")
+        st.write(f"Rows: {len(rec_logs_df)}")
+        if not rec_logs_df.empty:
+            st.dataframe(rec_logs_df.tail(20), use_container_width=True, hide_index=True)
+
+    # --- Recommendation audit ---
+    with st.expander("Recommendation audit", expanded=False):
+        audit_df = read_recommendation_audit_view(conn)
+        st.write(f"Rows: {len(audit_df)}")
+        if not audit_df.empty:
+            audit_display_cols = [c for c in [
+                "created_at", "game_pk", "away_team", "home_team", "slot", "batter_name",
+                "fair_hr_odds", "book_hr_odds", "adjusted_edge", "confidence",
+                "recommendation_tier", "realized_hr", "graded_at", "outcome_source",
+            ] if c in audit_df.columns]
+            st.dataframe(audit_df[audit_display_cols].tail(20), use_container_width=True, hide_index=True)
+
+    # --- Batter prop audit ---
+    with st.expander("Batter prop audit", expanded=False):
+        batter_audit_df = read_batter_prop_audit_view(conn)
+        st.write(f"Rows: {len(batter_audit_df)}")
+        if not batter_audit_df.empty:
+            st.dataframe(batter_audit_df.tail(20), use_container_width=True, hide_index=True)
+
+    # ------------------------------------------------------------------
+    # SECTION 7 — Export
+    # ------------------------------------------------------------------
+    st.subheader("Export")
+
+    if not sim_df.empty:
+        col_csv, col_json = st.columns(2)
+        with col_csv:
+            csv_data = sim_df.to_csv(index=False).encode("utf-8")
+            st.download_button(
+                label="Download CSV",
+                data=csv_data,
+                file_name="debug_sim_rows.csv",
+                mime="text/csv",
+                key="dbg_dl_csv",
+            )
+        with col_json:
+            json_data = json.dumps(
+                [
+                    {k: (v.item() if hasattr(v, "item") else v) for k, v in row.items()}
+                    for row in filtered_rows
+                ],
+                default=str,
+            ).encode("utf-8")
+            st.download_button(
+                label="Download JSON",
+                data=json_data,
+                file_name="debug_sim_rows.json",
+                mime="application/json",
+                key="dbg_dl_json",
+            )
+    else:
+        st.info("No data to export.")
+
+    # ------------------------------------------------------------------
+    # SECTION 8 — Audit Metadata (placeholders)
+    # ------------------------------------------------------------------
+    st.subheader("Audit Metadata")
+    st.json({
+        "model_version": "Batch 13",
+        "feature_version": "rolling_form+opportunity+drift",
+        "odds_snapshot_id": None,
+        "data_timestamp": str(pd.Timestamp.now()),
+    })
+
+    # ------------------------------------------------------------------
+    # SECTION 9 — Model Evaluation Metrics (CLV / ERE)
+    # ------------------------------------------------------------------
+    st.subheader("Model Evaluation Metrics")
+
+    try:
+        audit_df = read_recommendation_audit_view(conn)
+    except Exception:
+        audit_df = pd.DataFrame()
+
+    eval_tables = [
+        ("HR Probability Calibration", build_hr_calibration_table(audit_df)),
+        ("Edge Bucket Performance",    build_edge_bucket_table(audit_df)),
+        ("Confidence Bucket",          build_confidence_table(audit_df)),
+        ("Recommendation Tier",        build_tier_performance_table(audit_df)),
+        ("Global ERE",                 build_ere_table(audit_df)),
+        ("ERE by Edge Bucket",         build_ere_by_edge_bucket_table(audit_df)),
+        ("ERE by Confidence",          build_ere_by_confidence_bucket_table(audit_df)),
+        ("ERE by Tier",                build_ere_by_tier_table(audit_df)),
+        ("CLV Summary",                build_clv_table(audit_df)),
+        ("CLV by Tier",                build_clv_by_tier_table(audit_df)),
+    ]
+
+    for title, tbl in eval_tables:
+        if not tbl.empty:
+            st.write(title)
+            st.dataframe(tbl, use_container_width=True, hide_index=True)
+
+    # Batter-specific metrics
+    try:
+        batter_audit_df_eval = read_batter_prop_audit_view(conn)
+        for title, fn in [
+            ("Batter HR Rate by Tier",       build_batter_hr_tier_table),
+            ("Batter HR Rate by Confidence", build_batter_hr_confidence_table),
+            ("Batter HR Rate by Edge",       build_batter_hr_edge_table),
+        ]:
+            tbl = fn(batter_audit_df_eval)
+            if not tbl.empty:
+                st.write(title)
+                st.dataframe(tbl, use_container_width=True, hide_index=True)
+    except Exception:
+        pass
+
+    # Scores raw status (diagnostic)
+    if not scores_df.empty and "status" in scores_df.columns:
+        with st.expander("Raw score statuses", expanded=False):
+            st.write(sorted(scores_df["status"].fillna("").astype(str).unique().tolist()))

visualization/feedback_page.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import Any
+import streamlit as st
+
+from database.db import (
+    insert_feedback_submission,
+    read_feedback_submissions,
+)
+
+
+def render_feedback(conn: Any) -> None:
+    st.header("Feedback")
+    st.caption("Submit feedback or suggestions. All submissions are stored together.")
+
+    message = st.text_area(
+        "Your feedback", height=120, placeholder="Type your feedback here..."
+    )
+
+    if st.button("Submit"):
+        trimmed = (message or "").strip()
+        if not trimmed:
+            st.warning("Feedback cannot be empty.")
+        else:
+            try:
+                insert_feedback_submission(conn, trimmed)
+                st.success("Feedback submitted. Thank you!")
+            except Exception as e:
+                st.error(f"Failed to submit feedback: {e}")
+
+    st.divider()
+    st.subheader("Submitted Feedback")
+
+    try:
+        df = read_feedback_submissions(conn)
+    except Exception as e:
+        st.error(f"Could not load feedback: {e}")
+        return
+
+    if df.empty:
+        st.info("No feedback submitted yet.")
+        return
+
+    for _, row in df.iterrows():
+        st.markdown(f"**{row.get('created_at', '')}**")
+        st.write(row.get("message", ""))
+        st.divider()