Improved layouts

.claude/skills/leaderboard-manager/references/manage-display.md

@@ -6,34 +6,76 @@ renderer** (`render_leaderboard()` in `src/common/leaderboard.py`). Any change t
 function affects both boards simultaneously. Method-specific charts live in
 `src/pages/MethodDetails.py`.
 
+**A note on line numbers:** this file used to cite specific line numbers (e.g. "line 296").
+They drift out of date after almost any edit to `leaderboard.py` — a single reordering
+task can shift everything below it by 50+ lines. Below, locations are given as
+**function/variable/string anchors** you can `grep` for instead — these survive
+refactors. If you add a new durable line-number reference anyway, expect to fix it again
+next time someone edits the file.
+
+---
+
+## Page layout (top to bottom)
+
+`render_leaderboard()` renders, in order:
+
+1. Suitability table (`_render_suitability_table()`)
+2. Benchmark selector (`st.selectbox("Benchmark", ...)`) — always a single benchmark;
+   there is **no "All benchmarks" option**. Every chart and the table below operate on
+   whatever `selected_benchmark` is currently chosen.
+3. **Controls — always visible**, not collapsed. Look for `st.subheader("Scoring &
+   Target Controls")`: target-level radio, scoring-mode radio (+ blend-weight slider
+   when "Custom Blend" is selected), and the "Methods to display in charts" multiselect.
+   These used to be wrapped in `st.expander(..., expanded=False)`; that was removed so
+   users don't have to open a dropdown to see or change the target level.
+4. **Charts** — main "Mean Forward Model Runs vs Ensemble Size" chart, then (UQ only)
+   the "Mean Iterations for Coverage" chart, then (if `show_failure_panel=True`) the
+   failure-rate bar chart.
+5. **Leaderboard table** — `st.dataframe(leaderboard_df, ...)`.
+
+Charts render above the table and below the controls. If you need to reorder these
+sections again, see the gotcha below before moving the main chart.
+
+### Gotcha: the main chart is gated by `leaderboard_df`, not by its own emptiness check
+
+The main forward-model-runs chart is wrapped in `if not leaderboard_df.empty:` — the
+same DataFrame the table renders from — rather than an independent check on its own
+`chart_df`/`fail_df`. This is deliberate: `leaderboard_df` (from `build_scored_table()`)
+is empty in two distinct cases:
+
+- No rows at all for the current benchmark/target (nothing was ever run).
+- Every seed failed (`metric` is NaN for all rows) — a real "DNF" case.
+
+In the DNF case, the chart is intentionally suppressed too — the user sees a warning
+("All runs failed...") instead of a near-empty line chart with only fail-crosses at
+y=0. If you're adding a new chart section anywhere near the main chart, decide
+deliberately whether it should share this gate or have its own (the UQ iters chart and
+the failure-rate chart do **not** share it — they have their own internal emptiness
+checks, e.g. `if not all_ens_combos_iters.empty:`, so they can render even when the
+scored table is empty).
+
 ---
 
 ## Leaderboard table
 
 ### Column visibility and order
 
-The columns shown depend on whether "All" or a specific benchmark is selected. Both lists
-are defined in `src/common/leaderboard.py`:
-
-- **All-benchmarks view** (`table_column_order`, line 296–305):
-  ```python
-  ["Placement", "abbreviation", "Method", "family", "Score",
-   "Targets Used", "Ensemble Sizes Used", "Benchmarks Used"]
-  ```
-- **Single-benchmark view** (`table_column_order`, line 307–319):
-  ```python
-  ["Placement", "abbreviation", "Method", "family", "Score",
-   "Mean Forward Model Runs", "Minimum Forward Model Runs",
-   "Optimal Ensemble Size", "Targets Used", "Ensemble Sizes Used", "Benchmarks Used"]
-  ```
-
-To **show or hide** a column, add/remove it from the relevant list.
+Search for `table_column_order = [` in `src/common/leaderboard.py` — there is a single
+list (not one-per-view):
+```python
+table_column_order = [
+    "Placement", "abbreviation", "Method", "family", "Score",
+    "Mean Forward Model Runs", "Minimum Forward Model Runs",
+    "Mean Failure Rate (%)", "Optimal Ensemble Size", "Ensemble Sizes Used",
+]
+```
+To **show or hide** a column, add/remove it from this list.
 To **reorder** columns, rearrange entries within the list.
 
 ### Column labels and formatting
 
