streamlit-integr

README.md

@@ -2,15 +2,14 @@
 title: GRM Leaderboard
 colorFrom: gray
 colorTo: blue
-sdk: gradio
-sdk_version: "5.23.0"
-app_file: app.py
+sdk: streamlit
+app_file: streamlit_app.py
 pinned: false
 ---
 
 # GRM Leaderboard
 
-Static Gradio Space for comparing language models on a game-focused evaluation suite.
+Static Streamlit Space for comparing language models on a game-focused evaluation suite.
 
 ## What This Project Is
 
@@ -22,29 +21,30 @@ Static Gradio Space for comparing language models on a game-focused evaluation s
 ## Runtime
 
 - Platform: Hugging Face Spaces
-- UI framework: Gradio
-- Entry point: app.py
+- UI framework: Streamlit
+- Entry point: streamlit_app.py
 - Dependencies: requirements.txt
 - Space metadata: this README frontmatter
-- app.py includes compatibility handling for both Gradio 5 and Gradio 6
 
 ## Main Page Flow
 
 Tab 1:
 - Overview
-- Leaderboard
-- Per-Benchmark Score Breakdown
-- Evaluation Suite
-- Benchmark Details
+- Leaderboard and consolidated score explorer
+- Model detail and benchmark detail panels
 
 Tab 2:
+- Benchmark Library
 - GRM-Bench authored benchmark families
 
 ## File Ownership
 
-- app.py: page layout, tabs, CSS, overview copy, table rendering, and GRM-Bench authored sections
-- benchmarks.py: benchmark registry, category assignments, descriptions, summaries, and weights
-- scores.py: per-model benchmark scores on a 0.0 to 1.0 scale
+- streamlit_app.py: page layout, tabs, controls, score explorer, and benchmark library composition
+- data_views.py: table shaping for leaderboard, benchmark matrix, model details, and benchmark library
+- ui_theme.py: Streamlit CSS, header HTML, overview copy, and theme tokens
+- app.py: previous Gradio implementation retained during transition
+- benchmarks.py: benchmark registry, category assignments, PRD metadata, descriptions, summaries, and weights
+- scores.py: per-model benchmark scores on a 0 to 100 scale
 - scoring.py: category scoring, GRM score calculation, and ranking logic
 - requirements.txt: runtime dependencies
 - README.md: Space metadata and maintainer handoff notes
@@ -52,18 +52,19 @@ Tab 2:
 ## Data Model
 
 - benchmarks.py stores BENCHMARKS as a list of dicts
-- Each benchmark entry includes: name, category, calc_weight, description, summary, paper
+- Each benchmark entry includes: id, name, category, domain, source, phase, priority, calc_weight, included_in_grm, description, summary, methodology, detection_scope, paper
 - Valid categories are ROLEPLAY, ACTIONS, and GENERAL
 - scores.py stores MODEL_SCORES keyed by model display name
-- Each model score dict is keyed by benchmark name
+- Each model score dict is keyed by benchmark id
 - Missing scores are skipped during weighted averaging
+- scores.py stores MODEL_METADATA for model family, size, precision, and open-weight visibility
 
 ## Scoring
 
 - Category score = sum(score x weight) / sum(weight)
 - GRM score = average of Roleplay, Actions, and General category scores
-- scores.py values stay on a 0.0 to 1.0 scale
-- Displayed leaderboard values are converted to 0 to 100
+- scores.py values stay on a 0 to 100 scale to match the PRD source data
+- Non-scored dimensions can appear in the Benchmark Library but are excluded from official GRM calculation
 
 ## How To Update The Site
 
@@ -79,29 +80,29 @@ Add a new benchmark:
 - Add the benchmark entry to benchmarks.py
 - Set its category and calc_weight
 - Add corresponding values in scores.py for each model you want included
+- Set included_in_grm to false for future or reference-only dimensions
 
-Update the authored GRM-Bench tab:
-- Edit GRM_BENCH_SECTIONS in app.py
+Update the authored GRM-Bench families:
+- Edit GRM_BENCH_DIMENSIONS in benchmarks.py
 
 Update page structure, copy, or styling:
-- Edit app.py
+- Edit streamlit_app.py, data_views.py, or ui_theme.py
 
 ## Local Development
 
 - Install dependencies: pip install -r requirements.txt
-- Run locally: python app.py
-- The app launches a local Gradio server using the same static content as the Space
+- Run locally: streamlit run streamlit_app.py
+- The app launches a local Streamlit server using the same static content as the Space
 
 ## Deployment Notes
 
 - The live Space deploys from the remote main branch
 - README frontmatter controls the Space runtime metadata
-- requirements.txt must match imports used by app.py
-- Current scores in scores.py are placeholder/static values unless replaced with real outputs
+- requirements.txt must match imports used by streamlit_app.py
+- Current scores in scores.py are static PRD-backed values with TBD entries represented as missing scores
 
 ## Maintenance Notes
 
-- The UI uses Python-generated HTML tables, not Gradio Dataframes
+- The UI uses Streamlit dataframes and Python-generated data views
 - Leaderboard order is recalculated on each launch from scores.py
-- Gradio theme and CSS are injected conditionally based on the installed Gradio major version
-- If page scrolling behaves oddly, inspect the root overflow and flex overrides in app.py
+- Custom CSS is injected from ui_theme.py

app.py

@@ -388,14 +388,12 @@ def build_evaluation_suite_html() -> str:
         "<table class=\"data-table evaluation-suite-table\">",
         "<colgroup>",
         '<col class="evaluation-suite-category-col">',
-        '<col class="evaluation-suite-domain-col">',
         '<col class="evaluation-suite-benchmark-col">',
         '<col class="evaluation-suite-description-col">',
         '<col class="evaluation-suite-weight-col">',
         "</colgroup>",
         "<thead><tr>",
         "<th>Category</th>",
-        "<th>Domain</th>",
         "<th>Benchmark</th>",
         "<th>Description</th>",
         '<th class="weight-column" title="Weight">Wt.</th>',
@@ -405,27 +403,12 @@ def build_evaluation_suite_html() -> str:
     for category in CATEGORIES:
         benchmarks = get_benchmarks_by_category(category)
         rowspan = len(benchmarks)
-
-        domain_rowspans: dict[int, int] = {}
-        i = 0
-        while i < len(benchmarks):
-            d = benchmarks[i]["domain"]
-            j = i
-            while j < len(benchmarks) and benchmarks[j]["domain"] == d:
-                j += 1
-            domain_rowspans[i] = j - i
-            i = j
-
         for index, benchmark in enumerate(benchmarks):
             parts.append("<tr>")
             if index == 0:
                 parts.append(
                     f'<td class="category-cell" rowspan="{rowspan}">{escape(CATEGORY_DISPLAY[category])}</td>'
                 )
-            if index in domain_rowspans:
-                parts.append(
-                    f'<td class="domain-cell" rowspan="{domain_rowspans[index]}">{escape(benchmark["domain"])}</td>'
-                )
             parts.append(f'<td class="benchmark-cell">{escape(benchmark["name"])}</td>')
             parts.append(f'<td class="description-cell">{escape(benchmark["description"])}</td>')
             parts.append(f'<td class="weight-cell">{_fmt_weight(benchmark["calc_weight"])}</td>')
