Redesign Space and surface turnkey model evaluation

Launch-system interface, copyable endpoint and checkpoint commands, dense reward demo, complete-run scorer, and unchanged verified release bundle.

README.md

@@ -1,8 +1,8 @@
 ---
 title: FlavourBench
 emoji: 🍲
-colorFrom: blue
-colorTo: blue
+colorFrom: red
+colorTo: red
 sdk: gradio
 sdk_version: 6.9.0
 app_file: app.py
@@ -14,63 +14,72 @@ datasets:
 
 # FlavourBench
 
-**Josef Chen · Erim Hayretci**<br>
-Josef Chen, Independent Researcher · Erim Hayretci, Imperial College London
+![Which AI knows food best? FlavourBench leaderboard](./assets/flavourbench-leaderboard.svg)
+
+**Pick 3 ingredients from 8. Epicure scores all 56 legal portfolios first. Then every model faces
+the same 534 decisions.**
+
+The Space is both the public scorebook and a working benchmark interface:
 
-This Space explores the final FlavourBench complete common core: 27 frontier endpoints, 534
-identical tasks per model, 14,418 valid scored responses, and all 351 paired comparisons.
+- **Leaders** ranks all 27 endpoints with simultaneous intervals and statistical groups.
+- **Profiles** breaks each score into substitution, pairing, and constraint performance.
+- **Inspect** opens the exact prompt, answer, 56-choice score map, route, and content hashes.
+- **Run your model** builds a copyable endpoint or local-checkpoint command, demonstrates one dense
+  training reward, and scores a complete JSONL run.
+- **Compare** queries any of the 351 shared-task pairwise contrasts.
 
-Epicure scores all 56 legal three-ingredient portfolios before a model is called. The Space lets
-you inspect the resulting leaderboard without relying on an LLM judge. It includes:
+No model judge runs behind the interface. The Space performs deterministic lookups against the
+released reward maps and makes no model-provider calls.
 
-- the full score table with simultaneous 95% intervals and bootstrap rank intervals;
-- statistical rank groups and all Holm-adjusted pairwise comparisons;
-- family profiles and score replication across two independently compiled panels; and
-- exact prompts, candidate lists, Epicure score maps, model answers, and response hashes.
+## Run from your own environment
 
-Every ranked endpoint has one valid response for every task. The Space bundle is content-addressed
-and makes no provider calls.
+```bash
+python -m pip install "epicure-flavourbench @ git+https://github.com/josefchen/flavourbench.git"
 
-## Evaluate your own model
+export LAB_MODEL_API_KEY='...'
+flavourbench run \
+  --backend openai-compatible \
+  --base-url https://your-endpoint.example/v1 \
+  --api-key-env LAB_MODEL_API_KEY \
+  --model your-exact-model-id \
+  --responses responses.jsonl \
+  --report flavourbench-report.json \
+  --resume
+```
 
-The **Evaluate your model** tab scores a complete JSON or JSONL response artifact without receiving
-model credentials or weights. A public FlavourBench lab score is issued only when all 534 responses
-are present and parseable; incomplete runs retain coverage and per-task diagnostics. Uploads are not
-automatically added to the official leaderboard.
+Add `--limit 12` for a balanced smoke test. The runner checkpoints each answer and resumes without
+repeating completed calls. Credentials and model weights stay in your environment.
 
-Each JSONL row follows this compact contract:
+The accepted response contract is one JSON object per line:
 
 ```json
 {"task_id":"...","status":"completed","response":"FINAL_SELECTION: A,B,C"}
 ```
 
-The Space also exposes named Gradio endpoints:
-
-- `/score_completion` performs one deterministic reward-map lookup;
-- `/score_submission` scores JSON or JSON Lines supplied as text;
-- `/training_reward` scores only the 426 non-leaderboard development maps; and
-- `/score_uploaded_submission` powers the file-upload interface.
+A comparable score requires one valid answer for all 534 tasks. Partial runs still receive
+per-task and coverage diagnostics. Uploads are never added to the official leaderboard
+automatically.
 
-Use **Use via API** in the running Space for generated Python, JavaScript, and curl examples. The
-local SDK is preferable for high-throughput RL because it avoids network latency and Space rate
-limits. The Space exposes released FlavourBench reward maps, not the private Epicure corpus or a
-general arbitrary-task generation service.
+## API and training
 
-## Train on separate reward maps
+The Space exposes four named endpoints:
 
-The linked dataset now includes anchor-disjoint development splits for SFT, DPO, and GRPO. These
-training maps do not reuse any task ID or ingredient anchor from the 534-task official test set.
-Runnable LoRA recipes and the local dense reward function live in the source repository under
-`examples/lab`.
+| Endpoint | Use |
+|---|---|
+| `/score_completion` | Score one completion on one official task |
+| `/score_submission` | Score a complete JSON or JSONL artifact supplied as text |
+| `/training_reward` | Query one of 426 anchor-disjoint development reward maps |
+| `/score_uploaded_submission` | Score an uploaded artifact and return a report |
 
-Josef Chen is a Cohere Labs Catalyst Grant recipient. This acknowledgement does not imply Cohere
-endorsement of FlavourBench, Epicure, the protocol, or any model ranking.
+Use **Use via API** in the running Space for generated Python, JavaScript, and curl clients. For
+high-throughput RL, use the local deterministic reward function. The linked dataset includes
+ready-to-load SFT, DPO, and GRPO views plus runnable LoRA recipes for Hugging Face Jobs.
 