-Column display names and number formats are set in `st.dataframe(... column_config=...)`
-at lines 326–339. Each column has an entry like:
+Column display names and number formats are set in the `st.dataframe(... column_config=...)`
+call right after `table_column_order` is used. Each column has an entry like:
 
 ```python
 "Mean Forward Model Runs": st.column_config.NumberColumn(
@@ -48,8 +90,8 @@ To **rename** a displayed column header, change the string argument (second posi
 in the `column_config` entry. The dict key must still match the DataFrame column name.
 
 To **add a new column to the table**, you also need to produce it in `build_scored_table()`
-(line 111) — add it to the `.agg()` call or compute it after the groupby, then add a
-`column_config` entry and include it in `table_column_order`.
+— add it to a `.agg()` call or compute it after the groupby, then add a `column_config`
+entry and include it in `table_column_order`.
 
 ### Adding `failure_rate` to the leaderboard table
 
@@ -64,7 +106,8 @@ To add it:
 
 ## Scoring modes
 
-The four scoring modes are defined in `scoring_options` (line 82):
+The four scoring modes are defined in `scoring_options` (a list literal near the top of
+`render_leaderboard()`, right after `target_options` is computed):
 ```python
 scoring_options = [
     "Mean Forward Model Runs",
@@ -74,24 +117,27 @@ scoring_options = [
 ]
 ```
 
-Each mode maps to a sort key and a score column assignment in `build_scored_table()` at
-lines 185–203. To **add a new scoring mode**, add its name to `scoring_options` and add
-an `elif` branch in the scoring logic block that sets `scored_df["Score"]`,
-`sort_columns`, and `ascending`.
+Each mode maps to a sort key and a score column assignment inside `build_scored_table()`
+— search for the `if scoring_mode == "Mean Forward Model Runs": ... elif ...` chain. To
+**add a new scoring mode**, add its name to `scoring_options` and add an `elif` branch in
+that chain that sets `scored_df["Score"]`, `sort_columns`, and `ascending`.
 
-The "Custom Blend" slider weight (lines 357–368) is keyed to the session-state key
-`k_weight` — no change needed when adding a non-blend mode.
+The "Custom Blend" slider (`st.slider("Blend Weight: Forward Runs vs Ensemble Size", ...)`)
+is keyed to the session-state key `k_weight` and only rendered when
+`st.session_state[k_scoring] == "Custom Blend"` — no change needed when adding a
+non-blend mode. It lives in the always-visible controls section, not behind an expander.
 
 ---
 
 ## Leaderboard line chart
 
-The chart that appears in single-benchmark view ("Mean Forward Model Runs vs Ensemble
-Size") is at lines 387–396 (inside the `if selected_benchmark != "All":` guard at line
-376):
+The chart that appears above the table ("Mean Forward Model Runs vs Ensemble Size") is
+built right after `st.subheader("Mean Forward Model Runs vs Ensemble Size")`, inside the
+`if not leaderboard_df.empty:` guard described in the gotcha above:
 
 ```python
-ens_ticks = sorted(chart_df["ensemble_size"].unique().tolist())
+ens_ticks = sorted(all_ens_combos["ensemble_size"].unique().tolist()) if not all_ens_combos.empty else []
+main_color = _method_color(all_ens_combos["abbreviation"].unique().tolist())
 chart = (
     alt.Chart(chart_df)
     .mark_line(point=True)
@@ -102,7 +148,7 @@ chart = (
             axis=alt.Axis(values=ens_ticks, format="d"),   # integer ticks only
         ),
         y=alt.Y("mean_forward_runs:Q", title="Mean Forward Model Runs"),
-        color=alt.Color("abbreviation:N", title="Method"),
+        color=main_color,
         tooltip=["abbreviation", "ensemble_size",
                  alt.Tooltip("mean_forward_runs:Q", format=".4f")],
     )
@@ -119,11 +165,14 @@ Common changes:
 - **Add failure rate as a second Y-axis or tooltip**: add `failure_rate` to `chart_df`
   groupby and include it in `tooltip`.
 - **Change mark type** (e.g. bars): replace `mark_line(point=True)` with `mark_bar()`.
-- **Color palette**: add `.configure_range(category={"scheme": "tableau10"})` after the
-  chart construction.
+- **Restrict the legend to the methods actually plotted**: use `_method_color(...)` — see
+  "Method color legends" below. Do **not** reach for `.configure_range(category={"scheme":
+  ...})`; that overrides the whole palette rather than filtering the legend, and breaks
+  the per-method color stability the app relies on.
 
-The chart only renders when a single benchmark is selected (`if selected_benchmark != "All":`
-guard at line 376).
+There is no `if selected_benchmark != "All":` guard — a benchmark is always selected, so
+this chart renders whenever there's at least one non-DNF row for it (see the gotcha above
+for the exact condition).
 
 ---
 