@@ -452,7 +435,7 @@ def build_category_score_table_html(category: str, include_proprietary: bool = T
         row = [model]
         for benchmark_name in benchmark_names:
             score = MODEL_SCORES[model].get(benchmark_name)
-            row.append(f"{score * 100:.1f}" if score is not None else "TBD")
+            row.append(f"{score * 100:.1f}" if score is not None else "-")
         rows.append(row)
 
     return build_html_table(["Model"] + benchmark_names, rows, table_class="category-score-table")
@@ -587,214 +570,429 @@ OVERVIEW_HTML = _load_overview_html()
 
 
 CUSTOM_CSS = """
-/* ── Palette ──────────────────────────────────────────────────────────── */
 :root {
-    --bg:             #181b1e;
-    --surface:        #1d2126;
-    --surface-raised: #24282d;
-    --surface-header: #2b2f34;
-    --border:         #3c4048;
-    --border-subtle:  #313539;
-    --text:           #c8cdd2;
-    --text-bright:    #f5f7f8;
-    --text-dim:       #a2a8ae;
-    --accent:         #76b900;
-    --accent-hover:   #8fd400;
-}
-
-/* ── Page ─────────────────────────────────────────────────────────────── */
-html, body {
+    --bg-top: #202327;
+    --bg-bottom: #0f1012;
+    --surface: #15181b;
+    --surface-strong: #24282d;
+    --surface-alt: #1d2126;
+    --surface-alt-2: #262a2f;
+    --text-main: #f5f7f8;
+    --text-muted: #c1c6cb;
+    --text-soft: #a2a8ae;
+    --accent: #76b900;
+    --rule: rgba(255, 255, 255, 0.08);
+    --rule-soft: rgba(255, 255, 255, 0.05);
+}
+
+html,
+body {
     display: block !important;
     height: auto !important;
+    min-height: 100%;
+    overflow-x: hidden !important;
     overflow-y: auto !important;
+    scroll-behavior: auto !important;
+}
+
+body {
+    background: linear-gradient(180deg, var(--bg-top) 0%, var(--bg-bottom) 100%) !important;
+}
+
+.gradio-container,
+.gradio-container .main,
+.gradio-container .wrap,
+.gradio-container .contain,
+.gradio-container [role="tabpanel"] {
+    overflow: visible !important;
+    max-height: none !important;
 }
-body { background: var(--bg) !important; }
 
-/* ── Gradio container ─────────────────────────────────────────────────── */
 .gradio-container {
     max-width: 1260px !important;
     margin: 0 auto !important;
     padding: 24px 24px 48px !important;
     background: transparent !important;
-    color: var(--text) !important;
+    color: var(--text-main) !important;
     font-family: "Segoe UI", "Helvetica Neue", Arial, sans-serif !important;
 }
 
-/* ── Tabs ─────────────────────────────────────────────────────────────── */
+.page-header {
+    text-align: center;
+    margin: 4px auto 26px;
+}
+
+.page-eyebrow {
+    color: var(--text-soft);
+    text-transform: uppercase;
+    letter-spacing: 0.16em;
+    font-size: 0.76rem;
+    margin-bottom: 12px;
+}
+
+.page-header h1 {
+    color: var(--text-main);
+    font-size: 2.35rem;
+    line-height: 1.1;
+    letter-spacing: -0.02em;
+    margin: 0;
+    font-weight: 650;
+}
+
+.page-header p {
+    max-width: 860px;
+    margin: 12px auto 0;
+    color: var(--text-muted);
+    font-size: 1rem;
+    line-height: 1.65;
+}
+
 .gradio-container .tab-nav {
-    border-bottom: 1px solid var(--border) !important;
+    border-bottom: 1px solid var(--rule) !important;
     gap: 18px;
     margin: 0 0 18px 0 !important;
 }
+
 .gradio-container .tab-nav button {
     background: transparent !important;
     border: none !important;
     border-radius: 0 !important;
-    color: var(--text-dim) !important;
+    color: var(--text-soft) !important;
     font-size: 0.8rem !important;
     font-weight: 650 !important;
     letter-spacing: 0.08em !important;
+    min-width: unset !important;
     padding: 0 0 12px 0 !important;
     text-transform: uppercase !important;
 }
+
 .gradio-container .tab-nav button.selected,
 .gradio-container .tab-nav button[aria-selected="true"] {
     box-shadow: inset 0 -2px 0 var(--accent) !important;
-    color: var(--text-bright) !important;
+    color: var(--text-main) !important;
+}
+
+.gradio-container .prose {
+    color: var(--text-muted) !important;
+}
+
+.gradio-container .prose h2 {
+    color: var(--text-main) !important;
+    font-size: 1.6rem !important;
+    font-weight: 600 !important;
+    margin: 1.65rem 0 0.4rem !important;
+    letter-spacing: -0.01em;
+}
+
+.gradio-container .prose h3 {
+    color: var(--text-main) !important;
+    font-size: 1.1rem !important;
+    font-weight: 600 !important;
+    margin: 1.1rem 0 0.4rem !important;
 }
 
-/* ── Gradio Markdown / Prose ──────────────────────────────────────────── */
-.gradio-container .prose     { color: var(--text) !important; background: transparent !important; }
-.gradio-container .prose h2  { color: var(--text-bright) !important; font-size: 1.55rem !important; font-weight: 600 !important; }
-.gradio-container .prose h3  { color: var(--text-bright) !important; font-size: 1.1rem  !important; font-weight: 600 !important; }
 .gradio-container .prose p,
-.gradio-container .prose li  { color: var(--text) !important; font-size: 1.05rem !important; line-height: 1.7 !important; }
-.gradio-container .prose strong { color: var(--text-bright) !important; }
-.gradio-container .prose a   { color: var(--accent) !important; text-decoration: none !important; }
-
-/* ── Page header ──────────────────────────────────────────────────────── */
-.page-header   { text-align: center; margin: 4px auto 26px; }
-.page-eyebrow  { color: var(--text-dim); text-transform: uppercase; letter-spacing: 0.16em; font-size: 0.76rem; margin-bottom: 12px; }
-.page-header h1 { color: var(--text-bright); font-size: 2.35rem; line-height: 1.1; letter-spacing: -0.02em; margin: 0; font-weight: 650; }
-.page-header p  { max-width: 860px; margin: 12px auto 0; color: var(--text); font-size: 1rem; line-height: 1.65; }
-
-/* ── Overview copy ────────────────────────────────────────────────────── */
-.section-note      { color: var(--text-dim); font-size: 0.88rem; margin-top: 8px; }
-.longform-copy p   { color: var(--text); font-size: 1.05rem; line-height: 1.7; margin: 0 0 10px 0; }
-.formula-line      { color: var(--text-bright) !important; font-weight: 600; margin-top: 12px !important; }
-.formula-line.subdued { color: var(--text-dim) !important; font-weight: 500; }
-
-/* ── Custom HTML tables ───────────────────────────────────────────────── */
-.table-shell        { width: 100%; margin-top: 10px; }
-.table-scroll-shell { overflow-x: auto; }
-.leaderboard-shell,
-.evaluation-suite-shell { overflow-x: auto; }
-
-.data-table { width: 100%; border-collapse: collapse; }
+.gradio-container .prose li {
+    color: var(--text-muted) !important;
+    font-size: 0.98rem !important;
+    line-height: 1.65 !important;
+}
+
+.gradio-container .prose strong {
+    color: var(--text-main) !important;
+}
+
+.gradio-container .prose a,
+.benchmark-link a {
+    color: var(--accent) !important;
+    text-decoration: none !important;
+}
+
+.section-note {
+    color: var(--text-soft);
+    font-size: 0.88rem;
+    margin-top: 8px;
+}
+
+.longform-copy p {
+    color: var(--text-muted);
+    font-size: 0.98rem;
+    line-height: 1.68;
+    margin: 0 0 10px 0;
+}
+
+.formula-line {
+    color: var(--text-main) !important;
+    font-weight: 600;
+    margin-top: 12px !important;
+}
+
+.formula-line.subdued {
+    color: var(--text-soft) !important;
+    font-weight: 500;
+    margin-top: -1px !important;
+}
+
+.table-shell {
+    width: 100%;
+    margin-top: 10px;
+}
+
+.table-scroll-shell {
+    overflow-x: auto;
+    overflow-y: visible;
+}
+
+.evaluation-suite-shell {
+    overflow: visible;
+}
+
+.leaderboard-shell {
+    overflow: visible;
+}
+
+.data-table {
+    width: 100%;
+    border-collapse: collapse;
+    border-spacing: 0;
+}
 
 .data-table thead th {
-    background: var(--surface-header);
-    color: var(--text-dim);
+    background: #2b2f34;
+    color: #d2d7dc;
     font-size: 0.8rem;
     font-weight: 650;
     text-transform: uppercase;
     letter-spacing: 0.04em;
     text-align: left;
     padding: 11px 12px;
-    border: 1px solid var(--border);
 }
-.data-table thead th + th { border-left: 1px solid var(--border); }
 
-.data-table tbody tr:nth-child(odd)  td { background: var(--surface); }
-.data-table tbody tr:nth-child(even) td { background: var(--surface-raised); }
-.data-table tbody tr:hover           td { background: #30353a; }
+.data-table tbody tr:nth-child(odd) td {
+    background: #1c2024;
+}
+
+.data-table tbody tr:nth-child(even) td {
+    background: #24282d;
+}
 
 .data-table td {
-    color: var(--text);
+    color: var(--text-main);
     font-size: 0.94rem;
     line-height: 1.45;
     padding: 10px 12px;
     vertical-align: top;
-    border: 1px solid var(--border-subtle);
 }
 
-/* Rank-1 row highlight */
-# .leaderboard-table tbody tr:first-child td { background: #252d1d; }
+.evaluation-suite-table thead th {
+    padding: 9px 11px;
+    font-size: 0.78rem;
+}
 
-/* Evaluation suite overrides */
-.evaluation-suite-table { table-layout: fixed; }
-.evaluation-suite-table thead th { padding: 9px 11px; font-size: 0.78rem; }
-.evaluation-suite-table td       { padding: 7px 11px; font-size: 0.9rem; line-height: 1.3; }
+.evaluation-suite-table {
+    table-layout: fixed;
+}
 
-.evaluation-suite-category-col  { width: 8rem; }
-.evaluation-suite-domain-col    { width: 11rem; }
-.evaluation-suite-benchmark-col { width: 12.5rem; }
-.evaluation-suite-weight-col    { width: 5ch; }
+.evaluation-suite-table td {
+    padding: 7px 11px;
+    font-size: 0.9rem;
+    line-height: 1.3;
+}
+
+.evaluation-suite-category-col {
+    width: 8rem;
+}
+
+.evaluation-suite-benchmark-col {
+    width: 12.5rem;
+}
+
+.evaluation-suite-weight-col {
+    width: 5ch;
+}
 
 .evaluation-suite-table .weight-column,
 .evaluation-suite-table .weight-cell {
     font-variant-numeric: tabular-nums;
+    max-width: 5ch;
+    min-width: 5ch;
     text-align: center;
     white-space: nowrap;
     width: 5ch;
-    padding: 0 4px;
+    padding-left: 4px;
+    padding-right: 4px;
 }
+
 .evaluation-suite-table .category-cell {
-    color: var(--text-dim);
+    color: var(--text-soft);
     font-size: 0.79rem;
     font-weight: 650;
     text-transform: uppercase;
     letter-spacing: 0.06em;
-    vertical-align: middle;
+    vertical-align: top;
     min-width: 8rem;
-    background: var(--surface) !important;
 }
-.evaluation-suite-table .domain-cell {
-    color: var(--text-dim);
-    font-size: 0.82rem;
-    vertical-align: middle;
+
+.evaluation-suite-table .benchmark-cell,
+.evaluation-suite-table .description-cell {
     overflow-wrap: anywhere;
-    background: var(--surface) !important;
+    word-break: normal;
 }
-.evaluation-suite-table .benchmark-cell { width: 12.5rem; overflow-wrap: anywhere; }
-.evaluation-suite-table .description-cell { min-width: 0; overflow-wrap: anywhere; }
 
-.grm-bench-scope-table th:first-child,
-.grm-bench-scope-table td:first-child { min-width: 180px; width: 180px; }
+.evaluation-suite-table .benchmark-cell {
+    width: 12.5rem;
+}
+
+.evaluation-suite-table .description-cell {
+    min-width: 0;
+}
 
-/* ── Accordion ────────────────────────────────────────────────────────── */
-/* Gradio 4: .gradio-accordion  |  Gradio 5: details */
-.gradio-container .gradio-accordion,
-.gradio-container details {
+.leaderboard-table tbody tr:first-child td {
+    background: #252d1d;
+}
+
+.data-table tbody tr:hover td {
+    background: #30353a;
+}
+
+.gradio-accordion {
     background: transparent !important;
-    border: 1px solid var(--border) !important;
-    border-radius: 8px !important;
+    border: none !important;
+    box-shadow: none !important;
     margin-bottom: 6px !important;
-    overflow: hidden !important;
 }
-.gradio-container .gradio-accordion > .label-wrap,
-.gradio-container details > summary {
-    background: var(--surface-raised) !important;
-    color: var(--text-bright) !important;
+
+.gradio-accordion > .label-wrap {
+    background: #23272c !important;
+    color: var(--text-main) !important;
     border: none !important;
+    border-radius: 8px !important;
     padding: 0.75rem 0.9rem !important;
-    cursor: pointer;
+}
+
+.gradio-accordion > .label-wrap:hover {
+    background: #2a2f34 !important;
+}
+
+.benchmark-section {
+    margin-top: 18px;
+}
+
+.benchmark-section h3 {
+    color: var(--text-main);
+    font-size: 1.15rem;
     font-weight: 600;
-    font-size: 0.92rem;
-    list-style: none;
-}
-.gradio-container .gradio-accordion > .label-wrap:hover,
-.gradio-container details > summary:hover { background: #2a2f34 !important; }
-.gradio-container details[open] > summary  { border-bottom: 1px solid var(--border) !important; }
-.gradio-container details > summary::-webkit-details-marker { display: none; }
-
-/* ── Benchmark details ────────────────────────────────────────────────── */
-.benchmark-section   { margin-top: 18px; }
-.benchmark-section h3 { color: var(--text-bright); font-size: 1.15rem; font-weight: 600; margin: 0 0 8px 0; }
-.benchmark-entry     { padding: 12px 0; border-bottom: 1px solid var(--border-subtle); }
-.benchmark-entry-top { display: flex; align-items: baseline; justify-content: space-between; gap: 12px; flex-wrap: wrap; }
-.benchmark-entry-top h4  { margin: 0; color: var(--text-bright); font-size: 1rem; font-weight: 600; }
-.benchmark-weight        { color: var(--accent); font-size: 0.84rem; white-space: nowrap; }
-.benchmark-description   { color: var(--text-dim); margin: 6px 0 !important; }
-.benchmark-entry p       { color: var(--text); line-height: 1.62; margin: 0; }
-.benchmark-link          { margin-top: 7px; font-size: 0.86rem; }
-.benchmark-link a        { color: var(--accent); text-decoration: none; }
-
-/* ── GRM-Bench sections ───────────────────────────────────────────────── */
-.grm-bench-section          { border-top: 1px solid var(--border-subtle); margin-top: 24px; padding-top: 18px; }
-.grm-bench-section:first-of-type { margin-top: 16px; }
+    margin: 0 0 8px 0;
+}
+
+.benchmark-entry {
+    padding: 12px 0;
+    border-bottom: 1px solid var(--rule-soft);
+}
+
+.benchmark-entry-top {
+    display: flex;
+    align-items: baseline;
+    justify-content: space-between;
+    gap: 12px;
+    flex-wrap: wrap;
+}
+
+.benchmark-entry-top h4 {
+    margin: 0;
+    color: var(--text-main);
+    font-size: 1rem;
+    font-weight: 600;
+}
+
+.benchmark-weight {
+    color: var(--accent);
+    font-size: 0.84rem;
+    white-space: nowrap;
+}
+
+.benchmark-description {
+    color: var(--text-soft) !important;
+    margin: 6px 0 6px 0 !important;
+}
+
+.benchmark-entry p {
+    color: var(--text-muted);
+    line-height: 1.62;
+    margin: 0;
+}
+
+.benchmark-link {
+    margin-top: 7px;
+    font-size: 0.86rem;
+}
+
+.grm-bench-section {
+    border-top: 1px solid var(--rule-soft);
+    margin-top: 24px;
+    padding-top: 18px;
+}
+
+.grm-bench-section:first-of-type {
+    margin-top: 16px;
+}
+
 .grm-bench-kicker,
-.grm-bench-subtitle         { color: var(--text-dim); font-size: 0.78rem; font-weight: 650; letter-spacing: 0.08em; text-transform: uppercase; }
-.grm-bench-section h2       { color: var(--text-bright); font-size: 1.32rem; font-weight: 620; letter-spacing: -0.01em; margin: 4px 0 10px 0; }
-.grm-bench-section p        { color: var(--text); font-size: 1.05rem; line-height: 1.7; margin: 0 0 10px 0; }
-.grm-bench-subtitle         { margin: 14px 0 6px 0; }
-.grm-bench-sample           { background: #171b1f; border: 1px solid var(--border); border-radius: 10px; margin-top: 12px; padding: 14px 16px; }
-.grm-bench-sample-id        { color: var(--text-bright); font-size: 0.84rem; font-weight: 700; letter-spacing: 0.08em; text-transform: uppercase; }
-.grm-bench-sample-meta      { margin: 6px 0 0 0 !important; }
-.grm-bench-sample-label     { color: var(--text-bright); font-weight: 600; }
+.grm-bench-subtitle {
+    color: var(--text-soft);
+    font-size: 0.78rem;
+    font-weight: 650;
+    letter-spacing: 0.08em;
+    text-transform: uppercase;
+}
+
+.grm-bench-section h2 {
+    color: var(--text-main);
+    font-size: 1.32rem;
+    font-weight: 620;
+    letter-spacing: -0.01em;
+    margin: 4px 0 10px 0;
+}
+
+.grm-bench-section p {
+    color: var(--text-muted);
+    font-size: 0.97rem;
+    line-height: 1.66;
+    margin: 0 0 10px 0;
+}
+
+.grm-bench-subtitle {
+    margin: 14px 0 6px 0;
+}
+
+.grm-bench-sample {
+    background: #171b1f;
+    border: 1px solid var(--rule);
+    border-radius: 10px;
+    margin-top: 12px;
+    padding: 14px 16px;
+}
+
+.grm-bench-sample-id {
+    color: var(--text-main);
+    font-size: 0.84rem;
+    font-weight: 700;
+    letter-spacing: 0.08em;
+    text-transform: uppercase;
+}
+
+.grm-bench-sample-meta {
+    margin: 6px 0 0 0 !important;
+}
+
+.grm-bench-sample-label {
+    color: var(--text-main);
+    font-weight: 600;
+}
+
 .grm-bench-sample-code {
     background: #0f1215;
-    border: 1px solid var(--border-subtle);
+    border: 1px solid var(--rule-soft);
     border-radius: 8px;
     color: #d7dde3;
     font-family: Consolas, "SFMono-Regular", monospace;
@@ -805,96 +1003,51 @@ body { background: var(--bg) !important; }
     padding: 12px 14px;
     white-space: pre-wrap;
 }
-.grm-bench-sample-code code { font-family: inherit; }
 
-/* ── Scrollbars ───────────────────────────────────────────────────────── */
-::-webkit-scrollbar       { width: 6px; height: 6px; }
-::-webkit-scrollbar-track { background: var(--bg); }
-::-webkit-scrollbar-thumb { background: #3a3f45; border-radius: 3px; }
-::-webkit-scrollbar-thumb:hover { background: var(--accent); }
+.grm-bench-sample-code code {
+    font-family: inherit;
+}
+
+.grm-bench-scope-table th:first-child,
+.grm-bench-scope-table td:first-child {
+    min-width: 180px;
+    width: 180px;
+}
 
-/* ── Responsive ───────────────────────────────────────────────────────── */
 @media (max-width: 720px) {
-    .gradio-container { padding: 20px 14px 40px !important; }
-    .page-header h1   { font-size: 2rem; }
+    .gradio-container {
+        padding: 20px 14px 40px !important;
+    }
+
+    .page-header h1 {
+        font-size: 2rem;
+    }
+
     .data-table thead th,
-    .data-table td    { padding: 10px 9px; }
-    .leaderboard-shell,
-    .evaluation-suite-shell { overflow-x: auto; }
-    .evaluation-suite-table { min-width: 38rem; }
-}
+    .data-table td {
+        padding: 10px 9px;
+    }
 
-.red-text { color: red !important; }
-"""
+    .leaderboard-shell {
+        overflow-x: auto;
+        overflow-y: visible;
+    }
 
+    .evaluation-suite-shell {
+        overflow-x: auto;
+        overflow-y: visible;
+    }
+
+    .evaluation-suite-table {
+        min-width: 38rem;
+    }
+}
+"""
 
-_NVIDIA_DARK_THEME = gr.themes.Base().set(
-    # Page
-    body_background_fill="#181b1e",
-    body_text_color="#f5f7f8",
-    body_text_color_subdued="#a2a8ae",
-    # Blocks / panels
-    background_fill_primary="#1d2126",
-    background_fill_secondary="#15181b",
-    block_background_fill="#1d2126",
-    block_border_color="#3c4048",
-    block_border_width="1px",
-    block_label_background_fill="#23272c",
-    block_label_border_color="#3c4048",
-    block_label_text_color="#f5f7f8",
-    block_title_background_fill="transparent",
-    block_title_text_color="#f5f7f8",
-    block_info_text_color="#a2a8ae",
-    panel_background_fill="#1d2126",
-    panel_border_color="#3c4048",
-    # Inputs
-    input_background_fill="#24282d",
-    input_background_fill_focus="#2b2f34",
-    input_border_color="#3c4048",
-    input_border_color_focus="#76b900",
-    input_placeholder_color="#6b7280",
-    input_shadow="none",
-    input_shadow_focus="0 0 0 2px rgba(118,185,0,0.25)",
-    # Buttons
-    button_primary_background_fill="#76b900",
-    button_primary_background_fill_hover="#8fd400",
-    button_primary_border_color="transparent",
-    button_primary_text_color="#0f1012",
-    button_secondary_background_fill="#24282d",
-    button_secondary_background_fill_hover="#2b2f34",
-    button_secondary_border_color="#3c4048",
-    button_secondary_text_color="#f5f7f8",
-    # Borders / accent
-    border_color_accent="#76b900",
-    border_color_primary="#3c4048",
-    color_accent="#76b900",
-    link_text_color="#76b900",
-    link_text_color_hover="#8fd400",
-    link_text_color_visited="#5a9000",
-    # Table
-    table_even_background_fill="#1c2024",
-    table_odd_background_fill="#24282d",
-    table_row_focus="#30353a",
-    # Checkbox / radio
-    checkbox_background_color="#24282d",
-    checkbox_background_color_selected="#76b900",
-    checkbox_background_color_hover="#2b2f34",
-    checkbox_border_color="#3c4048",
-    checkbox_border_color_focus="#76b900",
-    checkbox_border_color_selected="#76b900",
-    checkbox_label_background_fill="transparent",
-    checkbox_label_background_fill_selected="rgba(118,185,0,0.12)",
-    checkbox_label_text_color="#f5f7f8",
-    # Slider
-    slider_color="#76b900",
-    # Shadows
-    shadow_drop="0 2px 8px rgba(0,0,0,0.45)",
-    shadow_drop_lg="0 4px 20px rgba(0,0,0,0.6)",
-)
 
 blocks_kwargs = {"title": "GRM Score - Game Ready Leaderboard"}
 if GRADIO_MAJOR_VERSION < 6:
-    blocks_kwargs["theme"] = _NVIDIA_DARK_THEME
+    blocks_kwargs["theme"] = gr.themes.Base()
     blocks_kwargs["css"] = CUSTOM_CSS
 
 
@@ -908,13 +1061,14 @@ with gr.Blocks(**blocks_kwargs) as demo:
 
             gr.Markdown("## Leaderboard")
             gr.Markdown(
-                "The leaderboard now sits directly after the overview so rankings are visible before the deeper methodology sections.", elem_classes=["red-text"]
+                "The leaderboard now sits directly after the overview so rankings are visible before the deeper methodology sections."
             )
             show_proprietary_models = gr.Checkbox(label="Show proprietary models", value=True)
             gr.HTML(
                 "<div class=\"section-note\">Turn this off to switch the ranking and score breakdowns to an open-source-only view.</div>"
             )
             leaderboard_html = gr.HTML(build_leaderboard_html())
+            gr.HTML("<div class=\"section-note\">Placeholder data for layout validation. Replace with real benchmark outputs when ready.</div>")
 
             gr.Markdown("## Per-Benchmark Score Breakdown")
             gr.Markdown("Expand a category to inspect the individual benchmark scores backing the leaderboard.")
@@ -952,6 +1106,6 @@ with gr.Blocks(**blocks_kwargs) as demo:
 if __name__ == "__main__":
     launch_kwargs = {}
     if GRADIO_MAJOR_VERSION >= 6:
-        launch_kwargs["theme"] = _NVIDIA_DARK_THEME
+        launch_kwargs["theme"] = gr.themes.Base()
         launch_kwargs["css"] = CUSTOM_CSS
     demo.launch(**launch_kwargs)

benchmarks.py

@@ -1,383 +1,735 @@
-"""
-GRM Evaluation Suite — Benchmark Registry
+"""GRM Evaluation Suite benchmark registry.
 
-Each benchmark is defined with:
-  - name: Display name
-  - category: ROLEPLAY | ACTIONS | GENERAL
-  - domain: Sub-category within the category (e.g. "Input resilience")
-  - description: Short description of what the benchmark tests
-  - calc_weight: 1.0 (P0/core), 0.5 (P1/supplementary), or 0.25 (P2/common-sense)
-  - summary: Multi-sentence methodology summary for display
-  - paper: URL to the paper or resource (if applicable)
+Benchmark scores are grouped into three equally weighted categories:
+Roleplay, Actions, and General. Individual benchmarks carry PRD-derived
+priority/source/domain metadata for filtering and methodology display.
 """
 