-[Paper](https://github.com/josefchen/flavourbench/blob/main/paper/build/flavourbench.pdf) |
-[Dataset](https://huggingface.co/datasets/josefchen/flavourbench) |
+[Dataset and lab kit](https://huggingface.co/datasets/josefchen/flavourbench) ·
+[Paper](https://github.com/josefchen/flavourbench/blob/main/paper/build/flavourbench.pdf) ·
 [Source](https://github.com/josefchen/flavourbench)
 
-## Citation
+Josef Chen, Independent Researcher · Erim Hayretci, Imperial College London
 
 ```bibtex
 @article{chen2026flavourbench,

app.py

@@ -4,6 +4,7 @@ import hashlib
 import html
 import json
 import os
+import shlex
 import tempfile
 from datetime import UTC, datetime
 from pathlib import Path
@@ -25,249 +26,427 @@ BUNDLE_PATH = Path(
     )
 )
 
-BLUE = "#1769AA"
-CHARCOAL = "#262B33"
+RUST = "#B54135"
+INK = "#171815"
 
 CSS = """
 :root {
-  --fb-accent: #1769AA;
-  --fb-accent-soft: #EAF3FA;
-  --fb-ink: #262B33;
-  --fb-muted: #657180;
-  --fb-paper: #F6F8FA;
-  --fb-panel: #FFFFFF;
-  --fb-rule: #D9E0E7;
-  --fb-code: #EEF2F5;
+  --fb-accent: #B54135;
+  --fb-accent-soft: #F1DDD8;
+  --fb-ink: #171815;
+  --fb-muted: #666960;
+  --fb-paper: #F4F3EE;
+  --fb-paper-raised: #FAF9F5;
+  --fb-rule: #C9CBC4;
+  --fb-code: #E8E7E1;
 }
 .dark {
-  --fb-accent-soft: #102B3E;
-  --fb-ink: #EAF0F4;
-  --fb-muted: #A7B2BC;
-  --fb-paper: #11171D;
-  --fb-panel: #182129;
-  --fb-rule: #30404D;
-  --fb-code: #202C35;
+  --fb-accent: #EF796D;
+  --fb-accent-soft: #422723;
+  --fb-ink: #F0EFE9;
+  --fb-muted: #A9ACA3;
+  --fb-paper: #171815;
+  --fb-paper-raised: #20211E;
+  --fb-rule: #41433D;
+  --fb-code: #2A2B27;
 }
+html { scroll-behavior: smooth; }
 body, .gradio-container {
   background: var(--fb-paper) !important;
   color: var(--fb-ink) !important;
   font-family: "Geist", "Avenir Next", system-ui, sans-serif !important;
 }
-.gradio-container { max-width: 1460px !important; }
-.fb-shell { max-width: 1360px; margin: 0 auto; }
+.gradio-container {
+  max-width: none !important;
+  padding: 0 !important;
+}
+.gradio-container > main { padding: 0 !important; }
+.fb-shell {
+  box-sizing: border-box;
+  margin: 0 auto;
+  max-width: 1440px;
+  padding-left: clamp(22px, 4vw, 62px);
+  padding-right: clamp(22px, 4vw, 62px);
+}
 .fb-hero {
   display: grid;
-  grid-template-columns: minmax(0, .9fr) minmax(520px, 1.1fr);
-  gap: 54px;
-  padding: 48px 8px 34px;
-  border-bottom: 1px solid var(--fb-rule);
+  gap: clamp(40px, 6vw, 96px);
+  grid-template-columns: minmax(360px, .82fr) minmax(540px, 1.18fr);
+  padding-bottom: 42px;
+  padding-top: clamp(46px, 6vw, 86px);
 }
 .fb-kicker {
   color: var(--fb-accent);
   font-family: "IBM Plex Mono", ui-monospace, monospace;
-  font-size: 12px;
-  font-weight: 700;
-  letter-spacing: .12em;
+  font-size: 11px;
+  font-weight: 600;
+  letter-spacing: .13em;
   text-transform: uppercase;
 }
 .fb-hero h1 {
   color: var(--fb-ink);
-  font-size: clamp(46px, 6vw, 78px);
-  letter-spacing: -.06em;
-  line-height: .96;
-  margin: 14px 0 18px;
-  max-width: 760px;
+  font-size: clamp(56px, 6vw, 92px);
+  font-weight: 650;
+  letter-spacing: -.065em;
+  line-height: .91;
+  margin: 18px 0 23px;
+  max-width: 740px;
 }
 .fb-dek {
   color: var(--fb-muted);
-  font-size: 19px;
-  line-height: 1.48;
+  font-size: clamp(17px, 1.6vw, 21px);
+  line-height: 1.46;
   margin: 0;
-  max-width: 640px;
-}
-.fb-byline {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 10px 22px;
-  margin: 16px 0 0;
-}
-.fb-byline span {
-  color: var(--fb-ink);
-  display: flex;
-  flex-direction: column;
-  font-size: 14px;
-  font-weight: 650;
-  letter-spacing: .01em;
-}
-.fb-byline small {
-  color: var(--fb-muted);
-  font-size: 11px;
-  font-weight: 500;
-  letter-spacing: .04em;
-  margin-top: 2px;
+  max-width: 570px;
 }
 .fb-stats {
+  border-top: 1px solid var(--fb-ink);
   display: grid;
-  grid-template-columns: repeat(4, minmax(92px, 1fr));
-  gap: 22px;
-  margin-top: 31px;
+  gap: 20px;
+  grid-template-columns: repeat(4, minmax(88px, 1fr));
+  margin-top: 36px;
+  padding-top: 13px;
 }
-.fb-stat { border-top: 2px solid var(--fb-rule); padding-top: 11px; }
 .fb-stat strong {
   color: var(--fb-ink);
   display: block;
-  font-size: 26px;
+  font-size: 25px;
+  font-weight: 620;
   letter-spacing: -.04em;
   line-height: 1;
 }
 .fb-stat span {
   color: var(--fb-muted);
   display: block;
-  font-size: 11px;
+  font-family: "IBM Plex Mono", ui-monospace, monospace;
+  font-size: 10px;
+  letter-spacing: .06em;
   margin-top: 7px;
   text-transform: uppercase;
-  letter-spacing: .07em;
 }
 .fb-frontier {
   align-self: end;
-  background: var(--fb-panel);
-  border: 1px solid var(--fb-rule);
-  border-top: 4px solid var(--fb-accent);
-  border-radius: 8px;
-  padding: 20px 22px 16px;
+  border-top: 1px solid var(--fb-ink);
+  min-width: 0;
+  padding-top: 12px;
 }
 .fb-frontier-head {
   align-items: baseline;
   display: flex;
+  gap: 16px;
   justify-content: space-between;
-  margin-bottom: 13px;
+  margin-bottom: 15px;
+}
+.fb-frontier-head strong { font-size: 15px; font-weight: 620; }
+.fb-frontier-head span {
+  color: var(--fb-muted);
+  font-family: "IBM Plex Mono", ui-monospace, monospace;
+  font-size: 10px;
+  text-align: right;
 }
-.fb-frontier-head strong { font-size: 14px; }
-.fb-frontier-head span { color: var(--fb-muted); font-size: 12px; }
 .fb-forest-row {
   align-items: center;
+  border-bottom: 1px solid var(--fb-rule);
   display: grid;
-  grid-template-columns: 150px 1fr 42px 38px;
-  gap: 10px;
-  min-height: 26px;
+  gap: 12px;
+  grid-template-columns: 22px minmax(130px, 190px) 1fr 47px;
+  min-height: 36px;
+}
+.fb-place {
+  color: var(--fb-muted);
+  font-family: "IBM Plex Mono", ui-monospace, monospace;
+  font-size: 10px;
 }
 .fb-model {
   color: var(--fb-ink);
   font-size: 12px;
+  font-weight: 560;
   overflow: hidden;
   text-overflow: ellipsis;
   white-space: nowrap;
 }
-.fb-axis { height: 13px; position: relative; }
+.fb-axis {
+  height: 10px;
+  position: relative;
+}
 .fb-axis::before {
   background: var(--fb-rule);
   content: "";
-  height: 1px;
+  height: 2px;
   left: 0;
   position: absolute;
   right: 0;
-  top: 6px;
-}
-.fb-ci {
-  border-top: 2px solid var(--fb-muted);
-  height: 1px;
-  position: absolute;
-  top: 5px;
+  top: 4px;
 }
-.fb-ci::before, .fb-ci::after {
-  background: var(--fb-muted);
-  content: "";
-  height: 7px;
+.fb-bar {
+  background: #A7ABA4;
+  height: 4px;
+  left: 0;
   position: absolute;
-  top: -4px;
-  width: 1px;
+  top: 3px;
 }
-.fb-ci::before { left: 0; }
-.fb-ci::after { right: 0; }
 .fb-point {
-  background: var(--fb-accent);
-  height: 11px;
+  background: var(--fb-ink);
+  border-radius: 50%;
+  height: 10px;
   position: absolute;
-  top: 1px;
-  width: 3px;
+  top: 0;
+  transform: translateX(-50%);
+  width: 10px;
 }
+.fb-forest-row:first-of-type .fb-bar,
+.fb-forest-row:first-of-type .fb-point { background: var(--fb-accent); }
+.fb-forest-row:first-of-type .fb-model,
+.fb-forest-row:first-of-type .fb-number { color: var(--fb-accent); }
 .fb-number {
   color: var(--fb-ink);
   font-family: "IBM Plex Mono", ui-monospace, monospace;
-  font-size: 11px;
+  font-size: 12px;
+  font-weight: 600;
   text-align: right;
 }
-.fb-group {
+.fb-chart-foot {
   color: var(--fb-muted);
+  display: flex;
   font-family: "IBM Plex Mono", ui-monospace, monospace;
-  font-size: 10px;
-  text-align: right;
+  font-size: 9px;
+  justify-content: space-between;
+  margin: 9px 59px 0 224px;
+}
+.tab-wrapper {
+  border-bottom: 1px solid var(--fb-rule);
+  border-top: 1px solid var(--fb-rule);
 }
-.fb-section { margin: 27px 0 8px; }
+.tab-nav {
+  margin: 0 auto !important;
+  max-width: 1316px !important;
+  padding-left: clamp(22px, 4vw, 62px) !important;
+  padding-right: clamp(22px, 4vw, 62px) !important;
+}
+.tab-nav button {
+  border: 0 !important;
+  color: var(--fb-muted) !important;
+  font-size: 13px !important;
+  padding: 15px 0 13px !important;
+  margin-right: 30px !important;
+}
+.tab-nav button.selected {
+  border-bottom: 2px solid var(--fb-accent) !important;
+  color: var(--fb-ink) !important;
+}
+.overflow-menu { display: none !important; }
+.tab-container.visually-hidden { display: none !important; }
+.tabitem {
+  box-sizing: border-box;
+  margin: 0 auto !important;
+  max-width: 1440px !important;
+  padding: 0 clamp(22px, 4vw, 62px) !important;
+}
+.fb-section { margin: 36px 0 18px; }
 .fb-section h2 {
   color: var(--fb-ink);
-  font-size: 30px;
-  letter-spacing: -.035em;
-  margin: 0 0 4px;
+  font-size: clamp(30px, 3vw, 45px);
+  font-weight: 620;
+  letter-spacing: -.045em;
+  line-height: 1.02;
+  margin: 0 0 9px;
+}
+.fb-section p {
+  color: var(--fb-muted);
+  font-size: 15px;
+  line-height: 1.5;
+  margin: 0;
+  max-width: 72ch;
 }
-.fb-section p { color: var(--fb-muted); margin: 0; max-width: 70ch; }
+.fb-step-line {
+  border-bottom: 1px solid var(--fb-rule);
+  border-top: 1px solid var(--fb-rule);
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  margin: 8px 0 26px;
+}
+.fb-step { padding: 18px 22px 20px 0; }
+.fb-step + .fb-step { border-left: 1px solid var(--fb-rule); padding-left: 22px; }
+.fb-step b {
+  color: var(--fb-accent);
+  display: block;
+  font-family: "IBM Plex Mono", ui-monospace, monospace;
+  font-size: 10px;
+  letter-spacing: .08em;
+  margin-bottom: 7px;
+  text-transform: uppercase;
+}
+.fb-step strong { display: block; font-size: 17px; margin-bottom: 4px; }
+.fb-step span { color: var(--fb-muted); font-size: 13px; line-height: 1.45; }
 .fb-metric-grid {
+  border-bottom: 1px solid var(--fb-rule);
+  border-top: 1px solid var(--fb-rule);
   display: grid;
   grid-template-columns: repeat(3, 1fr);
-  gap: 12px;
-  margin: 8px 0 16px;
+  margin: 10px 0 22px;
 }
-.fb-metric {
-  background: var(--fb-panel);
-  border: 1px solid var(--fb-rule);
-  border-radius: 8px;
-  padding: 16px;
+.fb-metric { min-width: 0; padding: 19px 22px 21px 0; }
+.fb-metric:nth-child(3n+2), .fb-metric:nth-child(3n+3) {
+  border-left: 1px solid var(--fb-rule);
+  padding-left: 22px;
 }
+.fb-metric:nth-child(n+4) { border-top: 1px solid var(--fb-rule); }
 .fb-metric small {
   color: var(--fb-muted);
   display: block;
-  font-size: 11px;
+  font-family: "IBM Plex Mono", ui-monospace, monospace;
+  font-size: 10px;
   letter-spacing: .05em;
   text-transform: uppercase;
 }
-.fb-metric strong { color: var(--fb-ink); display: block; font-size: 23px; margin-top: 5px; }
+.fb-metric strong {
+  color: var(--fb-ink);
+  display: block;
+  font-size: 24px;
+  font-weight: 620;
+  margin-top: 5px;
+  overflow-wrap: anywhere;
+}
 .fb-evidence {
-  background: var(--fb-accent-soft);
-  border-left: 4px solid var(--fb-accent);
-  border-radius: 0 8px 8px 0;
+  border-bottom: 1px solid var(--fb-rule);
+  border-top: 1px solid var(--fb-rule);
   color: var(--fb-ink);
-  line-height: 1.48;
-  padding: 17px 19px;
+  line-height: 1.52;
+  padding: 15px 0;
 }
+.fb-evidence strong:first-child { color: var(--fb-accent); }
 .fb-evidence code, .fb-hash {
   background: var(--fb-code);
   color: var(--fb-muted);
   font-family: "IBM Plex Mono", ui-monospace, monospace;
   font-size: 11px;
+  overflow-wrap: anywhere;
 }
 .fb-method {
   display: grid;
-  grid-template-columns: 1.15fr .85fr;
-  gap: 28px;
+  gap: clamp(30px, 6vw, 86px);
+  grid-template-columns: 1.25fr .75fr;
+}
+.fb-method h3 { font-size: 19px; margin: 23px 0 6px; }
+.fb-method p { color: var(--fb-muted); line-height: 1.55; }
+.fb-command-note {
+  color: var(--fb-muted);
+  font-family: "IBM Plex Mono", ui-monospace, monospace;
+  font-size: 10px;
+  line-height: 1.5;
+}
+.fb-table-wrap {
+  overflow-x: auto;
+  width: 100%;
 }
+.fb-table {
+  border: 0 !important;
+  color: var(--fb-ink);
+  font-family: "IBM Plex Mono", ui-monospace, monospace;
+  font-size: 12px;
+  min-width: 860px;
+  width: 100%;
+}
+.fb-table caption {
+  height: 1px;
+  overflow: hidden;
+  position: absolute;
+  width: 1px;
+}
+.fb-table th {
+  border-left: 0 !important;
+  border-right: 0 !important;
+  border-top: 0 !important;
+  border-bottom: 1px solid var(--fb-ink);
+  color: var(--fb-muted);
+  font-size: 10px;
+  font-weight: 600;
+  letter-spacing: .05em;
+  padding: 10px 12px 11px 0;
+  text-align: left;
+  text-transform: uppercase;
+}
+.fb-table td {
+  border-left: 0 !important;
+  border-right: 0 !important;
+  border-top: 0 !important;
+  border-bottom: 1px solid var(--fb-rule);
+  padding: 11px 12px 11px 0;
+  vertical-align: top;
+}
+.fb-table .fb-score-cell { font-weight: 600; }
+.fb-table tbody tr:first-child .fb-rank-cell,
+.fb-table tbody tr:first-child .fb-score-cell { color: var(--fb-accent); }
+.fb-table tbody tr:hover { background: color-mix(in srgb, var(--fb-ink) 3%, transparent); }
 .fb-footer {
   border-top: 1px solid var(--fb-rule);
   color: var(--fb-muted);
+  display: flex;
   font-size: 12px;
-  margin-top: 36px;
-  padding: 18px 8px 26px;
+  justify-content: space-between;
+  margin-top: 54px;
+  padding-bottom: 30px;
+  padding-top: 18px;
+}
+.fb-footer a { color: var(--fb-ink); text-decoration: none; }
+.fb-footer a:hover { color: var(--fb-accent); text-decoration: underline; }
+.gradio-container footer a, .gradio-container footer button { color: var(--fb-muted) !important; }
+.block, .form, .gradio-dataframe, .gradio-json, .gradio-textbox {
+  border-radius: 0 !important;
+  box-shadow: none !important;
+}
+.block:not(.gradio-dataframe):not(.gradio-json):not(.gradio-textbox) {
+  border-color: transparent !important;
+}
+button.primary {
+  background: var(--fb-ink) !important;
+  border: 1px solid var(--fb-ink) !important;
+  border-radius: 0 !important;
+  color: var(--fb-paper) !important;
+  min-height: 44px !important;
+}
+button.primary:hover { background: var(--fb-accent) !important; border-color: var(--fb-accent) !important; }
+input, textarea, select {
+  border-radius: 0 !important;
+  box-shadow: none !important;
 }
-.gradio-dataframe, .block { border-radius: 8px !important; }
-@media (max-width: 980px) {
-  .fb-hero, .fb-method { grid-template-columns: 1fr; }
-  .fb-hero { gap: 28px; padding-top: 34px; }
+input:focus, textarea:focus, select:focus, button:focus-visible, a:focus-visible {
+  outline: 2px solid var(--fb-accent) !important;
+  outline-offset: 2px !important;
 }
-@media (max-width: 700px) {
-  .fb-hero h1 { font-size: 48px; }
-  .fb-stats, .fb-metric-grid { grid-template-columns: repeat(2, 1fr); }
-  .fb-forest-row { grid-template-columns: 105px 1fr 36px 30px; }
+table { border-collapse: collapse !important; }
+th { background: var(--fb-paper) !important; }
+pre, code { border-radius: 0 !important; }
+@media (max-width: 1040px) {
+  .fb-hero { grid-template-columns: 1fr; }
+  .fb-frontier { max-width: 820px; }
+  .fb-method { grid-template-columns: 1fr; }
+}
+@media (max-width: 720px) {
+  .fb-hero { gap: 38px; padding-bottom: 32px; }
+  .fb-hero h1 { font-size: clamp(52px, 15vw, 72px); }
+  .fb-stats { gap: 16px 10px; grid-template-columns: repeat(2, 1fr); }
+  .fb-forest-row { gap: 8px; grid-template-columns: 19px minmax(96px, 142px) 1fr 42px; }
+  .fb-model { font-size: 11px; }
+  .fb-chart-foot { margin-left: 133px; margin-right: 50px; }
+  .fb-chart-foot span:nth-child(2) { display: none; }
+  .fb-step-line { grid-template-columns: 1fr; }
+  .fb-step + .fb-step { border-left: 0; border-top: 1px solid var(--fb-rule); padding-left: 0; }
+  .fb-metric-grid { grid-template-columns: repeat(2, 1fr); }
+  .fb-metric:nth-child(3n+2), .fb-metric:nth-child(3n+3) { border-left: 0; padding-left: 0; }
+  .fb-metric:nth-child(even) { border-left: 1px solid var(--fb-rule); padding-left: 18px; }
+  .fb-metric:nth-child(n+3) { border-top: 1px solid var(--fb-rule); }
+  .tab-nav { overflow-x: auto !important; }
+  .tab-nav button { margin-right: 22px !important; white-space: nowrap !important; }
+  .fb-footer { display: block; }
+  .fb-footer span { display: block; margin-top: 7px; }
+}
+@media (max-width: 430px) {
+  .fb-forest-row { grid-template-columns: 18px minmax(82px, 114px) 1fr 39px; }
+  .fb-chart-foot { margin-left: 109px; margin-right: 47px; }
 }
 @media (prefers-reduced-motion: reduce) {
+  html { scroll-behavior: auto; }
   *, *::before, *::after { animation: none !important; transition: none !important; }
 }
 """
@@ -341,6 +520,58 @@ TASK_LABEL_TO_ID = {
     f"{row['task_id']} | {str(row['family']).replace('_', ' ')}": str(row["task_id"])
     for row in TASKS
 }
+LAB_TASK_LABEL_TO_ID = {
+    f"{row['task_id']} | {str(row['family']).replace('_', ' ')} | {row['lab_split']}": str(
+        row["task_id"]
+    )
+    for row in LAB_TASKS
+}
+
+
+def _lab_name(row: dict[str, Any]) -> str:
+    model_name = str(row["model_name"])
+    prefixes = (
+        ("SpaceXAI:", "xAI"),
+        ("Anthropic:", "Anthropic"),
+        ("Claude ", "Anthropic"),
+        ("MoonshotAI:", "Kimi"),
+        ("ByteDance Seed:", "ByteDance"),
+        ("Thinking Machines:", "Thinking Machines"),
+        ("MiniMax:", "MiniMax"),
+        ("DeepSeek:", "DeepSeek"),
+        ("OpenAI:", "OpenAI"),
+        ("Google:", "Google"),
+        ("Meta:", "Meta"),
+        ("Qwen:", "Qwen"),
+        ("Tencent:", "Tencent"),
+        ("Z.ai:", "Z.ai"),
+        ("NVIDIA:", "NVIDIA"),
+        ("Cohere:", "Cohere"),
+        ("Mistral:", "Mistral"),
+    )
+    for prefix, lab in prefixes:
+        if model_name.startswith(prefix):
+            return lab
+    return str(row.get("provider_name") or model_name.split(":", 1)[0])
+
+
+def _model_label(model_name: str) -> str:
+    label = model_name.split(":", 1)[-1].strip()
+    return (
+        label.replace("GPT-5.6 ", "5.6 ")
+        .replace("Claude ", "")
+        .replace("DeepSeek ", "")
+        .replace("Command ", "")
+    )
+
+
+_seen_labs: set[str] = set()
+LAB_CHAMPIONS: list[dict[str, Any]] = []
+for _model in DISPLAY_MODELS:
+    _lab = _lab_name(_model)
+    if _lab not in _seen_labs:
+        _seen_labs.add(_lab)
+        LAB_CHAMPIONS.append(_model)
 
 
 def _completion_diagnostic(model_id: str) -> dict[str, Any]:
@@ -378,61 +609,51 @@ def _completion_diagnostic(model_id: str) -> dict[str, Any]:
     }
 
 
-def _short(value: str) -> str:
-    return (
-        value.replace("GPT-5.6 ", "5.6 ")
-        .replace("Claude ", "")
-        .replace("DeepSeek ", "DS ")
-        .replace("Command ", "Cmd ")
-    )
-
-
 def _frontier_html() -> str:
+    axis_floor = 55.0
+    axis_ceiling = 66.0
     rows = []
-    for model in DISPLAY_MODELS[:10]:
+    for place, model in enumerate(LAB_CHAMPIONS[:10], start=1):
         score = float(model["flavourbench_score"])
-        lower, upper = (float(value) for value in model["score_simultaneous_95_ci"])
-        left = max(0.0, min(100.0, lower))
-        right = max(left, min(100.0, upper))
-        group = model.get("statistical_rank_group")
+        position = max(0.0, min(100.0, (score - axis_floor) / (axis_ceiling - axis_floor) * 100))
+        full_name = str(model["model_name"])
+        lab = _lab_name(model)
+        label = _model_label(full_name)
         rows.append(
             "<div class='fb-forest-row'>"
-            f"<div class='fb-model' title='{html.escape(str(model['model_name']))}'>"
-            f"{html.escape(_short(str(model['model_name'])))}</div>"
+            f"<div class='fb-place'>{place:02d}</div>"
+            f"<div class='fb-model' title='{html.escape(full_name)}'>"
+            f"{html.escape(lab)} · {html.escape(label)}</div>"
             "<div class='fb-axis'>"
-            f"<span class='fb-ci' style='left:{left:.3f}%;width:{right - left:.3f}%'></span>"
-            f"<span class='fb-point' style='left:{score:.3f}%'></span>"
+            f"<span class='fb-bar' style='width:{position:.3f}%'></span>"
+            f"<span class='fb-point' style='left:{position:.3f}%'></span>"
             "</div>"
             f"<div class='fb-number'>{score:.1f}</div>"
-            f"<div class='fb-group'>G{group if group is not None else '-'}</div>"
             "</div>"
         )
-    return "".join(rows)
+    return "".join(rows) + (
+        f"<div class='fb-chart-foot'><span>{axis_floor:.0f}</span>"
+        f"<span>FlavourBench Score</span><span>{axis_ceiling:.0f}</span></div>"
+    )
 
 
 def _hero_html() -> str:
     inference = BUNDLE["analysis"]["inference"]
-    panel_phrase = f" across {PANEL_COUNT} collection panels" if PANEL_COUNT > 1 else ""
     return f"""
     <div class="fb-shell fb-hero">
       <section>
-        <div class="fb-kicker">Executable culinary evaluation</div>
-        <h1>{TASK_COUNT:,} decisions.<br>No model judge.</h1>
-        <p class="fb-dek">Executable score maps rank {MODEL_COUNT} frontier endpoints{panel_phrase}
-        with anchor-clustered uncertainty and inspectable responses.</p>
-        <div class="fb-byline">
-          <span>Josef Chen<small>Independent Researcher</small></span>
-          <span>Erim Hayretci<small>Imperial College London</small></span>
-        </div>
+        <div class="fb-kicker">FlavourBench / executable benchmark</div>
+        <h1>Which AI knows food best?</h1>
+        <p class="fb-dek">Epicure scores every legal answer first. Then {MODEL_COUNT} frontier endpoints face the same {TASK_COUNT} food decisions.</p>
         <div class="fb-stats">
-          <div class="fb-stat"><strong>{MODEL_COUNT}</strong><span>models</span></div>
-          <div class="fb-stat"><strong>{TASK_COUNT}</strong><span>tasks</span></div>
-          <div class="fb-stat"><strong>{PRIMARY_COUNT:,}</strong><span>primary cells</span></div>
-          <div class="fb-stat"><strong>{inference["pairwise_hypotheses"]}</strong><span>paired tests</span></div>
+          <div class="fb-stat"><strong>{MODEL_COUNT}</strong><span>frontier endpoints</span></div>
+          <div class="fb-stat"><strong>{TASK_COUNT}</strong><span>shared tasks</span></div>
+          <div class="fb-stat"><strong>{PRIMARY_COUNT:,}</strong><span>scored answers</span></div>
+          <div class="fb-stat"><strong>{inference["pairwise_hypotheses"]}</strong><span>model pairs</span></div>
         </div>
       </section>
-      <section class="fb-frontier" aria-label="Score forest with simultaneous intervals">
-        <div class="fb-frontier-head"><strong>FlavourBench Score</strong><span>Top 10, simultaneous 95%</span></div>
+      <section class="fb-frontier" aria-label="Best FlavourBench model from each leading lab">
+        <div class="fb-frontier-head"><strong>Best model from each lab</strong><span>Point estimates · focused 55 to 66 axis</span></div>
         {_frontier_html()}
       </section>
     </div>
@@ -447,18 +668,48 @@ def _leaderboard_frame() -> pd.DataFrame:
         rows.append(
             {
                 "Rank": model["point_estimate_rank"],
-                "Group": model["statistical_rank_group"],
                 "Model": model["model_name"],
-                "Score": round(float(model["flavourbench_score"]), 2),
+                "Score ↑": round(float(model["flavourbench_score"]), 2),
                 "Simultaneous 95%": f"{ci[0]:.2f} to {ci[1]:.2f}",
+                "Group": model["statistical_rank_group"],
                 "Rank 95%": f"{rank_ci[0]} to {rank_ci[1]}",
                 "Cells": f"{model['coverage']['valid_scored']}/{TASK_COUNT}",
-                "Backend": model["execution_backend"],
             }
         )
     return pd.DataFrame(rows)
 
 
+def _leaderboard_html() -> str:
+    rows = []
+    for model in DISPLAY_MODELS:
+        ci = model["score_simultaneous_95_ci"]
+        rank_ci = model["bootstrap_rank_95_interval"]
+        rows.append(
+            "<tr>"
+            f"<td class='fb-rank-cell'>{int(model['point_estimate_rank']):02d}</td>"
+            f"<td>{html.escape(str(model['model_name']))}</td>"
+            f"<td class='fb-score-cell'>{float(model['flavourbench_score']):.2f}</td>"
+            f"<td>{float(ci[0]):.2f} to {float(ci[1]):.2f}</td>"
+            f"<td>G{model['statistical_rank_group']}</td>"
+            f"<td>{rank_ci[0]} to {rank_ci[1]}</td>"
+            f"<td>{model['coverage']['valid_scored']}/{TASK_COUNT}</td>"
+            "</tr>"
+        )
+    return """
+    <div class="fb-table-wrap">
+      <table class="fb-table">
+        <caption>Complete FlavourBench common-core leaderboard</caption>
+        <thead><tr>
+          <th scope="col">Rank</th><th scope="col">Model</th><th scope="col">Score</th>
+          <th scope="col">Simultaneous 95%</th><th scope="col">Group</th>
+          <th scope="col">Rank 95%</th><th scope="col">Cells</th>
+        </tr></thead>
+        <tbody>""" + "".join(rows) + """</tbody>
+      </table>
+    </div>
+    """
+
+
 def _model_detail(model_name: str) -> tuple[str, pd.DataFrame]:
     model = MODEL_BY_NAME[model_name]
     rank_interval = model["bootstrap_rank_95_interval"]
@@ -614,6 +865,55 @@ def _training_reward_api(task_id: str, completion: str) -> dict[str, Any]:
     }
 
 
+def _command_preview(
+    runtime: str,
+    model: str,
+    base_url: str,
+    api_key_env: str,
+    scope: str,
+) -> str:
+    """Render a copyable lab command without receiving model credentials."""
+
+    model = " ".join(str(model or "").split()) or "your-exact-model-id"
+    base_url = " ".join(str(base_url or "").split()) or "https://your-endpoint.example/v1"
+    api_key_env = "".join(character for character in str(api_key_env or "") if character.isalnum() or character == "_")
+    api_key_env = api_key_env or "LAB_MODEL_API_KEY"
+    smoke = " --limit 12" if scope.startswith("12-task") else ""
+    backend = "transformers" if runtime.startswith("Local") else "openai-compatible"
+    route = ""
+    if backend == "openai-compatible":
+        route = f" \\\n+  --base-url {shlex.quote(base_url)} \\\n+  --api-key-env {shlex.quote(api_key_env)}"
+    command = (
+        "python -m pip install \"epicure-flavourbench @ "
+        "git+https://github.com/josefchen/flavourbench.git\"\n\n"
+        f"flavourbench run \\\n+  --backend {backend} \\\n+  --model {shlex.quote(model)}"
+        f"{route} \\\n+  --responses responses.jsonl \\\n+  --report flavourbench-report.json \\\n+  --resume{smoke}"
+    )
+    note = (
+        f"Set `{api_key_env}` in your shell before running. The key stays on your machine."
+        if backend == "openai-compatible"
+        else "The checkpoint runs locally through Transformers. No endpoint credential is used."
+    )
+    return f"```bash\n{command}\n```\n\n{note}"
+
+
+def _reward_preview(task_label: str, completion: str) -> str:
+    """Score one development completion for the interactive reward demonstration."""
+
+    task_id = LAB_TASK_LABEL_TO_ID[task_label]
+    try:
+        result = _training_reward_api(task_id, completion)
+    except SpaceLabError as error:
+        return f"<div class='fb-evidence'><strong>Not parseable.</strong> {html.escape(str(error))}</div>"
+    selection = html.escape(str(result.get("selection") or result.get("observed_selection") or ""))
+    return f"""
+    <div class="fb-evidence">
+      <strong>Reward {float(result['reward']):.4f}</strong> · score {float(result['score']):.2f} · selection <code>{selection}</code><br>
+      This map belongs to the anchor-disjoint development track. It cannot alter the public leaderboard.
+    </div>
+    """
+
+
 def _score_upload(
     artifact_path: str | None,
     model_name: str,
@@ -689,62 +989,56 @@ def _score_upload(
 
 theme = gr.themes.Base(
     primary_hue=gr.themes.Color(
-        c50="#EAF3FA",
-        c100="#D5E8F5",
-        c200="#A9D0E9",
-        c300="#75B3DA",
-        c400="#4292C6",
-        c500=BLUE,
-        c600="#12588F",
-        c700="#104873",
-        c800="#103C5D",
-        c900="#10334E",
-        c950="#081E30",
+        c50="#F8ECE9",
+        c100="#F1DDD8",
+        c200="#E7BCB5",
+        c300="#D98F84",
+        c400="#C96357",
+        c500=RUST,
+        c600="#98352D",
+        c700="#7C2E28",
+        c800="#662A25",
+        c900="#562722",
+        c950="#2F120F",
     ),
-    neutral_hue="slate",
+    neutral_hue="stone",
     font=gr.themes.GoogleFont("Geist", weights=(400, 500, 600, 700)),
     font_mono=gr.themes.GoogleFont("IBM Plex Mono", weights=(400, 600)),
 ).set(
-    body_background_fill="#F6F8FA",
-    block_background_fill="#FFFFFF",
-    block_border_width="1px",
+    body_background_fill="#F4F3EE",
+    block_background_fill="#F4F3EE",
+    block_border_width="0px",
     block_label_text_weight="600",
-    button_primary_background_fill=BLUE,
-    button_primary_background_fill_hover="#12588F",
+    button_primary_background_fill=INK,
+    button_primary_background_fill_hover=RUST,
 )
 
 
-with gr.Blocks(title="FlavourBench | Executable culinary evaluation") as demo:
+with gr.Blocks(title="FlavourBench | Which AI knows food best?") as demo:
     gr.HTML(_hero_html())
     with gr.Tabs():
-        with gr.Tab("Leaderboard"):
+        with gr.Tab("Leaders"):
             gr.HTML(
-                """
+                f"""
                 <div class="fb-section">
-                  <h2>The complete common-core leaderboard</h2>
-                  <p>Every model is scored on the same 534 tasks. Point ranks sit beside statistical groups and simultaneous intervals.</p>
+                  <h2>The full scoreboard</h2>
+                  <p>One score for the same {TASK_COUNT} tasks. Intervals and rank groups show which gaps the shared-task evidence can actually resolve.</p>
                 </div>
                 """
             )
-            gr.Dataframe(
-                value=_leaderboard_frame(),
-                interactive=False,
-                wrap=True,
-                show_search="filter",
-                show_row_numbers=False,
-                column_widths=[55, 55, 245, 80, 180, 110, 125, 120],
-            )
+            gr.HTML(_leaderboard_html())
             gr.Markdown(
-                "A point rank orders the observed scores. A statistical group keeps models together "
-                "when the shared-task evidence does not separate them after multiplicity control."
+                "**Read the score first.** The focused chart above uses point estimates. "
+                "The table adds simultaneous 95% bands, bootstrap rank intervals, and multiplicity-controlled groups. "
+                "A score of 100 means selecting Epicure's optimum on every task."
             )
 
-        with gr.Tab("Model profile"):
+        with gr.Tab("Profiles"):
             gr.HTML(
                 """
                 <div class="fb-section">
-                  <h2>Family profile and panel replication</h2>
-                  <p>Inspect where a model earns its score and how its estimate moves across the two independently compiled panels.</p>
+                  <h2>Where each model wins</h2>
+                  <p>Break the headline score into substitution, pairing, and constraint performance, then compare the two collection panels.</p>
                 </div>
                 """
             )
@@ -765,14 +1059,15 @@ with gr.Blocks(title="FlavourBench | Executable culinary evaluation") as demo:
                 _model_detail,
                 inputs=model_selector,
                 outputs=[model_summary, family_table],
+                api_visibility="private",
             )
 
-        with gr.Tab("Task lens"):
+        with gr.Tab("Inspect"):
             gr.HTML(
                 """
                 <div class="fb-section">
                   <h2>Open one scored decision</h2>
-                  <p>Read the prompt, the model answer, and the top of the precomputed reward surface.</p>
+                  <p>Every answer is traceable to the exact prompt, model response, and precomputed 56-choice reward surface.</p>
                 </div>
                 """
             )
@@ -791,36 +1086,120 @@ with gr.Blocks(title="FlavourBench | Executable culinary evaluation") as demo:
                     filterable=True,
                     scale=2,
                 )
-                inspect_task = gr.Button("Inspect", variant="primary", scale=0)
+                inspect_task = gr.Button("Inspect task", variant="primary", scale=0)
             initial = _task_detail(MODEL_NAMES[0], next(iter(TASK_LABEL_TO_ID)))
             task_status = gr.HTML(initial[0])
-            prompt = gr.Textbox(value=initial[1], label="Exact prompt", lines=13, interactive=False)
-            choices = gr.JSON(value=initial[2], label="Candidates")
+            prompt = gr.Textbox(value=initial[1], label="Exact prompt", lines=11, interactive=False)
+            choices = gr.JSON(value=initial[2], label="Eight candidates")
             score_map = gr.Dataframe(
                 value=initial[3],
-                label="Top 12 of 56 frozen selections",
+                label="Top 12 of 56 scored selections",
                 interactive=False,
                 wrap=True,
                 show_row_numbers=False,
             )
             answer = gr.Markdown(value=initial[4], label="Model response")
-            provenance = gr.Markdown(value=initial[5], label="Provenance")
+            provenance = gr.Markdown(value=initial[5], label="Content hashes and route")
             inspect_task.click(
                 _task_detail,
                 inputs=[task_model, task_selector],
                 outputs=[task_status, prompt, choices, score_map, answer, provenance],
+                api_visibility="private",
             )
 
-        with gr.Tab("Evaluate your model"):
+        with gr.Tab("Run your model"):
             gr.HTML(
                 f"""
                 <div class="fb-section">
-                  <h2>Bring a checkpoint or endpoint</h2>
-                  <p>Run the prompts in your own environment, upload the response artifact, and score it here. Credentials and model weights never enter this Space.</p>
+                  <h2>Run FlavourBench on any model</h2>
+                  <p>Your endpoint key or checkpoint stays in your environment. The open runner fetches the exact task set, resumes interrupted jobs, and writes a verifiable report.</p>
+                </div>
+                <div class="fb-step-line">
+                  <div class="fb-step"><b>01 / Connect</b><strong>Endpoint or checkpoint</strong><span>OpenAI-compatible APIs and local Transformers models use the same task contract.</span></div>
+                  <div class="fb-step"><b>02 / Run</b><strong>{TASK_COUNT} shared decisions</strong><span>Start with 12 tasks, then resume into the complete run without repeating finished calls.</span></div>
+                  <div class="fb-step"><b>03 / Verify</b><strong>Score plus uncertainty</strong><span>The report binds the task set, responses, score, coverage, and inference by hash.</span></div>
+                </div>
+                """
+            )
+            with gr.Row():
+                with gr.Column(scale=1):
+                    runtime = gr.Radio(
+                        choices=["Hosted OpenAI-compatible endpoint", "Local Transformers checkpoint"],
+                        value="Hosted OpenAI-compatible endpoint",
+                        label="Runtime",
+                    )
+                    run_model = gr.Textbox(
+                        value="your-exact-model-id",
+                        label="Model ID or checkpoint",
+                    )
+                    run_scope = gr.Radio(
+                        choices=["12-task smoke test", f"Full {TASK_COUNT}-task benchmark"],
+                        value="12-task smoke test",
+                        label="Run size",
+                    )
+                with gr.Column(scale=1):
+                    run_base_url = gr.Textbox(
+                        value="https://your-endpoint.example/v1",
+                        label="Base URL for hosted endpoints",
+                    )
+                    run_key_env = gr.Textbox(
+                        value="LAB_MODEL_API_KEY",
+                        label="Local environment variable containing the key",
+                    )
+                    generate_command = gr.Button("Build command", variant="primary")
+            initial_command = _command_preview(
+                "Hosted OpenAI-compatible endpoint",
+                "your-exact-model-id",
+                "https://your-endpoint.example/v1",
+                "LAB_MODEL_API_KEY",
+                "12-task smoke test",
+            )
+            run_command = gr.Markdown(initial_command)
+            generate_command.click(
+                _command_preview,
+                inputs=[runtime, run_model, run_base_url, run_key_env, run_scope],
+                outputs=run_command,
+                api_visibility="private",
+            )
+
+            gr.HTML(
+                """
+                <div class="fb-section">
+                  <h2>Try the training reward</h2>
+                  <p>Paste one completion and query an anchor-disjoint development map. This is the same deterministic reward used by the local GRPO recipe.</p>
                 </div>
-                <div class="fb-evidence">
-                  <strong>Comparable means complete.</strong> A lab score requires one valid answer for every one of the {TASK_COUNT} released tasks. Partial runs receive coverage and per-task diagnostics only.
+                """
+            )
+            initial_lab_label = next(iter(LAB_TASK_LABEL_TO_ID))
+            with gr.Row():
+                reward_task = gr.Dropdown(
+                    choices=list(LAB_TASK_LABEL_TO_ID),
+                    value=initial_lab_label,
+                    label="Development task",
+                    filterable=True,
+                    scale=2,
+                )
+                reward_completion = gr.Textbox(
+                    value="FINAL_SELECTION: A,B,C",
+                    label="Model completion",
+                    scale=2,
+                )
+                score_reward = gr.Button("Score answer", variant="primary", scale=0)
+            reward_result = gr.HTML(_reward_preview(initial_lab_label, "FINAL_SELECTION: A,B,C"))
+            score_reward.click(
+                _reward_preview,
+                inputs=[reward_task, reward_completion],
+                outputs=reward_result,
+                api_visibility="private",
+            )
+
+            gr.HTML(
+                f"""
+                <div class="fb-section">
+                  <h2>Score a completed run</h2>
+                  <p>Upload one JSON or JSONL response per task. Complete runs receive a FlavourBench Score; partial runs receive diagnostics only.</p>
                 </div>
+                <div class="fb-evidence"><strong>Comparable means complete.</strong> All {TASK_COUNT} responses must be present and parseable. Uploads are scored in-session and never added to the public leaderboard automatically.</div>
                 """
             )
             with gr.Row():
@@ -845,7 +1224,7 @@ with gr.Blocks(title="FlavourBench | Executable culinary evaluation") as demo:
                 file_types=[".jsonl", ".json"],
                 type="filepath",
             )
-            score_upload = gr.Button("Score artifact", variant="primary")
+            score_upload = gr.Button("Score complete artifact", variant="primary")
             lab_summary = gr.Markdown()
             lab_rows = gr.Dataframe(
                 interactive=False,
@@ -863,26 +1242,22 @@ with gr.Blocks(title="FlavourBench | Executable culinary evaluation") as demo:
             )
             gr.Markdown(
                 """
-The accepted JSONL contract is one object per task:
-
 ```json
 {"task_id":"...","status":"completed","response":"FINAL_SELECTION: A,B,C"}
 ```
 
-For automation, use the named `score_completion`, `score_submission`, and `training_reward`
-endpoints shown under **Use via API** in the Space footer. `training_reward` accepts only the 426
-development task IDs; it cannot score against the leaderboard by accident. The source repository
-also provides a local runner, scorer, schemas, and TRL recipes. Local reward lookup remains the
-recommended path for high-throughput training.
+The named `score_completion`, `score_submission`, and `training_reward` endpoints appear under
+**Use via API**. For high-throughput RL, use the local reward lookup and the runnable SFT, DPO,
+and GRPO recipes in the source repository.
                 """
             )
 
-        with gr.Tab("Pairwise evidence"):
+        with gr.Tab("Compare"):
             gr.HTML(
                 f"""
                 <div class="fb-section">
-                  <h2>Is the score gap resolved?</h2>
-                  <p>Query any paired contrast from the {PAIR_COUNT}-test family.</p>
+                  <h2>Does the gap hold up?</h2>
+                  <p>Query any of the {PAIR_COUNT} paired model contrasts on the same tasks, with Holm control across the full comparison family.</p>
                 </div>
                 """
             )
@@ -899,34 +1274,45 @@ recommended path for high-throughput training.
                     label="Second model",
                     filterable=True,
                 )
-                compare = gr.Button("Compare", variant="primary", scale=0)
+                compare = gr.Button("Compare models", variant="primary", scale=0)
             pair_result = gr.HTML(_pair_detail(MODEL_NAMES[0], MODEL_NAMES[1]))
-            compare.click(_pair_detail, inputs=[left_model, right_model], outputs=pair_result)
+            compare.click(
+                _pair_detail,
+                inputs=[left_model, right_model],
+                outputs=pair_result,
+                api_visibility="private",
+            )
 
-        with gr.Tab("Method and download"):
+        with gr.Tab("Method"):
             gr.HTML(
                 f"""
                 <div class="fb-section">
-                  <h2>One metric, complete evidence</h2>
-                  <p>The Space makes no model or provider calls. Its lab API performs deterministic lookups against the released reward maps.</p>
+                  <h2>One lookup, repeated {TASK_COUNT} times</h2>
+                  <p>The Space makes no provider calls. It reads released reward maps and returns deterministic scores.</p>
+                </div>
+                <div class="fb-step-line">
+                  <div class="fb-step"><b>Task</b><strong>Pick 3 of 8</strong><span>Each prompt defines exactly 56 legal portfolios.</span></div>
+                  <div class="fb-step"><b>Ground truth</b><strong>Score all 56 first</strong><span>Epicure constructs the task map before any evaluated model runs.</span></div>
+                  <div class="fb-step"><b>Benchmark</b><strong>Aggregate 534 choices</strong><span>The metric equal-weights substitution, pairing, and constraint families.</span></div>
                 </div>
                 <div class="fb-method">
                   <div>
                     <h3>Scoring contract</h3>
-                    <p>Every task exposes eight candidates and all 56 three-item scores. The
-                    FlavourBench Score is the equal-family mean across substitution, pairing, and
-                    constraint tasks. The release uses a complete 27-by-534 matrix: every ranked
-                    model contributes one valid response to every scored task.</p>
+                    <p>A task score ranges from 0 to 100 on its released Epicure map. The complete
+                    release is a {MODEL_COUNT} by {TASK_COUNT} matrix with one valid response in every cell.</p>
                     <h3>Inference</h3>
                     <p>Results use {INDEPENDENT_CLUSTER_COUNT:,} ingredient-anchor clusters,
-                    50,000 ingredient-anchor cluster bootstraps, simultaneous score bands,
-                    100,000 cluster sign flips, Holm correction, exact-chance tests, bootstrap rank
-                    intervals, and an independently compiled second panel.</p>
+                    50,000 shared cluster bootstraps, simultaneous score bands, 100,000 cluster
+                    sign flips, Holm correction, exact tests against a random legal choice, bootstrap rank intervals,
+                    and an independently compiled second panel.</p>
+                    <h3>Training boundary</h3>
+                    <p>The 426 SFT, DPO, and GRPO development maps use anchors that do not occur in
+                    the {TASK_COUNT}-task leaderboard. Training cannot query the official test reward maps by accident.</p>
                   </div>
                   <aside class="fb-evidence">
-                    <strong>Exact release</strong><br>
+                    <strong>Content-addressed release</strong><br>
                     <span class="fb-hash">{BUNDLE["release_artifact_sha256"]}</span><br><br>
-                    {MODEL_COUNT} models<br>{TASK_COUNT} tasks<br>{INDEPENDENT_CLUSTER_COUNT:,} anchor clusters<br>{PRIMARY_COUNT:,} complete scored responses<br>{BUNDLE["analysis"]["resolved_pair_count"]}/{PAIR_COUNT} resolved pairs
+                    {MODEL_COUNT} endpoints<br>{TASK_COUNT} tasks<br>{INDEPENDENT_CLUSTER_COUNT:,} anchor clusters<br>{PRIMARY_COUNT:,} complete answers<br>{BUNDLE["analysis"]["resolved_pair_count"]}/{PAIR_COUNT} resolved pairs
                   </aside>
                 </div>
                 """
@@ -936,12 +1322,9 @@ recommended path for high-throughput training.
 ```bash
 git clone https://github.com/josefchen/flavourbench.git
 cd flavourbench
-pip install -e '.[dev]'
-make -C paper -f Makefile.powered verify
-make -C paper -f Makefile.powered arxiv
+python -m pip install -e '.[dev]'
+pytest -q tests/lab_cli_test.py tests/hf_lab_space_api_test.py
 ```
-
-[Paper](https://github.com/josefchen/flavourbench/blob/main/paper/build/flavourbench.pdf) | [Dataset](https://huggingface.co/datasets/josefchen/flavourbench) | [Source](https://github.com/josefchen/flavourbench)
                 """
             )
 
@@ -967,7 +1350,8 @@ make -C paper -f Makefile.powered arxiv
     gr.HTML(
         """
         <div class="fb-shell fb-footer">
-          FlavourBench | Josef Chen, Independent Researcher · Erim Hayretci, Imperial College London
+          <div>FlavourBench · Josef Chen, Independent Researcher · Erim Hayretci, Imperial College London</div>
+          <span><a href="https://github.com/josefchen/flavourbench/blob/main/paper/build/flavourbench.pdf">Paper</a> · <a href="https://huggingface.co/datasets/josefchen/flavourbench">Dataset</a> · <a href="https://github.com/josefchen/flavourbench">Source</a></span>
         </div>
         """
     )