@@ -133,22 +182,17 @@ The per-method page (`src/pages/MethodDetails.py`) has its own controls.
 
 ### Target level radio
 
-Line 111:
-```python
-target_options = ["1.0", "1.1", "1.2"]
-selected_target = st.radio("RMSE Target Level", options=target_options, horizontal=True)
-```
-
-These are **hardcoded strings**. If the benchmark gains new target levels, update this
-list. A more robust approach is to derive them from the data:
+Search for `target_options = ["1.0", "1.1", "1.2"]` (a hardcoded list). If the benchmark
+gains new target levels, update this list. A more robust approach is to derive them from
+the data:
 ```python
 target_options = sorted(metric_store["rmse_target"].astype(str).unique().tolist())
 ```
 
 ### Per-method special-case charts
 
-The HM (History Matching) failure-analysis chart (lines 122–138) is the canonical
-example of a per-method detail chart:
+The HM (History Matching) failure-analysis chart (search for `if sel == "HM":`) is the
+canonical example of a per-method detail chart:
 
 ```python
 if sel == "HM":
@@ -178,19 +222,25 @@ encoding, change the `.encode()` arguments analogously to the leaderboard chart
 
 The UQ leaderboard passes a `budget_store` DataFrame to `render_leaderboard()` via the
 `budget_store` keyword argument. This enables two additional chart sections rendered in
-`src/common/leaderboard.py` after the main performance chart:
+`src/common/leaderboard.py`, both **after** the main chart and **before** the leaderboard
+table:
 
 1. **"Mean Iterations for Coverage vs Ensemble Size"** — line chart of `mean_iters` vs
-   ensemble size. Uses the same integer-tick pattern as the main chart.
-
-2. **"Failure Rate of Hitting Target ..."** — grouped bar chart with `ensemble_size:O`
-   on the x-axis (ordinal, not quantitative) and `mean_failure_rate:Q` on y. The title
-   reflects the currently selected target level.
-
-To **add or modify a UQ chart**, edit the `if budget_store is not None` block in
-`src/common/leaderboard.py`. The `budget_store` DataFrame has columns: `benchmark`,
-`algorithm_type`, `abbreviation`, `family`, `uq_target`, `ensemble_size`, `mean_budget`,
-`mean_iters`, `failure_count`, `failure_rate`, `n_seeds`.
+   ensemble size (`if budget_store is not None and not budget_store.empty:`). Uses the
+   same integer-tick pattern as the main chart. This section has its own emptiness check
+   (`if not all_ens_combos_iters.empty:`) — it is independent of `leaderboard_df`, so it
+   can render even when the scored table/main chart are suppressed by an all-failed
+   selection.
+
+2. **"Failure Rate of Hitting Target ..."** — grouped bar chart (`if show_failure_panel:`)
+   with `ensemble_size:O` on the x-axis (ordinal, not quantitative) and
+   `mean_failure_rate:Q` on y. The title reflects the currently selected target level.
+   Also independent of `leaderboard_df`.
+
+To **add or modify a UQ chart**, edit the `if budget_store is not None` block. The
+`budget_store` DataFrame has columns: `benchmark`, `algorithm_type`, `abbreviation`,
+`family`, `uq_target`, `ensemble_size`, `mean_budget`, `mean_iters`, `failure_count`,
+`failure_rate`, `n_seeds`.
 
 **Bar chart integer x-axis:** Use `ensemble_size:O` (ordinal) with an explicit sort list
 and `axis=alt.Axis(labelAngle=0)` to suppress diagonal labels:
@@ -224,23 +274,63 @@ When **adding a new method**, its color is assigned automatically — no manual
 needed, as long as it is appended to the end of `KNOWN_METHODS`. The palette cycles every
 10 methods.
 
-### How to import shared colors in a new chart
+### Method color legends: scale stability vs. legend filtering
+
+`src/common/leaderboard.py` defines a `_method_color(present_abbrevs: list[str])` helper
+— **use it (or its pattern) for every method-colored chart**, rather than building
+`alt.Color(...)` by hand:
+
+```python
+def _method_color(present_abbrevs: list[str]) -> alt.Color:
+    return alt.Color(
+        "abbreviation:N",
+        title="Method",
+        scale=alt.Scale(domain=list(METHOD_COLORS.keys()), range=list(METHOD_COLORS.values())),
+        legend=alt.Legend(values=sorted(present_abbrevs)),
+    )
+```
+
+This encodes two *separate* requirements that are easy to conflate:
+
+- **The `scale` domain/range must always be the full registry** (`METHOD_COLORS.keys()`
+  / `.values()`), never a filtered subset. This is what keeps a given method's color
+  stable across every chart, benchmark, and page — if you filtered the scale domain to
+  "just the methods in this chart," a method could get a different color depending on
+  which benchmark happens to be selected.
+- **The `legend` should be filtered to just the methods present in *this* chart's data**
+  (`legend=alt.Legend(values=...)`). Without this, Vega-Lite lists every method in the
+  domain in the legend regardless of whether it appears in the plotted data — on a
+  benchmark with 3 methods, the legend would still show all 9+ registered methods.
+
+When calling `_method_color()`, compute `present_abbrevs` from the actual DataFrame(s)
+plotted in that chart section (e.g. `all_ens_combos["abbreviation"].unique()`), **not**
+from the global "Methods to display in charts" multiselect. A method can be selected in
+the multiselect but have no data for the current benchmark/target combination — including
+it in the legend anyway would be misleading. Each chart section (main chart, UQ iters
+chart, failure-rate chart) computes and passes its own `present_abbrevs`, since the set
+of methods with data can differ section to section (e.g. a method might have forward-run
+data but no coverage/iters data).
+
+If a layered chart (`alt.layer(...)`) has multiple encode calls sharing one color field
+(e.g. the main chart's success-line layer, fail-cross layer, and single-ensemble rule
+layer), pass the **same** `_method_color(...)` result (same `present_abbrevs`) to all of
+them — Vega-Lite needs matching legend/scale specs across layers to merge them into one
+legend instead of drawing duplicates.
+
+### How to import shared colors in a new page/file
 
 ```python
 try:
     from common.method_registry import METHOD_COLORS
 except ModuleNotFoundError:
     from src.common.method_registry import METHOD_COLORS