-BENCHMARKS = [
-    # ── ROLEPLAY (33%) ──────────────────────────────────────────────
-    # Domain: Conversational breadth/coherence
+CATEGORIES = ["ROLEPLAY", "ACTIONS", "GENERAL"]
+CATEGORY_WEIGHT = 1 / 3
+
+CATEGORY_DISPLAY = {
+    "ROLEPLAY": "Roleplay",
+    "ACTIONS": "Actions",
+    "GENERAL": "General",
+}
+
+SOURCE_EXTERNAL = "External"
+SOURCE_GRM_BENCH = "GRM-Bench"
+
+
+def _scope(*items: tuple[str, str]) -> list[dict[str, str]]:
+    return [{"category": category, "description": description} for category, description in items]
+
+
+BENCHMARKS: list[dict] = [
     {
+        "id": "multichallenge",
         "name": "MultiChallenge",
         "category": "ROLEPLAY",
         "domain": "Conversational breadth/coherence",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P0",
         "calc_weight": 1.0,
-        "description": "Multi-turn instruction following & coherence across turns",
+        "included_in_grm": True,
+        "description": "Multi-turn instruction following and coherence across turns.",
         "summary": (
-            "MultiChallenge evaluates multi-turn instruction following where models must "
-            "maintain coherence across multiple challenging conversational turns. Each test "
-            "scenario involves complex, multi-constraint instructions that require the model "
-            "to track context, resolve references, and keep all prior commitments intact while "
-            "handling new user requests."
+            "MultiChallenge evaluates multi-turn instruction following where models must maintain coherence "
+            "across challenging conversational turns, track context, resolve references, and keep prior "
+            "commitments intact while handling new user requests."
         ),
-        "paper": None,
+        "methodology": "External benchmark score imported into the Roleplay category as a core signal.",
+        "detection_scope": [],
+                "paper": None,
+                "samples": [
+                        {
+                                "id": "TEST_001",
+                                "metadata": [
+                                        ["Tag(s)", "Role Confusion"],
+                                        [
+                                                "Summary",
+                                                "Tests identity confusion between two companions with opposite elemental specialties across 9 rounds of dialogue with heavy noun saturation. Kael (fire mage, Cinderforge Academy, Emberchill Ring) and Lyra (ice mage, Glacial Sanctum, Frostbane Amulet). The final user message deliberately misattributes all key facts. Model must correct every error without confusing the details itself.",
+                                        ],
+                                        [
+                                                "Expectation",
+                                                "Must correct all misattributions: Kael=Cinderforge (not Glacial Sanctum), Lyra=Glacial Sanctum (not Cinderforge), Kael wears Emberchill Ring (ice resist), Lyra wears Frostbane Amulet (fire resist).",
+                                        ],
+                                ],
+                                "code": """[
+    {
+        "role": "system",
+        "content": "You are Kael Emberheart, a fire mage and combat specialist who serves as one of the player's two companions in the Shadowveil Dungeon. You are accompanied by Lyra Frostweaver, an ice mage and defensive specialist.\n\nYOUR IDENTITY - KAEL EMBERHEART:\n- Class: Fire Mage..."
+    },
+    {
+        "role": "user",
+        "content": "Kael, quick question - what element do you specialize in? And what's your companion Lyra's element?"
+    },
+    {
+        "role": "assistant",
+        "content": "Ha! Fire, obviously - I'm Kael Emberheart, pyromancer supreme! Lyra's the frost mage. She handles the cold stuff, I bring the heat."
+    },
+    {
+        "role": "user",
+        "content": "There's an ice wraith ahead. Who's better suited to fight it - you or Lyra?"
+    },
+    ... (8x turns),
+    {
+        "role": "assistant",
+        "content": "The Convergence Blast! I launch a concentrated fireball and Lyra intercepts it mid-flight with a frost bolt. Extreme heat meets extreme cold - massive steam explosion that devastates everything in the blast zone. I bring the fire, she brings the ice, and the result is pure chaos. One of my favorite moves."
     },
     {
+        "role": "user",
+        "content": "Okay, one last thing before we push into the Embervault. I want to make sure I've got everyone straight. You're the one who trained at the Glacial Sanctum, right? And Lyra graduated from Cinderforge Academy? Also remind me - you're wearing the Frostbane Amulet for the fire resistance, and Lyra has the Emberchill Ring?"
+    }
+]""",
+                        },
+                        {
+                                "id": "TEST_021",
+                                "metadata": [
+                                        [
+                                                "Summary",
+                                                "Tests whether the model invents contents of an unread document. Eleanor found a sealed letter with an unbroken wax seal. She explicitly confirmed she has NOT opened or read it. The inspector pressures her to state exactly what it says. Model must refuse to fabricate contents.",
+                                        ],
+                                        ["Tag(s)", "Knowledge Boundary"],
+                                        [
+                                                "Expectation",
+                                                "Must NOT claim to know the letter's contents; should restate the seal is unbroken and she has not read it.",
+                                        ],
+                                ],
+                                "code": """[
+    {
+        "role": "system",
+        "content": "You are Eleanor Vale, lady's maid in a gothic mystery set at Blackthorne Manor.\n\n# PERSONALITY\n- Composed, discreet, observant\n- Speaks carefully and avoids exaggeration\n\n# CURRENT FACTS\n- You found a sealed letter on the late master's desk..."
+    },
+    {
+        "role": "user",
+        "content": "What did you find in the study?"
+    },
+    {
+        "role": "assistant",
+        "content": "A sealed letter addressed to Lady Whitcomb. The wax is intact, so I have not read what is inside."
+    },
+    {
+        "role": "user",
+        "content": "Can you tell whether it's important?"
+    },
+    {
+        "role": "assistant",
+        "content": "Only that it was hidden carefully, which suggests it may matter. But that is only an inference. I do not know its contents."
+    },
+    {
+        "role": "user",
+        "content": "The inspector is impatient. Tell him exactly what the letter says."
+    }
+]""",
+                        },
+                ],
+    },
+    {
+        "id": "rolebench",
         "name": "RoleBench",
         "category": "ROLEPLAY",
         "domain": "Conversational breadth/coherence",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P1",
         "calc_weight": 0.5,
-        "description": "Character-level roleplaying with explicit role framing",
+        "included_in_grm": True,
+        "description": "Character-level roleplaying with explicit role framing.",
         "summary": (
-            "RoleBench is the first systematic and fine-grained character-level benchmark "
-            "for role-playing, comprising 168,093 samples covering 100 distinct roles. "
-            "Created via the RoleLLM framework using Context-Instruct for role-specific "
-            "knowledge extraction and RoleGPT for speaking style imitation. Evaluates a "
-            "model's ability to maintain character persona, domain knowledge, and consistent "
-            "speaking style throughout interactions."
+            "RoleBench is a fine-grained character-level benchmark for role-playing. It tests whether a model "
+            "can maintain persona, domain knowledge, and speaking style throughout interactions."
         ),
+        "methodology": "External benchmark score imported as a supplementary Roleplay signal.",
+        "detection_scope": [],
         "paper": "https://arxiv.org/abs/2310.00746",
     },
     {
+        "id": "rolemrc",
         "name": "RoleMRC",
         "category": "ROLEPLAY",
         "domain": "Conversational breadth/coherence",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P0",
         "calc_weight": 1.0,
-        "description": "Follow complex nested instructions while remaining in character",
+        "included_in_grm": True,
+        "description": "Follow complex nested instructions while remaining in character.",
         "summary": (
-            "Role-based Machine Reading Comprehension benchmark that tests the ability to "
-            "follow complex, nested instructions while remaining fully in character. Combines "
-            "reading comprehension challenges with role-playing constraints, requiring models "
+            "RoleMRC combines reading-comprehension challenges with role-playing constraints, requiring models "
             "to extract and reason about information without breaking persona."
         ),
+        "methodology": "External benchmark score imported into the Roleplay category as a core signal.",
+        "detection_scope": [],
         "paper": None,
     },
     {
-        "name": "EQBench v3",
+        "id": "eq_bench_v3",
+        "name": "EQ-Bench v3",
         "category": "ROLEPLAY",
         "domain": "Conversational breadth/coherence",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P1",
         "calc_weight": 0.5,
-        "description": "Detect nuances in tone/intent and modulate response accordingly",
+        "included_in_grm": True,
+        "description": "Detect nuances in tone and intent, then modulate response accordingly.",
         "summary": (
-            "Emotional Quotient Benchmark v3 assesses a model's emotional intelligence — "
-            "specifically the ability to detect nuances in tone, intent, and emotional subtext, "
-            "and to modulate responses accordingly. Tests include recognizing sarcasm, empathy "
-            "calibration, emotional escalation/de-escalation, and context-appropriate tonal "
-            "shifts."
+            "EQ-Bench v3 assesses emotional intelligence signals such as intent recognition, empathy calibration, "
+            "and context-appropriate tonal shifts."
         ),
+        "methodology": "External benchmark score imported as a supplementary Roleplay signal.",
+        "detection_scope": [],
         "paper": "https://eqbench.com/",
     },
     {
+        "id": "grm_coherence",
         "name": "GRM - Coherence",
         "category": "ROLEPLAY",
         "domain": "Conversational breadth/coherence",
-        "calc_weight": 1.0,
-        "description": "Logically sound and coherent across turns, without contradictions",
+        "source": SOURCE_GRM_BENCH,
+        "phase": "Phase 1",
+        "priority": "P1",
+        "calc_weight": 0.5,
+        "included_in_grm": True,
+        "description": "Logically sound and coherent across turns without contradictions.",
         "summary": (
-            "Nvidia-authored benchmark testing resistance to incoherence in gaming dialogue. "
-            "Scenarios are crafted to invoke common coherence failures, then a model's "
-            "resilience is measured. Detection covers eight categories: factual/logical errors, "
-            "cause-effect failures, self-contradiction, personality/background violations, "
-            "role confusion, irrelevance, knowledge boundary violations, and false premise "
-            "acceptance."
+            "Nvidia-authored scenarios test resistance to incoherence in game dialogue. Incoherence can surface "
+            "as hallucinated details, role confusion, contradictions, irrelevance, or failure to respect what the "
+            "character can know."
+        ),
+        "methodology": (
+            "Scenarios are crafted to invoke common coherence failures, then measure whether the model stays "
+            "grounded under pressure."
+        ),
+        "detection_scope": _scope(
+            ("Factual / Logical", "Objectively false or contradicted by the system prompt or game state."),
+            ("Cause / Effect", "Fails simple logical state transitions or obvious state changes."),
+            ("Contradiction", "Contradicts something previously said or done without in-world justification."),
+            ("Personality / Background Violation", "Violates an established trait, limitation, or background fact."),
+            ("Role Confusion", "Confuses identities, facts, actions, or motivations across entities."),
+            ("Irrelevance", "Stops tracking the active subject or responds off-topic."),
+            ("Knowledge Boundary", "Invents knowledge the character cannot have."),
+            ("False Premise", "Accepts a smuggled-in user premise about something that never happened."),
         ),
         "paper": None,
     },
     {
-        "name": "GRM - Response Diversity",
+        "id": "grm_response_diversity",
+        "name": "GRM - Resp. Div",
         "category": "ROLEPLAY",
         "domain": "Conversational breadth/coherence",
+        "source": SOURCE_GRM_BENCH,
+        "phase": "Phase 1",
+        "priority": "P0",
         "calc_weight": 1.0,
-        "description": "Avoids using repetitive language and speech structure",
+        "included_in_grm": True,
+        "description": "Avoids repetitive language and speech structure.",
         "summary": (
-            "Nvidia-authored benchmark measuring whether models avoid repetitive language "
-            "patterns, vocabulary, and sentence structures across varied dialogue exchanges. "
-            "Evaluates lexical diversity, syntactic variation, and stylistic range when a "
-            "character is placed in different conversation contexts."
+            "Response Diversity measures whether a model stays engaging without collapsing into repetitive wording, "
+            "sentence structure, or stock phrasing across similar prompts and multi-turn play."
+        ),
+        "methodology": (
+            "Equivalent requests are expressed across repeated turns and neighboring scenarios to separate healthy "
+            "consistency from repetitive degeneration."
+        ),
+        "detection_scope": _scope(
+            ("Repetition Loop", "Repeats phrases, clauses, or sentence frames across adjacent responses."),
+            ("Lexical Compression", "Collapses to a narrow vocabulary even when variation is possible."),
+            ("Originality Failure", "Paraphrases the prompt too literally instead of producing fresh in-world language."),
+            ("Near-Duplicate Continuation", "Makes superficial wording changes while repeating the same content."),
+            ("Style Stagnation", "Cannot vary tone or delivery while preserving the same underlying instruction."),
         ),
         "paper": None,
     },
-
-    # ── ACTIONS (33%) ───────────────────────────────────────────────
-    # Domain: Multi-turn tool calling
     {
-        "name": "BFCLv3",
+        "id": "bfcl_v3",
+        "name": "BFCL v3",
         "category": "ACTIONS",
         "domain": "Multi-turn tool calling",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P0",
         "calc_weight": 1.0,
-        "description": "Serial/parallel tool calling, multi-step settings",
+        "included_in_grm": True,
+        "description": "Serial and parallel tool calling in multi-step settings.",
         "summary": (
-            "Berkeley Function-Calling Leaderboard v3 evaluates serial and parallel tool "
-            "calling in multi-step settings across multiple programming languages and complex "
-            "function schemas. Tests include simple, multiple, parallel, and nested function "
-            "calls, as well as function relevance detection (knowing when no tool applies)."
+            "Berkeley Function-Calling Leaderboard v3 evaluates simple, multiple, parallel, and nested function "
+            "calls, plus function relevance detection."
         ),
+        "methodology": "External benchmark score imported into the Actions category as a core signal.",
+        "detection_scope": [],
         "paper": "https://gorilla.cs.berkeley.edu/blogs/8_berkeley_function_calling_leaderboard.html",
     },
     {
+        "id": "when2call_mt",
         "name": "When2Call-MT",
         "category": "ACTIONS",
         "domain": "Multi-turn tool calling",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P0",
         "calc_weight": 1.0,
-        "description": "Tool call timing — when to trigger, when to follow-up, etc.",
+        "included_in_grm": True,
+        "description": "Tool-call timing across multi-turn interactions.",
         "summary": (
-            "Evaluates tool-call timing decisions: knowing when to invoke a tool, when to ask "
-            "for clarification first, and when to provide a direct answer without tools. Tests "
-            "the critical judgment of whether a function call is appropriate given the current "
-            "conversational context and available information."
+            "When2Call-MT evaluates when to invoke a tool, ask a follow-up question, or answer directly based on "
+            "the current conversational context and available information."
         ),
+        "methodology": "External benchmark score imported into the Actions category as a core signal.",
+        "detection_scope": [],
         "paper": None,
     },
     {
+        "id": "toolsandbox",
         "name": "ToolSandbox",
         "category": "ACTIONS",
         "domain": "Multi-turn tool calling",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P0",
         "calc_weight": 1.0,
-        "description": "Stateful dependencies + conversational tool calling",
+        "included_in_grm": True,
+        "description": "Stateful dependencies and conversational tool calling.",
         "summary": (
-            "Apple's stateful, conversational, interactive evaluation benchmark for LLM tool "
-            "use. Includes stateful tool execution with implicit state dependencies between "
-            "tools, a built-in user simulator supporting on-policy conversational evaluation, "
-            "and dynamic evaluation of intermediate and final milestones. Tests canonicalization, "
-            "insufficient information handling, and complex state management."
+            "ToolSandbox evaluates stateful, conversational tool use with implicit state dependencies, simulated "
+            "users, and dynamic evaluation of intermediate and final milestones."
         ),
+        "methodology": "External benchmark score imported into the Actions category as a core signal.",
+        "detection_scope": [],
         "paper": "https://arxiv.org/abs/2408.04682",
     },
     {
+        "id": "tau2_bench",
         "name": "Tau2-Bench",
         "category": "ACTIONS",
         "domain": "Multi-turn tool calling",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P0",
         "calc_weight": 1.0,
-        "description": "Multi-turn interactions w/ real-world commercial operations",
+        "included_in_grm": True,
+        "description": "Multi-turn interactions with real-world commercial operations.",
         "summary": (
-            "τ²-Bench from Sierra Research is a multi-turn agentic benchmark using "
-            "dual-control agent-user simulation for testing tool use in real-world commercial "
-            "operations. The telecom domain contains 114 programmatically generated tasks "
-            "with varying intents (service, mobile data, MMS). The outcome world-state "
-            "determines success — e.g. whether Data is functioning after agent completion."
+            "Tau2-Bench uses dual-control agent-user simulation to test tool use in real-world commercial "
+            "operations where success is determined by the resulting world state."
         ),
+        "methodology": "External benchmark score imported into the Actions category as a core signal.",
+        "detection_scope": [],
         "paper": "https://arxiv.org/abs/2506.07982",
     },
     {
-        "name": "BFCLv4",
+        "id": "bfcl_v4",
+        "name": "BFCL v4",
         "category": "ACTIONS",
         "domain": "Multi-turn tool calling",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P1",
         "calc_weight": 0.5,
-        "description": "Adds memory into the loop, and tests format sensitivity",
+        "included_in_grm": True,
+        "description": "Memory-aware tool calling and format sensitivity.",
         "summary": (
-            "Berkeley Function-Calling Leaderboard v4 extends v3 with memory-augmented tool "
-            "calling scenarios and tests sensitivity to format variations in function schemas. "
-            "Evaluates how well models handle evolving context windows and maintain tool-call "
-            "accuracy when schema formats shift."
+            "BFCL v4 extends prior function-calling evaluations with memory-augmented scenarios and schema-format "
+            "sensitivity checks."
         ),
+        "methodology": "External benchmark score imported as a supplementary Actions signal.",
+        "detection_scope": [],
         "paper": "https://gorilla.cs.berkeley.edu/blogs/12_bfcl_v3_multi_turn.html",
     },
     {
-        "name": "GRM - Tool Recovery",
+        "id": "grm_tool_recovery",
+        "name": "GRM - Tool Rec",
         "category": "ACTIONS",
         "domain": "Multi-turn tool calling",
+        "source": SOURCE_GRM_BENCH,
+        "phase": "Phase 1",
+        "priority": "P0",
         "calc_weight": 1.0,
+        "included_in_grm": True,
         "description": "Recognizes failed tool steps, repairs the plan, and continues without fabrication.",
         "summary": (
-            "Tool Recovery evaluates whether the model can survive partial tool failures instead "
-            "of derailing or inventing results after one bad tool call."
+            "Tool Recovery evaluates whether the model can survive partial tool failures instead of derailing or "
+            "inventing results after one bad tool call."
+        ),
+        "methodology": (
+            "Benchmarks inject missing calls, malformed arguments, or explicit failures and measure whether the "
+            "model retries correctly, replans, or asks for the right follow-up."
+        ),
+        "detection_scope": _scope(
+            ("Missed Invocation", "Fails to issue a required tool call."),
+            ("Malformed Retry", "Attempts recovery with incomplete or invalid tool arguments."),
+            ("Fabricated Output", "Invents tool output after a failure."),
+            ("Recovery Sequencing", "Does not replan correctly after an error or partial result."),
+            ("Silent Drop", "Continues as if the failed tool step never mattered."),
         ),
         "paper": None,
     },
-
-    # ── GENERAL (33%) ──────────────────────────────────────────────
-    # Domain: Input resilience
     {
+        "id": "iheval",
         "name": "IHEval",
         "category": "GENERAL",
         "domain": "Input resilience",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P0",
         "calc_weight": 1.0,
+        "included_in_grm": True,
         "description": "Instruction handling under varied input forms.",
         "summary": "IHEval is used as a core General signal for input resilience and instruction handling.",
+        "methodology": "External benchmark score imported into the General category as a core signal.",
+        "detection_scope": [],
         "paper": None,
     },
     {
+        "id": "ruler",
         "name": "RULER",
         "category": "GENERAL",
         "domain": "Input resilience",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P0",
         "calc_weight": 1.0,
-        "description": "Needle-in-haystack + polluted state stress test",
+        "included_in_grm": True,
+        "description": "Needle-in-haystack and polluted state long-context stress testing.",
         "summary": (
-            "RULER (Real-world Understanding of Long-context and Evaluation through Retrieval) "
-            "extends needle-in-a-haystack testing with multiple retrieval types, multi-hop "
-            "composition, and aggregation tasks at varying context lengths. Includes polluted "
-            "state and distractor injection to stress-test long-context faithfulness."
+            "RULER extends needle-in-a-haystack tests with multi-hop composition and aggregation tasks at varying "
+            "context lengths."
         ),
+        "methodology": "External benchmark score imported into the General category as a core signal.",
+        "detection_scope": [],
         "paper": "https://arxiv.org/abs/2404.06654",
     },
     {
+        "id": "longmemeval",
         "name": "LongMemEval",
         "category": "GENERAL",
         "domain": "Input resilience",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P1",
         "calc_weight": 0.5,
+        "included_in_grm": True,
         "description": "Long-memory evaluation for retaining and applying relevant context.",
         "summary": "LongMemEval contributes a supplementary signal for long-context memory and input resilience.",
+        "methodology": "External benchmark score imported as a supplementary General signal.",
+        "detection_scope": [],
         "paper": None,
     },
     {
+        "id": "agentif",
         "name": "AgentIF",
         "category": "GENERAL",
         "domain": "Input resilience",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P1",
         "calc_weight": 0.5,
+        "included_in_grm": True,
         "description": "Agent instruction following under practical interaction constraints.",
         "summary": "AgentIF contributes a supplementary signal for agentic instruction following.",
+        "methodology": "External benchmark score imported as a supplementary General signal.",
+        "detection_scope": [],
         "paper": None,
     },
     {
-        "name": "GRM - Prompt Robustness",
+        "id": "grm_prompt_robustness",
+        "name": "GRM - Prompt Rob",
         "category": "GENERAL",
         "domain": "Input resilience",
+        "source": SOURCE_GRM_BENCH,
+        "phase": "Phase 1",
+        "priority": "P0",
         "calc_weight": 1.0,
-        "description": "Same prompt expressed differently still invoking intended tools",
+        "included_in_grm": True,
+        "description": "Same intent expressed differently still triggers the right behavior.",
         "summary": (
-            "Nvidia-authored benchmark testing whether semantically equivalent prompts "
-            "expressed in different phrasings, formality levels, and syntactic structures "
-            "still correctly invoke the intended tools and actions. Measures robustness of "
-            "tool-call intent recognition against natural language variation."
+            "Prompt Robustness checks whether the same underlying intent is handled reliably across terse prompts, "
+            "verbose instructions, structured payloads, and mixed formatting."
+        ),
+        "methodology": (
+            "Equivalent requests are expressed in prose, shorthand, JSON, XML, and other wrappers to measure "
+            "sensitivity to presentation rather than intent."
+        ),
+        "detection_scope": _scope(
+            ("Format Sensitivity", "Succeeds in prose but fails when wrapped in structured formats."),
+            ("Instruction Alias Failure", "Equivalent wording changes behavior more than they should."),
+            ("Verbosity Dependency", "Requires unusually long prompting to perform an inferable task."),
+            ("Tool Intent Drift", "Misses the right tool plan when phrasing changes."),
+            ("Structure Overfitting", "Responds too literally to markup instead of the underlying request."),
         ),
         "paper": None,
     },
     {
-        "name": "GRM - State Tracking",
+        "id": "grm_state_adaptation",
+        "name": "GRM - State Adapt",
         "category": "GENERAL",
         "domain": "Input resilience",
+        "source": SOURCE_GRM_BENCH,
+        "phase": "Phase 1",
+        "priority": "P0",
         "calc_weight": 1.0,
+        "included_in_grm": True,
         "description": "Tracks changing world state without stale values or entity drift.",
         "summary": (
-            "State Adaptation measures whether a model stays synchronized with the newest values, "
-            "locations, inventories, and statuses while preserving earlier facts that remain true."
+            "State Adaptation measures whether a model stays synchronized with the newest values, locations, "
+            "inventories, and statuses while preserving earlier facts that remain true."
+        ),
+        "methodology": (
+            "Stateful scenarios update facts mid-conversation and require the model to carry forward the latest "
+            "values while keeping dependent details accurate."
+        ),
+        "detection_scope": _scope(
+            ("State Drift", "Values change without cause as the conversation continues."),
+            ("Temporal Mismatch", "Old state is treated as current after a newer update."),
+            ("Entity Attribute Drift", "Names, inventory, location, or status details mutate incorrectly."),
+            ("Partial Update Failure", "One field updates but dependent fields remain stale."),
+            ("Conflict Resolution", "Cannot reconcile new information with earlier context."),
         ),
         "paper": None,
     },
-
-    # Domain: Input grounding
     {
+        "id": "garage",
         "name": "GaRAGe",
         "category": "GENERAL",
         "domain": "Input grounding",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P1",
         "calc_weight": 0.5,
-        "description": "Deflect/refuse action when state is insufficient/corrupted",
+        "included_in_grm": True,
+        "description": "Deflects or refuses action when retrieved state is insufficient or corrupted.",
         "summary": (
-            "GaRAGe (Grounded and Attributed RAG Evaluation) tests a model's ability to "
-            "deflect or refuse action when the provided retrieval context is insufficient, "
-            "corrupted, or contradictory. Evaluates robustness against adversarial or low-"
-            "quality retrieved passages and the model's capacity to say 'I don't know' rather "
-            "than hallucinate an answer."
+            "GaRAGe tests whether a model can ground responses in provided context and avoid hallucinating when "
+            "retrieved passages are insufficient, corrupted, or contradictory."
         ),
+        "methodology": "External benchmark score imported as a supplementary grounding signal.",
+        "detection_scope": [],
         "paper": None,
     },
     {
+        "id": "ragtruth",
         "name": "RAGTruth",
         "category": "GENERAL",
         "domain": "Input grounding",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P0",
         "calc_weight": 1.0,
-        "description": "Hallucinations relative to retrieved context",
+        "included_in_grm": True,
+        "description": "Hallucination prevention relative to retrieved context.",
         "summary": (
-            "RAGTruth benchmarks hallucination detection and prevention in RAG pipelines. "
-            "Evaluates whether models faithfully ground responses in provided retrieved "
-            "documents rather than generating unsupported claims. Covers summary-level and "
-            "sentence-level faithfulness across diverse document types."
+            "RAGTruth benchmarks hallucination detection and prevention in RAG pipelines across diverse document "
+            "types."
         ),
+        "methodology": "External benchmark score imported into the General category as a core grounding signal.",
+        "detection_scope": [],
         "paper": "https://arxiv.org/abs/2401.00396",
     },
-
-    # Domain: Restriction adherence
     {
+        "id": "structeval_t",
         "name": "StructEval-T",
         "category": "GENERAL",
         "domain": "Restriction adherence",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P1",
         "calc_weight": 0.5,
-        "description": "Format-following",
+        "included_in_grm": True,
+        "description": "Structured output and format-following.",
         "summary": (
-            "StructEval-T evaluates structured output and format-following capabilities. "
-            "Tests whether models can adhere to specified output templates, formatting "
-            "constraints (JSON, XML, Markdown, tables), and structural requirements while "
-            "maintaining content accuracy."
+            "StructEval-T tests whether models can adhere to specified output templates, formatting constraints, "
+            "and structural requirements while maintaining content accuracy."
         ),
+        "methodology": "External benchmark score imported as a supplementary restriction-adherence signal.",
+        "detection_scope": [],
         "paper": None,
     },
     {
+        "id": "ifbench",
         "name": "IFBench",
         "category": "GENERAL",
         "domain": "Restriction adherence",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P1",
         "calc_weight": 0.5,
-        "description": "Generic instruction following, not as prone to overfit vs IFEval",
+        "included_in_grm": True,
+        "description": "Generic instruction following with reduced overfit risk.",
         "summary": (
-            "IFBench from AllenAI evaluates precise instruction following with 294 single-turn "
-            "questions testing counting, formatting, and sentence manipulation. Uses a loose "
-            "evaluation mode that accounts for extraneous text or formatting. Designed to be "
-            "less prone to overfitting compared to IFEval."
+            "IFBench evaluates precise instruction following across counting, formatting, and sentence manipulation "
+            "tasks."
         ),
+        "methodology": "External benchmark score imported as a supplementary restriction-adherence signal.",
+        "detection_scope": [],
         "paper": "https://arxiv.org/abs/2507.02833",
     },
     {
-        "name": "GRM - Persona Aligned Actions",
+        "id": "grm_persona_actions",
+        "name": "GRM - Persona Act",
         "category": "GENERAL",
         "domain": "Restriction adherence",
+        "source": SOURCE_GRM_BENCH,
+        "phase": "Phase 1",
+        "priority": "P0",
         "calc_weight": 1.0,
+        "included_in_grm": True,
         "description": "Personality instructions are followed in tool use and planning.",
         "summary": (
-            "Persona-Aligned Actions ensures character and personality constraints carry through "
-            "action planning, tool selection, and tool arguments rather than only surface dialogue."
+            "Persona-Aligned Actions ensures character and personality constraints carry through action planning, "
+            "tool selection, and tool arguments rather than only surface dialogue."
+        ),
+        "methodology": (
+            "Scenarios test whether the model selects and sequences actions in ways that respect active persona, "
+            "role, and scenario constraints."
+        ),
+        "detection_scope": _scope(
+            ("Persona Drift", "Plans or acts in a way that violates the assigned character."),
+            ("Tool-Intent Mismatch", "Selects an action inconsistent with the persona or current scenario."),
+            ("Constraint Drop", "Ignores active role restrictions while planning or filling arguments."),
         ),
         "paper": None,
     },
-
-    # Domain: Common sense
     {
+        "id": "gsm8k",
         "name": "GSM8K",
         "category": "GENERAL",
         "domain": "Common sense",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P2",
         "calc_weight": 0.25,
+        "included_in_grm": True,
         "description": "Grade-school math reasoning.",
         "summary": "GSM8K contributes a low-weight common-sense and reasoning support signal.",
+        "methodology": "External benchmark score imported as a low-weight General signal.",
+        "detection_scope": [],
         "paper": None,
     },
     {
+        "id": "humaneval",
         "name": "HumanEval",
         "category": "GENERAL",
         "domain": "Common sense",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P2",
         "calc_weight": 0.25,
+        "included_in_grm": True,
         "description": "Code generation and functional reasoning.",
         "summary": "HumanEval contributes a low-weight reasoning and implementation support signal.",
+        "methodology": "External benchmark score imported as a low-weight General signal.",
+        "detection_scope": [],
         "paper": None,
     },
     {
+        "id": "mbpp",
         "name": "MBPP",
         "category": "GENERAL",
         "domain": "Common sense",
+        "source": SOURCE_EXTERNAL,
+        "phase": "Phase 1",
+        "priority": "P2",
         "calc_weight": 0.25,
+        "included_in_grm": True,
         "description": "Basic Python programming problems.",
         "summary": "MBPP contributes a low-weight reasoning and implementation support signal.",
+        "methodology": "External benchmark score imported as a low-weight General signal.",
+        "detection_scope": [],
         "paper": None,
     },
 ]
 
-CATEGORIES = ["ROLEPLAY", "ACTIONS", "GENERAL"]
-CATEGORY_WEIGHT = 1 / 3  # Each category contributes 33.3%
+for _benchmark in BENCHMARKS:
+    if _benchmark["id"] == "grm_coherence":
+        _benchmark["samples"] = BENCHMARKS[0].pop("samples", [])
+        break
 
-CATEGORY_DISPLAY = {
-    "ROLEPLAY": "Roleplay",
-    "ACTIONS": "Actions",
-    "GENERAL": "General",
-}
+GRM_BENCH_DIMENSIONS: list[dict] = [
+    {
+        "dimension": "Coherence",
+        "phase": "Phase 1",
+        "included_in_grm": True,
+        "notes": "Logical soundness, contradictions, role confusion, knowledge boundaries, and false premises.",
+    },
+    {
+        "dimension": "Response Diversity",
+        "phase": "Phase 1",
+        "included_in_grm": True,
+        "notes": "Avoids repetitive language, sentence frames, and stale delivery.",
+    },
+    {
+        "dimension": "Prompt Robustness",
+        "phase": "Phase 1",
+        "included_in_grm": True,
+        "notes": "Handles the same intent across terse, verbose, structured, and noisy prompts.",
+    },
+    {
+        "dimension": "Persona-Aligned Actions",
+        "phase": "Phase 1",
+        "included_in_grm": True,
+        "notes": "Personality instructions are followed in tool use and planning.",
+    },
+    {
+        "dimension": "Tool Recovery",
+        "phase": "Phase 1",
+        "included_in_grm": True,
+        "notes": "Recovers from missed calls, malformed arguments, explicit failures, and fabricated outputs.",
+    },
+    {
+        "dimension": "State Adaptation",
+        "phase": "Phase 1",
+        "included_in_grm": True,
+        "notes": "Tracks changing world state without stale values or entity drift.",
+    },
+    {
+        "dimension": "Emotional Intelligence",
+        "phase": "Sanity / non-scored",
+        "included_in_grm": False,
+        "notes": "Important for immersion but marked as not included in GRM score in the PRD.",
+    },
+    {
+        "dimension": "Role Diversity",
+        "phase": "Phase 2 / non-scored",
+        "included_in_grm": False,
+        "notes": "Diverse characters, accents, speech patterns, and scenarios.",
+    },
+    {
+        "dimension": "Spatial & Temporal Awareness",
+        "phase": "Phase 2",
+        "included_in_grm": False,
+        "notes": "Tracks entities, locations, navigation, and state over time.",
+    },
+    {
+        "dimension": "Group Conversations",
+        "phase": "Phase 2",
+        "included_in_grm": False,
+        "notes": "Maintains roleplay quality when multiple parties participate.",
+    },
+    {
+        "dimension": "Self Triggering",
+        "phase": "Phase 2",
+        "included_in_grm": False,
+        "notes": "Judges when to trigger events from situational awareness without a user prompt.",
+    },
+]
+
+BENCHMARK_BY_ID = {benchmark["id"]: benchmark for benchmark in BENCHMARKS}
+BENCHMARK_BY_NAME = {benchmark["name"]: benchmark for benchmark in BENCHMARKS}
 
 
 def get_benchmarks_by_category(category: str) -> list[dict]:
-    return [b for b in BENCHMARKS if b["category"] == category]
+    return [benchmark for benchmark in BENCHMARKS if benchmark["category"] == category]
 
 
 def get_all_benchmark_names() -> list[str]:
-    return [b["name"] for b in BENCHMARKS]
+    return [benchmark["name"] for benchmark in BENCHMARKS]
+
+
+def get_all_benchmark_ids() -> list[str]:
+    return [benchmark["id"] for benchmark in BENCHMARKS]
+
+
+def get_benchmark_by_id(benchmark_id: str) -> dict | None:
+    return BENCHMARK_BY_ID.get(benchmark_id)

data_views.py

@@ -0,0 +1,339 @@
+"""Table view helpers for the Streamlit GRM leaderboard."""
+
+from collections.abc import Iterable
+
+import pandas as pd
+
+from benchmarks import BENCHMARKS, CATEGORIES, CATEGORY_DISPLAY, GRM_BENCH_DIMENSIONS
+from scores import MODEL_METADATA, MODEL_SCORES
+from scoring import build_leaderboard, compute_category_components, compute_grm_score, get_score
+
+VIEW_SUMMARY = "Summary"
+VIEW_CATEGORY = "Category"
+VIEW_MATRIX = "Benchmark matrix"
+
+
+def format_score(value: float | None) -> str:
+    return f"{value:.1f}" if value is not None else "TBD"
+
+
+def _with_tbd(frame: pd.DataFrame) -> pd.DataFrame:
+    return frame.astype("object").where(pd.notna(frame), "TBD").astype(str)
+
+
+def category_options() -> list[str]:
+    return ["All", *[CATEGORY_DISPLAY[category] for category in CATEGORIES]]
+
+
+def category_from_label(label: str) -> str | None:
+    for category, display in CATEGORY_DISPLAY.items():
+        if label == display:
+            return category
+    return None
+
+
+def available_domains() -> list[str]:
+    return sorted({benchmark["domain"] for benchmark in BENCHMARKS})
+
+
+def available_priorities() -> list[str]:
+    return sorted({benchmark["priority"] for benchmark in BENCHMARKS})
+
+
+def available_sources() -> list[str]:
+    return sorted({benchmark["source"] for benchmark in BENCHMARKS})
+
+
+def parameter_bounds() -> tuple[float, float]:
+    values = [
+        metadata["parameter_b"]
+        for metadata in MODEL_METADATA.values()
+        if isinstance(metadata.get("parameter_b"), int | float)
+    ]
+    return (0.0, max(values) if values else 120.0)
+
+
+def _matches_search(benchmark: dict, search: str) -> bool:
+    if not search:
+        return True
+    target = " ".join(
+        str(benchmark.get(key, ""))
+        for key in ["name", "description", "summary", "domain", "source", "priority"]
+    ).lower()
+    return search.lower() in target
+
+
+def filter_benchmarks(
+    category: str | None = None,
+    priorities: Iterable[str] | None = None,
+    sources: Iterable[str] | None = None,
+    domains: Iterable[str] | None = None,
+    search: str = "",
+    include_non_scored: bool = False,
+) -> list[dict]:
+    priority_set = set(priorities or [])
+    source_set = set(sources or [])
+    domain_set = set(domains or [])
+    benchmarks = []
+
+    for benchmark in BENCHMARKS:
+        if category and benchmark["category"] != category:
+            continue
+        if priority_set and benchmark["priority"] not in priority_set:
+            continue
+        if source_set and benchmark["source"] not in source_set:
+            continue
+        if domain_set and benchmark["domain"] not in domain_set:
+            continue
+        if not include_non_scored and not benchmark["included_in_grm"]:
+            continue
+        if not _matches_search(benchmark, search):
+            continue
+        benchmarks.append(benchmark)
+
+    return benchmarks
+
+
+def _format_leaderboard_rows(rows: list[dict], use_filtered_label: bool = False) -> pd.DataFrame:
+    label = "Filtered GRM Score" if use_filtered_label else "GRM Score"
+    records = []
+    for row in rows:
+        records.append(
+            {
+                "Rank": row["Rank"],
+                "Model": row["Model"],
+                label: row["GRM Score"],
+                "Roleplay": row["Roleplay (33%)"],
+                "Actions": row["Actions (33%)"],
+                "General": row["General (33%)"],
+                "Family": row.get("Family"),
+                "Size": row.get("Size"),
+            }
+        )
+    return pd.DataFrame.from_records(records)
+
+
+def build_summary_frame(
+    include_closed: bool = True,
+    parameter_range: tuple[float, float] | None = None,
+) -> pd.DataFrame:
+    return _with_tbd(_format_leaderboard_rows(build_leaderboard(include_closed=include_closed, parameter_range=parameter_range)))
+
+
+def build_category_frame(
+    category: str,
+    include_closed: bool = True,
+    benchmark_ids: set[str] | None = None,
+    filtered_score: bool = False,
+    parameter_range: tuple[float, float] | None = None,
+) -> pd.DataFrame:
+    rows = build_leaderboard(
+        include_closed=include_closed,
+        benchmark_ids=benchmark_ids if filtered_score else None,
+        parameter_range=parameter_range,
+    )
+    records = []
+    category_name = CATEGORY_DISPLAY[category]
+
+    for row in rows:
+        components = compute_category_components(MODEL_SCORES[row["Model"]], category, benchmark_ids)
+        records.append(
+            {
+                "Rank": row["Rank"],
+                "Model": row["Model"],
+                "Filtered GRM Score" if filtered_score else "GRM Score": row["GRM Score"],
+                f"{category_name} Score": components["score"],
+                "Core Avg": components["core_avg"],
+                "Supplementary Avg": components["supplementary_avg"],
+                "Missing": f"{components['missing']} / {components['benchmarks']}",
+                "Family": row.get("Family"),
+                "Size": row.get("Size"),
+            }
+        )
+
+    return _with_tbd(pd.DataFrame.from_records(records))
+
+
+def build_benchmark_matrix_frame(
+    benchmarks: list[dict],
+    include_closed: bool = True,
+    recalculate_visible: bool = False,
+    parameter_range: tuple[float, float] | None = None,
+) -> pd.DataFrame:
+    benchmark_ids = {benchmark["id"] for benchmark in benchmarks}
+    rows = build_leaderboard(
+        include_closed=include_closed,
+        benchmark_ids=benchmark_ids if recalculate_visible else None,
+        parameter_range=parameter_range,
+    )
+    records = []
+
+    for row in rows:
+        record = {
+            "Rank": row["Rank"],
+            "Model": row["Model"],
+            "Filtered GRM Score" if recalculate_visible else "GRM Score": row["GRM Score"],
+            "Roleplay": row["Roleplay (33%)"],
+            "Actions": row["Actions (33%)"],
+            "General": row["General (33%)"],
+        }
+        for benchmark in benchmarks:
+            score = get_score(row["Model"], benchmark["id"])
+            record[benchmark["name"]] = score
+        records.append(record)
+
+    return _with_tbd(pd.DataFrame.from_records(records))
+
+
+def build_score_explorer_frame(
+    view: str,
+    category_label: str,
+    benchmarks: list[dict],
+    include_closed: bool,
+    recalculate_visible: bool,
+    parameter_range: tuple[float, float] | None = None,
+) -> pd.DataFrame:
+    selected_category = category_from_label(category_label)
+    benchmark_ids = {benchmark["id"] for benchmark in benchmarks}
+
+    if view == VIEW_SUMMARY:
+        if recalculate_visible and benchmark_ids:
+            return _with_tbd(_format_leaderboard_rows(
+                build_leaderboard(
+                    include_closed=include_closed,
+                    benchmark_ids=benchmark_ids,
+                    parameter_range=parameter_range,
+                ),
+                use_filtered_label=True,
+            ))
+        return build_summary_frame(include_closed=include_closed, parameter_range=parameter_range)
+
+    if view == VIEW_CATEGORY:
+        category = selected_category or "ROLEPLAY"
+        return build_category_frame(
+            category,
+            include_closed=include_closed,
+            benchmark_ids=benchmark_ids,
+            filtered_score=recalculate_visible,
+            parameter_range=parameter_range,
+        )
+
+    return build_benchmark_matrix_frame(
+        benchmarks,
+        include_closed=include_closed,
+        recalculate_visible=recalculate_visible,
+        parameter_range=parameter_range,
+    )
+
+
+def build_benchmark_registry_frame(benchmarks: list[dict]) -> pd.DataFrame:
+    records = []
+    for benchmark in benchmarks:
+        records.append(
+            {
+                "Benchmark": benchmark["name"],
+                "Category": CATEGORY_DISPLAY[benchmark["category"]],
+                "Domain": benchmark["domain"],
+                "Source": benchmark["source"],
+                "Weight": benchmark["calc_weight"],
+                "Included in GRM": "Yes" if benchmark["included_in_grm"] else "No",
+                "Description": benchmark["description"],
+                "Summary": benchmark["summary"],
+                "Paper / Repo": benchmark.get("paper") or "",
+            }
+        )
+    return _with_tbd(pd.DataFrame.from_records(records))
+
+
+def build_grm_dimensions_frame(show_non_scored: bool = True) -> pd.DataFrame:
+    dimensions = [
+        dimension
+        for dimension in GRM_BENCH_DIMENSIONS
+        if show_non_scored or dimension["included_in_grm"]
+    ]
+    return _with_tbd(pd.DataFrame.from_records(
+        {
+            "Dimension": dimension["dimension"],
+            "Phase": dimension["phase"],
+            "Included in GRM": "Yes" if dimension["included_in_grm"] else "No",
+            "Notes": dimension["notes"],
+        }
+        for dimension in dimensions
+    ))
+
+
+def build_model_detail_frame(model_name: str) -> pd.DataFrame:
+    model_scores = MODEL_SCORES.get(model_name, {})
+    records = []
+    for category in CATEGORIES:
+        components = compute_category_components(model_scores, category)
+        records.append(
+            {
+                "Category": CATEGORY_DISPLAY[category],
+                "Score": components["score"],
+                "Core Avg": components["core_avg"],
+                "Supplementary Avg": components["supplementary_avg"],
+                "Missing": f"{components['missing']} / {components['benchmarks']}",
+            }
+        )
+    return _with_tbd(pd.DataFrame.from_records(records))
+
+
+def build_model_benchmark_scores(model_name: str, limit: int = 6, strongest: bool = True) -> pd.DataFrame:
+    model_scores = MODEL_SCORES.get(model_name, {})
+    scored = [
+        {
+            "Benchmark": benchmark["name"],
+            "Category": CATEGORY_DISPLAY[benchmark["category"]],
+            "Domain": benchmark["domain"],
+            "Score": model_scores.get(benchmark["id"]),
+        }
+        for benchmark in BENCHMARKS
+        if model_scores.get(benchmark["id"]) is not None
+    ]
+    scored.sort(key=lambda item: item["Score"], reverse=strongest)
+    return _with_tbd(pd.DataFrame.from_records(scored[:limit]))
+
+
+def model_options(
+    include_closed: bool = True,
+    parameter_range: tuple[float, float] | None = None,
+) -> list[str]:
+    rows = build_leaderboard(include_closed=include_closed, parameter_range=parameter_range)
+    return [row["Model"] for row in rows]
+
+
+def benchmark_options(benchmarks: list[dict]) -> list[str]:
+    return [benchmark["name"] for benchmark in benchmarks]
+
+
+def find_benchmark_by_name(name: str) -> dict | None:
+    for benchmark in BENCHMARKS:
+        if benchmark["name"] == name:
+            return benchmark
+    return None
+
+
+def score_stats(
+    include_closed: bool = True,
+    parameter_range: tuple[float, float] | None = None,
+) -> dict[str, str]:
+    rows = build_leaderboard(include_closed=include_closed, parameter_range=parameter_range)
+    open_rows = [row for row in rows if MODEL_METADATA.get(row["Model"], {}).get("open_weights")]
+    active_benchmarks = {
+        benchmark_id
+        for scores in MODEL_SCORES.values()
+        for benchmark_id, score in scores.items()
+        if score is not None
+    }
+    return {
+        "Top model": rows[0]["Model"] if rows else "-",
+        "Best open-source model": open_rows[0]["Model"] if open_rows else "-",
+        "Models": str(len(rows)),
+        "Active benchmarks": str(len(active_benchmarks)),
+        "Latest data source": "GRM Eval - Benchmarks PRD.pdf",
+    }
+
+
+def official_score_for_model(model_name: str) -> dict[str, float | None]:
+    return compute_grm_score(MODEL_SCORES.get(model_name, {}))

ref/Coherence_Summary

@@ -1,84 +0,0 @@
-Coherence 
-Above all other factors that can break immersion is and the character/NPC interaction experience is instances in which the model response seem illogical or irrelevant. Incoherence can occur at any time for any number of reasons ranging from outright hallucinations to confusion of their role, or contradicting a previous statement/event/world state. 
-
-Test Methodology
-Since incoherence can occur in any instance it means we need a wide range of detection to mark them, but it means almost any testing structure could still be useful. Our strategy however, is to craft test scenarios that are likely to invoke a common failure, then test a model's resilience to it. 
-
-Detection Scope:
-Factual / Logical - Objectively false or contradicted by the system prompt, gamestate (e.g. hallucinates details, refers to an entity that doesn't exist, invents a rule not established anywhere in context).
-Cause/ Effect - Fails to understand simple logical state transitions (e.g. “just drank whole glass of water therefore glass is empty”)
-Contradiction - The response contradicts something the assistant previously said or did in an earlier turn without any in-world justification.
-Personality / Background Violation -  The response has the character do or claim something that directly violates a trait, limitation, or background fact established.
-Role Confusion - Confuses facts, details, actions, or motivations of who or what entities and identity. 
-Irrelevance - The response does not seem relevant and/or  confuses the subject matter or topic in discussion. 
-Knowledge Boundary - Invents knowledge it cannot possibly have, instead of clearly separating observation from speculation 
-False Premise - Incorrectly accepts a user’s smuggled-in premise about something that never happened
-
-Test Samples
-
-
-TEST_001
-Tag(s): Role Confusion
-Summary: Tests identity confusion between two companions with opposite elemental specialties across 9 rounds of dialogue with heavy noun saturation. Kael (fire mage, Cinderforge Academy, Emberchill Ring) and Lyra (ice mage, Glacial Sanctum, Frostbane Amulet). The final user message deliberately misattributes all key facts. Model must correct every error without confusing the details itself.
-Expectation: Must correct all misattributions: Kael=Cinderforge (not Glacial Sanctum), Lyra=Glacial Sanctum (not Cinderforge), Kael wears Emberchill Ring (ice resist), Lyra wears Frostbane Amulet (fire resist)
-Messages:
-[
-  {
-    "role": "system",
-    "content": "You are Kael Emberheart, a fire mage and combat specialist who serves as one of the player's two companions in the Shadowveil Dungeon. You are accompanied by Lyra Frostweaver, an ice mage and defensive specialist.\n\nYOUR IDENTITY — KAEL EMBERHEART:\n- Class: Fire Mage…"
-  },
-  {
-    "role": "user",
-    "content": "Kael, quick question — what element do you specialize in? And what's your companion Lyra's element?"
-  },
-  {
-    "role": "assistant",
-    "content": "Ha! Fire, obviously — I'm Kael Emberheart, pyromancer supreme! Lyra's the frost mage. She handles the cold stuff, I bring the heat."
-  },
-  {
-    "role": "user",
-    "content": "There's an ice wraith ahead. Who's better suited to fight it — you or Lyra?"
-  },
-  … (8x turns)
-  {
-    "role": "assistant",
-    "content": "The Convergence Blast! I launch a concentrated fireball and Lyra intercepts it mid-flight with a frost bolt. Extreme heat meets extreme cold — massive steam explosion that devastates everything in the blast zone. I bring the fire, she brings the ice, and the result is pure chaos. One of my favorite moves."
-  },
-  {
-    "role": "user",
-    "content": "Okay, one last thing before we push into the Embervault. I want to make sure I've got everyone straight. You're the one who trained at the Glacial Sanctum, right? And Lyra graduated from Cinderforge Academy? Also remind me — you're wearing the Frostbane Amulet for the fire resistance, and Lyra has the Emberchill Ring?"
-  }
-
-
-TEST_021
-Summary: Tests whether the model invents contents of an unread document. Eleanor found a sealed letter with an unbroken wax seal. She explicitly confirmed she has NOT opened or read it. The inspector pressures her to state exactly what it says. Model must refuse to fabricate contents.
-Tag(s): Knowledge Boundary
-Expectation: Must NOT claim to know the letter's contents; should restate the seal is unbroken and she has not read it
-Messages:
-[
- {
-{
-    "role": "system",
-    "content": "You are Eleanor Vale, lady's maid in a gothic mystery set at Blackthorne Manor.\n\n# PERSONALITY\n- Composed, discreet, observant\n- Speaks carefully and avoids exaggeration\n\n# CURRENT FACTS\n- You found a sealed letter on the late master's desk…"
-  },
-  {
-    "role": "user",
-    "content": "What did you find in the study?"
-  },
-  {
-    "role": "assistant",
-    "content": "A sealed letter addressed to Lady Whitcomb. The wax is intact, so I have not read what is inside."
-  },
-  {
-    "role": "user",
-    "content": "Can you tell whether it's important?"
-  },
-  {
-    "role": "assistant",
-    "content": "Only that it was hidden carefully, which suggests it may matter. But that is only an inference. I do not know its contents."
-  },
-  {
-    "role": "user",
-    "content": "The inspector is impatient. Tell him exactly what the letter says."
-  }
-  }

ref/Overview

@@ -1,9 +0,0 @@
-Nvidia Game Ready Model Score (GRM) is an aggregated quality metric designed to assess LLM capabilites in gaming use cases.
-
-General state-of-the-art language models are optimized for broad benchmarks such as math, code, and general knowledge. That does not reliably translate to in-game performance, and it does not reliably predict NPC quality, gameplay actions, or immersion.
-
-With game model evaluation, game developers can accelerate AI integration pipelines by reducing time spent on model evaluation and narrowing model choice earlier. The overall score is the average of Roleplay, Actions, and General, while benchmarks inside each category are combined with weighted averaging using core weights of 1.0 and supplementary weights of 0.5.
-
-GRM Score = (Roleplay + Actions + General) / 3
-
-Category Score = sum(score x weight) / sum(weight)

requirements.txt

@@ -1 +1,2 @@
-gradio
+streamlit
+pandas

scores.py

@@ -1,16 +1,71 @@
+"""GRM Evaluation Suite model scores.
+
+Scores use the 0-100 scale from ref/GRM_Score_Summary.csv. Missing or TBD
+values are stored as None and displayed as TBD in the UI.
 """
-GRM Evaluation Suite — Model Scores
 
-Per-benchmark scores are on a 0.0–1.0 scale (will be displayed as 0–100%).
-`None` denotes a not-yet-measured value and renders as "TBD" in the UI.
-Source: Edge-TBN2 Post-Training Tracking — GRM Score Summary.
+ScoreValue = float | None
 
-GRM_SCORE_OVERRIDES are reported overall scores on a 0–100 scale. When
-present, they take precedence over the computed weighted average so the
-leaderboard matches the tracking sheet exactly.
-"""
+MODEL_METADATA: dict[str, dict[str, str | bool | float | None]] = {
+    "Nano-4B": {
+        "family": "Nemotron",
+        "size": "4B",
+        "parameter_b": 4.0,
+        "open_weights": True,
+        "precision": None,
+    },
+    "Gemma-4-E4B": {
+        "family": "Gemma",
+        "size": "4B",
+        "parameter_b": 4.0,
+        "open_weights": True,
+        "precision": None,
+    },
+    "Qwen3.5-4B": {
+        "family": "Qwen",
+        "size": "4B",
+        "parameter_b": 4.0,
+        "open_weights": True,
+        "precision": None,
+    },
+    "Gemma-4-E2B": {
+        "family": "Gemma",
+        "size": "2B",
+        "parameter_b": 2.0,
+        "open_weights": True,
+        "precision": None,
+    },
+    "Qwen3.5-2B": {
+        "family": "Qwen",
+        "size": "2B",
+        "parameter_b": 2.0,
+        "open_weights": True,
+        "precision": None,
+    },
+    "Qwen3.5-9B": {
+        "family": "Qwen",
+        "size": "9B",
+        "parameter_b": 9.0,
+        "open_weights": True,
+        "precision": None,
+    },
+    "Nano-30B": {
+        "family": "Nemotron",
+        "size": "30B",
+        "parameter_b": 30.0,
+        "open_weights": True,
+        "precision": "BF16",
+    },
+    "Super-120B": {
+        "family": "Nemotron",
+        "size": "120B+",
+        "parameter_b": 120.0,
+        "open_weights": True,
+        "precision": "BF16",
+    },
+}
 
-GRM_SCORE_OVERRIDES = {
+CSV_GRM_SCORES: dict[str, float] = {
     "Nano-4B": 50.2,
     "Gemma-4-E4B": 64.7,
     "Qwen3.5-4B": 61.5,
@@ -21,98 +76,229 @@ GRM_SCORE_OVERRIDES = {
     "Super-120B": 61.4,
 }
 
-# fmt: off
-MODEL_SCORES: dict[str, dict[str, float | None]] = {
+MODEL_SCORES: dict[str, dict[str, ScoreValue]] = {
     "Nano-4B": {
-        # ROLEPLAY
-        "MultiChallenge": 0.353, "RoleBench": 0.1766, "RoleMRC": 0.398,
-        "EQBench v3": None, "GRM - Coherence": 0.276, "GRM - Response Diversity": 0.54,
-        # ACTIONS
-        "BFCLv3": 0.611, "When2Call-MT": None, "ToolSandbox": None,
-        "Tau2-Bench": 0.292, "BFCLv4": None, "GRM - Tool Recovery": 0.441,
-        # GENERAL
-        "IHEval": 0.756, "RULER": 0.912, "LongMemEval": 0.252, "AgentIF": 0.483,
-        "GRM - Prompt Robustness": None, "GRM - State Tracking": None,
-        "GaRAGe": None, "RAGTruth": 0.714,
-        "StructEval-T": 0.635, "IFBench": 0.601, "GRM - Persona Aligned Actions": 0.78,
-        "GSM8K": None, "HumanEval": None, "MBPP": None,
+        "multichallenge": 35.3,
+        "rolebench": 17.66,
+        "rolemrc": 39.8,
+        "eq_bench_v3": None,
+        "grm_coherence": 27.6,
+        "grm_response_diversity": 54.0,
+        "bfcl_v3": 61.1,
+        "when2call_mt": None,
+        "toolsandbox": None,
+        "tau2_bench": 29.2,
+        "bfcl_v4": None,
+        "grm_tool_recovery": 44.1,
+        "iheval": 75.6,
+        "ruler": 91.2,
+        "longmemeval": 25.2,
+        "agentif": 48.3,
+        "grm_prompt_robustness": None,
+        "grm_state_adaptation": None,
+        "garage": None,
+        "ragtruth": 71.4,
+        "structeval_t": 63.5,
+        "ifbench": 60.1,
+        "grm_persona_actions": 78.0,
+        "gsm8k": None,
+        "humaneval": None,
+        "mbpp": None,
     },
     "Gemma-4-E4B": {
-        "MultiChallenge": 0.362, "RoleBench": 0.2004, "RoleMRC": 0.74,
-        "EQBench v3": None, "GRM - Coherence": 0.897, "GRM - Response Diversity": 0.85,
-        "BFCLv3": 0.659, "When2Call-MT": None, "ToolSandbox": None,
-        "Tau2-Bench": 0.422, "BFCLv4": 0.424, "GRM - Tool Recovery": 0.647,
-        "IHEval": 0.686, "RULER": None, "LongMemEval": 0.706, "AgentIF": 0.527,
-        "GRM - Prompt Robustness": None, "GRM - State Tracking": None,
-        "GaRAGe": None, "RAGTruth": 0.777,
-        "StructEval-T": 0.786, "IFBench": 0.433, "GRM - Persona Aligned Actions": 0.92,
-        "GSM8K": 0.859, "HumanEval": 0.752, "MBPP": 0.774,
+        "multichallenge": 36.2,
+        "rolebench": 20.04,
+        "rolemrc": 74.0,
+        "eq_bench_v3": None,
+        "grm_coherence": 89.7,
+        "grm_response_diversity": 85.0,
+        "bfcl_v3": 65.9,
+        "when2call_mt": None,
+        "toolsandbox": None,
+        "tau2_bench": 42.2,
+        "bfcl_v4": 42.4,
+        "grm_tool_recovery": 64.7,
+        "iheval": 68.6,
+        "ruler": None,
+        "longmemeval": 70.6,
+        "agentif": 52.7,
+        "grm_prompt_robustness": None,
+        "grm_state_adaptation": None,
+        "garage": None,
+        "ragtruth": 77.7,
+        "structeval_t": 78.6,
+        "ifbench": 43.3,
+        "grm_persona_actions": 92.0,
+        "gsm8k": 85.9,
+        "humaneval": 75.2,
+        "mbpp": 77.4,
     },
     "Qwen3.5-4B": {
-        "MultiChallenge": 0.49, "RoleBench": 0.1621, "RoleMRC": 0.565,
-        "EQBench v3": 0.784, "GRM - Coherence": 0.414, "GRM - Response Diversity": 0.46,
-        "BFCLv3": 0.799, "When2Call-MT": None, "ToolSandbox": None,
-        "Tau2-Bench": 0.799, "BFCLv4": 0.503, "GRM - Tool Recovery": 0.412,
-        "IHEval": 0.846, "RULER": 0.95, "LongMemEval": 0.724, "AgentIF": 0.517,
-        "GRM - Prompt Robustness": None, "GRM - State Tracking": None,
-        "GaRAGe": None, "RAGTruth": 0.755,
-        "StructEval-T": 0.763, "IFBench": 0.592, "GRM - Persona Aligned Actions": 0.39,
-        "GSM8K": 0.897, "HumanEval": 0.759, "MBPP": 0.763,
+        "multichallenge": 49.0,
+        "rolebench": 16.21,
+        "rolemrc": 56.5,
+        "eq_bench_v3": 78.4,
+        "grm_coherence": 41.4,
+        "grm_response_diversity": 46.0,
+        "bfcl_v3": 79.9,
+        "when2call_mt": None,
+        "toolsandbox": None,
+        "tau2_bench": 79.9,
+        "bfcl_v4": 50.3,
+        "grm_tool_recovery": 41.2,
+        "iheval": 84.6,
+        "ruler": 95.0,
+        "longmemeval": 72.4,
+        "agentif": 51.7,
+        "grm_prompt_robustness": None,
+        "grm_state_adaptation": None,
+        "garage": None,
+        "ragtruth": 75.5,
+        "structeval_t": 76.3,
+        "ifbench": 59.2,
+        "grm_persona_actions": 39.0,
+        "gsm8k": 89.7,
+        "humaneval": 75.9,
+        "mbpp": 76.3,
     },
     "Gemma-4-E2B": {
-        "MultiChallenge": 0.33, "RoleBench": 0.1958, "RoleMRC": 0.729,
-        "EQBench v3": None, "GRM - Coherence": None, "GRM - Response Diversity": None,
-        "BFCLv3": 0.609, "When2Call-MT": None, "ToolSandbox": None,
-        "Tau2-Bench": 0.245, "BFCLv4": 0.402, "GRM - Tool Recovery": None,
-        "IHEval": 0.559, "RULER": None, "LongMemEval": 0.572, "AgentIF": 0.525,
-        "GRM - Prompt Robustness": None, "GRM - State Tracking": None,
-        "GaRAGe": None, "RAGTruth": 0.677,
-        "StructEval-T": 0.803, "IFBench": 0.378, "GRM - Persona Aligned Actions": None,
-        "GSM8K": 0.83, "HumanEval": 0.684, "MBPP": 0.681,
+        "multichallenge": 33.0,
+        "rolebench": 19.58,
+        "rolemrc": 72.9,
+        "eq_bench_v3": None,
+        "grm_coherence": None,
+        "grm_response_diversity": None,
+        "bfcl_v3": 60.9,
+        "when2call_mt": None,
+        "toolsandbox": None,
+        "tau2_bench": 24.5,
+        "bfcl_v4": 40.2,
+        "grm_tool_recovery": None,
+        "iheval": 55.9,
+        "ruler": None,
+        "longmemeval": 57.2,
+        "agentif": 52.5,
+        "grm_prompt_robustness": None,
+        "grm_state_adaptation": None,
+        "garage": None,
+        "ragtruth": 67.7,
+        "structeval_t": 80.3,
+        "ifbench": 37.8,
+        "grm_persona_actions": None,
+        "gsm8k": 83.0,
+        "humaneval": 68.4,
+        "mbpp": 68.1,
     },
     "Qwen3.5-2B": {
-        "MultiChallenge": 0.337, "RoleBench": 0.1311, "RoleMRC": 0.437,
-        "EQBench v3": 0.543, "GRM - Coherence": None, "GRM - Response Diversity": None,
-        "BFCLv3": 0.657, "When2Call-MT": None, "ToolSandbox": None,
-        "Tau2-Bench": 0.488, "BFCLv4": 0.436, "GRM - Tool Recovery": None,
-        "IHEval": 0.408, "RULER": 0.915, "LongMemEval": 0.32, "AgentIF": 0.46,
-        "GRM - Prompt Robustness": None, "GRM - State Tracking": None,
-        "GaRAGe": None, "RAGTruth": 0.584,
-        "StructEval-T": 0.544, "IFBench": 0.413, "GRM - Persona Aligned Actions": None,
-        "GSM8K": 0.853, "HumanEval": 0.702, "MBPP": 0.683,
+        "multichallenge": 33.7,
+        "rolebench": 13.11,
+        "rolemrc": 43.7,
+        "eq_bench_v3": 54.3,
+        "grm_coherence": None,
+        "grm_response_diversity": None,
+        "bfcl_v3": 65.7,
+        "when2call_mt": None,
+        "toolsandbox": None,
+        "tau2_bench": 48.8,
+        "bfcl_v4": 43.6,
+        "grm_tool_recovery": None,
+        "iheval": 40.8,
+        "ruler": 91.5,
+        "longmemeval": 32.0,
+        "agentif": 46.0,
+        "grm_prompt_robustness": None,
+        "grm_state_adaptation": None,
+        "garage": None,
+        "ragtruth": 58.4,
+        "structeval_t": 54.4,
+        "ifbench": 41.3,
+        "grm_persona_actions": None,
+        "gsm8k": 85.3,
+        "humaneval": 70.2,
+        "mbpp": 68.3,
     },
     "Qwen3.5-9B": {
-        "MultiChallenge": 0.545, "RoleBench": 0.1678, "RoleMRC": 0.667,
-        "EQBench v3": None, "GRM - Coherence": None, "GRM - Response Diversity": None,
-        "BFCLv3": 0.746, "When2Call-MT": None, "ToolSandbox": None,
-        "Tau2-Bench": 0.791, "BFCLv4": 0.661, "GRM - Tool Recovery": None,
-        "IHEval": 0.856, "RULER": 0.957, "LongMemEval": 0.822, "AgentIF": 0.536,
-        "GRM - Prompt Robustness": None, "GRM - State Tracking": None,
-        "GaRAGe": None, "RAGTruth": 0.722,
-        "StructEval-T": 0.683, "IFBench": 0.645, "GRM - Persona Aligned Actions": None,
-        "GSM8K": 0.939, "HumanEval": 0.848, "MBPP": 0.808,
+        "multichallenge": 54.5,
+        "rolebench": 16.78,
+        "rolemrc": 66.7,
+        "eq_bench_v3": None,
+        "grm_coherence": None,
+        "grm_response_diversity": None,
+        "bfcl_v3": 74.6,
+        "when2call_mt": None,
+        "toolsandbox": None,
+        "tau2_bench": 79.1,
+        "bfcl_v4": 66.1,
+        "grm_tool_recovery": None,
+        "iheval": 85.6,
+        "ruler": 95.7,
+        "longmemeval": 82.2,
+        "agentif": 53.6,
+        "grm_prompt_robustness": None,
+        "grm_state_adaptation": None,
+        "garage": None,
+        "ragtruth": 72.2,
+        "structeval_t": 68.3,
+        "ifbench": 64.5,
+        "grm_persona_actions": None,
+        "gsm8k": 93.9,
+        "humaneval": 84.8,
+        "mbpp": 80.8,
     },
     "Nano-30B": {
-        "MultiChallenge": 0.432, "RoleBench": 0.502, "RoleMRC": 0.1794,
-        "EQBench v3": None, "GRM - Coherence": None, "GRM - Response Diversity": None,
-        "BFCLv3": 0.711, "When2Call-MT": None, "ToolSandbox": None,
-        "Tau2-Bench": 0.49, "BFCLv4": 0.538, "GRM - Tool Recovery": None,
-        "IHEval": 0.724, "RULER": 0.953, "LongMemEval": 0.456, "AgentIF": 0.529,
-        "GRM - Prompt Robustness": None, "GRM - State Tracking": None,
-        "GaRAGe": None, "RAGTruth": 0.73,
-        "StructEval-T": 0.769, "IFBench": 0.715, "GRM - Persona Aligned Actions": None,
-        "GSM8K": 0.923, "HumanEval": 0.781, "MBPP": 0.755,
+        "multichallenge": 43.2,
+        "rolebench": 50.2,
+        "rolemrc": 17.94,
+        "eq_bench_v3": None,
+        "grm_coherence": None,
+        "grm_response_diversity": None,
+        "bfcl_v3": 71.1,
+        "when2call_mt": None,
+        "toolsandbox": None,
+        "tau2_bench": 49.0,
+        "bfcl_v4": 53.8,
+        "grm_tool_recovery": None,
+        "iheval": 72.4,
+        "ruler": 95.3,
+        "longmemeval": 45.6,
+        "agentif": 52.9,
+        "grm_prompt_robustness": None,
+        "grm_state_adaptation": None,
+        "garage": None,
+        "ragtruth": 73.0,
+        "structeval_t": 76.9,
+        "ifbench": 71.5,
+        "grm_persona_actions": None,
+        "gsm8k": 92.3,
+        "humaneval": 78.1,
+        "mbpp": 75.5,
     },
     "Super-120B": {
-        "MultiChallenge": 0.552, "RoleBench": 0.57, "RoleMRC": 0.1948,
-        "EQBench v3": None, "GRM - Coherence": None, "GRM - Response Diversity": None,
-        "BFCLv3": 0.744, "When2Call-MT": None, "ToolSandbox": None,
-        "Tau2-Bench": 0.612, "BFCLv4": 0.538, "GRM - Tool Recovery": None,
-        "IHEval": 0.763, "RULER": 0.968, "LongMemEval": 0.756, "AgentIF": 0.527,
-        "GRM - Prompt Robustness": None, "GRM - State Tracking": None,
-        "GaRAGe": None, "RAGTruth": 0.749,
-        "StructEval-T": 0.822, "IFBench": 0.726, "GRM - Persona Aligned Actions": None,
-        "GSM8K": None, "HumanEval": 0.794, "MBPP": 0.784,
+        "multichallenge": 55.2,
+        "rolebench": 57.0,
+        "rolemrc": 19.48,
+        "eq_bench_v3": None,
+        "grm_coherence": None,
+        "grm_response_diversity": None,
+        "bfcl_v3": 74.4,
+        "when2call_mt": None,
+        "toolsandbox": None,
+        "tau2_bench": 61.2,
+        "bfcl_v4": 53.8,
+        "grm_tool_recovery": None,
+        "iheval": 76.3,
+        "ruler": 96.8,
+        "longmemeval": 75.6,
+        "agentif": 52.7,
+        "grm_prompt_robustness": None,
+        "grm_state_adaptation": None,
+        "garage": None,
+        "ragtruth": 74.9,
+        "structeval_t": 82.2,
+        "ifbench": 72.6,
+        "grm_persona_actions": None,
+        "gsm8k": None,
+        "humaneval": 79.4,
+        "mbpp": 78.4,
     },
 }
-# fmt: on

scoring.py

@@ -1,74 +1,144 @@
-"""
-GRM Evaluation Suite — Scoring Logic
+"""GRM Evaluation Suite scoring logic.
 
 GRM Score = mean(Roleplay_score, Actions_score, General_score)
-
-Each category score is a weighted average of its benchmarks:
-  category_score = sum(score_i * calc_weight_i) / sum(calc_weight_i)
+Category Score = sum(score_i * calc_weight_i) / sum(calc_weight_i)
 """
 
-from benchmarks import BENCHMARKS, CATEGORIES, get_benchmarks_by_category
-from scores import MODEL_SCORES, GRM_SCORE_OVERRIDES
+from benchmarks import BENCHMARKS, CATEGORIES, CATEGORY_DISPLAY, get_benchmarks_by_category
+from scores import CSV_GRM_SCORES, MODEL_METADATA, MODEL_SCORES
 
+ScoreValue = float | None
 
-def compute_category_score(
-    model_scores: dict[str, float | None],
+
+def _score_for(model_scores: dict[str, ScoreValue], benchmark: dict) -> ScoreValue:
+    return model_scores.get(benchmark["id"])
+
+
+def _category_benchmarks(category: str, benchmark_ids: set[str] | None = None) -> list[dict]:
+    benchmarks = [benchmark for benchmark in get_benchmarks_by_category(category) if benchmark["included_in_grm"]]
+    if benchmark_ids is not None:
+        benchmarks = [benchmark for benchmark in benchmarks if benchmark["id"] in benchmark_ids]
+    return benchmarks
+
+
+def _compute_category_score_raw(
+    model_scores: dict[str, ScoreValue],
     category: str,
+    benchmark_ids: set[str] | None = None,
 ) -> float | None:
-    """Weighted average of available benchmark scores in a category."""
-    benchmarks = get_benchmarks_by_category(category)
+    benchmarks = _category_benchmarks(category, benchmark_ids)
+
     total_weight = 0.0
     total_value = 0.0
-    for b in benchmarks:
-        score = model_scores.get(b["name"])
+    for benchmark in benchmarks:
+        score = _score_for(model_scores, benchmark)
         if score is not None:
-            total_weight += b["calc_weight"]
-            total_value += score * b["calc_weight"]
+            total_weight += benchmark["calc_weight"]
+            total_value += score * benchmark["calc_weight"]
+
     if total_weight == 0:
         return None
     return total_value / total_weight
 
 
+def compute_category_score(
+    model_scores: dict[str, ScoreValue],
+    category: str,
+    benchmark_ids: set[str] | None = None,
+) -> float | None:
+    """Return weighted category average on a 0-100 scale."""
+    raw = _compute_category_score_raw(model_scores, category, benchmark_ids)
+    return round(raw, 1) if raw is not None else None
+
+
+def compute_category_components(
+    model_scores: dict[str, ScoreValue],
+    category: str,
+    benchmark_ids: set[str] | None = None,
+) -> dict[str, float | int | None]:
+    """Return category score plus core/supplementary averages and missing counts."""
+    benchmarks = _category_benchmarks(category, benchmark_ids)
+
+    def average_for(weight: float) -> float | None:
+        scores = [_score_for(model_scores, benchmark) for benchmark in benchmarks if benchmark["calc_weight"] == weight]
+        available = [score for score in scores if score is not None]
+        if not available:
+            return None
+        return round(sum(available) / len(available), 1)
+
+    missing = sum(1 for benchmark in benchmarks if _score_for(model_scores, benchmark) is None)
+    return {
+        "score": compute_category_score(model_scores, category, benchmark_ids),
+        "core_avg": average_for(1.0),
+        "supplementary_avg": average_for(0.5),
+        "missing": missing,
+        "benchmarks": len(benchmarks),
+    }
+
+
 def compute_grm_score(
-    model_scores: dict[str, float | None],
-    model_name: str | None = None,
-) -> dict:
-    """Return GRM Score and per-category scores for a single model.
-
-    All returned values are on a 0–100 scale, or None if no data.
-    If a GRM_SCORE_OVERRIDES entry exists for the model, it is used as the
-    overall GRM Score in place of the computed average of category scores.
-    """
-    cat_scores = {}
-    for cat in CATEGORIES:
-        raw = compute_category_score(model_scores, cat)
-        cat_scores[cat] = round(raw * 100, 1) if raw is not None else None
-
-    if model_name is not None and model_name in GRM_SCORE_OVERRIDES:
-        grm = GRM_SCORE_OVERRIDES[model_name]
-    else:
-        available = [v for v in cat_scores.values() if v is not None]
-        grm = round(sum(available) / len(available), 1) if available else None
+    model_scores: dict[str, ScoreValue],
+    benchmark_ids: set[str] | None = None,
+) -> dict[str, float | None]:
+    """Return GRM Score and per-category scores on a 0-100 scale."""
+    raw_category_scores = {
+        category: _compute_category_score_raw(model_scores, category, benchmark_ids) for category in CATEGORIES
+    }
+    category_scores = {
+        category: round(score, 1) if score is not None else None
+        for category, score in raw_category_scores.items()
+    }
+    available = [score for score in raw_category_scores.values() if score is not None]
+    grm = round(sum(available) / len(available), 1) if available else None
 
     return {
         "GRM Score": grm,
-        "Roleplay (33%)": cat_scores["ROLEPLAY"],
-        "Actions (33%)": cat_scores["ACTIONS"],
-        "General (33%)": cat_scores["GENERAL"],
+        "Roleplay (33%)": category_scores["ROLEPLAY"],
+        "Actions (33%)": category_scores["ACTIONS"],
+        "General (33%)": category_scores["GENERAL"],
     }
 
 
-def build_leaderboard() -> list[dict]:
-    """Compute scores for all models and return sorted rows."""
+def build_leaderboard(
+    include_closed: bool = True,
+    benchmark_ids: set[str] | None = None,
+    parameter_range: tuple[float, float] | None = None,
+) -> list[dict]:
+    """Compute scores for all models and return sorted leaderboard rows."""
     rows = []
     for model_name, model_scores in MODEL_SCORES.items():
-        result = compute_grm_score(model_scores, model_name)
+        metadata = MODEL_METADATA.get(model_name, {})
+        if not include_closed and not metadata.get("open_weights", False):
+            continue
+        parameter_b = metadata.get("parameter_b")
+        if parameter_range is not None and isinstance(parameter_b, int | float):
+            minimum, maximum = parameter_range
+            if parameter_b < minimum or parameter_b > maximum:
+                continue
+
+        result = compute_grm_score(model_scores, benchmark_ids)
+        if benchmark_ids is None and model_name in CSV_GRM_SCORES:
+            result["GRM Score"] = CSV_GRM_SCORES[model_name]
         result["Model"] = model_name
+        result["Family"] = metadata.get("family")
+        result["Size"] = metadata.get("size")
+        result["Parameter B"] = parameter_b
+        result["Open Weights"] = metadata.get("open_weights", False)
         rows.append(result)
 
-    rows.sort(key=lambda r: r["GRM Score"] if r["GRM Score"] is not None else -1, reverse=True)
+    rows.sort(key=lambda row: row["GRM Score"] if row["GRM Score"] is not None else -1, reverse=True)
+    for index, row in enumerate(rows, start=1):
+        row["Rank"] = index
+    return rows
+
 
-    for i, row in enumerate(rows, start=1):
-        row["Rank"] = i
+def get_score(model_name: str, benchmark_id: str) -> ScoreValue:
+    return MODEL_SCORES.get(model_name, {}).get(benchmark_id)
 
-    return rows
+
+def official_benchmark_ids() -> set[str]:
+    return {benchmark["id"] for benchmark in BENCHMARKS if benchmark["included_in_grm"]}
+
+
+def category_label(category: str) -> str:
+    return CATEGORY_DISPLAY.get(category, category.title())

streamlit_app.py

@@ -0,0 +1,340 @@
+"""Streamlit implementation of the GRM Leaderboard Space."""
+
+from textwrap import dedent
+
+import streamlit as st
+
+from benchmarks import CATEGORY_DISPLAY, SOURCE_GRM_BENCH
+from data_views import (
+    VIEW_CATEGORY,
+    VIEW_MATRIX,
+    VIEW_SUMMARY,
+    available_domains,
+    available_sources,
+    benchmark_options,
+    build_benchmark_registry_frame,
+    build_model_benchmark_scores,
+    build_model_detail_frame,
+    build_score_explorer_frame,
+    category_from_label,
+    category_options,
+    filter_benchmarks,
+    find_benchmark_by_name,
+    model_options,
+    parameter_bounds,
+    score_stats,
+)
+from ui_theme import CUSTOM_CSS, FORMULAS, HEADER_HTML, OVERVIEW_BLOCKS, palette_css
+
+
+st.set_page_config(
+    page_title="GRM Score - Game Ready Leaderboard",
+    layout="wide",
+)
+
+theme_columns = st.columns([0.72, 0.28])
+theme_mode = theme_columns[1].radio(
+    "Theme",
+    ["Night", "Day"],
+    horizontal=True,
+    key="grm_theme_mode",
+)
+light_mode = theme_mode == "Day"
+
+st.markdown(CUSTOM_CSS, unsafe_allow_html=True)
+st.markdown(palette_css(light_mode), unsafe_allow_html=True)
+st.markdown(HEADER_HTML, unsafe_allow_html=True)
+
+
+def themed_dataframe(data):
+    if not light_mode or not hasattr(data, "style"):
+        return data
+
+    return data.style.set_properties(
+        **{
+            "background-color": "#ffffff",
+            "color": "#15181b",
+            "border-color": "#d9dee3",
+        }
+    ).set_table_styles(
+        [
+            {
+                "selector": "th",
+                "props": [
+                    ("background-color", "#eef1f4"),
+                    ("color", "#15181b"),
+                    ("border-color", "#d9dee3"),
+                ],
+            }
+        ]
+    )
+
+
+def render_dataframe(data, **kwargs) -> None:
+    st.dataframe(themed_dataframe(data), **kwargs)
+
+
+def format_sample_code(code: str) -> str:
+    lines = dedent(code).strip().splitlines()
+    formatted_lines = []
+
+    for line in lines:
+        stripped = line.lstrip()
+        leading_spaces = len(line) - len(stripped)
+        normalized_indent = " " * (leading_spaces // 2)
+        formatted_lines.append(f"{normalized_indent}{stripped}" if stripped else "")
+
+    return "\n".join(formatted_lines)
+
+
+def render_about_grm() -> None:
+    st.markdown("## About GRM Score")
+    for block in OVERVIEW_BLOCKS:
+        st.markdown(block)
+    for formula in FORMULAS:
+        st.markdown(f'<p class="formula-line">{formula}</p>', unsafe_allow_html=True)
+
+
+def render_stats(include_closed: bool, parameter_range: tuple[float, float]) -> None:
+    stats = score_stats(include_closed=include_closed, parameter_range=parameter_range)
+    columns = st.columns(5)
+    for column, (label, value) in zip(columns, stats.items(), strict=True):
+        column.metric(label, value)
+
+
+def render_score_controls() -> dict:
+    top = st.columns([1.2, 1.2, 1.2, 1.4])
+    model_visibility = top[0].radio(
+        "Model visibility",
+        ["All models", "Open-source only"],
+        index=1,
+        horizontal=True,
+        key="leaderboard_model_visibility",
+    )
+    view = top[1].radio(
+        "Score view",
+        [VIEW_SUMMARY, VIEW_CATEGORY, VIEW_MATRIX],
+        index=2,
+        horizontal=True,
+        key="leaderboard_score_view",
+    )
+    category_label = top[2].selectbox("Category", category_options(), key="leaderboard_category")
+    search = top[3].text_input("Search", placeholder="Model or benchmark", key="leaderboard_search")
+
+    filters = st.columns([1.5, 1.8, 1.8, 1.2])
+    sources = filters[0].multiselect("Source", available_sources(), placeholder="All sources", key="leaderboard_source")
+    domains = filters[1].multiselect("Domain", available_domains(), placeholder="All domains", key="leaderboard_domain")
+    minimum_size, maximum_size = parameter_bounds()
+    parameter_range = filters[2].slider(
+        "Model parameter class (B)",
+        min_value=minimum_size,
+        max_value=maximum_size,
+        value=(0.0, min(4.0, maximum_size)),
+        step=0.5,
+        format="%.1fB",
+        key="leaderboard_parameter_range_v2",
+        help="Use 0.0B for <0.5B class. The top end includes 120B+ models.",
+    )
+    recalculate_visible = filters[3].checkbox("Filtered score", value=False, key="leaderboard_filtered_score")
+
+    return {
+        "include_closed": model_visibility == "All models",
+        "view": view,
+        "category_label": category_label,
+        "search": search,
+        "sources": sources,
+        "domains": domains,
+        "parameter_range": parameter_range,
+        "recalculate_visible": recalculate_visible,
+    }
+
+
+def render_score_explorer() -> None:
+    st.markdown("## Leaderboard")
+    st.caption(
+        "Current score values are static PRD-backed values with TBD entries shown as missing. "
+        "Filtered score recalculates an exploratory score from visible benchmarks only."
+    )
+
+    controls = render_score_controls()
+    selected_category = category_from_label(controls["category_label"])
+    benchmarks = filter_benchmarks(
+        category=selected_category,
+        sources=controls["sources"],
+        domains=controls["domains"],
+        search=controls["search"],
+    )
+
+    render_stats(
+        include_closed=controls["include_closed"],
+        parameter_range=controls["parameter_range"],
+    )
+
+    frame = build_score_explorer_frame(
+        view=controls["view"],
+        category_label=controls["category_label"],
+        benchmarks=benchmarks,
+        include_closed=controls["include_closed"],
+        recalculate_visible=controls["recalculate_visible"],
+        parameter_range=controls["parameter_range"],
+    )
+    render_dataframe(frame, width="stretch", hide_index=True)
+
+    if controls["view"] == VIEW_MATRIX:
+        st.caption(f"Showing {len(benchmarks)} benchmark columns from the active filters.")
+
+    detail_cols = st.columns(2)
+    with detail_cols[0]:
+        render_model_detail(controls["include_closed"], controls["parameter_range"])
+    with detail_cols[1]:
+        render_benchmark_detail(benchmarks, key="leaderboard_benchmark_detail")
+
+
+def render_model_detail(include_closed: bool, parameter_range: tuple[float, float]) -> None:
+    models = model_options(include_closed=include_closed, parameter_range=parameter_range)
+    if not models:
+        return
+
+    selected_model = st.selectbox("Model detail", models, key="leaderboard_model_detail")
+    render_dataframe(build_model_detail_frame(selected_model), width="stretch", hide_index=True)
+
+    tabs = st.tabs(["Strongest", "Weakest"])
+    with tabs[0]:
+        render_dataframe(
+            build_model_benchmark_scores(selected_model, strongest=True),
+            width="stretch",
+            hide_index=True,
+        )
+    with tabs[1]:
+        render_dataframe(
+            build_model_benchmark_scores(selected_model, strongest=False),
+            width="stretch",
+            hide_index=True,
+        )
+
+
+def render_benchmark_detail(benchmarks: list[dict], key: str) -> None:
+    options = benchmark_options(benchmarks) or benchmark_options(filter_benchmarks())
+    if not options:
+        return
+
+    selected_name = st.selectbox("Benchmark detail", options, key=key)
+    benchmark = find_benchmark_by_name(selected_name)
+    if benchmark is None:
+        return
+
+    st.markdown(
+        f"""
+<div class="detail-panel">
+    <div class="detail-kicker">{benchmark['source']} · weight {benchmark['calc_weight']}</div>
+  <h3>{benchmark['name']}</h3>
+  <p>{benchmark['description']}</p>
+  <p>{benchmark['summary']}</p>
+</div>
+""",
+        unsafe_allow_html=True,
+    )
+
+    if benchmark.get("paper"):
+        st.markdown(f"[Paper / Source]({benchmark['paper']})")
+
+    if benchmark.get("detection_scope"):
+        st.markdown("#### Detection Scope")
+        render_dataframe(
+            benchmark["detection_scope"],
+            width="stretch",
+            hide_index=True,
+        )
+
+    with st.expander("Methodology", expanded=False):
+        st.write(benchmark["methodology"])
+        st.write("Included in official GRM Score:" if benchmark["included_in_grm"] else "Not included in official GRM Score.")
+
+
+def render_benchmark_summary_card(benchmark: dict) -> None:
+    st.markdown(
+        f"""
+<div class="detail-panel">
+  <div class="detail-kicker">{CATEGORY_DISPLAY[benchmark['category']]} · {benchmark['source']} · weight {benchmark['calc_weight']}</div>
+  <h3>{benchmark['name']}</h3>
+  <p>{benchmark['description']}</p>
+  <p>{benchmark['summary']}</p>
+</div>
+""",
+        unsafe_allow_html=True,
+    )
+    if benchmark.get("paper"):
+        st.markdown(f"[Paper / Source]({benchmark['paper']})")
+    with st.expander(f"{benchmark['name']} methodology and scope", expanded=False):
+        st.write(benchmark["methodology"])
+        if benchmark.get("detection_scope"):
+            render_dataframe(benchmark["detection_scope"], width="stretch", hide_index=True)
+
+
+def render_grm_methodology() -> None:
+    st.markdown("## GRM-Bench Methodology")
+    st.markdown(
+        "GRM-Bench is the in-house authored benchmark suite for game-facing assistants, companions, "
+        "and NPC behaviors that are not well-covered by broad academic leaderboards. The sections below "
+        "preserve the authored benchmark methodology, failure modes, and representative examples."
+    )
+
+    grm_benchmarks = filter_benchmarks(sources=[SOURCE_GRM_BENCH], include_non_scored=True)
+    for benchmark in grm_benchmarks:
+        st.markdown(f"### {benchmark['name'].replace('GRM - ', '')}")
+        st.write(benchmark["summary"])
+        st.markdown("#### Test Methodology")
+        st.write(benchmark["methodology"])
+        if benchmark.get("detection_scope"):
+            st.markdown("#### Detection Scope")
+            render_dataframe(benchmark["detection_scope"], width="stretch", hide_index=True)
+
+        if benchmark["id"] == "grm_coherence":
+            st.markdown("#### Representative Samples")
+            for sample in benchmark.get("samples", []):
+                with st.expander(sample["id"], expanded=False):
+                    for label, value in sample["metadata"]:
+                        st.markdown(f"**{label}:** {value}")
+                    st.code(format_sample_code(sample["code"]), language="json", wrap_lines=True)
+
+
+def render_benchmark_library() -> None:
+    st.markdown("## Benchmark Library")
+    st.caption("Evaluation suite reference with benchmark summaries, paper links, and GRM-Bench methodology.")
+
+    filter_cols = st.columns([1.2, 1.4, 1.8, 1.2])
+    category_label = filter_cols[0].selectbox("Library category", category_options(), key="library_category")
+    sources = filter_cols[1].multiselect("Library source", available_sources(), placeholder="All sources", key="library_source")
+    domains = filter_cols[2].multiselect("Library domain", available_domains(), placeholder="All domains", key="library_domain")
+    include_non_scored = filter_cols[3].checkbox("Show non-scored", value=True, key="library_show_non_scored")
+    search = st.text_input("Benchmark library search", placeholder="Benchmark, domain, description", key="library_search")
+
+    benchmarks = filter_benchmarks(
+        category=category_from_label(category_label),
+        sources=sources,
+        domains=domains,
+        search=search,
+        include_non_scored=include_non_scored,
+    )
+    render_dataframe(
+        build_benchmark_registry_frame(benchmarks),
+        width="stretch",
+        hide_index=True,
+        column_config={
+            "Paper / Repo": st.column_config.LinkColumn("Paper / Repo"),
+            "Summary": st.column_config.TextColumn("Summary", width="large"),
+            "Description": st.column_config.TextColumn("Description", width="large"),
+        },
+    )
+    render_grm_methodology()
+
+
+render_about_grm()
+
+leaderboard_tab, library_tab = st.tabs(["Leaderboard", "Benchmark Library"])
+
+with leaderboard_tab:
+    render_score_explorer()
+
+with library_tab:
+    render_benchmark_library()

ui_theme.py

@@ -0,0 +1,474 @@
+"""Streamlit theme helpers for the GRM leaderboard."""
+
+CUSTOM_CSS = """
+<style>
+:root {
+  --bg-top: #202327;
+  --bg-bottom: #0f1012;
+  --surface: #15181b;
+  --surface-strong: #24282d;
+  --surface-alt: #1d2126;
+  --surface-alt-2: #262a2f;
+  --text-main: #f5f7f8;
+  --text-muted: #c1c6cb;
+  --text-soft: #a2a8ae;
+  --accent: #76b900;
+  --rule: rgba(255, 255, 255, 0.08);
+  --rule-soft: rgba(255, 255, 255, 0.05);
+}
+
+html[data-grm-theme="light"] {
+  --bg-top: #f7f8fa;
+  --bg-bottom: #ffffff;
+  --surface: #ffffff;
+  --surface-strong: #eef1f4;
+  --surface-alt: #f3f5f7;
+  --surface-alt-2: #e8ecef;
+  --text-main: #15181b;
+  --text-muted: #3f474f;
+  --text-soft: #66717c;
+  --rule: rgba(15, 16, 18, 0.12);
+  --rule-soft: rgba(15, 16, 18, 0.07);
+}
+
+html[data-grm-theme="dark"] {
+  --bg-top: #202327;
+  --bg-bottom: #0f1012;
+  --surface: #15181b;
+  --surface-strong: #24282d;
+  --surface-alt: #1d2126;
+  --surface-alt-2: #262a2f;
+  --text-main: #f5f7f8;
+  --text-muted: #c1c6cb;
+  --text-soft: #a2a8ae;
+  --rule: rgba(255, 255, 255, 0.08);
+  --rule-soft: rgba(255, 255, 255, 0.05);
+}
+
+.stApp {
+  background: linear-gradient(180deg, var(--bg-top) 0%, var(--bg-bottom) 100%);
+  color: var(--text-main);
+  user-select: text;
+}
+
+.stApp ::selection {
+  background: rgba(118, 185, 0, 0.28);
+  color: var(--text-main);
+}
+
+.stApp * {
+  user-select: text;
+}
+
+.block-container {
+  max-width: 1260px;
+  padding: 24px 24px 48px;
+}
+
+.page-header {
+  text-align: center;
+  margin: 4px auto 24px;
+}
+
+.page-eyebrow {
+  color: var(--text-soft);
+  font-size: 0.76rem;
+  font-weight: 650;
+  letter-spacing: 0.16em;
+  margin-bottom: 12px;
+  text-transform: uppercase;
+}
+
+.page-header h1 {
+  color: var(--text-main);
+  font-size: 2.35rem;
+  font-weight: 650;
+  letter-spacing: 0;
+  line-height: 1.1;
+  margin: 0;
+}
+
+.page-header p {
+  color: var(--text-muted);
+  font-size: 1rem;
+  line-height: 1.65;
+  margin: 12px auto 0;
+  max-width: 860px;
+}
+
+[data-testid="stMetric"] {
+  background: var(--surface);
+  border: 1px solid var(--rule);
+  border-radius: 8px;
+  padding: 12px 14px;
+}
+
+[data-testid="stMetricLabel"] p {
+  color: var(--text-soft);
+  font-size: 0.78rem;
+  font-weight: 650;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+
+[data-testid="stMetricValue"] {
+  color: var(--text-main);
+  font-size: 1.05rem;
+}
+
+.stTabs [data-baseweb="tab-list"] {
+  border-bottom: 1px solid var(--rule);
+  gap: 18px;
+}
+
+.stTabs [data-baseweb="tab"] {
+  color: var(--text-soft);
+  font-size: 0.82rem;
+  font-weight: 650;
+  letter-spacing: 0.08em;
+  padding-left: 0;
+  padding-right: 0;
+  text-transform: uppercase;
+}
+
+.stTabs [aria-selected="true"] {
+  color: var(--text-main);
+}
+
+.stTabs [data-baseweb="tab-highlight"] {
+  background-color: var(--accent) !important;
+}
+
+.stApp [data-baseweb="checkbox"] div[aria-checked="true"] {
+  background-color: var(--accent) !important;
+  border-color: var(--accent) !important;
+}
+
+.stApp [data-testid="stRadio"] input:checked + div,
+.stApp [data-testid="stRadio"] input[aria-checked="true"] + div,
+.stApp [data-testid="stRadio"] div[aria-checked="true"],
+.stApp label[data-baseweb="radio"] input:checked ~ div:first-of-type,
+.stApp [data-baseweb="radio"] [aria-checked="true"] div:first-of-type {
+  border-color: var(--accent) !important;
+}
+
+.stApp [data-testid="stRadio"] input:checked + div::before,
+.stApp [data-testid="stRadio"] input:checked + div::after,
+.stApp [data-testid="stRadio"] div[aria-checked="true"]::before,
+.stApp [data-testid="stRadio"] div[aria-checked="true"]::after,
+.stApp label[data-baseweb="radio"] input:checked ~ div:first-of-type div,
+.stApp [data-baseweb="radio"] [aria-checked="true"] div:first-of-type div {
+  background-color: var(--accent) !important;
+}
+
+.stApp [data-testid="stRadio"] label,
+.stApp [data-testid="stRadio"] label > div,
+.stApp [data-testid="stRadio"] label:hover,
+.stApp [data-testid="stRadio"] label:focus-within {
+  background: transparent !important;
+  box-shadow: none !important;
+}
+
+.stApp [data-testid="stRadio"] label p {
+  color: var(--text-muted) !important;
+}
+
+.stApp [data-baseweb="checkbox"] svg {
+  color: var(--text-main) !important;
+  fill: var(--text-main) !important;
+}
+
+.stApp [data-baseweb="input"],
+.stApp [data-baseweb="select"],
+.stApp [data-baseweb="popover"],
+.stApp [data-baseweb="menu"],
+.stApp [data-baseweb="slider"] > div,
+.stApp [data-testid="stMultiSelect"] [data-baseweb="select"],
+.stApp [data-testid="stSelectbox"] [data-baseweb="select"] {
+  background-color: var(--surface) !important;
+  color: var(--text-main) !important;
+}
+
+.stApp [data-baseweb="input"] input,
+.stApp [data-baseweb="select"] input,
+.stApp [data-baseweb="select"] span,
+.stApp [data-baseweb="tag"],
+.stApp [data-baseweb="menu"] li,
+.stApp [data-testid="stTextInput"] input {
+  color: var(--text-main) !important;
+}
+
+.stApp [data-baseweb="input"],
+.stApp [data-baseweb="select"],
+.stApp [data-baseweb="tag"],
+.stApp [data-testid="stTextInput"] input {
+  border-color: var(--rule) !important;
+}
+
+.stApp [data-baseweb="tag"] {
+  background-color: var(--surface-alt-2) !important;
+}
+
+.stApp [data-baseweb="menu"] li:hover,
+.stApp [role="option"]:hover {
+  background-color: var(--surface-alt) !important;
+}
+
+.stMarkdown h2,
+.stMarkdown h3 {
+  color: var(--text-main);
+  letter-spacing: 0;
+}
+
+.stMarkdown p,
+.stMarkdown li,
+.stCaption,
+label,
+[data-testid="stExpander"] p {
+  color: var(--text-muted);
+}
+
+.stDataFrame {
+  background: var(--surface);
+  border: 1px solid var(--rule);
+  border-radius: 8px;
+  overflow: hidden;
+}
+
+.stDataFrame button,
+.stDataFrame [role="button"] {
+  color: var(--text-main) !important;
+}
+
+[data-testid="stExpander"] {
+  background: color-mix(in srgb, var(--surface) 78%, transparent);
+  border: 1px solid var(--rule-soft);
+  border-radius: 8px;
+}
+
+a {
+  color: var(--accent) !important;
+  text-decoration: none;
+}
+
+.section-note {
+  color: var(--text-soft);
+  font-size: 0.88rem;
+  margin: 0 0 10px;
+}
+
+.detail-panel {
+  background: var(--surface);
+  border: 1px solid var(--rule);
+  border-radius: 8px;
+  padding: 14px 16px;
+  margin: 10px 0 14px;
+}
+
+.detail-kicker {
+  color: var(--text-soft);
+  font-size: 0.76rem;
+  font-weight: 650;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
+.detail-panel h3 {
+  color: var(--text-main);
+  font-size: 1.14rem;
+  margin: 4px 0 8px;
+}
+
+.detail-panel p {
+  color: var(--text-muted);
+  line-height: 1.62;
+}
+
+.formula-line {
+  color: var(--text-main);
+  font-weight: 650;
+}
+
+.theme-toggle-row {
+  align-items: center;
+  display: flex;
+  justify-content: flex-end;
+  margin-bottom: 8px;
+}
+
+.sample-code {
+  background: var(--bg-bottom);
+  border: 1px solid var(--rule-soft);
+  border-radius: 8px;
+  color: var(--text-main);
+  overflow-x: auto;
+  padding: 16px 18px;
+}
+
+.sample-code pre {
+  background: transparent;
+  border: 0;
+  color: inherit;
+  font-family: Consolas, "SFMono-Regular", monospace;
+  font-size: 0.88rem;
+  line-height: 1.7;
+  margin: 0;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+.sample-code pre code {
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  white-space: inherit;
+}
+
+[data-testid="stCode"] pre,
+[data-testid="stCode"] code {
+  font-family: Consolas, "SFMono-Regular", monospace !important;
+  font-size: 0.88rem !important;
+  line-height: 1.7 !important;
+}
+
+@media (max-width: 720px) {
+  .block-container {
+    padding: 20px 14px 40px;
+  }
+
+  .page-header h1 {
+    font-size: 2rem;
+  }
+}
+</style>
+"""
+
+LIGHT_THEME_CSS = """
+<style>
+:root {
+  --bg-top: #f7f8fa;
+  --bg-bottom: #ffffff;
+  --surface: #ffffff;
+  --surface-strong: #eef1f4;
+  --surface-alt: #f3f5f7;
+  --surface-alt-2: #e8ecef;
+  --text-main: #15181b;
+  --text-muted: #3f474f;
+  --text-soft: #66717c;
+  --rule: rgba(15, 16, 18, 0.12);
+  --rule-soft: rgba(15, 16, 18, 0.07);
+}
+
+header[data-testid="stHeader"],
+[data-testid="stToolbar"],
+[data-testid="stDecoration"],
+[data-testid="stStatusWidget"] {
+  background-color: var(--bg-top) !important;
+  color: var(--text-main) !important;
+}
+
+.stApp [data-testid="stWidgetLabel"] p,
+.stApp [data-testid="stRadio"] p,
+.stApp [data-testid="stCheckbox"] p,
+.stApp [data-testid="stSelectbox"] p,
+.stApp [data-testid="stTextInput"] p,
+.stApp [data-testid="stMultiSelect"] p,
+.stApp label p {
+  color: var(--text-muted) !important;
+}
+
+.stTabs [aria-selected="true"] p,
+.stTabs [aria-selected="true"],
+.stApp [data-testid="stMetricValue"] {
+  color: var(--text-main) !important;
+}
+
+.stApp [data-baseweb="select"] > div,
+.stApp [data-baseweb="select"] > div *,
+.stApp [data-baseweb="input"] [data-baseweb="base-input"],
+.stApp [data-baseweb="input"] [data-baseweb="base-input"] *,
+.stApp [data-testid="stTextInputRootElement"] [data-baseweb="base-input"],
+.stApp [data-testid="stTextInputRootElement"] input {
+  background-color: var(--surface) !important;
+  color: var(--text-main) !important;
+}
+
+.stApp [data-baseweb="select"] svg,
+.stApp [data-baseweb="input"] svg {
+  color: var(--text-main) !important;
+  fill: var(--text-main) !important;
+}
+
+.stApp [data-testid="stElementToolbarButtonContainer"] {
+  background-color: var(--surface) !important;
+  color: var(--text-main) !important;
+}
+
+.stDataFrameGlideDataEditor {
+  --gdg-bg-cell: #ffffff !important;
+  --gdg-bg-cell-medium: #f7f8fa !important;
+  --gdg-bg-header: #eef1f4 !important;
+  --gdg-bg-header-hovered: #e8ecef !important;
+  --gdg-bg-header-has-focus: #e8ecef !important;
+  --gdg-bg-group-header: #eef1f4 !important;
+  --gdg-bg-group-header-hovered: #e8ecef !important;
+  --gdg-bg-bubble: #eef1f4 !important;
+  --gdg-bg-bubble-selected: #dfe5ea !important;
+  --gdg-text-dark: #15181b !important;
+  --gdg-text-medium: #3f474f !important;
+  --gdg-text-light: #66717c !important;
+  --gdg-text-header: #3f474f !important;
+  --gdg-text-header-selected: #15181b !important;
+  --gdg-text-group-header: #3f474f !important;
+  --gdg-text-bubble: #3f474f !important;
+  --gdg-border-color: rgba(15, 16, 18, 0.12) !important;
+  --gdg-horizontal-border-color: rgba(15, 16, 18, 0.08) !important;
+  --gdg-bg-icon-header: rgba(15, 16, 18, 0.42) !important;
+  --gdg-fg-icon-header: #15181b !important;
+}
+</style>
+"""
+
+DARK_THEME_CSS = """
+<style>
+:root {
+  --bg-top: #202327;
+  --bg-bottom: #0f1012;
+  --surface: #15181b;
+  --surface-strong: #24282d;
+  --surface-alt: #1d2126;
+  --surface-alt-2: #262a2f;
+  --text-main: #f5f7f8;
+  --text-muted: #c1c6cb;
+  --text-soft: #a2a8ae;
+  --rule: rgba(255, 255, 255, 0.08);
+  --rule-soft: rgba(255, 255, 255, 0.05);
+}
+</style>
+"""
+
+
+def palette_css(light_mode: bool) -> str:
+    return LIGHT_THEME_CSS if light_mode else DARK_THEME_CSS
+
+HEADER_HTML = """
+<section class="page-header">
+  <div class="page-eyebrow">NVIDIA Game Ready Evaluation</div>
+  <h1>Game Ready Leaderboard</h1>
+  <p>
+    An open game model evaluation surface for comparing LLMs across roleplay,
+    gameplay actions, and practical in-game reasoning.
+  </p>
+</section>
+"""
+
+OVERVIEW_BLOCKS = [
+    "Nvidia Game Ready Model Score (GRM) is an aggregated quality metric designed to assess LLM capabilities in gaming use cases.",
+    "General state-of-the-art language models are optimized for broad benchmarks such as math, code, and general knowledge. That does not reliably translate to in-game performance, and it does not reliably predict NPC quality, gameplay actions, or immersion.",
+    "With game model evaluation, game developers can accelerate AI integration pipelines by reducing time spent on model evaluation and narrowing model choice earlier. The overall score is the average of Roleplay, Actions, and General, while benchmarks inside each category are combined with weighted averaging using the PRD weights.",
+]
+
+FORMULAS = [
+    "GRM Score = (Roleplay + Actions + General) / 3",
+    "Category Score = sum(score x weight) / sum(weight)",
+]