Add efficiency, coding, generalist, and benchmark matrix views (#25)

* Add analytics views and benchmark matrices

* Add Bradley-Terry rankings tab with filters for benchmarks, models, harnesses, and rank-by metric

* Address CR: fix eqvdata population, empty filter handling, and per-table error isolation

* Address leaderboard review feedback

* Round trade-off table values to one decimal

* Round trade-off table values to one decimal

* Round trade-off metrics to two decimals

* Round trade-off metrics to two decimals

---------

Co-authored-by: rounakbende10 <rounakbende@gmail.com>

app.py

@@ -43,14 +43,31 @@ def patch_gradio_leaderboard():
 patch_gradio_leaderboard()
 
 import gradio as gr
+import pandas as pd
 from apscheduler.schedulers.background import BackgroundScheduler
 from gradio_leaderboard import ColumnFilter, Leaderboard, SelectColumns
 from huggingface_hub import HfApi
 
+from src.analytics import (
+    MATRIX_METRICS,
+    RANKING_METRICS,
+    TRADEOFF_METRICS,
+    benchmarks_for_category,
+    coverage_summary,
+    cross_benchmark_ranking_df,
+    enrich_analysis_df,
+    filter_category,
+    matrix_df,
+    ranking_df,
+)
 from src.charts import (
     clean_markdown_link,
+    create_coverage_matrix_plot,
     create_leaderboard_benchmark_plot,
+    create_matrix_plot,
     create_performance_vs_resource_plot,
+    create_ranking_plot,
+    create_tradeoff_plot,
 )
 from src.display.text_blocks import (
     HOW_TO_USE_TEXT,
@@ -63,41 +80,49 @@ from src.leaderboard import (
     get_benchmark_names,
     get_benchmark_run_df,
     get_efficiency_df,
-    get_token_efficiency_table_df,
 )
+from src.rankings import RANK_BY_OPTIONS, load_and_rank
 
 REPO_ID = "taagarwa/coding-agent-leaderboard"
 TOKEN = os.environ.get("HF_TOKEN")
 API = HfApi(token=TOKEN)
 COLOR_BY_CHOICES = ["Model", "Harness"]
 EFFICIENCY_COLOR_BY_CHOICES = ["Model", "Harness"]
-COLOR_PALETTE_CHOICES = [
-    "Citrus",
-    "Okabe-Ito",
-    "High contrast",
-    "Rainbow",
-    "Grayscale",
-    "Viridis",
-    "Plasma",
-    "Cividis",
-]
+COLOR_PALETTE_CHOICES = ["Citrus", "Okabe-Ito", "High contrast", "Rainbow"]
 DEFAULT_COLOR_PALETTE = "Citrus"
 PLOT_BACKGROUND_CHOICES = ["Dark", "White"]
 DEFAULT_PLOT_BACKGROUND = "Dark"
 RESPONSIVE_PLOT_MIN_HEIGHT_PX = 420
+TABLE_MAX_HEIGHT_PX = 720
 RESPONSIVE_PLOT_CSS = f"""
 <style>
 .responsive-plot {{
-  overflow-x: auto;
+  overflow-x: hidden;
   width: 100%;
+  min-width: 0;
   min-height: {RESPONSIVE_PLOT_MIN_HEIGHT_PX}px;
 }}
 .responsive-plot .plot-container,
 .responsive-plot .js-plotly-plot,
-.responsive-plot .plotly-graph-div {{
+.responsive-plot .plotly-graph-div,
+.responsive-plot .svg-container {{
   width: 100% !important;
+  max-width: 100% !important;
+  min-width: 0 !important;
   min-height: {RESPONSIVE_PLOT_MIN_HEIGHT_PX}px;
 }}
+.summary-cards {{
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+  gap: 0.6rem;
+}}
+.summary-card {{
+  border: 1px solid rgba(203,213,225,.18);
+  border-radius: 10px;
+  padding: .8rem;
+  background: rgba(39,33,30,.7);
+}}
+.summary-card strong {{ font-size: 1.35rem; display:block; }}
 </style>
 """
 FORCE_DARK_MODE_HEAD = (
@@ -108,7 +133,36 @@ FORCE_DARK_MODE_HEAD = (
   if (!url.searchParams.has("__theme")) {
     url.searchParams.set("__theme", "dark");
     window.location.replace(url.toString());
+    return;
   }
+
+  // Plotly often measures hidden Gradio tabs before they are visible. Resize every
+  // visible chart when a tab opens, its container changes size, or the window resizes.
+  const resizeVisiblePlots = () => {
+    if (!window.Plotly) return;
+    document.querySelectorAll('.responsive-plot .js-plotly-plot').forEach((plot) => {
+      if (plot.offsetParent !== null) window.Plotly.Plots.resize(plot);
+    });
+  };
+  const scheduleResize = () => {
+    requestAnimationFrame(() => {
+      resizeVisiblePlots();
+      setTimeout(resizeVisiblePlots, 80);
+      setTimeout(resizeVisiblePlots, 250);
+    });
+  };
+  window.addEventListener('resize', scheduleResize);
+  document.addEventListener('click', scheduleResize, true);
+  document.addEventListener('DOMContentLoaded', () => {
+    const observer = new ResizeObserver(scheduleResize);
+    document.querySelectorAll('.responsive-plot').forEach((el) => observer.observe(el));
+    const mutation = new MutationObserver(() => {
+      document.querySelectorAll('.responsive-plot').forEach((el) => observer.observe(el));
+      scheduleResize();
+    });
+    mutation.observe(document.body, {childList: true, subtree: true});
+    scheduleResize();
+  });
 })();
 </script>
 """
@@ -124,6 +178,9 @@ BENCHMARK_NAMES = get_benchmark_names()
 DEFAULT_BENCHMARK = BENCHMARK_NAMES[0] if BENCHMARK_NAMES else None
 BENCHMARK_RUN_DF = get_benchmark_run_df()
 ANALYSIS_DF = get_analysis_df()
+PR2_DF = enrich_analysis_df(ANALYSIS_DF)
+CODING_BENCHMARKS = benchmarks_for_category(PR2_DF, "Coding")
+GENERALIST_BENCHMARKS = benchmarks_for_category(PR2_DF, "Generalist")
 
 
 def render_leaderboard_benchmark_plot(
@@ -141,7 +198,6 @@ def render_leaderboard_benchmark_plot(
     )
 
 
-
 def render_efficiency(
     benchmark_name,
     token_metric,
@@ -157,12 +213,11 @@ def render_efficiency(
         resource_metric=token_metric,
         analysis_df=ANALYSIS_DF,
     )
-    table_df = get_token_efficiency_table_df(
-        benchmark_name=benchmark_name,
-        analysis_df=ANALYSIS_DF,
-    )
     exclusion_count = plot_df.attrs.get("exclusion_count", 0)
-    note = f"{exclusion_count} runs excluded for this benchmark because {token_metric.lower()} was missing or non-positive."
+    note = (
+        f"{exclusion_count} runs excluded for this benchmark because "
+        f"{token_metric.lower()} was missing or non-positive."
+    )
     figure = create_performance_vs_resource_plot(
         plot_df,
         resource_metric=token_metric,
@@ -173,34 +228,338 @@ def render_efficiency(
         palette_name=color_palette,
         background_name=plot_background,
     )
-    return figure, table_df, note
+    return figure, note
 
 
-def build_header_html(df):
-    n_results = len(df)
-    n_models = df["Model"].nunique()
-    n_harnesses = df["Harness"].apply(clean_markdown_link).nunique()
-    n_benchmarks = df["Benchmark"].apply(clean_markdown_link).nunique()
+PAGE_TABLE_COLUMNS = [
+    "Model",
+    "Harness",
+    "Benchmark",
+    "Score (%)",
+    "Within-Benchmark Rank",
+    "Within-Benchmark Percentile",
+    "Total Tokens Per Task",
+    "Cost Per Task",
+    "Total Time Per Task",
+    "Agent Time Per Task",
+    "Execution Error Rate (%)",
+    "Tokens Per Successful Task",
+    "Cost Per Successful Task",
+    "Time Per Successful Task",
+]
+
+PAGE_TABLE_SORT_COLUMNS = {
+    "Score": "Score (%)",
+    "Rank": "Within-Benchmark Rank",
+    "Percentile": "Within-Benchmark Percentile",
+    "Total tokens": "Total Tokens Per Task",
+    "Cost": "Cost Per Task",
+    "Response time": "Total Time Per Task",
+    "Agent time": "Agent Time Per Task",
+    "Execution error rate": "Execution Error Rate (%)",
+}
+
+
+def render_page_table(benchmark, sort_metric="Score", sort_order="Largest value first"):
+    """One compact table per page with all metrics relevant to ranking/trade-off views."""
+    data = PR2_DF.copy()
+    if benchmark and benchmark != "All benchmarks":
+        data = data[data["Benchmark"] == benchmark].copy()
+    columns = [column for column in PAGE_TABLE_COLUMNS if column in data.columns]
+    data = data[columns].copy()
+    if data.empty:
+        return data
+
+    data["_agent"] = data["Model"].astype(str) + " / " + data["Harness"].astype(str)
+    if sort_order == "Alphabetical (A–Z)":
+        data = data.sort_values(["_agent", "Benchmark"], ascending=[True, True], kind="mergesort")
+    elif sort_order == "Alphabetical (Z–A)":
+        data = data.sort_values(["_agent", "Benchmark"], ascending=[False, True], kind="mergesort")
+    else:
+        sort_column = PAGE_TABLE_SORT_COLUMNS.get(sort_metric, "Score (%)")
+        values = pd.to_numeric(data.get(sort_column), errors="coerce")
+        data["_sort_value"] = values
+        ascending = sort_order == "Lowest value first"
+        data = data.sort_values(
+            ["_sort_value", "_agent", "Benchmark"],
+            ascending=[ascending, True, True],
+            na_position="last",
+            kind="mergesort",
+        ).drop(columns="_sort_value")
+    data = data.drop(columns="_agent").reset_index(drop=True)
+
+    # Metrics displayed to 2 decimal places
+    decimal_columns = [
+        "Score (%)",
+        "Within-Benchmark Percentile",
+        "Execution Error Rate (%)",
+        "Cost Per Successful Task",
+    ]
+
+    for column in decimal_columns:
+        if column in data.columns:
+            data[column] = pd.to_numeric(data[column], errors="coerce").round(2)
+
+    # Token and time metrics displayed as whole numbers
+    whole_number_columns = [
+        "Total Tokens Per Task",
+        "Total Time Per Task",
+        "Agent Time Per Task",
+        "Tokens Per Successful Task",
+        "Time Per Successful Task",
+    ]
+
+    for column in whole_number_columns:
+        if column in data.columns:
+            data[column] = pd.to_numeric(data[column], errors="coerce").round(0)
+
+    return data
 
+
+def render_ranking(
+    metric,
+    benchmark,
+    color_by="Model",
+    color_palette=DEFAULT_COLOR_PALETTE,
+    plot_background=DEFAULT_PLOT_BACKGROUND,
+    sort_order="Largest value first",
+):
+    def sort_table(table, metric_column, higher_is_better):
+        if table is None or table.empty:
+            return table
+        work = table.copy()
+        work["_agent"] = work["Model"].astype(str) + " / " + work["Harness"].astype(str)
+        if sort_order == "Alphabetical (A–Z)":
+            work = work.sort_values("_agent", ascending=True, kind="mergesort")
+        elif sort_order == "Alphabetical (Z–A)":
+            work = work.sort_values("_agent", ascending=False, kind="mergesort")
+        elif sort_order == "Lowest value first":
+            work = work.sort_values(
+                [metric_column, "_agent"],
+                ascending=[True, True],
+                kind="mergesort",
+            )
+        else:
+            work = work.sort_values(
+                [metric_column, "_agent"],
+                ascending=[False, True],
+                kind="mergesort",
+            )
+        return work.drop(columns="_agent").reset_index(drop=True)
+
+    if metric == "Score" and benchmark == "All benchmarks":
+        table = cross_benchmark_ranking_df(PR2_DF, minimum_coverage=0.5)
+        table = sort_table(table, "Normalized Performance", True)
+        plot_df = table.rename(columns={"Normalized Performance": "_metric"}).copy()
+        if not plot_df.empty:
+            plot_df["Benchmark"] = "Normalized across benchmarks"
+        figure = create_ranking_plot(
+            plot_df,
+            "_metric",
+            "Normalized performance (0–100)",
+            True,
+            color_by=color_by,
+            palette_name=color_palette,
+            background_name=plot_background,
+            sort_order=sort_order,
+        )
+        return figure, table
+
+    table = ranking_df(PR2_DF, metric, benchmark=benchmark)
+    spec = RANKING_METRICS[metric]
+    table = sort_table(table, spec.column, spec.higher_is_better)
+    figure = create_ranking_plot(
+        table,
+        spec.column,
+        spec.label,
+        spec.higher_is_better,
+        color_by=color_by,
+        palette_name=color_palette,
+        background_name=plot_background,
+        sort_order=sort_order,
+    )
+    return figure, table
+
+
+TRADEOFF_PAIRS = {
+    "Score vs cost": ("Cost Per Task", "Score (%)", "Cost per task (USD)", "Score (%)", True, True),
+    "Score vs tokens": ("Total Tokens Per Task", "Score (%)", "Total tokens per task", "Score (%)", True, True),
+    "Score vs total time": ("Total Time Per Task", "Score (%)", "Total time per task (seconds)", "Score (%)", True, True),
+    "Score vs agent time": ("Agent Time Per Task", "Score (%)", "Agent time per task (seconds)", "Score (%)", True, True),
+    "Score vs execution error rate": (
+        "Execution Error Rate (%)", "Score (%)", "Execution error rate (%)", "Score (%)", True, True
+    ),
+    "Tokens vs cost": ("Total Tokens Per Task", "Cost Per Task", "Total tokens per task", "Cost per task (USD)", True, False),
+    "Cost vs total time": ("Cost Per Task", "Total Time Per Task", "Cost per task (USD)", "Total time per task (seconds)", True, False),
+}
+
+
+def render_tradeoff(
+    pair,
+    benchmark,
+    color_by,
+    show_labels,
+    x_scale,
+    show_pareto,
+    color_palette,
+    plot_background,
+):
+    x_column, y_column, x_label, y_label, lower_x, higher_y = TRADEOFF_PAIRS[pair]
+    data = PR2_DF[PR2_DF["Benchmark"] == benchmark].copy()
+    figure = create_tradeoff_plot(
+        data,
+        x_column=x_column,
+        y_column=y_column,
+        x_label=x_label,
+        y_label=y_label,
+        color_by=color_by,
+        show_labels=show_labels,
+        x_scale=x_scale,
+        show_pareto_frontier=show_pareto,
+        lower_x_is_better=lower_x,
+        higher_y_is_better=higher_y,
+        palette_name=color_palette,
+        background_name=plot_background,
+    )
+    valid = data[[x_column, y_column]].apply(pd.to_numeric, errors="coerce").dropna()
+    note = f"{len(valid)} comparable runs shown for {benchmark}; missing metrics are omitted, not treated as zero."
+    return figure, note
+
+
+def render_matrix(
+    metric,
+    category,
+    include_incomplete,
+    sort_by,
+    show_values,
+    reverse_scale,
+    plot_background,
+):
+    category_filter = None if category == "All" else category
+    matrix = matrix_df(
+        PR2_DF,
+        metric,
+        category=category_filter,
+        include_incomplete=include_incomplete,
+        sort_by=sort_by,
+    )
+    if metric == "Coverage":
+        return create_coverage_matrix_plot(matrix, plot_background)
+    spec = MATRIX_METRICS[metric]
+    display_matrix = None
+    display_metric_label = None
+    if metric == "Within-benchmark percentile":
+        display_matrix = matrix_df(
+            PR2_DF,
+            "Score",
+            category=category_filter,
+            include_incomplete=include_incomplete,
+            sort_by=sort_by,
+        ).reindex(index=matrix.index, columns=matrix.columns)
+        display_metric_label = "Benchmark score (%)"
+    return create_matrix_plot(
+        matrix,
+        f"{metric} matrix",
+        spec.label,
+        higher_is_better=spec.higher_is_better,
+        show_values=show_values,
+        reverse_scale=reverse_scale,
+        background_name=plot_background,
+        display_matrix=display_matrix,
+        display_metric_label=display_metric_label,
+    )
+
+
+def category_leaderboard(category):
+    data = filter_category(PR2_DF, category)
+    if data.empty:
+        return pd.DataFrame()
+    normalized = cross_benchmark_ranking_df(data, minimum_coverage=0)
+    return normalized
+
+
+def render_category_tradeoff(category, benchmark, metric, color_by, show_labels, plot_background):
+    data = filter_category(PR2_DF, category)
+    data = data[data["Benchmark"] == benchmark]
+    spec = TRADEOFF_METRICS[metric]
+    return create_tradeoff_plot(
+        data,
+        x_column=spec.column,
+        y_column="Score (%)",
+        x_label=spec.label,
+        y_label="Score (%)",
+        color_by=color_by,
+        show_labels=show_labels,
+        show_pareto_frontier=metric != "Execution error rate",
+        lower_x_is_better=True,
+        higher_y_is_better=True,
+        background_name=plot_background,
+    )
+
+
+def render_category_matrix(category, metric, show_values, plot_background):
+    matrix = matrix_df(PR2_DF, metric, category=category, include_incomplete=True)
+    if metric == "Coverage":
+        return create_coverage_matrix_plot(matrix, plot_background)
+    spec = MATRIX_METRICS[metric]
+    display_matrix = None
+    display_metric_label = None
+    if metric == "Within-benchmark percentile":
+        display_matrix = matrix_df(
+            PR2_DF, "Score", category=category, include_incomplete=True
+        ).reindex(index=matrix.index, columns=matrix.columns)
+        display_metric_label = "Benchmark score (%)"
+    return create_matrix_plot(
+        matrix,
+        f"{category} — {metric}",
+        spec.label,
+        higher_is_better=spec.higher_is_better,
+        show_values=show_values,
+        background_name=plot_background,
+        display_matrix=display_matrix,
+        display_metric_label=display_metric_label,
+    )
+
+
+def build_header_html(df):
+    summary = coverage_summary(PR2_DF)
     return f"""
     <base target="_blank">
     <div style="padding: 1.5rem 0.5rem 1rem 0.5rem; text-align: left; color: #F8FAFC;">
-        <h1 style="margin: 0 0 0.5rem 0; font-size: 2rem;">
-            Coding Agent Leaderboard
-        </h1>
+        <h1 style="margin: 0 0 0.5rem 0; font-size: 2rem;">Coding Agent Leaderboard</h1>
         <div style="height: 4px; border-radius: 2px; background: linear-gradient(90deg, #84cc16, #f59e0b); margin-bottom: 0.75rem;"></div>
-        <p style="margin: 0 0 0.75rem 0; font-size: 1.1rem; color: #E5E7EB;">
-            Compare coding agents across models and harnesses
+        <p style="margin: 0 0 0.9rem 0; font-size: 1.1rem; color: #E5E7EB;">
+            Performance, efficiency, coverage, and reliability across coding-agent benchmarks.
+            Each result is one model + harness run on one benchmark.
         </p>
-        <div style="display: flex; gap: 0.5rem; flex-wrap: wrap; font-size: 0.95rem; color: #CBD5E1;">
-            <span style="font-weight: 600;">{n_results} Results</span>
-            <span>·</span>
-            <span style="font-weight: 600;">{n_models} Models</span>
-            <span>·</span>
-            <span style="font-weight: 600;">{n_harnesses} Harnesses</span>
-            <span>·</span>
-            <span style="font-weight: 600;">{n_benchmarks} Benchmarks</span>
+        <div class="summary-cards">
+          <div class="summary-card"><strong>{summary['results']}</strong>benchmark results</div>
+          <div class="summary-card"><strong>{summary['models']}</strong>models</div>
+          <div class="summary-card"><strong>{summary['harnesses']}</strong>harnesses</div>
+          <div class="summary-card"><strong>{summary['benchmarks']}</strong>benchmarks</div>
+          <div class="summary-card"><strong>{summary['token_coverage_pct']:.0f}%</strong>token coverage</div>
+          <div class="summary-card"><strong>{summary['cost_coverage_pct']:.0f}%</strong>cost coverage</div>
+          <div class="summary-card"><strong>{summary['time_coverage_pct']:.0f}%</strong>timing coverage</div>
         </div>
+        <p style="margin: 0.9rem 0 0 0; color: #CBD5E1; font-size: 0.95rem;">
+            Cross-benchmark ordering uses within-benchmark percentiles rather than averaging incompatible raw score scales.
+            Missing metrics remain missing and reduce coverage; they are never converted to zero.
+        </p>
+    </div>
+    """
+
+
+def build_overview_html():
+    summary = coverage_summary(PR2_DF)
+    return f"""
+    <div class="summary-cards">
+      <div class="summary-card"><strong>{summary['results']}</strong>benchmark results</div>
+      <div class="summary-card"><strong>{summary['models']}</strong>models</div>
+      <div class="summary-card"><strong>{summary['harnesses']}</strong>harnesses</div>
+      <div class="summary-card"><strong>{summary['benchmarks']}</strong>benchmarks</div>
+      <div class="summary-card"><strong>{summary['token_coverage_pct']:.0f}%</strong>token coverage</div>
+      <div class="summary-card"><strong>{summary['cost_coverage_pct']:.0f}%</strong>cost coverage</div>
+      <div class="summary-card"><strong>{summary['time_coverage_pct']:.0f}%</strong>timing coverage</div>
     </div>
     """
 
@@ -245,155 +604,452 @@ def init_benchmark_runs(dataframe):
     )
 
 
+def add_category_section(category, benchmarks):
+    if not benchmarks:
+        gr.Markdown(f"No active benchmarks are currently classified as **{category}**.")
+        return
+    gr.Markdown(
+        f"Results classified as **{category}**. Cross-benchmark ordering uses within-benchmark "
+        "percentiles and reports coverage; raw benchmark scores are not averaged together."
+    )
+    gr.Markdown("#### Trade-offs")
+    with gr.Row():
+        benchmark = gr.Dropdown(choices=benchmarks, value=benchmarks[0], label="Benchmark")
+        metric = gr.Dropdown(
+            choices=["Cost per task", "Total tokens per task", "Total time per task", "Execution error rate"],
+            value="Cost per task",
+            label="X metric",
+        )
+        color_by = gr.Radio(choices=COLOR_BY_CHOICES, value="Model", label="Color by")
+        labels = gr.Checkbox(value=False, label="Show point labels")
+        background = gr.Dropdown(
+            choices=PLOT_BACKGROUND_CHOICES, value=DEFAULT_PLOT_BACKGROUND, label="Image background"
+        )
+    plot = gr.Plot(
+        value=render_category_tradeoff(category, benchmarks[0], "Cost per task", "Model", False, "Dark"),
+        show_label=False,
+        elem_classes="responsive-plot",
+    )
+    controls = [benchmark, metric, color_by, labels, background]
+    for control in controls:
+        control.change(
+            fn=lambda b, m, c, l, bg, cat=category: render_category_tradeoff(cat, b, m, c, l, bg),
+            inputs=controls,
+            outputs=plot,
+        )
+
+    gr.Markdown("#### Matrix")
+    with gr.Row():
+        matrix_metric = gr.Dropdown(
+            choices=[
+                "Score", "Within-benchmark percentile", "Within-benchmark rank",
+                "Total tokens", "Cost", "Total time", "Agent time", "Execution error rate", "Coverage"
+            ],
+            value="Within-benchmark percentile",
+            label="Metric",
+        )
+        matrix_values = gr.Checkbox(value=True, label="Show cell values")
+        matrix_background = gr.Dropdown(
+            choices=PLOT_BACKGROUND_CHOICES, value=DEFAULT_PLOT_BACKGROUND, label="Image background"
+        )
+    matrix_plot = gr.Plot(
+        value=render_category_matrix(category, "Within-benchmark percentile", True, "Dark"),
+        show_label=False,
+        elem_classes="responsive-plot",
+    )
+    matrix_controls = [matrix_metric, matrix_values, matrix_background]
+    for control in matrix_controls:
+        control.change(
+            fn=lambda m, v, bg, cat=category: render_category_matrix(cat, m, v, bg),
+            inputs=matrix_controls,
+            outputs=matrix_plot,
+        )
+
+    gr.Markdown("#### Category ranking data")
+    gr.Dataframe(
+        value=category_leaderboard(category), interactive=False, show_label=False, max_height=TABLE_MAX_HEIGHT_PX
+    )
+
+
 demo = gr.Blocks(theme="citrus", head=FORCE_DARK_MODE_HEAD)
 with demo:
+    # Overview is deliberately always visible above the page navigation.
     gr.HTML(build_header_html(BENCHMARK_RUN_DF))
-    gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text")
 
     with gr.Tabs():
-        with gr.Tab("🏆 Leaderboard"):
-            gr.Markdown("### Benchmark scores")
+        with gr.Tab("Rankings"):
+            gr.Markdown(
+                "### Rankings\n"
+                "All ranking charts are shown on one page. Use the shared display controls below, then choose a benchmark "
+                "for each metric. Tables are capped to a scrollable height so the visualizations stay primary."
+            )
             with gr.Row():
-                leaderboard_color_by = gr.Radio(
-                    choices=COLOR_BY_CHOICES,
-                    value="Model",
-                    label="Color by",
-                    elem_classes="color-control",
-                )
-                leaderboard_palette = gr.Dropdown(
-                    choices=COLOR_PALETTE_CHOICES,
-                    value=DEFAULT_COLOR_PALETTE,
-                    label="Color palette",
-                    elem_classes="color-control",
-                )
-                leaderboard_background = gr.Dropdown(
-                    choices=PLOT_BACKGROUND_CHOICES,
-                    value=DEFAULT_PLOT_BACKGROUND,
-                    label="Image background",
-                    elem_classes="color-control",
-                )
-
-            leaderboard_plots = []
-            for benchmark_name in BENCHMARK_NAMES:
-                gr.Markdown(f"#### {benchmark_name}")
-                plot = gr.Plot(
-                    value=render_leaderboard_benchmark_plot(
-                        benchmark_name,
-                        "Model",
-                        DEFAULT_COLOR_PALETTE,
-                        DEFAULT_PLOT_BACKGROUND,
-                    ),
-                    show_label=False,
-                    elem_classes="responsive-plot",
-                )
-                leaderboard_plots.append((benchmark_name, plot))
-
-            for benchmark_name, plot in leaderboard_plots:
-                for control in (leaderboard_color_by, leaderboard_palette, leaderboard_background):
+                ranking_color = gr.Radio(choices=COLOR_BY_CHOICES, value="Model", label="Color by")
+                ranking_sort = gr.Dropdown(
+                    choices=[
+                        "Largest value first",
+                        "Lowest value first",
+                        "Alphabetical (A–Z)",
+                        "Alphabetical (Z–A)",
+                    ],
+                    value="Largest value first",
+                    label="Chart order",
+                )
+                ranking_palette = gr.Dropdown(
+                    choices=COLOR_PALETTE_CHOICES, value=DEFAULT_COLOR_PALETTE, label="Color palette"
+                )
+                ranking_background = gr.Dropdown(
+                    choices=PLOT_BACKGROUND_CHOICES, value=DEFAULT_PLOT_BACKGROUND, label="Image background"
+                )
+
+            ranking_sections = [("Score", "Score", ["All benchmarks", *BENCHMARK_NAMES], "All benchmarks")]
+            ranking_sections += [
+                ("Token usage", "Total tokens", BENCHMARK_NAMES, DEFAULT_BENCHMARK),
+                ("Cost", "Cost", BENCHMARK_NAMES, DEFAULT_BENCHMARK),
+                ("Response time", "Response time", BENCHMARK_NAMES, DEFAULT_BENCHMARK),
+                ("Reliability", "Reliability", BENCHMARK_NAMES, DEFAULT_BENCHMARK),
+                ("Tokens per successful task", "Tokens per successful task", BENCHMARK_NAMES, DEFAULT_BENCHMARK),
+                ("Cost per successful task", "Cost per successful task", BENCHMARK_NAMES, DEFAULT_BENCHMARK),
+                ("Time per successful task", "Time per successful task", BENCHMARK_NAMES, DEFAULT_BENCHMARK),
+            ]
+            shared_ranking_controls = [ranking_color, ranking_palette, ranking_background, ranking_sort]
+            for section_label, metric_name, benchmark_choices, default_benchmark in ranking_sections:
+                spec = RANKING_METRICS[metric_name]
+                gr.Markdown(f"#### {section_label}\n{spec.label}. {'Higher' if spec.higher_is_better else 'Lower'} is better.")
+                benchmark = gr.Dropdown(
+                    choices=benchmark_choices, value=default_benchmark, label="Benchmark"
+                )
+                initial = render_ranking(
+                    metric_name,
+                    default_benchmark,
+                    "Model",
+                    DEFAULT_COLOR_PALETTE,
+                    DEFAULT_PLOT_BACKGROUND,
+                    "Largest value first",
+                )
+                plot = gr.Plot(value=initial[0], show_label=False, elem_classes="responsive-plot")
+                controls = [benchmark, *shared_ranking_controls]
+                for control in controls:
                     control.change(
-                        fn=lambda color_by, palette, background, name=benchmark_name: render_leaderboard_benchmark_plot(
-                            name, color_by, palette, background
-                        ),
-                        inputs=[leaderboard_color_by, leaderboard_palette, leaderboard_background],
+                        fn=lambda b, c, p, bg, so, m=metric_name: render_ranking(m, b, c, p, bg, so)[0],
+                        inputs=controls,
                         outputs=plot,
                     )
 
-        with gr.Tab("⚡ Efficiency") as efficiency_tab:
             gr.Markdown(
-                "### Efficiency\n"
-                "Compare score with resource use within one benchmark. The x-axis can show total tokens, "
-                "cost per task, or agent execution time per task. The dashed Pareto frontier connects runs "
-                "for which no other displayed run uses an equal or lower amount of the selected resource "
-                "while achieving an equal or higher score. Tokens Per Solved Task remains in the ranking "
-                "table as a reference metric."
+                "### Ranking data\n"
+                "One table for the page, placed after all charts. It includes the score, resource, timing, "
+                "reliability, and per-success values for the selected benchmark."
             )
+            with gr.Row():
+                ranking_table_benchmark = gr.Dropdown(
+                    choices=BENCHMARK_NAMES, value=DEFAULT_BENCHMARK, label="Table benchmark"
+                )
+                ranking_table_metric = gr.Dropdown(
+                    choices=list(PAGE_TABLE_SORT_COLUMNS), value="Score", label="Sort table by"
+                )
+                ranking_table_order = gr.Dropdown(
+                    choices=[
+                        "Largest value first",
+                        "Lowest value first",
+                        "Alphabetical (A–Z)",
+                        "Alphabetical (Z–A)",
+                    ],
+                    value="Largest value first",
+                    label="Table order",
+                )
+            ranking_page_table = gr.Dataframe(
+                value=render_page_table(DEFAULT_BENCHMARK, "Score", "Largest value first"),
+                interactive=False,
+                show_label=False,
+                max_height=TABLE_MAX_HEIGHT_PX,
+            )
+            ranking_table_controls = [ranking_table_benchmark, ranking_table_metric, ranking_table_order]
+            for control in ranking_table_controls:
+                control.change(
+                    fn=render_page_table,
+                    inputs=ranking_table_controls,
+                    outputs=ranking_page_table,
+                )
+
+        with gr.Tab("Trade-offs"):
+            gr.Markdown(
+                "### Trade-offs\n"
+                "Efficiency and metric-pair views are displayed together. Pareto frontiers support both maximize and "
+                "minimize directions, so a checked frontier is shown whenever valid comparable points exist."
+            )
+            gr.Markdown("#### Efficiency")
             with gr.Row():
                 efficiency_benchmark = gr.Dropdown(
-                    choices=BENCHMARK_NAMES,
-                    value=BENCHMARK_NAMES[0] if BENCHMARK_NAMES else None,
-                    label="Benchmark",
+                    choices=BENCHMARK_NAMES, value=DEFAULT_BENCHMARK, label="Benchmark"
                 )
                 efficiency_metric = gr.Dropdown(
-                    choices=list(EFFICIENCY_RESOURCE_METRICS),
-                    value="Total tokens",
-                    label="Resource metric",
+                    choices=list(EFFICIENCY_RESOURCE_METRICS), value="Total tokens", label="Resource metric"
                 )
                 efficiency_color_by = gr.Radio(
-                    choices=EFFICIENCY_COLOR_BY_CHOICES,
-                    value="Model",
-                    label="Color by",
+                    choices=EFFICIENCY_COLOR_BY_CHOICES, value="Model", label="Color by"
                 )
                 efficiency_scale = gr.Radio(choices=["Log", "Linear"], value="Log", label="X-axis scale")
             with gr.Row():
                 efficiency_pareto = gr.Checkbox(value=True, label="Show Pareto frontier")
                 efficiency_labels = gr.Checkbox(value=False, label="Show point labels")
                 efficiency_palette = gr.Dropdown(
-                    choices=COLOR_PALETTE_CHOICES,
-                    value=DEFAULT_COLOR_PALETTE,
-                    label="Color palette",
+                    choices=COLOR_PALETTE_CHOICES, value=DEFAULT_COLOR_PALETTE, label="Color palette"
                 )
                 efficiency_background = gr.Dropdown(
-                    choices=PLOT_BACKGROUND_CHOICES,
-                    value=DEFAULT_PLOT_BACKGROUND,
-                    label="Image background",
+                    choices=PLOT_BACKGROUND_CHOICES, value=DEFAULT_PLOT_BACKGROUND, label="Image background"
                 )
-
             initial_efficiency = render_efficiency(
-                BENCHMARK_NAMES[0] if BENCHMARK_NAMES else None,
-                "Total tokens",
-                "Model",
-                "Log",
-                True,
-                False,
-                DEFAULT_COLOR_PALETTE,
-                DEFAULT_PLOT_BACKGROUND,
+                DEFAULT_BENCHMARK, "Total tokens", "Model", "Log", True, False,
+                DEFAULT_COLOR_PALETTE, DEFAULT_PLOT_BACKGROUND,
             )
-            efficiency_note = gr.Markdown(initial_efficiency[2])
+            efficiency_note = gr.Markdown(initial_efficiency[1])
             efficiency_plot = gr.Plot(
-                value=initial_efficiency[0],
-                show_label=False,
-                elem_classes="responsive-plot",
+                value=initial_efficiency[0], show_label=False, elem_classes="responsive-plot"
             )
-            gr.Markdown("#### Efficiency ranking")
-            efficiency_table = gr.Dataframe(
-                value=initial_efficiency[1],
-                interactive=False,
-                show_label=False,
-            )
-
             efficiency_controls = [
-                efficiency_benchmark,
-                efficiency_metric,
-                efficiency_color_by,
-                efficiency_scale,
-                efficiency_pareto,
-                efficiency_labels,
-                efficiency_palette,
-                efficiency_background,
+                efficiency_benchmark, efficiency_metric, efficiency_color_by, efficiency_scale,
+                efficiency_pareto, efficiency_labels, efficiency_palette, efficiency_background,
             ]
             for control in efficiency_controls:
                 control.change(
                     fn=render_efficiency,
                     inputs=efficiency_controls,
-                    outputs=[efficiency_plot, efficiency_table, efficiency_note],
+                    outputs=[efficiency_plot, efficiency_note],
                 )
 
-            # Gradio initially lays out hidden tabs without reliable dimensions. Re-render
-            # once Efficiency becomes visible so Plotly can autosize against the real
-            # container instead of keeping the hidden-tab geometry.
-            efficiency_tab.select(
-                fn=render_efficiency,
-                inputs=efficiency_controls,
-                outputs=[efficiency_plot, efficiency_table, efficiency_note],
+            gr.Markdown("#### Metric pairs")
+            with gr.Row():
+                tradeoff_pair = gr.Dropdown(
+                    choices=list(TRADEOFF_PAIRS), value="Score vs cost", label="Trade-off"
+                )
+                tradeoff_benchmark = gr.Dropdown(
+                    choices=BENCHMARK_NAMES, value=DEFAULT_BENCHMARK, label="Benchmark"
+                )
+                tradeoff_color = gr.Radio(choices=COLOR_BY_CHOICES, value="Model", label="Color by")
+                tradeoff_scale = gr.Radio(choices=["Linear", "Log"], value="Linear", label="X-axis scale")
+            with gr.Row():
+                tradeoff_labels = gr.Checkbox(value=False, label="Show point labels")
+                tradeoff_pareto = gr.Checkbox(value=True, label="Show Pareto frontier")
+                tradeoff_palette = gr.Dropdown(
+                    choices=COLOR_PALETTE_CHOICES, value=DEFAULT_COLOR_PALETTE, label="Color palette"
+                )
+                tradeoff_background = gr.Dropdown(
+                    choices=PLOT_BACKGROUND_CHOICES, value=DEFAULT_PLOT_BACKGROUND, label="Image background"
+                )
+            initial_tradeoff = render_tradeoff(
+                "Score vs cost", DEFAULT_BENCHMARK, "Model", False, "Linear", True,
+                DEFAULT_COLOR_PALETTE, DEFAULT_PLOT_BACKGROUND,
             )
+            tradeoff_note = gr.Markdown(initial_tradeoff[1])
+            tradeoff_plot = gr.Plot(
+                value=initial_tradeoff[0], show_label=False, elem_classes="responsive-plot"
+            )
+            tradeoff_controls = [
+                tradeoff_pair, tradeoff_benchmark, tradeoff_color, tradeoff_labels,
+                tradeoff_scale, tradeoff_pareto, tradeoff_palette, tradeoff_background,
+            ]
+            for control in tradeoff_controls:
+                control.change(
+                    fn=render_tradeoff,
+                    inputs=tradeoff_controls,
+                    outputs=[tradeoff_plot, tradeoff_note],
+                )
 
-        with gr.Tab("🏃 Benchmark Runs"):
-            benchmark_runs = init_benchmark_runs(BENCHMARK_RUN_DF)
+            gr.Markdown(
+                "### Trade-off data\n"
+                "A single table for this page appears after both charts and includes every metric used by the trade-off views."
+            )
+            with gr.Row():
+                tradeoff_table_benchmark = gr.Dropdown(
+                    choices=BENCHMARK_NAMES, value=DEFAULT_BENCHMARK, label="Table benchmark"
+                )
+                tradeoff_table_metric = gr.Dropdown(
+                    choices=list(PAGE_TABLE_SORT_COLUMNS), value="Score", label="Sort table by"
+                )
+                tradeoff_table_order = gr.Dropdown(
+                    choices=[
+                        "Largest value first",
+                        "Lowest value first",
+                        "Alphabetical (A–Z)",
+                        "Alphabetical (Z–A)",
+                    ],
+                    value="Largest value first",
+                    label="Table order",
+                )
+            tradeoff_page_table = gr.Dataframe(
+                value=render_page_table(DEFAULT_BENCHMARK, "Score", "Largest value first"),
+                interactive=False,
+                show_label=False,
+                max_height=TABLE_MAX_HEIGHT_PX,
+            )
+            tradeoff_table_controls = [tradeoff_table_benchmark, tradeoff_table_metric, tradeoff_table_order]
+            for control in tradeoff_table_controls:
+                control.change(
+                    fn=render_page_table,
+                    inputs=tradeoff_table_controls,
+                    outputs=tradeoff_page_table,
+                )
 
-        with gr.Tab("ℹ️ About"):
+        with gr.Tab("Matrices"):
+            gr.Markdown(
+                "### Model × benchmark matrices\n"
+                "The within-benchmark percentile controls the color scale, while cell labels show the actual benchmark "
+                "score. Missing cells stay missing."
+            )
+            with gr.Row():
+                matrix_metric = gr.Dropdown(
+                    choices=[*MATRIX_METRICS.keys(), "Coverage"],
+                    value="Within-benchmark percentile",
+                    label="Metric",
+                )
+                matrix_category = gr.Dropdown(
+                    choices=["All", "Coding", "Generalist"], value="All", label="Benchmark category"
+                )
+                matrix_sort = gr.Dropdown(
+                    choices=[
+                        "Normalized performance (high to low)",
+                        "Normalized performance (low to high)",
+                        "Coverage (high to low)",
+                        "Coverage (low to high)",
+                        "Alphabetical",
+                        "Alphabetical (Z–A)",
+                    ],
+                    value="Normalized performance (high to low)",
+                    label="Sort rows",
+                )
+                matrix_background = gr.Dropdown(
+                    choices=PLOT_BACKGROUND_CHOICES, value=DEFAULT_PLOT_BACKGROUND, label="Image background"
+                )
+            with gr.Row():
+                matrix_incomplete = gr.Checkbox(value=True, label="Include incomplete rows")
+                matrix_values = gr.Checkbox(value=True, label="Show cell values")
+                matrix_reverse = gr.Checkbox(value=False, label="Reverse color scale")
+            initial_matrix = render_matrix(
+                "Within-benchmark percentile", "All", True,
+                "Normalized performance (high to low)", True, False, "Dark"
+            )
+            matrix_plot = gr.Plot(value=initial_matrix, show_label=False, elem_classes="responsive-plot")
+            matrix_controls = [
+                matrix_metric, matrix_category, matrix_incomplete, matrix_sort,
+                matrix_values, matrix_reverse, matrix_background,
+            ]
+            for control in matrix_controls:
+                control.change(fn=render_matrix, inputs=matrix_controls, outputs=matrix_plot)
+
+
+        with gr.Tab("📊 Bradley-Terry Rankings"):
+            gr.Markdown("### Bradley-Terry Paired Comparison Rankings")
+            gr.Markdown(
+                "Rankings computed across all benchmarks using "
+                "[paired comparison methods](https://github.com/erikerlandson/paired-comparison-ranking). "
+                "Handles missing data and inconsistent orderings."
+            )
+
+            rank_csv = pd.read_csv("results.csv")
+            rank_csv = rank_csv.dropna(subset=["metrics.score"])
+            rank_model_choices = sorted(rank_csv["model.name"].unique().tolist())
+            rank_harness_choices = sorted(rank_csv["harness.name"].unique().tolist())
+            rank_benchmark_choices = sorted(rank_csv["benchmark.name"].unique().tolist())
+
+            with gr.Row():
+                rank_by = gr.Dropdown(
+                    choices=list(RANK_BY_OPTIONS.keys()),
+                    value="Benchmark Score",
+                    label="Rank by",
+                )
+                rank_oss_models = gr.Checkbox(value=False, label="Open models only")
+                rank_oss_harnesses = gr.Checkbox(value=False, label="Open harnesses only")
+
+            with gr.Row():
+                rank_benchmark_filter = gr.CheckboxGroup(
+                    choices=rank_benchmark_choices,
+                    value=rank_benchmark_choices,
+                    label="Benchmarks",
+                )
+
+            with gr.Row():
+                rank_model_filter = gr.CheckboxGroup(
+                    choices=rank_model_choices,
+                    value=rank_model_choices,
+                    label="Models",
+                )
+
+            with gr.Row():
+                rank_harness_filter = gr.CheckboxGroup(
+                    choices=rank_harness_choices,
+                    value=rank_harness_choices,
+                    label="Harnesses",
+                )
+
+            harness_df_init, model_df_init, pair_df_init = load_and_rank("results.csv")
+
+            gr.Markdown("#### Harness Rankings")
+            harness_table = gr.Dataframe(value=harness_df_init, interactive=False)
+            gr.Markdown("#### Model Rankings")
+            model_table = gr.Dataframe(value=model_df_init, interactive=False)
+            gr.Markdown("#### (Model, Harness) Rankings")
+            pair_table = gr.Dataframe(value=pair_df_init, interactive=False)
+
+            def update_rankings(rank_by_val, oss_models, oss_harnesses, benchmarks, models, harnesses):
+                return load_and_rank(
+                    "results.csv",
+                    open_models_only=oss_models,
+                    open_harnesses_only=oss_harnesses,
+                    benchmarks=benchmarks,
+                    models=models,
+                    harnesses=harnesses,
+                    rank_by=rank_by_val,
+                )
+
+            ranking_inputs = [
+                rank_by,
+                rank_oss_models,
+                rank_oss_harnesses,
+                rank_benchmark_filter,
+                rank_model_filter,
+                rank_harness_filter,
+            ]
+            for control in ranking_inputs:
+                control.change(
+                    fn=update_rankings,
+                    inputs=ranking_inputs,
+                    outputs=[harness_table, model_table, pair_table],
+                )
+
+        with gr.Tab("Coding"):
+            gr.Markdown(
+                "### Coding\n"
+                "Coding benchmarks are defined centrally in the benchmark catalog. The aggregate leaderboard uses "
+                "within-benchmark percentiles and displays benchmark coverage."
+            )
+            add_category_section("Coding", CODING_BENCHMARKS)
+
+        with gr.Tab("Generalist"):
+            gr.Markdown(
+                "### Terminal & Generalist\n"
+                "This category reflects active terminal/generalist benchmarks present in the repository."
+            )
+            add_category_section("Generalist", GENERALIST_BENCHMARKS)
+
+        with gr.Tab("Results Explorer"):
+            gr.Markdown("### Benchmark runs")
+            benchmark_runs = init_benchmark_runs(BENCHMARK_RUN_DF)
+            gr.Markdown("### Methodology")
+            gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text")
+            gr.Markdown(
+                "### Analytics methodology notes\n"
+                "- **Normalized ordering:** rank/percentile is calculated independently inside each benchmark, then "
+                "aggregated by model + harness with coverage shown beside it.\n"
+                "- **Execution error rate:** recorded errors divided by recorded task count; unresolved tasks are not "
+                "relabeled as errors.\n"
+                "- **Missing metrics:** omitted from metric-specific comparisons and preserved as missing matrix cells.\n"
+                "- **Pareto frontier:** benchmark-specific and direction-aware for maximize/minimize metric pairs."
+            )
             gr.Markdown(LLM_BENCHMARKS_TEXT, elem_classes="markdown-text")
             gr.Markdown(HOW_TO_USE_TEXT, elem_classes="markdown-text")
 
+
 scheduler = BackgroundScheduler()
 scheduler.add_job(restart_space, "interval", seconds=1800)
 scheduler.start()

requirements.txt

@@ -15,3 +15,5 @@ tqdm
 transformers
 tokenizers>=0.15.0
 sentencepiece
+choix
+scipy

src/analytics.py

@@ -0,0 +1,314 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import pandas as pd
+
+
+BENCHMARK_CATALOG: dict[str, dict[str, object]] = {
+    "SWE-Bench Verified": {
+        "category": "Coding",
+        "capabilities": ["repository-repair", "software-engineering"],
+    },
+    "SWE-Bench Pro -- Ansible": {
+        "category": "Coding",
+        "capabilities": ["repository-repair", "software-engineering", "ansible"],
+    },
+    "RH SWE-Bench": {
+        "category": "Coding",
+        "capabilities": ["repository-repair", "software-engineering"],
+    },
+    "Terminal Bench 2.0": {
+        "category": "Generalist",
+        "capabilities": ["shell", "tool-use"],
+    },
+    "Shellbench": {
+        "category": "Generalist",
+        "capabilities": ["shell", "tool-use"],
+    },
+}
+
+DEFAULT_BENCHMARK_CATEGORY = "Other"
+
+
+@dataclass(frozen=True)
+class MetricSpec:
+    column: str
+    label: str
+    higher_is_better: bool
+    positive_only: bool = False
+
+
+RANKING_METRICS: dict[str, MetricSpec] = {
+    "Score": MetricSpec("Score (%)", "Score (%)", True),
+    "Total tokens": MetricSpec("Total Tokens Per Task", "Total tokens per task", False, True),
+    "Input tokens": MetricSpec("Input Tokens Per Task", "Input tokens per task", False, True),
+    "Output tokens": MetricSpec("Output Tokens Per Task", "Output tokens per task", False, True),
+    "Cache tokens": MetricSpec("Cache Tokens Per Task", "Cache tokens per task", False, True),
+    "Cost": MetricSpec("Cost Per Task", "Cost per task (USD)", False, True),
+    "Response time": MetricSpec("Total Time Per Task", "Total time per task (seconds)", False, True),
+    "Agent time": MetricSpec("Agent Time Per Task", "Agent time per task (seconds)", False, True),
+    "Reliability": MetricSpec("Execution Error Rate (%)", "Execution error rate (%)", False),
+    "Tokens per successful task": MetricSpec("Tokens Per Successful Task", "Tokens per successful task", False, True),
+    "Cost per successful task": MetricSpec("Cost Per Successful Task", "Cost per successful task (USD)", False, True),
+    "Time per successful task": MetricSpec("Time Per Successful Task", "Time per successful task (seconds)", False, True),
+}
+
+
+TRADEOFF_METRICS: dict[str, MetricSpec] = {
+    "Score": RANKING_METRICS["Score"],
+    "Cost per task": RANKING_METRICS["Cost"],
+    "Total tokens per task": RANKING_METRICS["Total tokens"],
+    "Total time per task": RANKING_METRICS["Response time"],
+    "Agent time per task": RANKING_METRICS["Agent time"],
+    "Execution error rate": RANKING_METRICS["Reliability"],
+}
+
+
+MATRIX_METRICS: dict[str, MetricSpec] = {
+    "Score": RANKING_METRICS["Score"],
+    "Within-benchmark percentile": MetricSpec("Within-Benchmark Percentile", "Within-benchmark percentile", True),
+    "Within-benchmark rank": MetricSpec("Within-Benchmark Rank", "Within-benchmark rank", False),
+    "Total tokens": RANKING_METRICS["Total tokens"],
+    "Cost": RANKING_METRICS["Cost"],
+    "Total time": RANKING_METRICS["Response time"],
+    "Agent time": RANKING_METRICS["Agent time"],
+    "Execution error rate": RANKING_METRICS["Reliability"],
+}
+
+
+def benchmark_metadata(name: str) -> dict[str, object]:
+    metadata = BENCHMARK_CATALOG.get(name)
+    if metadata is not None:
+        return metadata
+    return {"category": DEFAULT_BENCHMARK_CATEGORY, "capabilities": []}
+
+
+def benchmark_category(name: str) -> str:
+    return str(benchmark_metadata(name)["category"])
+
+
+def benchmarks_for_category(dataframe: pd.DataFrame, category: str) -> list[str]:
+    if dataframe is None or dataframe.empty or "Benchmark" not in dataframe:
+        return []
+    names = sorted(str(value) for value in dataframe["Benchmark"].dropna().unique())
+    return [name for name in names if benchmark_category(name) == category]
+
+
+def enrich_analysis_df(dataframe: pd.DataFrame) -> pd.DataFrame:
+    """Add PR2 taxonomy, reliability, per-success and normalized performance fields."""
+    if dataframe is None:
+        return pd.DataFrame()
+    df = dataframe.copy()
+    if df.empty:
+        for column in (
+            "Benchmark Category",
+            "Execution Error Rate (%)",
+            "Tokens Per Successful Task",
+            "Cost Per Successful Task",
+            "Time Per Successful Task",
+            "Total Benchmark Cost",
+            "Within-Benchmark Rank",
+            "Within-Benchmark Percentile",
+        ):
+            if column not in df:
+                df[column] = pd.Series(dtype="float64" if column != "Benchmark Category" else "object")
+        return df
+
+    df["Benchmark Category"] = df["Benchmark"].map(lambda value: benchmark_category(str(value)))
+
+    tasks = pd.to_numeric(df.get("Tasks"), errors="coerce")
+    errors = pd.to_numeric(df.get("Errors"), errors="coerce")
+    valid_tasks = tasks.notna() & (tasks > 0)
+    df["Execution Error Rate (%)"] = (errors / tasks * 100).where(valid_tasks & errors.notna())
+
+    score_fraction = pd.to_numeric(df.get("Score"), errors="coerce")
+    successful = score_fraction.notna() & (score_fraction > 0)
+    for source, target in (
+        ("Total Tokens Per Task", "Tokens Per Successful Task"),
+        ("Cost Per Task", "Cost Per Successful Task"),
+        ("Total Time Per Task", "Time Per Successful Task"),
+    ):
+        values = pd.to_numeric(df.get(source), errors="coerce")
+        df[target] = (values / score_fraction).where(successful & values.notna() & (values > 0))
+
+    cost = pd.to_numeric(df.get("Cost Per Task"), errors="coerce")
+    df["Total Benchmark Cost"] = (cost * tasks).where(cost.notna() & (cost > 0) & valid_tasks)
+
+    scores = pd.to_numeric(df.get("Score (%)"), errors="coerce")
+    df["Within-Benchmark Rank"] = scores.groupby(df["Benchmark"]).rank(method="min", ascending=False)
+
+    def percentile(group: pd.Series) -> pd.Series:
+        valid = group.dropna()
+        out = pd.Series(index=group.index, dtype=float)
+        if valid.empty:
+            return out
+        ranks = valid.rank(method="average", ascending=False)
+        if len(valid) == 1:
+            out.loc[valid.index] = 100.0
+        else:
+            out.loc[valid.index] = 100.0 * (len(valid) - ranks) / (len(valid) - 1)
+        return out
+
+    df["Within-Benchmark Percentile"] = scores.groupby(df["Benchmark"], group_keys=False).apply(percentile)
+    return df
+
+
+def filter_category(dataframe: pd.DataFrame, category: str) -> pd.DataFrame:
+    df = enrich_analysis_df(dataframe)
+    return df[df["Benchmark Category"] == category].copy()
+
+
+def ranking_df(
+    dataframe: pd.DataFrame,
+    metric: str,
+    benchmark: str | None = None,
+    category: str | None = None,
+) -> pd.DataFrame:
+    df = enrich_analysis_df(dataframe)
+    spec = RANKING_METRICS[metric]
+    if category:
+        df = df[df["Benchmark Category"] == category]
+    if benchmark and benchmark != "All benchmarks":
+        df = df[df["Benchmark"] == benchmark]
+    elif benchmark == "All benchmarks":
+        if metric != "Score":
+            # Resource units can be compared across benchmarks, but rows remain per benchmark;
+            # do not silently aggregate them.
+            pass
+        else:
+            return cross_benchmark_ranking_df(df)
+
+    values = pd.to_numeric(df[spec.column], errors="coerce")
+    valid = values.notna()
+    if spec.positive_only:
+        valid &= values > 0
+    df = df.loc[valid].copy()
+    df[spec.column] = values.loc[valid]
+    columns = [
+        "Model", "Harness", "Benchmark", "Benchmark Category", spec.column,
+        "Score (%)", "Execution Error Rate (%)"
+    ]
+    columns = list(dict.fromkeys(column for column in columns if column in df))
+    return df.sort_values(
+        [spec.column, "Model", "Harness"],
+        ascending=[not spec.higher_is_better, True, True],
+        kind="mergesort",
+    )[columns].reset_index(drop=True)
+
+
+def cross_benchmark_ranking_df(
+    dataframe: pd.DataFrame,
+    minimum_coverage: float | int = 0.5,
+) -> pd.DataFrame:
+    """Aggregate within-benchmark percentiles without averaging incompatible raw scores."""
+    df = enrich_analysis_df(dataframe)
+    if df.empty:
+        return pd.DataFrame(columns=[
+            "Model", "Harness", "Normalized Performance", "Benchmarks Covered",
+            "Eligible Benchmarks", "Coverage (%)",
+        ])
+    eligible = int(df["Benchmark"].nunique())
+    grouped = (
+        df.dropna(subset=["Within-Benchmark Percentile"])
+        .groupby(["Model", "Harness"], as_index=False)
+        .agg(
+            **{
+                "Normalized Performance": ("Within-Benchmark Percentile", "mean"),
+                "Benchmarks Covered": ("Benchmark", "nunique"),
+            }
+        )
+    )
+    grouped["Eligible Benchmarks"] = eligible
+    grouped["Coverage (%)"] = grouped["Benchmarks Covered"] / eligible * 100 if eligible else 0.0
+
+    if isinstance(minimum_coverage, float) and minimum_coverage <= 1:
+        threshold_pct = minimum_coverage * 100
+        grouped = grouped[grouped["Coverage (%)"] >= threshold_pct]
+    else:
+        grouped = grouped[grouped["Benchmarks Covered"] >= int(minimum_coverage)]
+    return grouped.sort_values(
+        ["Normalized Performance", "Benchmarks Covered", "Model", "Harness"],
+        ascending=[False, False, True, True],
+        kind="mergesort",
+    ).reset_index(drop=True)
+
+
+def matrix_df(
+    dataframe: pd.DataFrame,
+    metric: str,
+    category: str | None = None,
+    include_incomplete: bool = True,
+    sort_by: str = "Normalized performance",
+) -> pd.DataFrame:
+    df = enrich_analysis_df(dataframe)
+    if category:
+        df = df[df["Benchmark Category"] == category]
+    if df.empty:
+        return pd.DataFrame()
+
+    df["Agent"] = df["Model"].astype(str) + " / " + df["Harness"].astype(str)
+    benchmarks = sorted(df["Benchmark"].dropna().unique())
+    agents = sorted(df["Agent"].dropna().unique())
+
+    if metric == "Coverage":
+        available = df.assign(_coverage=1).pivot_table(
+            index="Agent", columns="Benchmark", values="_coverage", aggfunc="max"
+        )
+        matrix = available.reindex(index=agents, columns=benchmarks)
+    else:
+        spec = MATRIX_METRICS[metric]
+        values = pd.to_numeric(df[spec.column], errors="coerce")
+        work = df.assign(_value=values)
+        matrix = work.pivot_table(index="Agent", columns="Benchmark", values="_value", aggfunc="mean")
+        matrix = matrix.reindex(index=agents, columns=benchmarks)
+
+    if not include_incomplete:
+        matrix = matrix.dropna(axis=0, how="any")
+
+    if matrix.empty:
+        return matrix
+
+    if sort_by in {"Coverage", "Coverage (high to low)", "Coverage (low to high)"}:
+        ascending = sort_by == "Coverage (low to high)"
+        coverage = matrix.notna().sum(axis=1)
+        order = coverage.sort_values(ascending=ascending, kind="mergesort").index
+        matrix = matrix.loc[order]
+    elif sort_by in {"Normalized performance", "Normalized performance (high to low)", "Normalized performance (low to high)"}:
+        perf = cross_benchmark_ranking_df(df, minimum_coverage=0)
+        perf["Agent"] = perf["Model"] + " / " + perf["Harness"]
+        perf = perf.sort_values(
+            ["Normalized Performance", "Agent"],
+            ascending=[sort_by == "Normalized performance (low to high)", True],
+            kind="mergesort",
+        )
+        order = [agent for agent in perf["Agent"] if agent in matrix.index]
+        order += [agent for agent in matrix.index if agent not in order]
+        matrix = matrix.loc[order]
+    elif sort_by == "Alphabetical (Z–A)":
+        matrix = matrix.loc[sorted(matrix.index, reverse=True)]
+    elif sort_by in {"Alphabetical", "Stable"}:
+        matrix = matrix.loc[sorted(matrix.index)]
+    return matrix
+
+
+def coverage_summary(dataframe: pd.DataFrame) -> dict[str, float | int]:
+    df = enrich_analysis_df(dataframe)
+    total = len(df)
+    def pct(column: str, positive: bool = False) -> float:
+        if total == 0:
+            return 0.0
+        values = pd.to_numeric(df[column], errors="coerce")
+        mask = values.notna()
+        if positive:
+            mask &= values > 0
+        return float(mask.mean() * 100)
+    return {
+        "results": total,
+        "models": int(df["Model"].nunique()) if total else 0,
+        "harnesses": int(df["Harness"].nunique()) if total else 0,
+        "benchmarks": int(df["Benchmark"].nunique()) if total else 0,
+        "token_coverage_pct": pct("Total Tokens Per Task", True),
+        "cost_coverage_pct": pct("Cost Per Task", True),
+        "time_coverage_pct": pct("Total Time Per Task", True),
+    }

src/charts.py

@@ -346,8 +346,6 @@ def create_leaderboard_benchmark_plot(
     )
     fig.update_xaxes(tickangle=-28)
     fig = apply_plot_theme(fig, background_name)
-    min_width = max(600, len(plot_df) * 80)
-    fig.update_layout(width=min_width)
     return fig
 
 
@@ -651,3 +649,262 @@ def create_token_pareto_frontier_plot(
         palette_name=palette_name,
         background_name=background_name,
     )
+
+
+def create_ranking_plot(
+    dataframe: pd.DataFrame,
+    metric_column: str,
+    metric_label: str,
+    higher_is_better: bool,
+    color_by: ColorBy = "Model",
+    palette_name: str | None = DEFAULT_PALETTE,
+    background_name: str | None = DEFAULT_BACKGROUND,
+    sort_order: str = "Largest value first",
+) -> Figure:
+    """Generic horizontal ranking chart for any numeric metric."""
+    if dataframe is None or dataframe.empty or metric_column not in dataframe:
+        return empty_figure(f"No data available for {metric_label}.", background_name)
+    plot_df = dataframe.copy()
+    plot_df[metric_column] = pd.to_numeric(plot_df[metric_column], errors="coerce")
+    plot_df = plot_df.dropna(subset=[metric_column])
+    if plot_df.empty:
+        return empty_figure(f"No data available for {metric_label}.", background_name)
+    plot_df["Agent"] = plot_df["Model"].astype(str) + " / " + plot_df["Harness"].astype(str)
+    if sort_order == "Alphabetical (A–Z)":
+        plot_df = plot_df.sort_values(["Agent", metric_column], ascending=[True, False], kind="mergesort")
+    elif sort_order == "Alphabetical (Z–A)":
+        plot_df = plot_df.sort_values(["Agent", metric_column], ascending=[False, False], kind="mergesort")
+    elif sort_order == "Lowest value first":
+        plot_df = plot_df.sort_values(
+            [metric_column, "Agent"],
+            ascending=[True, True],
+            kind="mergesort",
+        )
+    else:
+        plot_df = plot_df.sort_values(
+            [metric_column, "Agent"],
+            ascending=[False, True],
+            kind="mergesort",
+        )
+    colors = color_map_for(plot_df[color_by], color_by, palette_name)
+    theme = get_plot_background(background_name)
+    fig = go.Figure()
+    for group, group_df in plot_df.groupby(color_by, sort=True):
+        fig.add_trace(
+            go.Bar(
+                x=group_df[metric_column],
+                y=group_df["Agent"],
+                orientation="h",
+                name=str(group),
+                marker={
+                    "color": colors[str(group)],
+                    "line": {"width": 1, "color": theme["marker_line_color"]},
+                },
+                customdata=group_df[["Benchmark", "Model", "Harness"]],
+                hovertemplate=(
+                    "<b>%{customdata[1]}</b><br>"
+                    "Harness: %{customdata[2]}<br>"
+                    "Benchmark: %{customdata[0]}<br>"
+                    f"{metric_label}: %{{x:.4g}}<extra></extra>"
+                ),
+            )
+        )
+    agent_order = plot_df["Agent"].drop_duplicates().tolist()
+    fig.update_layout(
+        xaxis={"title": metric_label},
+        yaxis={
+            "title": None,
+            "autorange": "reversed",
+            "categoryorder": "array",
+            "categoryarray": agent_order,
+        },
+        legend_title_text=color_by,
+        barmode="group",
+    )
+    return apply_plot_theme(fig, background_name)
+
+
+def create_tradeoff_plot(
+    dataframe: pd.DataFrame,
+    x_column: str,
+    y_column: str,
+    x_label: str,
+    y_label: str,
+    color_by: ColorBy = "Model",
+    show_labels: bool = False,
+    palette_name: str | None = DEFAULT_PALETTE,
+    background_name: str | None = DEFAULT_BACKGROUND,
+    x_scale: Literal["Linear", "Log"] = "Linear",
+    y_scale: Literal["Linear", "Log"] = "Linear",
+    show_pareto_frontier: bool = False,
+    lower_x_is_better: bool = True,
+    higher_y_is_better: bool = True,
+) -> Figure:
+    """Generic two-metric scatter used by PR2 trade-off views."""
+    if dataframe is None or dataframe.empty:
+        return empty_figure("No trade-off data available.", background_name)
+    if x_column not in dataframe or y_column not in dataframe:
+        return empty_figure("Selected trade-off metric is unavailable.", background_name)
+    if color_by not in ("Model", "Harness") or color_by not in dataframe:
+        return empty_figure(f"Color dimension not available: {color_by}.", background_name)
+
+    plot_df = dataframe.copy()
+    plot_df[x_column] = pd.to_numeric(plot_df[x_column], errors="coerce")
+    plot_df[y_column] = pd.to_numeric(plot_df[y_column], errors="coerce")
+    plot_df = plot_df.dropna(subset=[x_column, y_column])
+    if x_scale == "Log":
+        plot_df = plot_df[plot_df[x_column] > 0]
+    if y_scale == "Log":
+        plot_df = plot_df[plot_df[y_column] > 0]
+    if plot_df.empty:
+        return empty_figure("No valid points for the selected trade-off.", background_name)
+
+    colors = color_map_for(plot_df[color_by], color_by, palette_name)
+    theme = get_plot_background(background_name)
+    fig = go.Figure()
+    for group, group_df in plot_df.groupby(color_by, sort=True):
+        label_kwargs = scatter_label_kwargs(group_df, show_labels)
+        fig.add_trace(
+            go.Scatter(
+                x=group_df[x_column],
+                y=group_df[y_column],
+                name=str(group),
+                **label_kwargs,
+                marker={
+                    "size": 13,
+                    "color": colors[str(group)],
+                    "line": {"width": 1, "color": theme["marker_line_color"]},
+                },
+                customdata=group_df[["Model", "Harness", "Benchmark"]],
+                hovertemplate=(
+                    "<b>%{customdata[0]}</b><br>"
+                    "Harness: %{customdata[1]}<br>"
+                    "Benchmark: %{customdata[2]}<br>"
+                    f"{x_label}: %{{x:.4g}}<br>"
+                    f"{y_label}: %{{y:.4g}}<extra></extra>"
+                ),
+            )
+        )
+
+    if show_pareto_frontier:
+        from src.leaderboard import get_pareto_frontier_df
+
+        frontier = get_pareto_frontier_df(
+            plot_df,
+            x_column,
+            y_column,
+            lower_x_is_better=lower_x_is_better,
+            higher_y_is_better=higher_y_is_better,
+        )
+        if not frontier.empty:
+            fig.add_trace(
+                go.Scatter(
+                    x=frontier[x_column],
+                    y=frontier[y_column],
+                    mode="lines+markers",
+                    name="Pareto frontier",
+                    line={"width": 3, "dash": "dash", "color": theme["text_primary"]},
+                    marker={"size": 9, "symbol": "diamond-open"},
+                    hovertemplate=f"{x_label}: %{{x:.4g}}<br>{y_label}: %{{y:.4g}}<extra></extra>",
+                )
+            )
+
+    fig.update_layout(
+        xaxis={"title": x_label, "type": "log" if x_scale == "Log" else "linear"},
+        yaxis={"title": y_label, "type": "log" if y_scale == "Log" else "linear"},
+        legend_title_text=color_by,
+    )
+    return apply_plot_theme(fig, background_name)
+
+
+def create_matrix_plot(
+    matrix: pd.DataFrame,
+    title: str,
+    metric_label: str,
+    higher_is_better: bool = True,
+    show_values: bool = True,
+    reverse_scale: bool | None = None,
+    background_name: str | None = DEFAULT_BACKGROUND,
+    display_matrix: pd.DataFrame | None = None,
+    display_metric_label: str | None = None,
+) -> Figure:
+    """Render a reusable model/harness × benchmark matrix."""
+    if matrix is None or matrix.empty:
+        return empty_figure(f"No data available for {title}.", background_name)
+    reverse = (not higher_is_better) if reverse_scale is None else reverse_scale
+    colorscale = "Viridis_r" if reverse else "Viridis"
+    z = matrix.to_numpy(dtype=float)
+    text = None
+    texttemplate = None
+    display_values = matrix if display_matrix is None else display_matrix.reindex(
+        index=matrix.index, columns=matrix.columns
+    )
+    display_z = display_values.to_numpy(dtype=float)
+    if show_values:
+        text = [[("" if pd.isna(value) else f"{value:.4g}") for value in row] for row in display_z]
+        texttemplate = "%{text}"
+    hover_label = display_metric_label or metric_label
+    customdata = display_z if display_matrix is not None else None
+    hovertemplate = (
+        "Agent: %{y}<br>"
+        "Benchmark: %{x}<br>"
+        + (
+            f"{hover_label}: %{{customdata:.4g}}<br>{metric_label}: %{{z:.4g}}<extra></extra>"
+            if display_matrix is not None
+            else f"{metric_label}: %{{z:.4g}}<extra></extra>"
+        )
+    )
+    fig = go.Figure(
+        go.Heatmap(
+            z=z,
+            x=[str(value) for value in matrix.columns],
+            y=[str(value) for value in matrix.index],
+            colorscale=colorscale,
+            colorbar={"title": metric_label},
+            text=text,
+            texttemplate=texttemplate,
+            customdata=customdata,
+            hovertemplate=hovertemplate,
+            hoverongaps=False,
+        )
+    )
+    fig.update_layout(
+        title=title,
+        xaxis={"title": "Benchmark"},
+        yaxis={"title": "Model / Harness", "autorange": "reversed"},
+        height=max(480, 28 * len(matrix.index) + 180),
+    )
+    return apply_plot_theme(fig, background_name)
+
+
+def create_coverage_matrix_plot(
+    matrix: pd.DataFrame,
+    background_name: str | None = DEFAULT_BACKGROUND,
+) -> Figure:
+    """Render coverage as available/missing without converting missing data to score zero."""
+    if matrix is None or matrix.empty:
+        return empty_figure("No benchmark coverage data available.", background_name)
+    display = matrix.copy()
+    z = display.notna().astype(int).to_numpy()
+    text = [["Available" if value else "Missing" for value in row] for row in z]
+    fig = go.Figure(
+        go.Heatmap(
+            z=z,
+            x=[str(value) for value in display.columns],
+            y=[str(value) for value in display.index],
+            zmin=0,
+            zmax=1,
+            colorscale=[[0, "#475569"], [1, "#84cc16"]],
+            showscale=False,
+            text=text,
+            texttemplate="%{text}",
+            hovertemplate="Agent: %{y}<br>Benchmark: %{x}<br>Status: %{text}<extra></extra>",
+        )
+    )
+    fig.update_layout(
+        title="Benchmark coverage",
+        xaxis={"title": "Benchmark"},
+        yaxis={"title": "Model / Harness", "autorange": "reversed"},
+        height=max(480, 28 * len(display.index) + 180),
+    )
+    return apply_plot_theme(fig, background_name)

src/leaderboard.py

@@ -215,44 +215,70 @@ def get_token_efficiency_table_df(
     return table_df
 
 
-def get_resource_pareto_frontier_df(
+def get_pareto_frontier_df(
     dataframe: pd.DataFrame,
-    token_metric: str,
-    score_column: str = "Score (%)",
+    x_column: str,
+    y_column: str,
+    *,
+    lower_x_is_better: bool = True,
+    higher_y_is_better: bool = True,
+    require_positive_x: bool = False,
 ) -> pd.DataFrame:
-    """Return deterministic non-dominated points for lower resource use/higher score."""
-    if token_metric not in dataframe.columns or score_column not in dataframe.columns:
+    """Return deterministic non-dominated points for arbitrary metric directions.
+
+    Ties are preserved. A row is excluded only when another row is at least as
+    good on both axes and strictly better on at least one axis.
+    """
+    if x_column not in dataframe.columns or y_column not in dataframe.columns:
         return dataframe.iloc[0:0].copy()
 
     candidates = dataframe.copy()
-    candidates[token_metric] = pd.to_numeric(candidates[token_metric], errors="coerce")
-    candidates[score_column] = pd.to_numeric(candidates[score_column], errors="coerce")
-    candidates = candidates.dropna(subset=[token_metric, score_column])
-    candidates = candidates[candidates[token_metric] > 0]
+    candidates[x_column] = pd.to_numeric(candidates[x_column], errors="coerce")
+    candidates[y_column] = pd.to_numeric(candidates[y_column], errors="coerce")
+    candidates = candidates.dropna(subset=[x_column, y_column])
+    if require_positive_x:
+        candidates = candidates[candidates[x_column] > 0]
     if candidates.empty:
         return candidates
 
-    tie_breakers = [column for column in ("Benchmark", "Model", "Harness", "Run Label") if column in candidates]
-    candidates = candidates.sort_values(
-        [token_metric, score_column, *tie_breakers],
-        ascending=[True, False, *([True] * len(tie_breakers))],
+    x = candidates[x_column]
+    y = candidates[y_column]
+    frontier_mask = pd.Series(True, index=candidates.index)
+    for idx in candidates.index:
+        x_at_idx = x.loc[idx]
+        y_at_idx = y.loc[idx]
+        x_at_least_as_good = x <= x_at_idx if lower_x_is_better else x >= x_at_idx
+        y_at_least_as_good = y >= y_at_idx if higher_y_is_better else y <= y_at_idx
+        x_strictly_better = x < x_at_idx if lower_x_is_better else x > x_at_idx
+        y_strictly_better = y > y_at_idx if higher_y_is_better else y < y_at_idx
+        dominated = x_at_least_as_good & y_at_least_as_good & (x_strictly_better | y_strictly_better)
+        dominated.loc[idx] = False
+        if dominated.any():
+            frontier_mask.loc[idx] = False
+
+    frontier = candidates.loc[frontier_mask].copy()
+    tie_breakers = [column for column in ("Benchmark", "Model", "Harness", "Run Label") if column in frontier]
+    return frontier.sort_values(
+        [x_column, y_column, *tie_breakers],
+        ascending=[lower_x_is_better, not higher_y_is_better, *([True] * len(tie_breakers))],
         kind="mergesort",
     )
 
-    frontier_indices: list[object] = []
-    best_score_at_lower_tokens = float("-inf")
-    for _, token_group in candidates.groupby(token_metric, sort=True):
-        group_best_score = float(token_group[score_column].max())
-        if group_best_score > best_score_at_lower_tokens:
-            frontier_indices.extend(token_group[token_group[score_column] == group_best_score].index.tolist())
-            best_score_at_lower_tokens = group_best_score
-
-    return candidates.loc[frontier_indices].sort_values(
-        [token_metric, score_column, *tie_breakers],
-        ascending=[True, False, *([True] * len(tie_breakers))],
-        kind="mergesort",
-    )
 
+def get_resource_pareto_frontier_df(
+    dataframe: pd.DataFrame,
+    token_metric: str,
+    score_column: str = "Score (%)",
+) -> pd.DataFrame:
+    """Return deterministic non-dominated points for lower resource use/higher score."""
+    return get_pareto_frontier_df(
+        dataframe,
+        token_metric,
+        score_column,
+        lower_x_is_better=True,
+        higher_y_is_better=True,
+        require_positive_x=True,
+    )
 
 def get_token_pareto_frontier_df(
     dataframe: pd.DataFrame,

src/rankings.py

@@ -0,0 +1,152 @@
+from typing import Any
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import choix
+
+
+def prepare_ranking_data(
+    df: pd.DataFrame,
+    catcol: str | list[str],
+    metcol: str,
+    descending: bool = False,
+    eqvcol: str | list[str] = [],
+) -> tuple[list[tuple[int, int]], list[Any], dict]:
+    ndata = df.shape[0]
+    if ndata < 2:
+        raise ValueError("Not enough data to prepare ranking comparisons")
+    catcol = catcol if isinstance(catcol, list) else [catcol]
+    eqvcol = eqvcol if isinstance(eqvcol, list) else [eqvcol]
+    ncat = len(catcol)
+    neqv = len(eqvcol)
+    tcols = catcol + eqvcol + [metcol]
+    t = list(df[tcols].itertuples(index=False, name=None))
+    metvals = [x[-1] for x in t]
+    if ncat > 1:
+        catvals = [x[:ncat] for x in t]
+    else:
+        catvals = [x[0] for x in t]
+    if neqv > 1:
+        eqvvals = [x[ncat : ncat + neqv] for x in t]
+    elif neqv == 1:
+        eqvvals = [x[ncat] for x in t]
+    else:
+        eqvvals = ["[ALL]"] * ndata
+    umap = dict([(y, x) for x, y in enumerate(sorted(set(catvals)))])
+    cats = sorted(umap.keys())
+    eqvcats = sorted(set(eqvvals))
+    eqvdata = {}
+    for eqv in eqvcats:
+        eqvdata[eqv] = [[] for _ in range(len(cats))]
+    compvals = [(umap[c], m, e) for c, m, e in zip(catvals, metvals, eqvvals)]
+    for category, metric, equivalence in compvals:
+        eqvdata[equivalence][category].append(metric)
+    comps = []
+    for i in range(ndata):
+        ic, im, ie = compvals[i]
+        for j in range(i):
+            jc, jm, je = compvals[j]
+            if ie != je:
+                continue
+            if im == jm:
+                continue
+            iwin = im < jm if descending else im > jm
+            if iwin:
+                comps.append((ic, jc))
+            else:
+                comps.append((jc, ic))
+    return comps, cats, eqvdata
+
+
+def ranking_dataframe(cats, params, eqvdata) -> pd.DataFrame:
+    ranking = np.argsort(params)[::-1]
+    rows = []
+    for rank, idx in enumerate(ranking, start=1):
+        row = {
+            "Rank": rank,
+            "Category": cats[idx] if not isinstance(cats[idx], tuple) else " + ".join(cats[idx]),
+        }
+        for k in sorted(eqvdata.keys()):
+            mets = eqvdata[k][idx]
+            row[k] = round(float(np.mean(mets)), 3) if len(mets) > 0 else None
+        rows.append(row)
+    return pd.DataFrame(rows)
+
+
+RANK_BY_OPTIONS = {
+    "Benchmark Score": ("metrics.score", False),
+    "Mean Cost Per Task (USD)": ("metrics.mean_cost_usd_per_task", True),
+    "Mean Tokens Per Task": ("metrics.mean_tokens_per_task", True),
+}
+
+
+def compute_ranking(df, catcol, metcol="metrics.score", descending=False, eqvcol="benchmark.name"):
+    comps, cats, eqvdata = prepare_ranking_data(
+        df, catcol, metcol, descending=descending, eqvcol=eqvcol
+    )
+    params = choix.ilsr_pairwise(len(cats), comps, alpha=1e-3)
+    return ranking_dataframe(cats, params, eqvdata)
+
+
+def rank_harnesses(df: pd.DataFrame, metcol="metrics.score", descending=False) -> pd.DataFrame:
+    return compute_ranking(df, "harness.name", metcol, descending)
+
+
+def rank_models(df: pd.DataFrame, metcol="metrics.score", descending=False) -> pd.DataFrame:
+    return compute_ranking(df, "model.name", metcol, descending)
+
+
+def rank_pairs(df: pd.DataFrame, metcol="metrics.score", descending=False) -> pd.DataFrame:
+    return compute_ranking(df, ["model.name", "harness.name"], metcol, descending)
+
+
+def _load_csv(csv_path: str | Path = "results.csv") -> pd.DataFrame:
+    df = pd.read_csv(csv_path)
+    df = df.dropna(subset=["metrics.score"])
+    df = df.loc[df["metrics.score"] > 0]
+    return df.reset_index(drop=True)
+
+
+def _empty_table():
+    return pd.DataFrame({"Rank": [], "Category": []})
+
+
+def load_and_rank(
+    csv_path: str | Path = "results.csv",
+    open_models_only: bool = False,
+    open_harnesses_only: bool = False,
+    benchmarks: list[str] | None = None,
+    models: list[str] | None = None,
+    harnesses: list[str] | None = None,
+    rank_by: str = "Benchmark Score",
+) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
+    df = _load_csv(csv_path)
+    if open_models_only:
+        df = df.loc[df["model.is_oss"] == True]
+    if open_harnesses_only:
+        df = df.loc[df["harness.is_oss"] == True]
+    if benchmarks is not None:
+        df = df.loc[df["benchmark.name"].isin(benchmarks)]
+    if models is not None:
+        df = df.loc[df["model.name"].isin(models)]
+    if harnesses is not None:
+        df = df.loc[df["harness.name"].isin(harnesses)]
+
+    metcol, descending = RANK_BY_OPTIONS.get(rank_by, ("metrics.score", False))
+    df = df.dropna(subset=[metcol])
+    if descending:
+        df = df.loc[df[metcol] > 0]
+    df = df.reset_index(drop=True)
+
+    if len(df) < 2:
+        empty = _empty_table()
+        return empty, empty, empty
+
+    results = []
+    for rank_fn in (rank_harnesses, rank_models, rank_pairs):
+        try:
+            results.append(rank_fn(df, metcol, descending))
+        except ValueError:
+            results.append(_empty_table())
+    return results[0], results[1], results[2]

tests/test_pr2_analytics.py

@@ -0,0 +1,205 @@
+import pandas as pd
+import plotly.graph_objects as go
+
+from src.analytics import (
+    BENCHMARK_CATALOG,
+    benchmark_category,
+    benchmarks_for_category,
+    cross_benchmark_ranking_df,
+    enrich_analysis_df,
+    filter_category,
+    matrix_df,
+    ranking_df,
+)
+from src.charts import create_coverage_matrix_plot, create_matrix_plot, create_tradeoff_plot
+
+
+def frame():
+    return pd.DataFrame(
+        [
+            {
+                "Benchmark": "SWE-Bench Verified", "Model": "a", "Harness": "h", "Run Label": "a / h",
+                "Category": "FOSS", "Score": .8, "Score (%)": 80, "Tasks": 10, "Errors": 1,
+                "Input Tokens Per Task": 50, "Cache Tokens Per Task": 10, "Output Tokens Per Task": 20,
+                "Total Tokens Per Task": 80, "Tokens Per Solved Task": 100, "Cost Per Task": .2,
+                "Total Time Per Task": 10, "Agent Time Per Task": 8, "Token Data Available": True,
+            },
+            {
+                "Benchmark": "SWE-Bench Verified", "Model": "b", "Harness": "h", "Run Label": "b / h",
+                "Category": "FOSS", "Score": .4, "Score (%)": 40, "Tasks": 10, "Errors": 2,
+                "Input Tokens Per Task": 90, "Cache Tokens Per Task": None, "Output Tokens Per Task": 30,
+                "Total Tokens Per Task": 120, "Tokens Per Solved Task": 300, "Cost Per Task": .1,
+                "Total Time Per Task": 20, "Agent Time Per Task": 15, "Token Data Available": True,
+            },
+            {
+                "Benchmark": "Terminal Bench 2.0", "Model": "a", "Harness": "h", "Run Label": "a / h",
+                "Category": "FOSS", "Score": .2, "Score (%)": 20, "Tasks": 10, "Errors": 0,
+                "Input Tokens Per Task": 30, "Cache Tokens Per Task": 5, "Output Tokens Per Task": 10,
+                "Total Tokens Per Task": 45, "Tokens Per Solved Task": 225, "Cost Per Task": .3,
+                "Total Time Per Task": 30, "Agent Time Per Task": 25, "Token Data Available": True,
+            },
+            {
+                "Benchmark": "Terminal Bench 2.0", "Model": "c", "Harness": "h", "Run Label": "c / h",
+                "Category": "FOSS", "Score": .9, "Score (%)": 90, "Tasks": 10, "Errors": None,
+                "Input Tokens Per Task": None, "Cache Tokens Per Task": None, "Output Tokens Per Task": None,
+                "Total Tokens Per Task": None, "Tokens Per Solved Task": None, "Cost Per Task": None,
+                "Total Time Per Task": None, "Agent Time Per Task": None, "Token Data Available": False,
+            },
+            {
+                "Benchmark": "New Benchmark", "Model": "z", "Harness": "h", "Run Label": "z / h",
+                "Category": "FOSS", "Score": .5, "Score (%)": 50, "Tasks": 10, "Errors": 0,
+                "Input Tokens Per Task": 1, "Cache Tokens Per Task": 1, "Output Tokens Per Task": 1,
+                "Total Tokens Per Task": 3, "Tokens Per Solved Task": 6, "Cost Per Task": .01,
+                "Total Time Per Task": 1, "Agent Time Per Task": 1, "Token Data Available": True,
+            },
+        ]
+    )
+
+
+def test_benchmark_catalog_and_unknown_fallback():
+    assert benchmark_category("SWE-Bench Verified") == "Coding"
+    assert benchmark_category("Terminal Bench 2.0") == "Generalist"
+    assert benchmark_category("Shellbench") == "Generalist"
+    assert benchmark_category("New Benchmark") == "Other"
+    assert "SWE-Bench Pro -- Ansible" in BENCHMARK_CATALOG
+
+
+def test_category_filtering_keeps_unknown_visible_as_other():
+    df = frame()
+    assert set(benchmarks_for_category(df, "Coding")) == {"SWE-Bench Verified"}
+    assert set(filter_category(df, "Generalist")["Benchmark"]) == {"Terminal Bench 2.0"}
+    assert set(filter_category(df, "Other")["Benchmark"]) == {"New Benchmark"}
+
+
+def test_derived_reliability_and_per_success_metrics():
+    df = enrich_analysis_df(frame())
+    first = df.iloc[0]
+    assert first["Execution Error Rate (%)"] == 10
+    assert first["Tokens Per Successful Task"] == 100
+    assert first["Cost Per Successful Task"] == .25
+    assert first["Time Per Successful Task"] == 12.5
+    assert pd.isna(df.loc[df["Model"].eq("c"), "Execution Error Rate (%)"]).all()
+
+
+def test_within_benchmark_percentile_and_rank():
+    df = enrich_analysis_df(frame())
+    coding = df[df["Benchmark"] == "SWE-Bench Verified"].set_index("Model")
+    assert coding.loc["a", "Within-Benchmark Rank"] == 1
+    assert coding.loc["b", "Within-Benchmark Rank"] == 2
+    assert coding.loc["a", "Within-Benchmark Percentile"] == 100
+    assert coding.loc["b", "Within-Benchmark Percentile"] == 0
+
+
+def test_cross_benchmark_ordering_uses_normalization_and_coverage_threshold():
+    df = frame()
+    ranked = cross_benchmark_ranking_df(df, minimum_coverage=0.5)
+    a = ranked[ranked["Model"] == "a"].iloc[0]
+    assert a["Benchmarks Covered"] == 2
+    assert a["Eligible Benchmarks"] == 3
+    assert a["Normalized Performance"] == 50
+    strict = cross_benchmark_ranking_df(df, minimum_coverage=1.0)
+    assert strict.empty
+
+
+def test_token_ranking_excludes_missing_and_orders_lower_first():
+    ranked = ranking_df(frame(), "Total tokens", benchmark="Terminal Bench 2.0")
+    assert ranked["Model"].tolist() == ["a"]
+
+
+def test_score_rank_and_metric_matrices_preserve_missing_cells():
+    df = frame()
+    score = matrix_df(df, "Score")
+    rank = matrix_df(df, "Within-benchmark rank")
+    cost = matrix_df(df, "Cost")
+    assert pd.isna(score.loc["b / h", "Terminal Bench 2.0"])
+    assert rank.loc["a / h", "SWE-Bench Verified"] == 1
+    assert pd.isna(cost.loc["c / h", "Terminal Bench 2.0"])
+
+
+def test_coverage_matrix_uses_missing_not_zero_score():
+    matrix = matrix_df(frame(), "Coverage")
+    assert matrix.loc["a / h", "SWE-Bench Verified"] == 1
+    assert pd.isna(matrix.loc["b / h", "Terminal Bench 2.0"])
+    figure = create_coverage_matrix_plot(matrix)
+    assert isinstance(figure, go.Figure)
+    assert "Available" in figure.data[0].text[0] or "Missing" in figure.data[0].text[0]
+
+
+def test_generic_tradeoff_and_matrix_charts_construct():
+    df = enrich_analysis_df(frame())
+    figure = create_tradeoff_plot(
+        df[df["Benchmark"] == "SWE-Bench Verified"],
+        "Total Tokens Per Task", "Score (%)",
+        "Total tokens per task", "Score (%)",
+        show_pareto_frontier=True,
+    )
+    matrix_figure = create_matrix_plot(matrix_df(df, "Score"), "Score matrix", "Score (%)")
+    assert isinstance(figure, go.Figure)
+    assert isinstance(matrix_figure, go.Figure)
+    assert any(trace.name == "Pareto frontier" for trace in figure.data)
+
+
+def test_tradeoff_pareto_supports_lower_is_better_on_both_axes():
+    df = pd.DataFrame(
+        {
+            "Model": ["a", "b", "c"],
+            "Harness": ["h", "h", "h"],
+            "Benchmark": ["bench", "bench", "bench"],
+            "Total Tokens Per Task": [100, 200, 300],
+            "Cost Per Task": [0.3, 0.2, 0.4],
+        }
+    )
+    figure = create_tradeoff_plot(
+        df,
+        "Total Tokens Per Task",
+        "Cost Per Task",
+        "Tokens",
+        "Cost",
+        show_pareto_frontier=True,
+        lower_x_is_better=True,
+        higher_y_is_better=False,
+    )
+    frontier = next(trace for trace in figure.data if trace.name == "Pareto frontier")
+    assert list(frontier.x) == [100, 200]
+    assert list(frontier.y) == [0.3, 0.2]
+
+
+def test_matrix_can_color_by_percentile_but_display_raw_values():
+    color_matrix = pd.DataFrame([[100.0, 0.0]], index=["a / h"], columns=["b1", "b2"] )
+    raw_matrix = pd.DataFrame([[82.5, 41.25]], index=["a / h"], columns=["b1", "b2"] )
+    figure = create_matrix_plot(
+        color_matrix,
+        "Score matrix",
+        "Within-benchmark percentile",
+        display_matrix=raw_matrix,
+        display_metric_label="Benchmark score (%)",
+    )
+    assert list(figure.data[0].z[0]) == [100.0, 0.0]
+    assert list(figure.data[0].text[0]) == ["82.5", "41.25"]
+    assert "Benchmark score (%)" in figure.data[0].hovertemplate
+
+
+def test_ranking_plot_order_can_be_value_or_alphabetical():
+    from src.charts import create_ranking_plot
+
+    df = pd.DataFrame(
+        {
+            "Model": ["b", "a", "c"],
+            "Harness": ["h", "h", "h"],
+            "Benchmark": ["bench", "bench", "bench"],
+            "Score (%)": [20, 10, 30],
+        }
+    )
+    largest = create_ranking_plot(
+        df, "Score (%)", "Score", True, sort_order="Largest value first"
+    )
+    lowest = create_ranking_plot(
+        df, "Score (%)", "Score", True, sort_order="Lowest value first"
+    )
+    alpha = create_ranking_plot(
+        df, "Score (%)", "Score", True, sort_order="Alphabetical (A–Z)"
+    )
+
+    assert list(largest.layout.yaxis.categoryarray) == ["c / h", "b / h", "a / h"]
+    assert list(lowest.layout.yaxis.categoryarray) == ["a / h", "b / h", "c / h"]
+    assert list(alpha.layout.yaxis.categoryarray) == ["a / h", "b / h", "c / h"]

tests/test_token_efficiency.py

@@ -75,16 +75,18 @@ def make_result(
     )
 
 
-def test_cost_vs_performance_tab_removed_without_efficiency_cost_regression():
+def test_cost_vs_performance_tab_removed_and_navigation_is_single_layer():
     app_source = Path("app.py").read_text()
 
     assert 'gr.Tab("💰 Cost vs Performance")' not in app_source
     assert "cost_benchmark" not in app_source
     assert "cost_controls" not in app_source
     assert "render_score_vs_cost_plot" not in app_source
-    assert 'with gr.Tab("⚡ Efficiency")' in app_source
-    assert app_source.index('with gr.Tab("🏆 Leaderboard")') < app_source.index('with gr.Tab("⚡ Efficiency")')
-    assert app_source.index('with gr.Tab("⚡ Efficiency")') < app_source.index('with gr.Tab("🏃 Benchmark Runs")')
+    assert 'with gr.Tab("Overview")' not in app_source
+    assert app_source.count("with gr.Tabs():") == 1
+    assert 'with gr.Tab("Rankings")' in app_source
+    assert 'with gr.Tab("Trade-offs")' in app_source
+    assert 'with gr.Tab("Matrices")' in app_source
 
 def test_analysis_df_columns_and_derived_metrics():
     dataframe = get_analysis_df(
@@ -385,9 +387,27 @@ def test_efficiency_figure_uses_responsive_autosizing_without_fixed_width():
     assert figure.layout.height is None
 
 
-def test_shared_plot_container_has_minimum_height_and_efficiency_tab_refresh():
+def test_shared_plot_container_has_minimum_height_and_scrollable_tables():
     app_source = (Path(__file__).parents[1] / "app.py").read_text()
 
     assert "RESPONSIVE_PLOT_MIN_HEIGHT_PX = 420" in app_source
     assert "min-height: {RESPONSIVE_PLOT_MIN_HEIGHT_PX}px" in app_source
-    assert "efficiency_tab.select(" in app_source
+    assert "TABLE_MAX_HEIGHT_PX = 720" in app_source
+    assert "max_height=TABLE_MAX_HEIGHT_PX" in app_source
+
+
+def test_page_tables_are_single_and_below_visualizations_and_plots_resize():
+    app_source = Path("app.py").read_text()
+
+    rankings = app_source[app_source.index('with gr.Tab("Rankings")'):app_source.index('with gr.Tab("Trade-offs")')]
+    tradeoffs = app_source[app_source.index('with gr.Tab("Trade-offs")'):app_source.index('with gr.Tab("Matrices")')]
+
+    assert rankings.count("gr.Dataframe(") == 1
+    assert tradeoffs.count("gr.Dataframe(") == 1
+    assert rankings.rindex("gr.Dataframe(") > rankings.rindex("gr.Plot(")
+    assert tradeoffs.rindex("gr.Dataframe(") > tradeoffs.rindex("gr.Plot(")
+    assert '"Largest value first"' in rankings
+    assert '"Lowest value first"' in rankings
+    assert '"Alphabetical (A–Z)"' in rankings
+    assert "ResizeObserver" in app_source
+    assert "window.Plotly.Plots.resize" in app_source