-
-method_color = alt.Color(
-    "abbreviation:N",
-    title="Method",
-    scale=alt.Scale(domain=list(METHOD_COLORS.keys()), range=list(METHOD_COLORS.values())),
-)
 ```
 
-Always use the full registry domain/range (not a filtered per-benchmark subset) so colors
-are stable when the user switches benchmarks or navigates between pages.
+`_method_color()` itself currently lives in `leaderboard.py` (not `method_registry.py`)
+and is private (`_`-prefixed). If a future page outside `leaderboard.py` needs
+method-colored charts with the same scale-stable/legend-filtered behavior, promote
+`_method_color()` to `method_registry.py` (dropping the underscore) rather than
+duplicating the function — don't hand-roll a second copy.
 
 ### General plotting conventions
 
@@ -249,7 +339,7 @@ new Altair chart in the app:
 
 | Concern | Convention |
 |---|---|
-| Method color | `METHOD_COLORS` via the import above — never a local palette |
+| Method color | `_method_color(present_abbrevs)` (see above) — never a local palette or an unfiltered legend |
 | Benchmark color | `alt.Color("benchmark:N")` — Altair assigns automatically; no custom palette needed |
 | Full-width charts | `st.altair_chart(chart, use_container_width=True)` — never `width="stretch"` |
 | Ensemble-size x-axis (quantitative) | `alt.Axis(values=ens_ticks, format="d")` — derive ticks from data, integer format |
@@ -266,7 +356,12 @@ new Altair chart in the app:
    per-method surfaces).
 2. If adding a column: produce it in the aggregation AND add a `column_config` entry AND
    add it to `table_column_order`.
-3. Restart or clear Streamlit cache to pick up Python changes (code changes take effect on
+3. If adding or reordering a chart section: check whether it should share the
+   `leaderboard_df`-emptiness gate (main chart) or have its own independent emptiness
+   check (UQ iters chart, failure panel) — see the gotcha under "Page layout" above.
+4. If the chart colors by `abbreviation`: use `_method_color(present_abbrevs)` computed
+   from that section's actual plotted data, not the global multiselect.
+5. Restart or clear Streamlit cache to pick up Python changes (code changes take effect on
    restart; cache only matters for data changes).
-4. Smoke-test on both the "All" view and a single-benchmark view to catch the different
-   `table_column_order` branches.
+6. Smoke-test with a benchmark/target combination where every run fails (all-DNF) to
+   confirm the warning/chart-suppression behavior still matches what you intended.

src/common/leaderboard.py

@@ -33,6 +33,22 @@ _SUITABLE   = "#009E73"  # Okabe-Ito teal-green (colorblind-safe)
 _UNSUITABLE = "#C0392B"  # dark red
 _UNTESTED   = "#BDBDBD"  # gray
 
+
+def _method_color(present_abbrevs: list[str]) -> alt.Color:
+    """Color encoding for the ``abbreviation`` field.
+
+    The scale domain/range is always the full method registry so a given
+    method keeps the same color across every chart and page. The legend,
+    however, is restricted to *present_abbrevs* so it only lists methods
+    actually plotted in this chart section rather than every known method.
+    """
+    return alt.Color(
+        "abbreviation:N",
+        title="Method",
+        scale=alt.Scale(domain=list(METHOD_COLORS.keys()), range=list(METHOD_COLORS.values())),
+        legend=alt.Legend(values=sorted(present_abbrevs)),
+    )
+
 # Family display order in the leaderboard table (lower = earlier).
 # Unknown families fall back to 99 and appear at the end.
 _FAMILY_ORDER: dict[str, int] = {
@@ -186,7 +202,7 @@ def render_leaderboard(
         If ``True``, render a grouped-bar failure-rate chart below the main
         performance chart.
     show_scoring_modes:
-        If ``True``, show scoring-mode radio controls in the expander.
+        If ``True``, show scoring-mode radio controls.
     canonical_target_levels:
         If provided, the target-level selector always offers exactly these
         values (as strings) regardless of what is present in the data.  Use
@@ -269,14 +285,6 @@ def render_leaderboard(
     valid_saved       = [m for m in saved_methods if m in available_methods]
     st.session_state[k_methods] = valid_saved if valid_saved else available_methods
 
-    # Color scale fixed to the full registry so every chart in the app uses the same
-    # color per method regardless of which benchmark or page is shown.
-    method_color = alt.Color(
-        "abbreviation:N",
-        title="Method",
-        scale=alt.Scale(domain=list(METHOD_COLORS.keys()), range=list(METHOD_COLORS.values())),
-    )
-
     def build_scored_table(input_df: pd.DataFrame, add_rank: bool = True) -> pd.DataFrame:
         ranking_source = input_df[input_df[target_str_col] == selected_target]
         if ranking_source.empty:
@@ -437,93 +445,52 @@ def render_leaderboard(
             f"and normalized ensemble-size score ({ensemble_weight:.0%})"
         )
 
-    # Controls expander — always shown so users can change target even when the
-    # current selection yields all failures.
-    with st.expander("Scoring & Target Controls", expanded=False):
+    # Controls — always visible (not collapsed behind a dropdown) so users can
+    # change target/scoring/methods even when the current selection yields all
+    # failures.
+    st.subheader("Scoring & Target Controls")
+    st.radio(
+        target_label,
+        options=target_options,
+        horizontal=True,
+        key=k_target,
+    )
+
+    if show_scoring_modes:
         st.radio(
-            target_label,
-            options=target_options,
+            "Scoring Method",
+            options=scoring_options,
             horizontal=True,
-            key=k_target,
+            key=k_scoring,
         )
 
-        if show_scoring_modes:
-            st.radio(
-                "Scoring Method",
-                options=scoring_options,
-                horizontal=True,
-                key=k_scoring,
+        if st.session_state.get(k_scoring, "Mean Forward Model Runs") == "Custom Blend":
+            st.slider(
+                "Blend Weight: Forward Runs vs Ensemble Size",
+                min_value=0,
+                max_value=100,
+                step=5,
+                key=k_weight,
+                help=(
+                    "Higher forward-runs weight prioritizes fewer model evaluations; "
+                    "higher ensemble-size weight prioritizes smaller ensembles."
+                ),
             )
 
-            if st.session_state.get(k_scoring, "Mean Forward Model Runs") == "Custom Blend":
-                st.slider(
-                    "Blend Weight: Forward Runs vs Ensemble Size",
-                    min_value=0,
-                    max_value=100,
-                    step=5,
-                    key=k_weight,
-                    help=(
-                        "Higher forward-runs weight prioritizes fewer model evaluations; "
-                        "higher ensemble-size weight prioritizes smaller ensembles."
-                    ),
-                )
-
-        st.multiselect(
-            "Methods to display in charts",
-            options=available_methods,
-            key=k_methods,
-        )
+    st.multiselect(
+        "Methods to display in charts",
+        options=available_methods,
+        key=k_methods,
+    )
 
     selected_methods = st.session_state.get(k_methods, available_methods)
     if not selected_methods:
         selected_methods = available_methods
 
-    table_column_order = [
-        "Placement",
-        "abbreviation",
-        "Method",
-        "family",
-        "Score",
-        "Mean Forward Model Runs",
-        "Minimum Forward Model Runs",
-        "Mean Failure Rate (%)",
-        "Optimal Ensemble Size",
-        "Ensemble Sizes Used",
-    ]
-
-    if leaderboard_df.empty:
-        st.warning(
-            "All runs failed to reach the target at this selection. "
-            "See the failure rate chart below."
-            if show_failure_panel
-            else "No rows available for the current benchmark/target selection."
-        )
-    else:
-        st.subheader(f"Ranked Leaderboard — {selected_benchmark}")
-        st.dataframe(
-            leaderboard_df,
-            hide_index=True,
-            use_container_width=True,
-            column_config={
-                "Placement": st.column_config.TextColumn("Placement"),
-                "family": st.column_config.TextColumn("Family"),
-                "Method": st.column_config.TextColumn("Method"),
-                "abbreviation": st.column_config.TextColumn("Abbrev."),
-                "Mean Forward Model Runs": st.column_config.NumberColumn("Mean Forward Model Runs", format="%.4f"),
-                "Minimum Forward Model Runs": st.column_config.NumberColumn("Minimum Forward Model Runs", format="%.4f"),
-                "Score": st.column_config.ProgressColumn("Score (0-100)", min_value=0.0, max_value=100.0, format="%.1f"),
-                "Optimal Ensemble Size": st.column_config.NumberColumn("Mean Optimal Ensemble Size", format="%.2f"),
-                "Mean Failure Rate (%)": st.column_config.NumberColumn("Mean Failure Rate (%)", format="%.1f"),
-                "Ensemble Sizes Used": st.column_config.NumberColumn("Ensemble Sizes Used", format="%d"),
-            },
-            column_order=table_column_order,
-        )
-
-        st.info(
-            f"Score is a normalized 0–100 ranking based on **{score_basis}**. "
-            "Values are computed from all ensemble sizes after averaging over random seeds."
-        )
+    st.divider()
 
+    # --- Charts (rendered above the leaderboard table, below the controls) ---
+    if not leaderboard_df.empty:
         st.subheader("Mean Forward Model Runs vs Ensemble Size")
         chart_source = filtered[filtered[target_str_col] == selected_target]
         chart_source = chart_source[chart_source["abbreviation"].isin(selected_methods)]
@@ -533,6 +500,7 @@ def render_leaderboard(
 
         all_ens_combos = chart_source[["abbreviation", "ensemble_size"]].drop_duplicates()
         ens_ticks = sorted(all_ens_combos["ensemble_size"].unique().tolist()) if not all_ens_combos.empty else []
+        main_color = _method_color(all_ens_combos["abbreviation"].unique().tolist())
 
         if not chart_df.empty:
             _ok = chart_df[["abbreviation", "ensemble_size"]].assign(_ok=True)
@@ -554,7 +522,7 @@ def render_leaderboard(
                         axis=alt.Axis(values=ens_ticks, format="d"),
                     ),
                     y=alt.Y("mean_forward_runs:Q", title="Mean Forward Model Runs"),
-                    color=method_color,
+                    color=main_color,
                     tooltip=["abbreviation", "ensemble_size", alt.Tooltip("mean_forward_runs:Q", format=".4f")],
                 )
             )
@@ -574,7 +542,7 @@ def render_leaderboard(
                         axis=alt.Axis(values=ens_ticks, format="d"),
                     ),
                     y=y_fwd,
-                    color=method_color,
+                    color=main_color,
                     tooltip=[
                         alt.Tooltip("abbreviation:N", title="Method"),
                         alt.Tooltip("ensemble_size:Q", title="Ensemble Size"),
@@ -603,7 +571,7 @@ def render_leaderboard(
                             "ensemble_size:Q",
                             axis=alt.Axis(values=ens_ticks, format="d"),
                         ),
-                        color=method_color,
+                        color=main_color,
                         tooltip=[
                             alt.Tooltip("abbreviation:N", title="Method"),
                             alt.Tooltip("ensemble_size:Q", title="Ensemble Size"),
@@ -630,6 +598,7 @@ def render_leaderboard(
         all_ens_combos_iters = bf[["abbreviation", "ensemble_size"]].drop_duplicates()
         if not all_ens_combos_iters.empty:
             iters_ticks = sorted(all_ens_combos_iters["ensemble_size"].unique().tolist())
+            iters_color = _method_color(all_ens_combos_iters["abbreviation"].unique().tolist())
 
             if not iters_df.empty:
                 _ok_iters = iters_df[["abbreviation", "ensemble_size"]].assign(_ok=True)
@@ -652,7 +621,7 @@ def render_leaderboard(
                             axis=alt.Axis(values=iters_ticks, format="d"),
                         ),
                         y=alt.Y("mean_iters:Q", title="Mean Iterations"),
-                        color=method_color,
+                        color=iters_color,
                         tooltip=[
                             alt.Tooltip("abbreviation:N", title="Method"),
                             alt.Tooltip("ensemble_size:Q", title="Ensemble Size"),
@@ -676,7 +645,7 @@ def render_leaderboard(
                             axis=alt.Axis(values=iters_ticks, format="d"),
                         ),
                         y=y_iters,
-                        color=method_color,
+                        color=iters_color,
                         tooltip=[
                             alt.Tooltip("abbreviation:N", title="Method"),
                             alt.Tooltip("ensemble_size:Q", title="Ensemble Size"),
@@ -715,7 +684,7 @@ def render_leaderboard(
                         title="Failure Rate (%)",
                         scale=alt.Scale(domain=[0, 100]),
                     ),
-                    color=method_color,
+                    color=_method_color(failure_df["abbreviation"].unique().tolist()),
                     tooltip=[
                         alt.Tooltip("abbreviation:N", title="Method"),
                         alt.Tooltip("ensemble_size:O", title="Ensemble Size"),
@@ -730,6 +699,55 @@ def render_leaderboard(
             )
             st.altair_chart(failure_chart + ceiling_line, use_container_width=True)
 
+    st.divider()
+
+    # --- Leaderboard table (rendered below the charts) ---
+    table_column_order = [
+        "Placement",
+        "abbreviation",
+        "Method",
+        "family",
+        "Score",
+        "Mean Forward Model Runs",
+        "Minimum Forward Model Runs",
+        "Mean Failure Rate (%)",
+        "Optimal Ensemble Size",
+        "Ensemble Sizes Used",
+    ]
+
+    if leaderboard_df.empty:
+        st.warning(
+            "All runs failed to reach the target at this selection. "
+            "See the failure rate chart above."
+            if show_failure_panel
+            else "No rows available for the current benchmark/target selection."
+        )
+    else:
+        st.subheader(f"Ranked Leaderboard — {selected_benchmark}")
+        st.dataframe(
+            leaderboard_df,
+            hide_index=True,
+            use_container_width=True,
+            column_config={
+                "Placement": st.column_config.TextColumn("Placement"),
+                "family": st.column_config.TextColumn("Family"),
+                "Method": st.column_config.TextColumn("Method"),
+                "abbreviation": st.column_config.TextColumn("Abbrev."),
+                "Mean Forward Model Runs": st.column_config.NumberColumn("Mean Forward Model Runs", format="%.4f"),
+                "Minimum Forward Model Runs": st.column_config.NumberColumn("Minimum Forward Model Runs", format="%.4f"),
+                "Score": st.column_config.ProgressColumn("Score (0-100)", min_value=0.0, max_value=100.0, format="%.1f"),
+                "Optimal Ensemble Size": st.column_config.NumberColumn("Mean Optimal Ensemble Size", format="%.2f"),
+                "Mean Failure Rate (%)": st.column_config.NumberColumn("Mean Failure Rate (%)", format="%.1f"),
+                "Ensemble Sizes Used": st.column_config.NumberColumn("Ensemble Sizes Used", format="%d"),
+            },
+            column_order=table_column_order,
+        )
+
+        st.info(
+            f"Score is a normalized 0–100 ranking based on **{score_basis}**. "
+            "Values are computed from all ensemble sizes after averaging over random seeds."
+        )
+
     st.caption("Top 3 are shown as podium spots; remaining methods are directly comparable via normalized score.")
 
     if raw_page is not None: