Recover props terminal UI redesign; fix pitcher filter and cache hang

- Restore be663f7 'Redesign Props page terminal UI' (521 insertions) lost
during HF Space recovery git reset
- Fix _filter_probable_starters_to_slate() to use _canonical_team() instead
of _normalize_team_key() so 'sfg' matches 'san francisco giants'
- Add LIMIT 5000 to cached_upcoming_props_rows query to prevent 5+ min
full-table scan as table grows unbounded
- Wrap read_cached_upcoming_props_bundle() in thread+10s timeout; on
timeout raises RuntimeError caught by existing except block → falls
through to live HTTP fetch
- Re-apply timeout banner (360s auto-reload) and async _maybe_log_props

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

app.py

@@ -1014,7 +1014,18 @@ def load_upcoming_hr_props() -> pd.DataFrame:
 @st.cache_data(ttl=300, show_spinner=False)
 def load_upcoming_hr_props_bundle() -> dict:
     try:
-        cached_bundle = read_cached_upcoming_props_bundle(conn, cache_key="default")
+        _cache_result: list[dict | None] = [None]
+        def _read_db_cache() -> None:
+            try:
+                _cache_result[0] = read_cached_upcoming_props_bundle(conn, cache_key="default")
+            except Exception:
+                pass
+        _dbt = threading.Thread(target=_read_db_cache, daemon=True)
+        _dbt.start()
+        _dbt.join(timeout=10)
+        if _cache_result[0] is None:
+            raise RuntimeError("DB cache read timed out — falling through to live fetch")
+        cached_bundle = _cache_result[0]
         cache_meta = cached_bundle.get("cache_meta", pd.DataFrame())
         merged = cached_bundle.get("merged_props_feed", pd.DataFrame())
         coverage = cached_bundle.get("coverage_summary", pd.DataFrame())

database/db.py

