PRIMO Space redesign: baselines, open boards, Contribute tab, quickstart, PRIMO identity

README.md

@@ -22,10 +22,14 @@ per-category leaderboard. The datasets are opaque (`d001`, `d002`…) — you ne
 see the disease, tissue, or target — so you grade the *embedding*, not per-task
 tuning.
 
-The Space has five tabs: **Home** (a grid of boards), **Leaderboard** (one board
-at a time), **Tasks**, a **Submit** form (sign in with Hugging Face), and
-**About**. Every board has its own URL — `?board=rheumatology-bulk-rna` — so a
-board can be linked to directly.
+The Space has six tabs: **Home** (a grid of boards), **Leaderboard** (one board
+at a time), **Tasks**, a **Submit** form (sign in with Hugging Face),
+**Contribute**, and **About**. Every board has its own URL —
+`?board=rheumatology-bulk-rna` — and every tab too, as `?tab=contribute`.
+
+Home also shows **open boards**: greyed-out cards for the omics layers PRIMO does
+not cover yet. They are declared in `boards.py` (`OPEN_BOARDS`) and drop out on
+their own once the registry covers that slice.
 
 🌐 Website: http://primomics.org/ ·
 📄 Paper: https://openreview.net/forum?id=v2SA8gHwqo ·
@@ -35,7 +39,7 @@ board can be linked to directly.
 
 PRIMO benchmarks any omics modality. Today's datasets are all **bulk RNA-seq**,
 covering **immune-mediated inflammatory diseases (IMIDs)** with real clinical
-labels from published cohorts (more modalities are coming):
+labels from published cohorts:
 
 - **Gastroenterology** — Crohn's disease, ulcerative colitis (anti-TNF response, severity scores)
 - **Dermatology** — atopic dermatitis, psoriasis (severity scores)
@@ -87,6 +91,18 @@ and an AUROC on single-cell are not the same number.
 Partial and failed submissions still get feedback, and their scores always appear
 in each board's **per-task** table even when they are not ranked.
 
+## Make a submission
+
+`quickstart.py` is the shortest path: it downloads every dataset, embeds each one
+(log2(CPM+1) → PCA) and writes the file the Submit tab wants. Swap its `embed`
+function for your encoder and nothing else changes. `example_submission.csv`
+shows the expected shape in four lines.
+
+```bash
+pip install anndata scikit-learn pandas pyyaml huggingface_hub
+python quickstart.py --out submission.parquet
+```
+
 ## Run the scorer locally
 
 ```bash
@@ -95,6 +111,15 @@ export HF_TOKEN=...   # read access to the PRIMO datasets
 python evaluator.py --submission my_embeddings.parquet
 ```
 
+## Baselines
+
+`task_results.csv` carries an `is_baseline` flag. Reference submissions we
+produce ourselves (a random embedding, PCA / HVG recipes over log-CPM) are
+published with it set, rendered as `name (baseline)`, and **ranked in place** —
+a foundation model losing to a PCA is the result worth publishing, so it is
+never hidden at the bottom of the table. They are generated and pushed by
+`benchmark/public_benchmark/baselines.py --score --publish`.
+
 ## Space configuration
 
 - **`hf_oauth: true`** (set above) turns on the Submit tab's *Sign in with
@@ -110,3 +135,17 @@ python evaluator.py --submission my_embeddings.parquet
 - Submitter contact metadata (HF username, email, paper / model links, notes)
   persists to a separate `submissions.csv` in the same **private** results
   dataset — it never reaches the public leaderboard.
+
+## Moving to another Hugging Face org
+
+The three dataset repos are derived from one constant, `ORG` in `evaluator.py`.
+The rest of the org name is spelled out and has to be changed by hand:
+
+- `SPACE_REPO` in `benchmark/public_benchmark/deploy_space.py`
+- `PUBLIC_REPO` in `quickstart.py`
+- the links in this file and in `pages/*.md`
+
+The theme follows the PRIMO charter: Funnel Display for headings, Funnel Sans for
+everything else, Scienta Navy `#080F5F` / PRIMO Cyan `#16B3C0` on Paper
+`#F3F8F8`. `colorFrom`/`colorTo` above stay `indigo`/`blue` because Hugging Face
+only accepts eight named colours and none of them is cyan.

app.py

@@ -1,8 +1,9 @@
 """Gradio front-end for the PRIMO public benchmark.
 
-Five pages: Home (a grid of boards), Leaderboard (one board at a time), Tasks
-("what is actually being tested?"), Submit ("how do I enter?"), About ("can I
-trust this?").
+Six pages: Home (a grid of boards), Leaderboard (one board at a time), Tasks
+("what is actually being tested?"), Submit ("how do I enter?"), Contribute
+("what is missing, and how do I add it?"), About ("can I trust this?"). A tab is
+addressable as ``?tab=contribute``, which is what the open cards on Home link to.
 
 Upload one embedding file spanning every dataset (rows keyed by ``dataset_id``
 + ``sample_id``); a fixed linear probe scores each task (a dataset may carry
@@ -24,17 +25,16 @@ what to fix; an evaluator-side failure says "our side, please retry" and logs
 the traceback rather than blaming the submission.
 """
 
-import io
 import os
 import traceback
 from datetime import datetime, timezone
+from html import escape
 from pathlib import Path
 
 import gradio as gr
 import pandas as pd
 from boards import Board, build_boards, by_slug
 from evaluator import (
-    RESULTS_REPO,
     EvaluatorError,
     SubmissionError,
     _norm_id,
@@ -44,7 +44,7 @@ from evaluator import (
     score_all,
     scoreable_tasks,
 )
-from home import home_html
+from home import banner_html, home_html
 from leaderboard import (
     TASK_COLUMNS,
     per_task_table,
@@ -52,62 +52,71 @@ from leaderboard import (
     source_repositories,
     tasks_table,
 )
+from results import (
+    BASELINE_TAG,
+    IS_BASELINE,
+    RESULT_COLUMNS,
+    append_results,
+    append_submission,
+    read_results,
+)
 
 PAGES_DIR = Path(__file__).parent / "pages"
 STYLE = (Path(__file__).parent / "style.css").read_text()
 
 TOKEN = os.environ.get("HF_TOKEN")
-RESULTS_FILE = "task_results.csv"
-SUBMISSIONS_FILE = "submissions.csv"
-RESULT_COLUMNS = ["model_name", "task_id", "score", "submitted_at"]
-SUBMISSION_COLUMNS = [
-    "model_name",
-    "submitted_at",
-    "hf_username",
-    "email",
-    "paper_link",
-    "hf_model_link",
-    "notes",
-]
-
-INK = "#0b0f19"
-PANEL = "#10151f"
-LINE = "#1f2733"
-TEXT = "#e8ebf2"
-MUTED = "#8b93a7"
+TAB_IDS = ("home", "leaderboard", "tasks", "submit", "contribute", "about")
+
+NAVY = "#080F5F"
+DEEP_NAVY = "#050A3C"
+CYAN = "#16B3C0"
+PAPER = "#F3F8F8"
+SLATE = "#54686B"
+HAIRLINE = "#D6E2E3"
+SURFACE = "#FFFFFF"
+CYAN_INK = "#0F7F89"
 
 THEME = gr.themes.Base(
-    primary_hue=gr.themes.colors.blue,
+    primary_hue=gr.themes.colors.cyan,
     secondary_hue=gr.themes.colors.blue,
     neutral_hue=gr.themes.colors.slate,
-    font=(gr.themes.GoogleFont("Inter"), "ui-sans-serif", "system-ui", "sans-serif"),
+    font=(
+        gr.themes.GoogleFont("Funnel Sans"),
+        "ui-sans-serif",
+        "system-ui",
+        "sans-serif",
+    ),
 ).set(
-    body_background_fill=INK,
-    body_background_fill_dark=INK,
-    background_fill_primary=INK,
-    background_fill_primary_dark=INK,
-    background_fill_secondary=PANEL,
-    background_fill_secondary_dark=PANEL,
-    block_background_fill=INK,
-    block_background_fill_dark=INK,
-    panel_background_fill=PANEL,
-    block_label_background_fill=PANEL,
-    block_label_text_color=MUTED,
-    body_text_color=TEXT,
-    body_text_color_dark=TEXT,
-    body_text_color_subdued=MUTED,
-    body_text_color_subdued_dark=MUTED,
-    border_color_primary=LINE,
-    border_color_primary_dark=LINE,
-    block_border_color=LINE,
-    input_background_fill=PANEL,
-    input_background_fill_dark=PANEL,
-    button_secondary_background_fill=PANEL,
-    table_border_color=LINE,
-    table_text_color=TEXT,
-    table_even_background_fill=INK,
-    table_odd_background_fill=PANEL,
-    link_text_color="#60a5fa",
+    color_accent=CYAN,
+    border_color_accent=CYAN,
+    body_background_fill=PAPER,
+    body_background_fill_dark=PAPER,
+    background_fill_primary=SURFACE,
+    background_fill_primary_dark=SURFACE,
+    background_fill_secondary=PAPER,
+    background_fill_secondary_dark=PAPER,
+    block_background_fill=SURFACE,
+    block_background_fill_dark=SURFACE,
+    panel_background_fill=PAPER,
+    block_label_background_fill=PAPER,
+    block_label_text_color=SLATE,
+    body_text_color=DEEP_NAVY,
+    body_text_color_dark=DEEP_NAVY,
+    body_text_color_subdued=SLATE,
+    body_text_color_subdued_dark=SLATE,
+    border_color_primary=HAIRLINE,
+    border_color_primary_dark=HAIRLINE,
+    block_border_color=HAIRLINE,
+    input_background_fill=SURFACE,
+    input_background_fill_dark=SURFACE,
+    button_primary_background_fill=NAVY,
+    button_primary_text_color=PAPER,
+    button_secondary_background_fill=SURFACE,
+    table_border_color=HAIRLINE,
+    table_text_color=DEEP_NAVY,
+    table_even_background_fill=SURFACE,
+    table_odd_background_fill=PAPER,
+    link_text_color=CYAN_INK,
 )
 
 
@@ -120,53 +129,6 @@ def _page_text(name: str) -> str:
     return (PAGES_DIR / f"{name}.md").read_text()
 
 
-def _read_csv(filename: str, columns: list[str]) -> pd.DataFrame:
-    from huggingface_hub import hf_hub_download
-    from huggingface_hub.utils import EntryNotFoundError, RepositoryNotFoundError
-
-    try:
-        path = hf_hub_download(RESULTS_REPO, filename, repo_type="dataset", token=TOKEN)
-    except (RepositoryNotFoundError, EntryNotFoundError):
-        return pd.DataFrame(columns=columns)
-    return pd.read_csv(path)
-
-
-def _upload_csv(filename: str, df: pd.DataFrame) -> None:
-    from huggingface_hub import HfApi
-
-    api = HfApi(token=TOKEN)
-    api.create_repo(RESULTS_REPO, repo_type="dataset", private=True, exist_ok=True)
-    buffer = io.BytesIO()
-    df.to_csv(buffer, index=False)
-    buffer.seek(0)
-    api.upload_file(
-        path_or_fileobj=buffer,
-        path_in_repo=filename,
-        repo_id=RESULTS_REPO,
-        repo_type="dataset",
-    )
-
-
-def _read_results() -> pd.DataFrame:
-    return _read_csv(RESULTS_FILE, RESULT_COLUMNS)
-
-
-def _append_results(rows: list[dict]) -> None:
-    if not rows:
-        return
-    df = pd.concat([_read_results(), pd.DataFrame(rows)], ignore_index=True)
-    _upload_csv(RESULTS_FILE, df)
-
-
-def _append_submission(meta: dict) -> None:
-    """Persist a submitter's contact metadata to the private results repo."""
-    df = pd.concat(
-        [_read_csv(SUBMISSIONS_FILE, SUBMISSION_COLUMNS), pd.DataFrame([meta])],
-        ignore_index=True,
-    )
-    _upload_csv(SUBMISSIONS_FILE, df)
-
-
 def _registry_by_id() -> dict[str, dict]:
     """Scoreable tasks keyed by task_id (dataset present in the public manifest)."""
     datasets = manifest_ids(fetch_manifest(TOKEN))
@@ -182,7 +144,7 @@ def _page_state() -> tuple[dict[str, dict], list[Board], pd.DataFrame]:
     """
     try:
         by_id = _registry_by_id()
-        return by_id, build_boards(by_id), _read_results()
+        return by_id, build_boards(by_id), read_results(TOKEN)
     except Exception:  # noqa: BLE001
         traceback.print_exc()
         return {}, [], pd.DataFrame(columns=RESULT_COLUMNS)
@@ -206,7 +168,7 @@ def _score_columns(df: pd.DataFrame) -> list[str]:
 
 
 def _styled(df: pd.DataFrame, label: str, axis: int, pinned: int) -> gr.DataFrame:
-    """A dark, MTEB-style table: best value in bold, ids pinned, searchable.
+    """An MTEB-style table: best value in bold, ids pinned, searchable.
 
     ``axis=0`` bolds the best model per column (the ranked table); ``axis=1``
     bolds the best model per row (the per-task table, read across). The label
@@ -235,15 +197,19 @@ def _styled(df: pd.DataFrame, label: str, axis: int, pinned: int) -> gr.DataFram
 
 
 def _board_header(board: Board | None) -> str:
+    """The board title strip. Registry strings are escaped: they are data, not code."""
     if board is None:
         return (
             '<div class="primo-board-head"><h2>No board available</h2>'
             "<p>The task registry could not be loaded — please retry shortly.</p></div>"
         )
     return (
-        f'<div class="primo-board-head primo-accent"><h2>{board.icon} {board.name}</h2>'
-        f"<p>{board.blurb} — {board.n_tasks} tasks · {board.n_cohorts} cohorts · "
-        f"{board.n_patients:,} patients · {board.modality}</p></div>"
+        '<div class="primo-board-head primo-accent"><h2>'
+        f'<span class="primo-code primo-code-modality">{escape(board.code)}</span>'
+        f"{escape(board.name)}</h2>"
+        f"<p>{escape(board.blurb)} — {board.n_tasks} tasks · "
+        f"{board.n_cohorts} cohorts · {board.n_patients:,} patients · "
+        f"{escape(board.modality)}</p></div>"
     )
 
 
@@ -270,7 +236,7 @@ def _board_page(slug: str | None):
 
 
 def _board_choices(boards: list[Board]) -> list[tuple[str, str]]:
-    return [(f"{b.icon}  {b.name} · {b.group}", b.slug) for b in boards]
+    return [(f"{b.code} · {b.name} · {b.group}", b.slug) for b in boards]
 
 
 def _tasks_page() -> pd.DataFrame:
@@ -345,6 +311,11 @@ def evaluate(
         return _refuse("Please enter a model name.")
     if not email or not email.strip():
         return _refuse("Please enter a contact email.")
+    if BASELINE_TAG in model_name.lower():
+        return _refuse(
+            f"`{BASELINE_TAG}` is reserved for our reference submissions — please "
+            "pick another model name."
+        )
     try:
         result = score_all(submission_path, TOKEN)
     except SubmissionError as error:
@@ -368,6 +339,7 @@ def evaluate(
             "task_id": task.task_id,
             "score": round(float(task.score), 4),
             "submitted_at": submitted_at,
+            IS_BASELINE: False,
         }
         for task in result["per_task"]
     ]
@@ -381,25 +353,38 @@ def evaluate(
         "notes": (notes or "").strip(),
     }
     try:
-        _append_results(rows)
-        _append_submission(meta)
+        append_results(rows, TOKEN)
+        append_submission(meta, TOKEN)
     except Exception as error:  # noqa: BLE001
         traceback.print_exc()
         summary += f"\n\n⚠️ scored, but the leaderboard was not saved: {error}"
     return (summary, *_board_page(slug))
 
 
+def _landing_tab(params: dict, has_board: bool) -> str:
+    """Which tab a visitor lands on: ``?tab=`` wins, then ``?board=``, else Home.
+
+    An unknown ``?tab=`` falls through to Home rather than selecting nothing,
+    which would render the Space with every panel collapsed.
+    """
+    tab = params.get("tab")
+    if tab in TAB_IDS:
+        return tab
+    return "leaderboard" if has_board else "home"
+
+
 def _init(request: gr.Request):
-    """Render home + the board named by ``?board=``, landing on it when asked."""
+    """Render home + the board named by ``?board=``, landing where asked."""
     by_id, boards, df = _page_state()
-    slug = request.query_params.get("board") if request else None
-    board = by_slug(boards, slug)
-    selected = "leaderboard" if slug and board else "home"
+    params = dict(request.query_params) if request else {}
+    board = by_slug(boards, params.get("board"))
+    selected = _landing_tab(params, bool(params.get("board") and board))
     return (
         gr.Tabs(selected=selected),
         gr.Dropdown(
             choices=_board_choices(boards), value=board.slug if board else None
         ),
+        banner_html(boards),
         home_html(boards, df, by_id),
         *_board_page(board.slug if board else None),
     )
@@ -411,9 +396,13 @@ def build_demo() -> gr.Blocks:
     ) as demo:
         gr.Markdown(
             "# 🧬 PRIMO — Patient Representations in Multi-Omics\n\n"
-            "A **benchmark for omics foundation models**: does your model's patient "
-            "embedding capture real clinical signal?"
+            "**Omics foundation models are benchmarked on cells and genes. "
+            "Medicine acts on patients.** PRIMO scores one thing: does your "
+            "model's patient embedding predict a real clinical outcome — drug "
+            "response, disease severity, molecular subtype — on cohorts whose "
+            "labels you never see?"
         )
+        banner = gr.HTML()
         with gr.Tabs() as tabs:
             with gr.Tab("Home", id="home"):
                 home = gr.HTML()
@@ -465,6 +454,8 @@ def build_demo() -> gr.Blocks:
                         )
                 run_btn = gr.Button("Evaluate", variant="primary")
                 result_md = gr.Markdown()
+            with gr.Tab("Contribute", id="contribute"):
+                gr.Markdown(_page_text("contribute"))
             with gr.Tab("About", id="about"):
                 about_md = gr.Markdown()
 
@@ -475,7 +466,7 @@ def build_demo() -> gr.Blocks:
             [result_md, *board_view],
         )
         board_sel.change(_board_page, board_sel, board_view)
-        demo.load(_init, None, [tabs, board_sel, home, *board_view])
+        demo.load(_init, None, [tabs, board_sel, banner, home, *board_view])
         demo.load(_tasks_page, None, tasks_df)
         demo.load(_about_page, None, about_md)
     return demo

boards.py

@@ -12,6 +12,12 @@ because an AUROC on bulk RNA and an AUROC on single-cell are not the same
 number. With one modality in the registry that is invisible; a second one
 doubles the cards instead of silently mixing them.
 
+``OPEN_BOARDS`` names the slices PRIMO does NOT cover, so the home page states
+its own gaps instead of implying the registry is the whole territory. They are a
+hand-written constant, not a roadmap: a slice belongs here when a contributor
+could plausibly bring it, and it disappears on its own the day the registry
+covers it.
+
 Pure functions over registry dicts -- no Gradio, no network, no HTML.
 """
 
@@ -32,18 +38,8 @@ GROUP_NOTE = {
     CATEGORY_GROUP: "Per-question leaderboards",
 }
 
-ICONS = {
-    "bulk RNA": "🧬",
-    "single-cell RNA": "🔬",
-    "proteomics": "⚗️",
-    "Gastroenterology": "🩺",
-    "Dermatology": "🧴",
-    "Rheumatology": "🦴",
-    "treatment_outcome": "💊",
-    "clinical_scores": "📈",
-    "endotype": "🧩",
-}
-FALLBACK_ICON = "🔹"
+CODE_LENGTH = 3
+FALLBACK_CODE = "—"
 
 CATEGORY_BLURB = {
     "treatment_outcome": "Will this patient respond to the drug?",
@@ -64,6 +60,18 @@ def metric_label(metric: str) -> str:
     return METRIC_LABEL.get(metric, metric)
 
 
+def short_code(name: str) -> str:
+    """The board's letter tag, standing in for what used to be a per-board emoji.
+
+    Derived from the name rather than looked up, because a lookup table is what
+    breaks: spatial transcriptomics or metabolomics would land on a shrug the day
+    somebody adds them. Colour carries the group; these letters only carry the
+    board.
+    """
+    letters = re.sub(r"[^a-z]", "", name.lower())
+    return letters[:CODE_LENGTH].upper() or FALLBACK_CODE
+
+
 def slugify(*parts: str) -> str:
     """URL-safe key for a board, stable enough to paste into a link."""
     joined = "-".join(str(p) for p in parts)
@@ -90,7 +98,7 @@ class Board:
     slug: str
     group: str
     name: str
-    icon: str
+    code: str
     blurb: str
     modality: str
     task_ids: frozenset[str]
@@ -152,11 +160,12 @@ def _blurb(group: str, name: str, tasks: list[dict]) -> str:
 def _board(group: str, name: str, modality: str, tasks: list[dict]) -> Board:
     """One card. The modality board owns the bare slug; the rest are suffixed by it."""
     n_cohorts, n_patients, n_diseases = _cohort_stats(tasks)
+    display = name if group == MODALITY_GROUP else label(name)
     return Board(
         slug=slugify(modality) if group == MODALITY_GROUP else slugify(name, modality),
         group=group,
-        name=name if group == MODALITY_GROUP else label(name),
-        icon=ICONS.get(name, FALLBACK_ICON),
+        name=display,
+        code=short_code(display),
         blurb=_blurb(group, name, tasks),
         modality=modality,
         task_ids=frozenset(_norm_id(t["task_id"]) for t in tasks),
@@ -188,6 +197,39 @@ def build_boards(by_id: dict[str, dict]) -> list[Board]:
     return boards
 
 
+@dataclass(frozen=True)
+class OpenBoard:
+    """A slice nobody can be ranked on yet: a stated gap, not a leaderboard.
+
+    Deliberately not a ``Board``: it has no tasks, no cohorts and no patients, and
+    zeroing those fields would print "0 patients" on a card whose whole job is to
+    read as an invitation.
+    """
+
+    group: str
+    name: str
+    blurb: str
+
+
+OPEN_BOARDS: tuple[OpenBoard, ...] = (
+    OpenBoard(
+        MODALITY_GROUP,
+        "single-cell RNA",
+        "Dissociated tissue, labelled at the patient level. No cohort yet.",
+    ),
+    OpenBoard(
+        MODALITY_GROUP,
+        "proteomics",
+        "Plasma or tissue proteins paired with clinical follow-up. No cohort yet.",
+    ),
+    OpenBoard(
+        MODALITY_GROUP,
+        "spatial transcriptomics",
+        "Expression kept in place in the tissue, with patient outcomes. No cohort yet.",
+    ),
+)
+
+
 def in_group(boards: list[Board], group: str) -> list[Board]:
     """Cards of one section, biggest first -- the fullest board reads as the headline."""
     return sorted(
@@ -195,6 +237,20 @@ def in_group(boards: list[Board], group: str) -> list[Board]:
     )
 
 
+def open_in_group(boards: list[Board], group: str) -> list[OpenBoard]:
+    """Open cards of one section, minus any slice the registry has since covered.
+
+    The day a single-cell cohort lands, its board is built from the registry and
+    the matching open card drops out with no edit here.
+    """
+    covered = {board.name.lower() for board in in_group(boards, group)}
+    return [
+        board
+        for board in OPEN_BOARDS
+        if board.group == group and board.name.lower() not in covered
+    ]
+
+
 def featured(boards: list[Board]) -> list[Board]:
     """The hero row: every modality board, topped up with the largest others."""
     heroes = in_group(boards, MODALITY_GROUP)

evaluator.py

@@ -46,9 +46,10 @@ SPLIT = "split"
 SPLIT_TRAIN = "train"
 SPLIT_TEST = "test"
 
-PUBLIC_REPO = "ScientaLab/primo"
-LABELS_REPO = "ScientaLab/primo-labels"
-RESULTS_REPO = "ScientaLab/primo-results"
+ORG = "ScientaLab"
+PUBLIC_REPO = f"{ORG}/primo"
+LABELS_REPO = f"{ORG}/primo-labels"
+RESULTS_REPO = f"{ORG}/primo-results"
 MANIFEST_FILENAME = "datasets.yaml"
 TASKS_FILENAME = "tasks.yaml"
 LABELS_FILENAME = "labels.csv"

example_submission.csv

@@ -0,0 +1,5 @@
+dataset_id,sample_id,e0,e1,e2
+d001,SAMPLE_A,0.121,-0.443,0.982
+d001,SAMPLE_B,-0.075,0.310,0.044
+d002,SAMPLE_C,0.512,0.028,-0.157
+d002,SAMPLE_D,-0.301,-0.119,0.663

home.py

@@ -5,6 +5,11 @@ to ``gr.HTML``. Each card is a plain ``<a href="?board=...">``: clicking it
 reloads the Space on that board, which costs a page load but buys shareable
 per-board URLs and needs no JavaScript.
 
+Two things here are not leaderboards. The version strip states what v0 actually
+covers, counted off the registry so it cannot go stale. The greyed-out OPEN cards
+state what it does not cover, and link to Contribute instead of to a board: the
+page is supposed to show its own gaps, not imply the registry is the territory.
+
 Every string that comes from the registry goes through ``html.escape`` -- the
 titles, blurbs and disease names are authored data, not constants.
 """
@@ -18,11 +23,13 @@ from boards import (
     GROUP_NOTE,
     MODALITY_GROUP,
     Board,
+    OpenBoard,
     featured,
     in_group,
     metric_label,
+    open_in_group,
 )
-from leaderboard import top_models
+from leaderboard import TopModel, top_models
 
 SECTIONS = (MODALITY_GROUP, AREA_GROUP, CATEGORY_GROUP)
 N_TOP_MODELS = 3
@@ -31,6 +38,32 @@ GROUP_ACCENT = {
     AREA_GROUP: "area",
     CATEGORY_GROUP: "category",
 }
+VERSION = "v0"
+
+
+def _plural(count: int, noun: str) -> str:
+    return f"{count} {noun}" if count == 1 else f"{count} {noun}s"
+
+
+def banner_html(boards: list[Board]) -> str:
+    """The version strip shown above every tab: what the benchmark covers today.
+
+    Counted off the registry rather than written by hand, so it can never claim a
+    scope that has since changed. An unavailable registry yields no strip at all
+    -- a version claim nobody can check is worse than none.
+    """
+    modalities = in_group(boards, MODALITY_GROUP)
+    if not modalities:
+        return ""
+    areas = len({board.name for board in in_group(boards, AREA_GROUP)})
+    return (
+        f'<div class="primo-banner"><span class="primo-banner-tag">{VERSION}</span>'
+        f'<span>{escape(", ".join(b.name for b in modalities))} · '
+        f'{_plural(areas, "therapeutic area")} · '
+        f'{_plural(sum(b.n_tasks for b in modalities), "task")}. '
+        "The scope is incomplete by design — the open boards on Home say where."
+        "</span></div>"
+    )
 
 
 def _stat(name: str, value: object) -> str:
@@ -51,29 +84,43 @@ def _pills(board: Board) -> str:
     return f'<div class="primo-pills">{"".join(pills)}</div>'
 
 
-def _top_models(rows: list[tuple[str, float]]) -> str:
+def _top_row(row: TopModel) -> str:
+    tag = '<span class="primo-tag">baseline</span>' if row.is_baseline else ""
+    css = "primo-top-row primo-top-baseline" if row.is_baseline else "primo-top-row"
+    return (
+        f'<div class="{css}"><span>{escape(row.name)}{tag}</span>'
+        f"<span>{row.score:.3f}</span></div>"
+    )
+
+
+def _top_models(rows: list[TopModel]) -> str:
+    """The card's mini-ranking.
+
+    A board whose only entries are our own baselines says so: "be the first" is
+    misleading once a PCA already holds a score somebody has to beat.
+    """
     if not rows:
         return (
             '<div class="primo-top primo-top-empty">No ranked model yet — '
             "be the first.</div>"
         )
-    body = "".join(
-        f'<div class="primo-top-row"><span>{escape(model)}</span>'
-        f"<span>{score:.3f}</span></div>"
-        for model, score in rows
+    foot = (
+        '<div class="primo-top-foot">No submitted model yet — beat the baseline.</div>'
+        if all(row.is_baseline for row in rows)
+        else ""
     )
     return (
         '<div class="primo-top"><div class="primo-top-head">'
         "<span>TOP MODELS</span><span>MEAN</span></div>"
-        f"{body}</div>"
+        f'{"".join(_top_row(row) for row in rows)}{foot}</div>'
     )
 
 
-def _card(board: Board, top: list[tuple[str, float]] | None) -> str:
+def _card(board: Board, top: list[TopModel] | None) -> str:
     accent = GROUP_ACCENT.get(board.group, "modality")
     inner = [
         '<div class="primo-card-head">'
-        f'<span class="primo-icon">{escape(board.icon)}</span>'
+        f'<span class="primo-code primo-code-{accent}">{escape(board.code)}</span>'
         f'<span class="primo-card-title">{escape(board.name)}</span></div>'
     ]
     if top is None:
@@ -99,30 +146,46 @@ def _card(board: Board, top: list[tuple[str, float]] | None) -> str:
     )
 
 
-def _section(group: str, boards: list[Board]) -> str:
+def _open_card(board: OpenBoard) -> str:
+    """A greyed-out card for a slice nobody covers: no stats, one call to action."""
+    return (
+        '<a class="primo-card primo-card-open" target="_self" href="?tab=contribute">'
+        f'<div class="primo-card-head"><span class="primo-card-title">'
+        f'{escape(board.name)}</span><span class="primo-badge-open">OPEN</span></div>'
+        f'<p class="primo-blurb">{escape(board.blurb)}</p>'
+        '<div class="primo-open-cta">Propose a cohort →</div></a>'
+    )
+
+
+def _section(group: str, boards: list[Board], opens: list[OpenBoard]) -> str:
+    open_count = (
+        f'<span class="primo-count-open">+{len(opens)} open</span>' if opens else ""
+    )
     cards = "".join(_card(b, None) for b in boards)
+    cards += "".join(_open_card(b) for b in opens)
     return (
         '<section class="primo-section">'
         '<div class="primo-section-head"><h3>'
-        f'{escape(group)} <span class="primo-count">{len(boards)}</span></h3>'
+        f'{escape(group)} <span class="primo-count">{len(boards)}</span>'
+        f"{open_count}</h3>"
         f'<span class="primo-section-note">{escape(GROUP_NOTE.get(group, ""))}</span>'
         f'</div><div class="primo-grid">{cards}</div></section>'
     )
 
 
 def _sections(boards: list[Board]) -> str:
-    """One block per facet, skipping the ones that would say nothing.
+    """One block per facet: what is covered, then what is openly missing.
 
-    A registry with a single modality gets no Modality section: that board is
-    already the first hero card, and a lone card in a full-width box reads as a
-    bug. The section reappears by itself the day a second modality lands.
+    The Modality section is shown even when a single modality exists. A lone card
+    would read as a bug; a lone card beside the omics layers nobody has brought
+    yet reads as the point of the page.
     """
     out = []
     for group in SECTIONS:
-        cards = in_group(boards, group)
-        if not cards or (group == MODALITY_GROUP and len(cards) == 1):
+        cards, opens = in_group(boards, group), open_in_group(boards, group)
+        if not cards and not opens:
             continue
-        out.append(_section(group, cards))
+        out.append(_section(group, cards, opens))
     return "".join(out)
 
 

leaderboard.py

@@ -13,13 +13,20 @@ Two tables per board, deliberately different:
                    submissions, so a newcomer who covered three cohorts sees
                    their numbers instead of vanishing. Never a ranking.
 
+Our own baselines are entries like any other: they are labelled, and they rank
+where their score puts them. A baseline pinned to the bottom would hide the one
+result worth publishing -- a foundation model losing to a PCA.
+
 Task metadata is read defensively: a registry written before diseases were
 recorded yields blank cells rather than breaking the page.
 """
 
+from dataclasses import dataclass
+
 import pandas as pd
 from boards import Board, label, metric_label
 from evaluator import _norm_id
+from results import IS_BASELINE, MODEL_NAME, display_name, with_baseline_flag
 from scoring import TaskScore, category_means, sort_key
 
 EMPTY_RANKED_COLUMNS = ["Model"]
@@ -27,16 +34,31 @@ EMPTY_PER_TASK_COLUMNS = ["Task"]
 SCORE_DECIMALS = 3
 
 
+@dataclass(frozen=True)
+class TopModel:
+    """One line of a home card's mini-ranking."""
+
+    name: str
+    score: float
+    is_baseline: bool
+
+
 def _round(value: float | None) -> float | None:
     return round(value, SCORE_DECIMALS) if value is not None else None
 
 
 def latest_only(df: pd.DataFrame) -> pd.DataFrame:
-    """Keep each model's most recent submission, so nobody can shop for a lucky run."""
-    if df.empty:
-        return df
-    latest = df.groupby("model_name")["submitted_at"].transform("max")
-    return df[df["submitted_at"] == latest]
+    """Keep each entry's most recent submission, so nobody can shop for a lucky run.
+
+    An entry is ``(name, is_baseline)``, not just the name. Sharing one namespace
+    would let somebody who submits a model called ``pca-50`` bury the published
+    ``pca-50`` baseline simply by submitting after it.
+    """
+    flagged = with_baseline_flag(df)
+    if flagged.empty:
+        return flagged
+    latest = flagged.groupby([MODEL_NAME, IS_BASELINE])["submitted_at"].transform("max")
+    return flagged[flagged["submitted_at"] == latest]
 
 
 def scores_from_rows(rows: pd.DataFrame, by_id: dict[str, dict]) -> list[TaskScore]:
@@ -72,8 +94,8 @@ def _entries(df: pd.DataFrame, by_id: dict[str, dict], board: Board) -> list[dic
     """Per-category means for every model that covered the whole board."""
     scoped = _board_registry(by_id, board)
     entries = []
-    for (model, submitted), rows in latest_only(df).groupby(
-        ["model_name", "submitted_at"]
+    for (model, is_baseline, submitted), rows in latest_only(df).groupby(
+        [MODEL_NAME, IS_BASELINE, "submitted_at"]
     ):
         if not board.task_ids.issubset({_norm_id(t) for t in rows["task_id"]}):
             continue
@@ -84,6 +106,7 @@ def _entries(df: pd.DataFrame, by_id: dict[str, dict], board: Board) -> list[dic
                 "submitted_at": submitted,
                 "categories": categories,
                 "rank": sort_key(categories),
+                "is_baseline": bool(is_baseline),
             }
         )
     return sorted(entries, key=lambda e: -e["rank"])
@@ -111,7 +134,8 @@ def ranked_table(
     rows = []
     for position, entry in enumerate(entries, start=1):
         categories = entry["categories"]
-        row = {"Rank": position, "Model": entry["model_name"]}
+        model = display_name(entry["model_name"], entry["is_baseline"])
+        row = {"Rank": position, "Model": model}
         if len(columns) > 1:
             row["Mean"] = _round(entry["rank"])
         for cat in columns:
@@ -138,7 +162,8 @@ def per_task_table(
     for _, r in latest_only(df).iterrows():
         task_id = _norm_id(r["task_id"])
         if task_id in scoped:
-            scores[(task_id, str(r["model_name"]))] = float(r["score"])
+            model = display_name(str(r[MODEL_NAME]), bool(r[IS_BASELINE]))
+            scores[(task_id, model)] = float(r["score"])
     if not scores:
         return pd.DataFrame(columns=EMPTY_PER_TASK_COLUMNS)
 
@@ -165,10 +190,14 @@ def per_task_table(
 
 def top_models(
     df: pd.DataFrame, by_id: dict[str, dict], board: Board, limit: int
-) -> list[tuple[str, float]]:
-    """``(model, mean)`` for the board's best full-coverage models -- the card teaser."""
+) -> list[TopModel]:
+    """The board's best full-coverage entries -- the card teaser, baselines included."""
     return [
-        (str(e["model_name"]), round(e["rank"], SCORE_DECIMALS))
+        TopModel(
+            name=str(e["model_name"]),
+            score=round(e["rank"], SCORE_DECIMALS),
+            is_baseline=e["is_baseline"],
+        )
         for e in _entries(df, by_id, board)[:limit]
     ]
 

pages/about.md

@@ -11,8 +11,7 @@ Reconstruction is easy to score. Clinical usefulness is not. That is the gap
 PRIMO measures.
 
 Today every cohort is **bulk RNA-seq**, in **immune-mediated inflammatory
-diseases**. More modalities are coming. Three questions are asked of each
-patient:
+diseases**. Three questions are asked of each patient:
 
 | Task family | The question | Metric |
 |---|---|---|
@@ -64,12 +63,12 @@ Licences in force:
 
 {licenses}
 
-## Cite PRIMO, or add a cohort to it
+## Cite PRIMO
 
 Cite the benchmark paper: <https://openreview.net/forum?id=v2SA8gHwqo>
 
-PRIMO grows by adding cohorts, not models. If you hold a clinically annotated
-omics cohort, [get in touch](mailto:karim.elkanbi@scientalab.com).
+To add a cohort, open a modality, or partner on the methodology, see the
+**Contribute** tab.
 
 ## Links
 

pages/contribute.md

@@ -0,0 +1,44 @@
+PRIMO is an open benchmark, and it is **deliberately incomplete** — the strip at
+the top of this page says exactly how far it reaches today. Everything past that
+line is something somebody else has to bring.
+
+## Add a cohort or a task
+
+What we need is rare and it is not a model: **an omics cohort with patient-level
+clinical labels** — drug response, a severity score, a molecular subtype. If you
+hold one, or know a group that does, tell us:
+
+- **modality** and roughly how many patients
+- **what is labelled**, and how many patients carry that label
+- **disease and tissue**
+- **licence**, and whether the data can be redistributed
+
+[Propose a cohort](mailto:karim.elkanbi@scientalab.com?subject=PRIMO%20—%20cohort%20proposal)
+
+We do not have a formal acceptance process yet. It is being written with the
+first partners, and we would rather say that than invent rules we have not
+agreed on. What we can promise today is a real answer and a technical
+conversation.
+
+## Add a modality
+
+The **OPEN** cards on Home are the omics layers PRIMO does not reach yet. They
+are not a roadmap — they are gaps, and each one is claimable. Opening a modality
+takes one cohort with clinical labels, not a whole atlas.
+
+[Claim an open board](mailto:karim.elkanbi@scientalab.com?subject=PRIMO%20—%20open%20board)
+
+## Become a founding partner
+
+Founding partners shape PRIMO rather than just appear on it: a voice on the
+methodology, co-signature on what we publish, and early access to the results.
+
+[Talk to us about partnership](mailto:karim.elkanbi@scientalab.com?subject=PRIMO%20founding%20partner)
+· [primomics.org](http://primomics.org/)
+
+## Smaller ways in
+
+- **Question the method.** Open a thread in the Space's **Community** tab.
+- **Submit a model.** Baselines are on the leaderboard already; beat them.
+- **Read the paper** — [OpenReview](https://openreview.net/forum?id=v2SA8gHwqo)
+- **Look at the data** — [ScientaLab/primo](https://huggingface.co/datasets/ScientaLab/primo)

pages/submit.md

@@ -1,4 +1,19 @@
-Submit your model in **three steps**:
+**Start here, not with the docs.** Two files, both in this Space's repo:
+
+- 📥 [`quickstart.py`](https://huggingface.co/spaces/ScientaLab/primo-eval/blob/main/quickstart.py)
+  — downloads every dataset, embeds them, writes a valid submission. Swap its
+  `embed` function for your model and you are done.
+- 📄 [`example_submission.csv`](https://huggingface.co/spaces/ScientaLab/primo-eval/blob/main/example_submission.csv)
+  — four lines, fake numbers, the exact shape we expect.
+
+```bash
+pip install anndata scikit-learn pandas pyyaml huggingface_hub
+python quickstart.py --out submission.parquet
+```
+
+---
+
+Or do it by hand, in **three steps**:
 
 1. **Get the data** → download the datasets from [ScientaLab/primo](https://huggingface.co/datasets/ScientaLab/primo) (start with its `datasets.yaml`).
 2. **Embed every dataset** → build **one** file: `dataset_id`, `sample_id`, then one column per embedding dim (`e0`, `e1`, …). CSV / TSV / Parquet, or NPZ.
@@ -16,3 +31,7 @@ d002,S1,0.31,0.02,-0.15
 scored: you get ranked on every **board** whose tasks you covered in full, and
 your numbers always appear in each board's **per-task** table. Nothing is
 thrown away.
+
+**Your first target is the baselines.** Reference submissions we run ourselves —
+a random embedding, a PCA of log-CPM — appear on the boards labelled
+`(baseline)`. Beating them is the bar.

quickstart.py

@@ -0,0 +1,100 @@
+"""Produce a valid PRIMO submission in one command, then swap in your own model.
+
+Downloads every public dataset, embeds each one, and writes the single file the
+Submit tab expects. The embedding here is deliberately dumb -- log2(CPM+1) then
+PCA -- because the point is the plumbing, not the score: replace ``embed`` with
+your encoder and nothing else changes.
+
+    pip install anndata scikit-learn pandas pyyaml huggingface_hub
+    python quickstart.py --out submission.parquet
+
+Standalone on purpose: no import from this Space and none from our monorepo, so
+it keeps working if you copy the file into your own project.
+"""
+
+import argparse
+from pathlib import Path
+
+import anndata as ad
+import numpy as np
+import pandas as pd
+import yaml
+from huggingface_hub import snapshot_download
+from sklearn.decomposition import PCA
+
+PUBLIC_REPO = "ScientaLab/primo"
+MANIFEST_FILENAME = "datasets.yaml"
+
+DATASET_ID = "dataset_id"
+SAMPLE_ID = "sample_id"
+
+TARGET_SUM = 1_000_000
+N_COMPONENTS = 50
+RANDOM_STATE = 0
+
+
+def embed(adata: ad.AnnData) -> np.ndarray:
+    """One dataset's raw counts -> one vector per patient. Replace me.
+
+    Whatever you return, the contract is the same: one row per sample, in
+    ``adata.obs_names`` order, all finite. The embedding width is yours to pick
+    and may differ from one dataset to the next.
+    """
+    x = adata.X
+    x = x.toarray() if hasattr(x, "toarray") else np.asarray(x)
+    x = x.astype(float)
+    counts = x.sum(axis=1, keepdims=True)
+    x = np.log2(x / np.where(counts == 0, 1, counts) * TARGET_SUM + 1)
+    k = min(N_COMPONENTS, x.shape[0] - 1, x.shape[1])
+    return PCA(n_components=k, random_state=RANDOM_STATE).fit_transform(x)
+
+
+def download(token: str | None) -> Path:
+    """Pull the public benchmark (manifest + every ``expression.h5ad``)."""
+    return Path(snapshot_download(PUBLIC_REPO, repo_type="dataset", token=token))
+
+
+def dataset_ids(root: Path) -> list[str]:
+    """The opaque ids to embed, read off the public manifest."""
+    manifest = yaml.safe_load((root / MANIFEST_FILENAME).read_text())
+    entries = manifest.get("datasets", []) if isinstance(manifest, dict) else manifest
+    return [str(entry["id"]) for entry in entries]
+
+
+def build(root: Path) -> pd.DataFrame:
+    """Embed every dataset into the one frame the Submit tab expects.
+
+    Datasets of different widths stack into one table; the extra columns of a
+    narrower dataset stay empty and the evaluator drops them per dataset, so each
+    dataset keeps its own embedding size.
+    """
+    blocks = []
+    for dataset_id in dataset_ids(root):
+        adata = ad.read_h5ad(root / dataset_id / "expression.h5ad")
+        vectors = embed(adata)
+        print(f"{dataset_id}: {adata.n_obs} samples -> {vectors.shape[1]} dims")
+        block = pd.DataFrame(
+            vectors, columns=[f"e{i}" for i in range(vectors.shape[1])]
+        )
+        block.insert(0, SAMPLE_ID, adata.obs_names.to_numpy())
+        block.insert(0, DATASET_ID, dataset_id)
+        blocks.append(block)
+    return pd.concat(blocks, ignore_index=True)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("--out", type=Path, default=Path("submission.parquet"))
+    parser.add_argument("--token", default=None, help="HF token, if you need one.")
+    args = parser.parse_args()
+
+    submission = build(download(args.token))
+    if args.out.suffix == ".csv":
+        submission.to_csv(args.out, index=False)
+    else:
+        submission.to_parquet(args.out, index=False)
+    print(f"\nWrote {args.out} — {len(submission)} rows. Upload it on the Submit tab.")
+
+
+if __name__ == "__main__":
+    main()

results.py

@@ -0,0 +1,111 @@
+"""Persisted leaderboard rows: the results-CSV schema and its Hugging Face IO.
+
+Kept out of ``app.py`` so the schema has one owner and so the baseline publisher
+(``benchmark/public_benchmark/baselines.py``) can append rows without importing
+Gradio. ``huggingface_hub`` is imported lazily, so the unit tests touch no
+network.
+
+``is_baseline`` marks a reference submission we produced ourselves (a random
+embedding, a PCA of log-CPM) rather than a model somebody sent us. Baselines are
+ranked in place, never pinned: the point of showing them is that a foundation
+model can lose to a PCA, and a row pushed to the bottom of the table would hide
+exactly that.
+
+Rows written before the flag existed carry no column at all, so every reader
+goes through ``with_baseline_flag``: a missing or unparsable flag means "a
+submitted model", the conservative reading.
+"""
+
+import io
+
+import pandas as pd
+from evaluator import RESULTS_REPO
+
+RESULTS_FILE = "task_results.csv"
+SUBMISSIONS_FILE = "submissions.csv"
+
+MODEL_NAME = "model_name"
+IS_BASELINE = "is_baseline"
+
+RESULT_COLUMNS = [MODEL_NAME, "task_id", "score", "submitted_at", IS_BASELINE]
+SUBMISSION_COLUMNS = [
+    MODEL_NAME,
+    "submitted_at",
+    "hf_username",
+    "email",
+    "paper_link",
+    "hf_model_link",
+    "notes",
+]
+
+TRUTHY = ("true", "1")
+BASELINE_TAG = "(baseline)"
+
+
+def with_baseline_flag(df: pd.DataFrame) -> pd.DataFrame:
+    """Guarantee a boolean ``is_baseline`` column, whatever the CSV held.
+
+    Read back from CSV the column can be bool, the strings ``True``/``False``, or
+    absent on rows written before baselines existed; all of those must collapse
+    to a real boolean before anything ranks on it.
+    """
+    if IS_BASELINE not in df.columns:
+        return df.assign(**{IS_BASELINE: False})
+    flags = df[IS_BASELINE].astype(str).str.strip().str.lower().isin(TRUTHY)
+    return df.assign(**{IS_BASELINE: flags})
+
+
+def display_name(model: str, is_baseline: bool) -> str:
+    """Leaderboard label: a baseline says so, in the one column everybody reads."""
+    return f"{model} {BASELINE_TAG}" if is_baseline else model
+
+
+def read_csv(filename: str, columns: list[str], token: str | None) -> pd.DataFrame:
+    """One CSV from the private results dataset; an absent file is an empty table."""
+    from huggingface_hub import hf_hub_download
+    from huggingface_hub.utils import EntryNotFoundError, RepositoryNotFoundError
+
+    try:
+        path = hf_hub_download(RESULTS_REPO, filename, repo_type="dataset", token=token)
+    except (RepositoryNotFoundError, EntryNotFoundError):
+        return pd.DataFrame(columns=columns)
+    return pd.read_csv(path)
+
+
+def upload_csv(filename: str, df: pd.DataFrame, token: str | None) -> None:
+    """Overwrite one CSV in the private results dataset."""
+    from huggingface_hub import HfApi
+
+    api = HfApi(token=token)
+    api.create_repo(RESULTS_REPO, repo_type="dataset", private=True, exist_ok=True)
+    buffer = io.BytesIO()
+    df.to_csv(buffer, index=False)
+    buffer.seek(0)
+    api.upload_file(
+        path_or_fileobj=buffer,
+        path_in_repo=filename,
+        repo_id=RESULTS_REPO,
+        repo_type="dataset",
+    )
+
+
+def read_results(token: str | None) -> pd.DataFrame:
+    """Every persisted task score, with the baseline flag normalised."""
+    return with_baseline_flag(read_csv(RESULTS_FILE, RESULT_COLUMNS, token))
+
+
+def append_results(rows: list[dict], token: str | None) -> None:
+    """Append scored rows to the leaderboard, keeping the history intact."""
+    if not rows:
+        return
+    df = pd.concat([read_results(token), pd.DataFrame(rows)], ignore_index=True)
+    upload_csv(RESULTS_FILE, with_baseline_flag(df), token)
+
+
+def append_submission(meta: dict, token: str | None) -> None:
+    """Persist a submitter's contact metadata, never shown on a public page."""
+    df = pd.concat(
+        [read_csv(SUBMISSIONS_FILE, SUBMISSION_COLUMNS, token), pd.DataFrame([meta])],
+        ignore_index=True,
+    )
+    upload_csv(SUBMISSIONS_FILE, df, token)

style.css

@@ -1,15 +1,64 @@
+@import url("https://fonts.googleapis.com/css2?family=Funnel+Display:wght@400..800&display=swap");
+
+/* PRIMO charter, light. Cyan is a mark colour: at 2.2:1 on Paper it is
+   unreadable as text, so anything you have to read uses --primo-cyan-ink
+   (4.5:1), and raw cyan is kept for rules, dots and borders. */
 :root {
-  --primo-bg: #0b0f19;
-  --primo-card: #10151f;
-  --primo-card-hover: #151b28;
-  --primo-line: #1f2733;
-  --primo-text: #e8ebf2;
-  --primo-muted: #8b93a7;
-  --primo-dim: #626b7e;
-  --primo-modality: #60a5fa;
-  --primo-area: #2dd4bf;
-  --primo-category: #fbbf24;
-  --primo-featured: #818cf8;
+  --primo-navy: #080f5f;
+  --primo-deep-navy: #050a3c;
+  --primo-cyan: #16b3c0;
+  --primo-cyan-ink: #0f7f89;
+  --primo-paper: #f3f8f8;
+  --primo-slate: #54686b;
+  --primo-hairline: #d6e2e3;
+
+  --primo-bg: var(--primo-paper);
+  --primo-card: #ffffff;
+  --primo-card-hover: #ffffff;
+  --primo-line: var(--primo-hairline);
+  --primo-text: var(--primo-deep-navy);
+  --primo-muted: var(--primo-slate);
+  --primo-dim: #8ca0a3;
+  --primo-modality: var(--primo-navy);
+  --primo-area: var(--primo-cyan-ink);
+  --primo-category: var(--primo-slate);
+  --primo-featured: var(--primo-navy);
+  --primo-wash: rgba(8, 15, 95, 0.04);
+}
+
+.primo-home h2,
+.primo-home h3,
+.primo-board-head h2,
+.prose h1,
+.prose h2,
+.prose h3 {
+  font-family: "Funnel Display", "Funnel Sans", ui-sans-serif, system-ui, sans-serif;
+  letter-spacing: -0.015em;
+}
+
+.primo-banner {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  flex-wrap: wrap;
+  font-size: 0.82rem;
+  color: var(--primo-muted);
+  border: 1px solid var(--primo-line);
+  border-radius: 10px;
+  padding: 9px 14px;
+  margin-bottom: 4px;
+}
+
+.primo-banner-tag {
+  font-size: 0.7rem;
+  font-weight: 700;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--primo-featured);
+  background: var(--primo-wash);
+  border: 1px solid rgba(8, 15, 95, 0.18);
+  border-radius: 999px;
+  padding: 2px 9px;
 }
 
 .primo-home {
@@ -47,8 +96,8 @@
   font-weight: 600;
   letter-spacing: 0.08em;
   color: var(--primo-featured);
-  background: rgba(129, 140, 248, 0.12);
-  border: 1px solid rgba(129, 140, 248, 0.25);
+  background: var(--primo-wash);
+  border: 1px solid rgba(8, 15, 95, 0.18);
   border-radius: 999px;
   padding: 4px 12px;
   margin-bottom: 12px;
@@ -75,12 +124,13 @@
   padding: 16px 18px;
   text-decoration: none !important;
   color: inherit;
-  transition: background 0.15s ease, border-color 0.15s ease, transform 0.15s ease;
+  transition: box-shadow 0.15s ease, border-color 0.15s ease, transform 0.15s ease;
 }
 
 .primo-card:hover {
   background: var(--primo-card-hover);
   transform: translateY(-2px);
+  box-shadow: 0 6px 18px rgba(8, 15, 95, 0.1);
 }
 
 .primo-accent-modality {
@@ -102,6 +152,50 @@
   border-color: var(--primo-category);
 }
 
+/* ``align-self`` so an open card sizes to its own text: stretched to match a
+   full board it becomes a large empty rectangle, which reads as broken. */
+.primo-card-open {
+  align-self: start;
+  background: transparent;
+  border-style: dashed;
+  border-left-color: var(--primo-line);
+  opacity: 0.72;
+}
+
+.primo-card-open:hover {
+  opacity: 1;
+  background: var(--primo-card);
+  border-color: var(--primo-dim);
+}
+
+.primo-card-open .primo-card-title {
+  color: var(--primo-muted);
+}
+
+.primo-badge-open {
+  margin-left: auto;
+  font-size: 0.6rem;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  color: var(--primo-dim);
+  border: 1px solid var(--primo-line);
+  border-radius: 999px;
+  padding: 2px 8px;
+}
+
+.primo-open-cta {
+  font-size: 0.8rem;
+  font-weight: 600;
+  color: var(--primo-area);
+}
+
+.primo-count-open {
+  font-size: 0.7rem;
+  font-weight: 600;
+  color: var(--primo-dim);
+  margin-left: 6px;
+}
+
 .primo-card-head {
   display: flex;
   align-items: center;
@@ -109,9 +203,32 @@
   margin-bottom: 8px;
 }
 
-.primo-icon {
-  font-size: 1.25rem;
+/* Replaces the per-board emoji: letters scale to any modality anyone adds, and
+   the colour is the group's, so a new board needs no design decision. */
+.primo-code {
+  flex: none;
+  font-size: 0.66rem;
+  font-weight: 700;
+  letter-spacing: 0.07em;
   line-height: 1;
+  color: var(--primo-card);
+  background: var(--primo-modality);
+  border-radius: 5px;
+  padding: 5px 6px;
+}
+
+.primo-code-area {
+  background: var(--primo-area);
+}
+
+.primo-code-category {
+  background: var(--primo-category);
+}
+
+.primo-board-head .primo-code {
+  vertical-align: middle;
+  display: inline-block;
+  margin-right: 9px;
 }
 
 .primo-card-title {
@@ -198,6 +315,29 @@
   font-style: italic;
 }
 
+.primo-top-baseline span:first-child {
+  color: var(--primo-muted);
+}
+
+.primo-tag {
+  font-size: 0.6rem;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--primo-dim);
+  border: 1px solid var(--primo-line);
+  border-radius: 999px;
+  padding: 1px 6px;
+  margin-left: 7px;
+}
+
+.primo-top-foot {
+  font-size: 0.75rem;
+  color: var(--primo-dim);
+  font-style: italic;
+  border-top: 1px solid var(--primo-line);
+  padding-top: 7px;
+}
+
 .primo-pills {
   display: flex;
   flex-wrap: wrap;
@@ -207,7 +347,7 @@
 .primo-pill {
   font-size: 0.72rem;
   color: var(--primo-muted);
-  background: rgba(255, 255, 255, 0.04);
+  background: var(--primo-wash);
   border: 1px solid var(--primo-line);
   border-radius: 999px;
   padding: 2px 10px;
@@ -215,16 +355,18 @@
 
 .primo-pill-modality {
   color: var(--primo-modality);
-  border-color: rgba(96, 165, 250, 0.3);
-  background: rgba(96, 165, 250, 0.08);
+  border-color: rgba(8, 15, 95, 0.22);
+  background: var(--primo-wash);
 }
 
+/* Transparent, not white: the cards inside are white, and a white box behind
+   them would flatten the two into one surface. */
 .primo-section {
   border: 1px solid var(--primo-line);
   border-radius: 14px;
   padding: 0 0 18px;
   margin-bottom: 20px;
-  background: rgba(255, 255, 255, 0.012);
+  background: transparent;
 }
 
 .primo-section-head {
@@ -249,7 +391,7 @@
   font-size: 0.75rem;
   font-weight: 600;
   color: var(--primo-muted);
-  background: rgba(255, 255, 255, 0.06);
+  background: var(--primo-wash);
   border-radius: 999px;
   padding: 2px 9px;
   margin-left: 6px;
@@ -291,9 +433,9 @@
    theme. Scoped to :not(pre) so fenced blocks keep their own styling. */
 .md :not(pre) > code,
 .prose :not(pre) > code {
-  background: rgba(129, 140, 248, 0.12) !important;
-  color: #a5b4fc !important;
-  border: 1px solid rgba(129, 140, 248, 0.22);
+  background: rgba(22, 179, 192, 0.1) !important;
+  color: var(--primo-cyan-ink) !important;
+  border: 1px solid rgba(22, 179, 192, 0.3);
   border-radius: 5px;
   padding: 1px 6px;
   font-size: 0.9em;