@@ -1299,6 +1299,7 @@ def read_cached_upcoming_props_bundle(
             SELECT * FROM cached_upcoming_props_rows
             WHERE cache_key = :cache_key
             ORDER BY fetched_at DESC, event_id, player_name
+            LIMIT 5000
             """
         ),
         conn,

visualization/props_page.py

@@ -33,6 +33,7 @@ from database.db import (
 )
 from utils.helpers import utc_now_iso
 from data.mlb_starters import (
+    _canonical_team,
     build_oddsapi_starter_fallback_map,
     lookup_pitchers_for_game,
     merge_probable_starters_with_odds_fallback,
@@ -310,6 +311,158 @@ def _render_props_ui_styles() -> None:
             color: #afc0d3;
             margin: 0.9rem 0 1.1rem 0;
         }
+        .props-ops-header {
+            border: 1px solid rgba(123, 145, 120, 0.28);
+            border-radius: 18px;
+            padding: 1rem 1.1rem;
+            background:
+                radial-gradient(circle at top right, rgba(78, 104, 74, 0.18), transparent 32%),
+                linear-gradient(180deg, rgba(18, 23, 20, 0.98), rgba(10, 14, 16, 0.98));
+            margin-bottom: 0.85rem;
+        }
+        .props-ops-kicker {
+            letter-spacing: 0.16em;
+            text-transform: uppercase;
+            font-size: 0.68rem;
+            color: #b0c98f;
+            font-weight: 800;
+        }
+        .props-ops-title {
+            color: #f5f2e8;
+            font-size: 1.85rem;
+            font-weight: 850;
+            line-height: 1.02;
+            margin-top: 0.35rem;
+        }
+        .props-ops-sub {
+            color: #b8c0b4;
+            font-size: 0.92rem;
+            margin-top: 0.35rem;
+        }
+        .props-terminal-board {
+            border: 1px solid rgba(114, 132, 108, 0.26);
+            border-radius: 18px;
+            padding: 1rem;
+            background: linear-gradient(180deg, rgba(17, 20, 18, 0.98), rgba(11, 14, 15, 0.98));
+            margin-bottom: 1rem;
+        }
+        .props-terminal-highlight {
+            border: 1px solid rgba(165, 184, 114, 0.28);
+            border-left: 4px solid #bccb62;
+            border-radius: 16px;
+            padding: 1rem 1rem 0.9rem 1rem;
+            background: linear-gradient(180deg, rgba(31, 36, 30, 0.96), rgba(18, 23, 22, 0.98));
+            margin-bottom: 0.8rem;
+        }
+        .props-terminal-rank {
+            display: inline-block;
+            color: #121512;
+            background: #d6dd9e;
+            border-radius: 999px;
+            padding: 0.12rem 0.48rem;
+            font-size: 0.72rem;
+            font-weight: 800;
+            letter-spacing: 0.08em;
+            text-transform: uppercase;
+            margin-bottom: 0.55rem;
+        }
+        .props-terminal-mini {
+            border: 1px solid rgba(88, 99, 91, 0.32);
+            border-radius: 14px;
+            padding: 0.8rem 0.85rem;
+            background: rgba(19, 22, 22, 0.94);
+            min-height: 182px;
+        }
+        .props-terminal-name {
+            color: #f6f2e8;
+            font-weight: 760;
+            font-size: 1.02rem;
+            margin-bottom: 0.15rem;
+        }
+        .props-terminal-line {
+            color: #bfc7bc;
+            font-size: 0.82rem;
+            margin-bottom: 0.7rem;
+        }
+        .props-terminal-thesis {
+            color: #9fac9a;
+            font-size: 0.8rem;
+            line-height: 1.4;
+            margin-top: 0.65rem;
+        }
+        .props-terminal-grid {
+            display: grid;
+            grid-template-columns: repeat(2, minmax(0, 1fr));
+            gap: 0.55rem 0.8rem;
+        }
+        .props-terminal-metric {
+            color: #8e998f;
+            font-size: 0.68rem;
+            text-transform: uppercase;
+            letter-spacing: 0.08em;
+        }
+        .props-terminal-value {
+            color: #f4efe5;
+            font-size: 1.02rem;
+            font-weight: 760;
+        }
+        .props-terminal-value.good { color: #9fe09d; }
+        .props-terminal-value.neutral { color: #e3c87f; }
+        .props-terminal-value.bad { color: #f19797; }
+        .props-game-nav {
+            border: 1px solid rgba(93, 104, 98, 0.26);
+            border-radius: 18px;
+            padding: 0.95rem 1rem 0.6rem 1rem;
+            background: linear-gradient(180deg, rgba(18, 20, 22, 0.96), rgba(11, 13, 15, 0.98));
+            margin-bottom: 1rem;
+        }
+        .props-game-nav-card {
+            border: 1px solid rgba(79, 92, 88, 0.28);
+            border-radius: 14px;
+            padding: 0.75rem 0.8rem;
+            background: rgba(20, 22, 24, 0.94);
+            margin-bottom: 0.45rem;
+        }
+        .props-game-nav-card.selected {
+            border-color: rgba(181, 198, 117, 0.42);
+            box-shadow: 0 0 0 1px rgba(181, 198, 117, 0.16);
+        }
+        .props-game-nav-title {
+            color: #f3efe5;
+            font-size: 0.96rem;
+            font-weight: 760;
+        }
+        .props-game-nav-meta {
+            color: #9da89d;
+            font-size: 0.77rem;
+            margin-top: 0.25rem;
+            line-height: 1.4;
+        }
+        .props-workspace {
+            border: 1px solid rgba(100, 111, 105, 0.26);
+            border-radius: 18px;
+            padding: 1rem;
+            background: linear-gradient(180deg, rgba(17, 20, 19, 0.98), rgba(11, 13, 14, 0.98));
+            margin-bottom: 1rem;
+        }
+        .props-workspace-title {
+            color: #f6f2e8;
+            font-size: 1.2rem;
+            font-weight: 780;
+        }
+        .props-workspace-sub {
+            color: #9eaa9e;
+            font-size: 0.83rem;
+            margin-top: 0.2rem;
+            margin-bottom: 0.85rem;
+        }
+        .props-secondary-shell {
+            border: 1px solid rgba(80, 93, 94, 0.24);
+            border-radius: 16px;
+            padding: 0.9rem 1rem;
+            background: rgba(15, 18, 20, 0.9);
+            margin-top: 0.8rem;
+        }
         </style>
         """,
         unsafe_allow_html=True,
@@ -646,13 +799,13 @@ def _filter_probable_starters_to_slate(
 ) -> dict:
     if not probable_starters or not slate_teams:
         return {}
-    team_scope = {_normalize_team_key(team) for team in slate_teams if str(team).strip()}
+    team_scope = {_canonical_team(team) for team in slate_teams if str(team).strip()}
     out: dict = {}
     for key, payload in probable_starters.items():
         if not isinstance(key, tuple) or len(key) != 2:
             continue
-        away_norm = _normalize_team_key(key[0])
-        home_norm = _normalize_team_key(key[1])
+        away_norm = _canonical_team(key[0])
+        home_norm = _canonical_team(key[1])
         if away_norm in team_scope and home_norm in team_scope:
             out[key] = payload
     return out
@@ -1080,6 +1233,26 @@ def _render_filter_controls(mapped: pd.DataFrame, market_type: str) -> tuple[lis
     return selected_books, min_edge, sort_option, view
 
 
+def _get_current_filter_state(mapped: pd.DataFrame, market_type: str) -> tuple[list[str], float, str, str]:
+    all_books = sorted(mapped["sportsbook"].dropna().unique().tolist()) if "sportsbook" in mapped.columns else []
+    selected_books = st.session_state.get("props_books", all_books)
+    if not isinstance(selected_books, list) or not selected_books:
+        selected_books = all_books
+    selected_books = [book for book in selected_books if book in all_books] or all_books
+
+    if market_type == "hr":
+        min_edge = float(st.session_state.get("props_min_edge", -0.50))
+        sort_option = str(st.session_state.get("props_sort", "EV"))
+    else:
+        min_edge = -0.50
+        sort_option = str(st.session_state.get("props_sort", "EV"))
+
+    view = str(st.session_state.get("props_view", "All Books"))
+    if view not in {"All Books", "Best Line"}:
+        view = "All Books"
+    return selected_books, min_edge, sort_option, view
+
+
 def _render_market_coverage_note(display: pd.DataFrame, market_type: str) -> None:
     if display is None or display.empty or "sportsbook" not in display.columns:
         return
@@ -1574,6 +1747,306 @@ def render_best_on_slate_cards(best_df: pd.DataFrame, summary: dict[str, Any] |
             )
 
 
+def _build_terminal_top_bets_df(display: pd.DataFrame, market_type: str, limit: int = 7) -> pd.DataFrame:
+    if display is None or display.empty:
+        return pd.DataFrame()
+
+    working = display.copy()
+    if market_type == "hr":
+        working = _modeled_hr_primary_subset(working)
+    elif "is_modeled" in working.columns:
+        working = working[working["is_modeled"] == True].copy()
+    if working.empty:
+        return pd.DataFrame()
+
+    working = select_best_lines_per_prop(working)
+    sort_cols: list[str] = []
+    ascending: list[bool] = []
+    for col in ("bet_ev", "edge", "confidence_score", "final_recommendation_score"):
+        if col in working.columns:
+            sort_cols.append(col)
+            ascending.append(False)
+    if "odds_american" in working.columns:
+        sort_cols.append("odds_american")
+        ascending.append(False)
+    if sort_cols:
+        working = working.sort_values(sort_cols, ascending=ascending, na_position="last")
+    return working.head(max(1, int(limit))).reset_index(drop=True)
+
+
+def _render_terminal_header(display: pd.DataFrame, market_type: str, top_bets_df: pd.DataFrame) -> None:
+    market_label = _market_label(market_type)
+    available_books = (
+        sorted(display["sportsbook"].dropna().astype(str).unique().tolist())
+        if display is not None and not display.empty and "sportsbook" in display.columns
+        else []
+    )
+    best_edge = (
+        pd.to_numeric(top_bets_df.get("edge"), errors="coerce").dropna().max()
+        if not top_bets_df.empty and "edge" in top_bets_df.columns
+        else None
+    )
+    best_ev = (
+        pd.to_numeric(top_bets_df.get("bet_ev"), errors="coerce").dropna().max()
+        if not top_bets_df.empty and "bet_ev" in top_bets_df.columns
+        else None
+    )
+    st.markdown(
+        f"""
+        <div class="props-ops-header">
+            <div class="props-ops-kicker">Baseball Ops Terminal</div>
+            <div class="props-ops-title">{market_label} Slate Board</div>
+            <div class="props-ops-sub">Top value first, fast matchup navigation second, deep prop detail only when you want it.</div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+    metrics = st.columns(5)
+    metrics[0].metric("Games", int(display["event_id"].nunique()) if display is not None and not display.empty and "event_id" in display.columns else 0)
+    metrics[1].metric("Books", len(available_books))
+    metrics[2].metric("Top Bets", int(len(top_bets_df)))
+    metrics[3].metric("Best Edge", _format_edge(float(best_edge)) if best_edge is not None else "-")
+    metrics[4].metric("Best EV", _format_ev(float(best_ev)) if best_ev is not None else "-")
+
+
+def _render_top_bet_highlight(row: pd.Series | dict[str, Any], rank_label: str) -> None:
+    player = str(row.get("player_name_raw") or row.get("player_name") or "-")
+    matchup = _build_matchup(row)
+    market_line = _display_market_line_label(row)
+    book = str(row.get("sportsbook") or "-")
+    model_voice = str(row.get("model_voice") or "No model voice available.")
+    market_family = str(row.get("market_family") or row.get("market") or "").strip().lower()
+    probability_value = row.get("model_hr_prob") if market_family == "hr" else row.get("fair_prob")
+    probability_label = "Pregame HR%" if market_family == "hr" else "Fair%"
+    edge_class = _metric_tone_class("edge", row.get("edge"))
+    ev_class = _metric_tone_class("ev", row.get("bet_ev"))
+    st.markdown(
+        f"""
+        <div class="props-terminal-highlight">
+            <div class="props-terminal-rank">{rank_label}</div>
+            <div class="props-player">{player}</div>
+            <div class="props-matchup">{matchup}</div>
+            <div class="props-terminal-line">{market_line} | {book}</div>
+            <div class="props-terminal-grid">
+                <div><div class="props-terminal-metric">Odds</div><div class="props-terminal-value">{_format_odds(row.get('odds_american'))}</div></div>
+                <div><div class="props-terminal-metric">EV</div><div class="props-terminal-value {ev_class}">{_format_ev(row.get('bet_ev'))}</div></div>
+                <div><div class="props-terminal-metric">Edge</div><div class="props-terminal-value {edge_class}">{_format_edge(row.get('edge'))}</div></div>
+                <div><div class="props-terminal-metric">{probability_label}</div><div class="props-terminal-value">{_format_pct(probability_value)}</div></div>
+                <div><div class="props-terminal-metric">Implied</div><div class="props-terminal-value">{_format_pct(row.get('implied_prob'))}</div></div>
+                <div><div class="props-terminal-metric">Confidence</div><div class="props-terminal-value">{_format_confidence(row.get('confidence_score'))}</div></div>
+            </div>
+            <div class="props-terminal-thesis"><strong>Thesis:</strong> {model_voice}</div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+
+def _render_terminal_mini_card(row: pd.Series | dict[str, Any], rank: int) -> None:
+    player = str(row.get("player_name_raw") or row.get("player_name") or "-")
+    matchup = _build_matchup(row)
+    market_line = _display_market_line_label(row)
+    book = str(row.get("sportsbook") or "-")
+    model_voice = str(row.get("model_voice") or "No thesis available.")
+    model_voice = model_voice[:140] + ("..." if len(model_voice) > 140 else "")
+    edge_class = _metric_tone_class("edge", row.get("edge"))
+    ev_class = _metric_tone_class("ev", row.get("bet_ev"))
+    st.markdown(
+        f"""
+        <div class="props-terminal-mini">
+            <div class="props-terminal-rank">#{rank}</div>
+            <div class="props-terminal-name">{player}</div>
+            <div class="props-matchup">{matchup}</div>
+            <div class="props-terminal-line">{market_line} | {book}</div>
+            <div class="props-terminal-grid">
+                <div><div class="props-terminal-metric">EV</div><div class="props-terminal-value {ev_class}">{_format_ev(row.get('bet_ev'))}</div></div>
+                <div><div class="props-terminal-metric">Edge</div><div class="props-terminal-value {edge_class}">{_format_edge(row.get('edge'))}</div></div>
+                <div><div class="props-terminal-metric">Odds</div><div class="props-terminal-value">{_format_odds(row.get('odds_american'))}</div></div>
+                <div><div class="props-terminal-metric">Conf</div><div class="props-terminal-value">{_format_confidence(row.get('confidence_score'))}</div></div>
+            </div>
+            <div class="props-terminal-thesis">{model_voice}</div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+
+def render_terminal_top_bets_board(top_bets_df: pd.DataFrame, market_type: str) -> None:
+    st.markdown('<div class="props-section-kicker">Top Bets</div>', unsafe_allow_html=True)
+    st.markdown("#### Best Current Value On The Slate")
+    if top_bets_df is None or top_bets_df.empty:
+        st.info(f"No top {_market_label(market_type)} bets are available for the current filters.")
+        return
+
+    st.markdown('<div class="props-terminal-board">', unsafe_allow_html=True)
+    _render_top_bet_highlight(top_bets_df.iloc[0], "Top Play")
+    if len(top_bets_df) > 1:
+        remaining = top_bets_df.iloc[1:].reset_index(drop=True)
+        cols_per_row = 3
+        for start in range(0, len(remaining), cols_per_row):
+            cols = st.columns(min(cols_per_row, len(remaining) - start))
+            for idx, (_, row) in enumerate(remaining.iloc[start:start + cols_per_row].iterrows(), start=start + 2):
+                with cols[idx - start - 2]:
+                    _render_terminal_mini_card(row, idx)
+    st.markdown("</div>", unsafe_allow_html=True)
+
+
+def _build_generic_game_workspace(display: pd.DataFrame) -> tuple[pd.DataFrame, dict[str, Any]]:
+    if display is None or display.empty:
+        return pd.DataFrame(), {}
+
+    working = select_best_lines_per_prop(display.copy())
+    summary_rows: list[dict[str, Any]] = []
+    game_map: dict[str, Any] = {}
+
+    for (event_id, away_team, home_team, commence_time), game_df in working.groupby(
+        ["event_id", "away_team", "home_team", "commence_time"],
+        dropna=False,
+    ):
+        game_key = str(event_id or f"{away_team}|{home_team}|{commence_time}")
+        sort_df = game_df.copy()
+        if "bet_ev" in sort_df.columns:
+            sort_df = sort_df.sort_values(["bet_ev", "edge", "confidence_score"], ascending=[False, False, False], na_position="last")
+        top_row = sort_df.iloc[0].to_dict() if not sort_df.empty else {}
+        player_rows: list[dict[str, Any]] = []
+        for player_name, player_df in sort_df.groupby("player_name", dropna=False):
+            primary_row = player_df.iloc[0].to_dict()
+            player_rows.append(
+                {
+                    "player_key": f"{game_key}|{str(primary_row.get('player_name') or '').strip().lower()}",
+                    "player_name": primary_row.get("player_name"),
+                    "player_name_raw": primary_row.get("player_name_raw"),
+                    "best_display_label": primary_row.get("display_label"),
+                    "best_book": primary_row.get("sportsbook"),
+                    "best_odds_american": primary_row.get("odds_american"),
+                    "best_edge": primary_row.get("edge"),
+                    "best_bet_ev": primary_row.get("bet_ev"),
+                    "best_confidence_score": primary_row.get("confidence_score"),
+                    "best_verdict": primary_row.get("verdict"),
+                    "best_model_hr_prob": primary_row.get("fair_prob"),
+                    "model_voice": primary_row.get("model_voice"),
+                    "model_voice_primary_reason": primary_row.get("model_voice_primary_reason"),
+                    "model_voice_caveat": primary_row.get("model_voice_caveat"),
+                    "details": {
+                        "best_primary_row": primary_row,
+                        "primary_rows": player_df.to_dict("records"),
+                        "alt_rows": [],
+                    },
+                }
+            )
+        game_map[game_key] = {
+            "game_key": game_key,
+            "event_id": event_id,
+            "away_team": away_team,
+            "home_team": home_team,
+            "commence_time": commence_time,
+            "modeled_props_count": int(len(sort_df)),
+            "players_count": int(game_df["player_name"].nunique()),
+            "best_edge": top_row.get("edge"),
+            "best_bet_ev": top_row.get("bet_ev"),
+            "top_player_name": top_row.get("player_name"),
+            "top_display_label": top_row.get("display_label"),
+            "top_book": top_row.get("sportsbook"),
+            "top_verdict": top_row.get("verdict"),
+            "players": player_rows,
+        }
+        summary_rows.append({key: value for key, value in game_map[game_key].items() if key != "players"})
+
+    summary_df = pd.DataFrame(summary_rows)
+    if not summary_df.empty and "best_edge" in summary_df.columns:
+        summary_df = summary_df.sort_values(["best_edge", "best_bet_ev"], ascending=[False, False], na_position="last").reset_index(drop=True)
+    return summary_df, game_map
+
+
+def _normalize_game_summary_rows(
+    market_type: str,
+    analysis_display: pd.DataFrame,
+    view_model: dict[str, Any] | None = None,
+) -> tuple[pd.DataFrame, dict[str, Any]]:
+    if market_type == "hr" and isinstance(view_model, dict):
+        return (
+            view_model.get("games_summary_df", pd.DataFrame()),
+            view_model.get("game_player_props_map", {}),
+        )
+    return _build_generic_game_workspace(analysis_display)
+
+
+def render_game_navigator_terminal(game_summary_df: pd.DataFrame, market_type: str) -> str | None:
+    st.markdown('<div class="props-section-kicker">Game Navigator</div>', unsafe_allow_html=True)
+    st.markdown("#### Jump Into A Matchup")
+    if game_summary_df is None or game_summary_df.empty:
+        st.info(f"No {_market_label(market_type)} games are available for navigation.")
+        return None
+
+    state_key = f"props_selected_game_{market_type}"
+    ordered_game_keys = game_summary_df["game_key"].astype(str).tolist()
+    current = st.session_state.get(state_key)
+    if current not in ordered_game_keys:
+        current = ordered_game_keys[0]
+        st.session_state[state_key] = current
+
+    st.markdown('<div class="props-game-nav">', unsafe_allow_html=True)
+    cols_per_row = 3
+    for start in range(0, len(game_summary_df), cols_per_row):
+        row_df = game_summary_df.iloc[start:start + cols_per_row]
+        cols = st.columns(len(row_df))
+        for col, (_, row) in zip(cols, row_df.iterrows()):
+            game_key = str(row.get("game_key") or "")
+            selected_class = " selected" if game_key == current else ""
+            with col:
+                st.markdown(
+                    f"""
+                    <div class="props-game-nav-card{selected_class}">
+                        <div class="props-game-nav-title">{_build_matchup(row)}</div>
+                        <div class="props-game-nav-meta">
+                            {_build_game_time(row)}<br/>
+                            {int(row.get('modeled_props_count') or 0)} modeled props | best edge {_format_edge(row.get('best_edge'))}<br/>
+                            top: {str(row.get('top_player_name') or '-')} | {str(row.get('top_display_label') or '-')}
+                        </div>
+                    </div>
+                    """,
+                    unsafe_allow_html=True,
+                )
+                if st.button("View Game", key=f"props_game_nav_{market_type}_{game_key}", use_container_width=True):
+                    st.session_state[state_key] = game_key
+                    current = game_key
+    st.markdown("</div>", unsafe_allow_html=True)
+    return current
+
+
+def render_selected_game_workspace(
+    *,
+    selected_game_key: str | None,
+    game_map: dict[str, Any],
+    market_type: str,
+) -> None:
+    st.markdown('<div class="props-section-kicker">Selected Game</div>', unsafe_allow_html=True)
+    st.markdown("#### Prop Workspace")
+    if not selected_game_key or selected_game_key not in game_map:
+        st.info("Select a game to inspect player props and books.")
+        return
+
+    game_payload = game_map[selected_game_key]
+    st.markdown(
+        f"""
+        <div class="props-workspace">
+            <div class="props-workspace-title">{_build_matchup(game_payload)}</div>
+            <div class="props-workspace-sub">
+                {_build_game_time(game_payload)} | {int(game_payload.get('modeled_props_count') or 0)} modeled props | best edge {_format_edge(game_payload.get('best_edge'))} | best EV {_format_ev(game_payload.get('best_bet_ev'))}
+            </div>
+        </div>
+        """,
+        unsafe_allow_html=True,
+    )
+
+    player_entries = game_payload.get("players") or []
+    if not player_entries:
+        st.info("No player props available for this game.")
+        return
+
+    for player_entry in player_entries:
+        render_player_hr_row(player_entry)
+
 def render_player_hr_details(player_details: dict[str, Any]) -> None:
     primary_rows = pd.DataFrame(player_details.get("primary_rows") or [])
     alt_rows = pd.DataFrame(player_details.get("alt_rows") or [])
@@ -1989,14 +2462,14 @@ def render_props(
     )
     import time as _time
     if prepared_bundle.get("snapshot_source_status") in ("runtime_fallback_timeout", "patch_build_timeout"):
-        st.session_state.setdefault("props_baseline_reload_at", _time.time() + 80)
+        st.session_state.setdefault("props_baseline_reload_at", _time.time() + 360)
     _reload_at = st.session_state.get("props_baseline_reload_at")
     if _reload_at:
         if _time.time() < _reload_at:
             st.info(
                 "📊 **Player baseline data is loading in the background.** "
                 "Props are shown with basic line analysis. "
-                "The page will refresh automatically with full Statcast enrichment in about a minute."
+                "The page will refresh automatically with full Statcast enrichment in a few minutes."
             )
         else:
             del st.session_state["props_baseline_reload_at"]
@@ -2070,20 +2543,33 @@ def render_props(
         st.session_state["props_view_model_bundle"] = view_model
     else:
         st.session_state.pop("props_view_model_bundle", None)
-    render_props_hero(mapped, view_model=view_model)
-    _render_props_legend()
-    _render_market_coverage_note(mapped, market_type)
-
-    st.caption(
-        f"{_market_label(market_type)} - upcoming games - ranked by current model strength. "
-        "Best-Value cards show the strongest modeled looks even when the slate is negative."
+    selected_books, min_edge, sort_option, view = _get_current_filter_state(mapped, market_type)
+    analysis_display, table_display = _prepare_display_frames(
+        mapped=mapped,
+        market_type=market_type,
+        selected_books=selected_books,
+        min_edge=min_edge,
+        sort_option=sort_option,
+        view=view,
     )
 
+    if analysis_display.empty:
+        _render_terminal_header(mapped, market_type, pd.DataFrame())
+        st.info("No props match the current filters.")
+        return
+
+    top_bets_df = _build_terminal_top_bets_df(analysis_display, market_type, limit=7)
+    _render_terminal_header(analysis_display, market_type, top_bets_df)
+    render_terminal_top_bets_board(top_bets_df, market_type)
+
     st.markdown('<div class="props-filter-rail">', unsafe_allow_html=True)
-    st.markdown('<div class="props-section-kicker">Filters</div>', unsafe_allow_html=True)
-    st.markdown('<div class="props-filter-sub">Tune book coverage, edge floor, and list style without losing the featured/actionable surface.</div>', unsafe_allow_html=True)
+    st.markdown('<div class="props-section-kicker">Controls</div>', unsafe_allow_html=True)
+    st.markdown('<div class="props-filter-sub">Use the active filters to reshape the board, then jump directly into a matchup workspace below.</div>', unsafe_allow_html=True)
     selected_books, min_edge, sort_option, view = _render_filter_controls(mapped, market_type)
     st.markdown("</div>", unsafe_allow_html=True)
+    st.markdown('<div class="props-secondary-shell">', unsafe_allow_html=True)
+    _render_market_coverage_note(mapped, market_type)
+    st.markdown("</div>", unsafe_allow_html=True)
     analysis_display, table_display = _prepare_display_frames(
         mapped=mapped,
         market_type=market_type,
@@ -2109,32 +2595,32 @@ def render_props(
         "summary": best_on_slate_summary,
     }
 
-    if market_type == "hr":
-        view_model = build_hr_props_view_model(analysis_display)
-        _render_summary_metrics(table_display, market_type)
-        render_best_on_slate_cards(best_on_slate_df, best_on_slate_summary)
-        st.markdown(
-            '<div class="props-release-note">This version is intentionally HR-first. Featured cards rank the strongest modeled 1+ HR looks on the slate, while alternate HR ladders remain available inside each player expander for research and line shopping. A negative edge or EV still means pass.</div>',
-            unsafe_allow_html=True,
-        )
-        render_featured_hr_cards(view_model.get("featured_props_df", pd.DataFrame()))
-        render_game_explorer(view_model.get("game_player_props_map", {}))
-        with st.expander("Flat Table View", expanded=False):
-            render_flat_props_table(table_display, market_type)
+    filtered_view_model = build_hr_props_view_model(analysis_display) if market_type == "hr" else None
+    game_summary_df, game_map = _normalize_game_summary_rows(
+        market_type=market_type,
+        analysis_display=analysis_display,
+        view_model=filtered_view_model,
+    )
+    selected_game_key = render_game_navigator_terminal(game_summary_df, market_type)
+    render_selected_game_workspace(
+        selected_game_key=selected_game_key,
+        game_map=game_map,
+        market_type=market_type,
+    )
+
+    st.markdown('<div class="props-section-kicker">Research Surfaces</div>', unsafe_allow_html=True)
+    bottom_tabs = st.tabs(["Flat Table", "Probability", "Execution", "Legend"])
+    with bottom_tabs[0]:
+        render_flat_props_table(table_display, market_type)
+    with bottom_tabs[1]:
         render_probability_diagnostics(analysis_display)
+    with bottom_tabs[2]:
         render_execution_layer(analysis_display)
-        st.caption(
-            "Pregame HR% is produced by the shared pregame engine. It starts from a "
-            "batter baseline and applies available pregame layers such as pitcher, "
-            "matchup, park/weather, trajectory, and rolling form context. Live-only "
-            "signals like pitch telemetry, bullpen transitions, and count/base-out "
-            "state are intentionally skipped here and remain part of the live Dashboard path."
-        )
-        return
-
-    st.subheader("Props")
-    st.caption("Strikeouts and game-scope markets are shown here as they become available. Verdicts remain model-driven.")
-    _render_summary_metrics(table_display, market_type)
-    render_best_on_slate_cards(best_on_slate_df, best_on_slate_summary)
-    render_flat_props_table(table_display, market_type)
-    render_probability_diagnostics(analysis_display)
+        if market_type == "hr":
+            st.caption(
+                "Pregame HR% starts from the batter baseline and applies pitcher, matchup, park/weather, trajectory, and rolling context. "
+                "Live-only pitch telemetry and count/base-out state remain part of the live Dashboard path."
+            )
+    with bottom_tabs[3]:
+        _render_summary_metrics(table_display, market_type)
+        _render_props_legend()