Add cross-species perturbation task coverage

README.md

@@ -170,7 +170,7 @@ Keep the live benchmark unchanged until the local artifact and baseline checks
 pass. Then deploy in this order: the backward-compatible scorer, public baseline
 inputs, private targets and registry, and finally refreshed baselines. Existing
 task-result rows stay in place; their submissions simply lack coverage for the
-new datasets until their owners submit embeddings for `d011`–`d014`.
+new datasets until their owners submit embeddings for `d011`–`d016`.
 
 ## Baselines
 

conftest.py

@@ -0,0 +1,145 @@
+"""Shared fixtures for the Space unit tests -- no network, no Gradio.
+
+One small registry stands in for the real ``tasks.yaml``: two tasks share a
+dataset (so per-cohort counting is exercised), three therapeutic areas and
+three categories, all on one modality. Every dataset gets its own ``cohort_id``
+here; the tests that care about shared cohorts rewrite one.
+"""
+
+import pandas as pd
+import pytest
+from boards import build_boards
+from results import IS_BASELINE
+
+RESULT_ROW = ["model_name", "task_id", "score", "submitted_at"]
+
+REGISTRY = {
+    "t001": {
+        "task_id": "t001",
+        "dataset_id": "d001",
+        "cohort_id": "ibd-antitnf",
+        "category": "treatment_outcome",
+        "metric": "auroc",
+        "modality": "bulk RNA",
+        "therapeutic_area": "Gastroenterology",
+        "diseases": ["Crohn Disease", "Colitis, Ulcerative"],
+        "tissue": "Digestive system",
+        "title": "IBD adalimumab remission",
+        "description": "Will this patient respond?",
+        "n_samples": 90,
+        "label": {0: "no", 1: "yes"},
+        "sources": ["E-MTAB-7604"],
+        "license": "EMBL-EBI Terms of Use",
+    },
+    "t002": {
+        "task_id": "t002",
+        "dataset_id": "d002",
+        "cohort_id": "cd-mucosa",
+        "category": "clinical_scores",
+        "metric": "pearson",
+        "modality": "bulk RNA",
+        "therapeutic_area": "Gastroenterology",
+        "diseases": ["Crohn Disease"],
+        "tissue": "Digestive system",
+        "title": "Crohn SES-CD",
+        "description": "How severe?",
+        "n_samples": 120,
+        "sources": ["GSE193677"],
+        "license": "Public (NCBI GEO)",
+    },
+    "t003": {
+        "task_id": "t003",
+        "dataset_id": "d002",
+        "cohort_id": "cd-mucosa",
+        "category": "clinical_scores",
+        "metric": "pearson",
+        "modality": "bulk RNA",
+        "therapeutic_area": "Gastroenterology",
+        "diseases": ["Crohn Disease"],
+        "tissue": "Digestive system",
+        "title": "Crohn HBI",
+        "description": "How severe?",
+        "n_samples": 110,
+        "sources": ["GSE193677"],
+        "license": "Public (NCBI GEO)",
+    },
+    "t004": {
+        "task_id": "t004",
+        "dataset_id": "d005",
+        "cohort_id": "pso-skin",
+        "category": "clinical_scores",
+        "metric": "pearson",
+        "modality": "bulk RNA",
+        "therapeutic_area": "Dermatology",
+        "diseases": ["Psoriasis"],
+        "tissue": "Skin",
+        "title": "Psoriasis PASI",
+        "description": "How severe?",
+        "n_samples": 80,
+        "sources": ["GSE54456"],
+        "license": "Public (NCBI GEO)",
+    },
+    "t005": {
+        "task_id": "t005",
+        "dataset_id": "d007",
+        "cohort_id": "ra-cohort",
+        "category": "endotype",
+        "metric": "auroc",
+        "modality": "bulk RNA",
+        "therapeutic_area": "Rheumatology",
+        "diseases": ["Arthritis, Rheumatoid"],
+        "tissue": "Blood",
+        "title": "RA blood endotype",
+        "description": "Which subtype?",
+        "n_samples": 60,
+        "label": {0: "fibroid", 1: "lymphoid"},
+        "sources": ["E-MTAB-6141"],
+        "license": "EMBL-EBI Terms of Use",
+    },
+}
+
+
+@pytest.fixture
+def registry() -> dict[str, dict]:
+    return {task_id: dict(task) for task_id, task in REGISTRY.items()}
+
+
+@pytest.fixture
+def boards(registry):
+    return build_boards(registry)
+
+
+@pytest.fixture
+def named(boards):
+    """Look a board up by its display name, e.g. ``named("Rheumatology")``."""
+
+    def _named(name: str):
+        return next(
+            board for board in boards if board.name == name or board.modality == name
+        )
+
+    return _named
+
+
+@pytest.fixture
+def results():
+    """A ``task_results.csv`` frame from ``(model, task_id, score, at)`` rows.
+
+    Deliberately without ``is_baseline``: this is the shape of every row written
+    before baselines existed, so the whole suite keeps exercising that path.
+    """
+
+    def _results(*rows) -> pd.DataFrame:
+        return pd.DataFrame(list(rows), columns=RESULT_ROW)
+
+    return _results
+
+
+@pytest.fixture
+def flagged_results():
+    """The same, with the flag: ``(model, task_id, score, at, is_baseline)`` rows."""
+
+    def _flagged(*rows) -> pd.DataFrame:
+        return pd.DataFrame(list(rows), columns=[*RESULT_ROW, IS_BASELINE])
+
+    return _flagged

test_boards.py

@@ -0,0 +1,207 @@
+"""Unit tests for board construction (no network, no Gradio)."""
+
+from boards import (
+    AREA_GROUP,
+    CATEGORY_GROUP,
+    MODALITY_GROUP,
+    OPEN_BOARDS,
+    build_boards,
+    by_slug,
+    featured,
+    in_group,
+    metric_label,
+    open_in_group,
+    short_code,
+)
+
+
+def test_modality_board_holds_every_task_of_that_modality(named, registry):
+    assert named("bulk RNA").task_ids == set(registry)
+
+
+def test_area_and_category_boards_each_partition_the_modality(boards, registry):
+    for group in (AREA_GROUP, CATEGORY_GROUP):
+        covered = [tid for b in in_group(boards, group) for tid in b.task_ids]
+        assert sorted(covered) == sorted(registry)
+
+
+def test_patients_are_counted_per_cohort_not_per_task(named):
+    """t002 and t003 read off the same biopsies -- one cohort, not two."""
+    gastro = named("Gastroenterology")
+    assert gastro.n_tasks == 3
+    assert gastro.n_cohorts == 2
+    assert gastro.n_patients == 90 + 120
+
+
+def test_board_counts_roll_up_to_the_modality(named):
+    board = named("bulk RNA")
+    assert (board.n_cohorts, board.n_patients, board.n_diseases) == (4, 350, 4)
+
+
+def test_datasets_cut_from_the_same_patients_are_counted_once(registry):
+    """Two arms of one trial are two dataset_ids but one group of people."""
+    registry["t005"]["cohort_id"] = registry["t001"]["cohort_id"]
+    board = next(b for b in build_boards(registry) if b.name == "bulk RNAseq")
+    assert board.n_cohorts == 3
+    assert board.n_patients == 90 + 120 + 80
+
+
+def test_a_registry_without_cohorts_still_counts_per_dataset(registry):
+    """Falling back to dataset_id is the old behaviour, not a crash."""
+    for task in registry.values():
+        del task["cohort_id"]
+    board = next(b for b in build_boards(registry) if b.name == "bulk RNAseq")
+    assert (board.n_cohorts, board.n_patients) == (4, 350)
+
+
+def test_a_board_never_spans_two_modalities(registry):
+    registry["t006"] = {
+        **registry["t005"],
+        "task_id": "t006",
+        "modality": "single-cell",
+    }
+    for board in build_boards(registry):
+        modalities = {registry[t]["modality"] for t in board.task_ids}
+        assert modalities == {board.modality}
+
+
+def test_a_second_modality_adds_cards_instead_of_mixing_them(registry, boards):
+    """One single-cell task earns its own modality, area and category card."""
+    registry["t006"] = {
+        **registry["t005"],
+        "task_id": "t006",
+        "modality": "single-cell",
+    }
+    grown = build_boards(registry)
+    assert len(in_group(grown, MODALITY_GROUP)) == 2
+    assert len(grown) == len(boards) + 3
+    rheumatology = [b for b in grown if b.name == "Rheumatology"]
+    assert {b.modality for b in rheumatology} == {"bulk RNA", "single-cell"}
+
+
+def test_featured_leads_with_the_modality_board(boards):
+    assert [b.name for b in featured(boards)][0] == "bulk RNAseq"
+    assert len(featured(boards)) == 3
+
+
+def test_slugs_are_unique_and_url_safe(boards):
+    slugs = [b.slug for b in boards]
+    assert len(set(slugs)) == len(slugs)
+    assert all(s.replace("-", "").isalnum() for s in slugs)
+
+
+def test_unknown_slug_falls_back_to_the_hero_board(boards):
+    assert by_slug(boards, "does-not-exist").name == "bulk RNAseq"
+    assert by_slug(boards, None).name == "bulk RNAseq"
+    assert by_slug([], "anything") is None
+
+
+def test_slug_round_trips(boards):
+    for board in boards:
+        assert by_slug(boards, board.slug) is board
+
+
+def test_registry_without_areas_degrades_to_modality_boards(registry):
+    for task in registry.values():
+        del task["therapeutic_area"]
+    boards = build_boards(registry)
+    assert in_group(boards, AREA_GROUP) == []
+    assert [b.name for b in in_group(boards, MODALITY_GROUP)] == ["bulk RNAseq"]
+
+
+def test_empty_registry_yields_no_boards():
+    assert build_boards({}) == []
+
+
+def test_short_codes_come_from_the_name_not_a_lookup_table():
+    """A modality nobody planned for still gets a tag instead of a fallback."""
+    assert short_code("bulk RNA") == "BUL"
+    assert short_code("single-cell RNA") == "SIN"
+    assert short_code("Treatment outcome") == "TRE"
+    assert short_code("spatial metabolomics") == "SPA"
+    assert short_code("") == "n/a"
+    assert short_code("42 (!)") == "n/a"
+
+
+def test_every_board_carries_a_code(boards):
+    assert all(board.code.isalpha() and len(board.code) == 3 for board in boards)
+
+
+def _declared(group: str) -> list[str]:
+    return [b.name for b in OPEN_BOARDS if b.group == group]
+
+
+def test_open_boards_are_the_slices_the_registry_lacks(boards):
+    for group in (MODALITY_GROUP, AREA_GROUP):
+        names = [b.name for b in open_in_group(boards, group)]
+        assert names == _declared(group)
+    assert "bulk RNA" not in _declared(MODALITY_GROUP)
+    assert "Gastroenterology" not in _declared(AREA_GROUP)
+
+
+def test_an_open_board_drops_out_when_the_registry_covers_it(registry):
+    registry["t006"] = {
+        **registry["t005"],
+        "task_id": "t006",
+        "modality": "single-cell RNA",
+    }
+    boards = build_boards(registry)
+    names = [b.name for b in open_in_group(boards, MODALITY_GROUP)]
+    assert "single-cell RNAseq" not in names
+    assert len(names) == len(_declared(MODALITY_GROUP)) - 1
+
+
+def test_an_open_area_drops_out_when_a_cohort_lands_there(registry):
+    registry["t006"] = {
+        **registry["t005"],
+        "task_id": "t006",
+        "therapeutic_area": "Oncology",
+    }
+    names = [b.name for b in open_in_group(build_boards(registry), AREA_GROUP)]
+    assert "Oncology" not in names
+    assert names == ["Neurology", "Pulmonology"]
+
+
+def test_task_categories_never_get_an_open_card(boards):
+    """A category is pinned to one metric, so an open one would promise a probe."""
+    assert open_in_group(boards, CATEGORY_GROUP) == []
+    assert _declared(CATEGORY_GROUP) == []
+
+
+def test_an_empty_registry_still_states_every_open_slice():
+    assert len(open_in_group([], MODALITY_GROUP)) == len(_declared(MODALITY_GROUP))
+    assert len(open_in_group([], AREA_GROUP)) == len(_declared(AREA_GROUP))
+
+
+def test_a_truncated_list_drops_the_and(registry):
+    """``a, b and c…`` reads as an ellipsis stuck to c; ``a, b, c…`` reads as more."""
+    from boards import _join
+
+    assert _join(["a", "b"]) == "a and b"
+    assert _join(["a", "b", "c"]) == "a, b and c"
+    assert _join(["a", "b", "c", "d"]) == "a, b, c…"
+    assert _join([]) == "n/a"
+
+
+def test_blurbs_describe_what_the_board_asks(named):
+    assert "bulk RNAseq" in named("bulk RNA").blurb
+    assert "respond" in named("Treatment outcome").blurb
+    assert named("Clinical scores").blurb == "How severe is this patient's disease?"
+    assert "Psoriasis" in named("Dermatology").blurb
+
+
+def test_perturbation_category_is_a_regular_board_with_residual_spearman(registry):
+    registry["t018"] = {
+        **registry["t005"],
+        "task_id": "t018",
+        "category": "perturbation_prediction",
+        "metric": "residual_spearman",
+    }
+    board = next(
+        board
+        for board in build_boards(registry)
+        if board.name == "Perturbation response"
+    )
+    assert board.task_ids == {"t018"}
+    assert "treatment" in board.blurb.lower()
+    assert metric_label("residual_spearman") == "Residual Spearman score"

test_evaluator.py

@@ -0,0 +1,787 @@
+"""Unit tests for the standalone PRIMO probe + score_all (no network)."""
+
+import evaluator as ev
+import numpy as np
+import pandas as pd
+import pytest
+
+
+def test_results_stay_with_scientalab_until_the_history_is_migrated():
+    assert ev.RESULTS_REPO == "ScientaLab/primo-results"
+
+
+def _labels(y, folds, ids=None, repeat_folds=None):
+    ids = ids if ids is not None else [f"s{i}" for i in range(len(y))]
+    labels = pd.DataFrame({ev.SAMPLE_ID: ids, ev.LABEL: y, ev.FOLD: folds})
+    if repeat_folds is not None:
+        for repeat, values in enumerate(repeat_folds, start=1):
+            labels[f"{ev.FOLD}_{repeat}"] = values
+    return labels
+
+
+def _emb_frame(matrix, ids=None):
+    ids = ids if ids is not None else [f"s{i}" for i in range(len(matrix))]
+    df = pd.DataFrame(matrix)
+    df.index = ids
+    return df
+
+
+def _folds(n, k=5):
+    return np.array([i % k for i in range(n)])
+
+
+def _task(task_id, dataset_id, task_type, metric, therapeutic_area, category=None):
+    if category is None:
+        category = "treatment_outcome" if metric == "auroc" else "clinical_scores"
+    return {
+        "task_id": task_id,
+        "dataset_id": dataset_id,
+        "task_type": task_type,
+        "metric": metric,
+        "category": category,
+        "therapeutic_area": therapeutic_area,
+        "disease": "PRIVATE",
+        "tissue": "PRIVATE",
+    }
+
+
+def _classification(n=60, seed=42, signal=True):
+    rng = np.random.default_rng(seed)
+    y = np.array([0, 1] * (n // 2))
+    emb = rng.normal(size=(n, 8))
+    if signal:
+        emb[:, 0] += 3.0 * y
+    ids = [f"s{i}" for i in range(n)]
+    task = _task("t001", "d001", "classification", "auroc", "Gastro")
+    return task, _labels(y, _folds(n), ids), ids, emb
+
+
+def _regression(n=60, seed=7, signal=True):
+    rng = np.random.default_rng(seed)
+    y = rng.normal(size=n)
+    emb = rng.normal(size=(n, 8))
+    if signal:
+        emb[:, 0] += 2.0 * y
+    ids = [f"r{i}" for i in range(n)]
+    task = _task("t002", "d002", "regression", "pearson", "Derm")
+    return task, _labels(y, _folds(n), ids), ids, emb
+
+
+def _write_csv(path, blocks):
+    """blocks = {dataset_id: (ids, matrix)} -> a multi-dataset CSV (NaN-padded)."""
+    frames = []
+    for dataset_id, (ids, mat) in blocks.items():
+        df = pd.DataFrame(mat, columns=[f"e{j}" for j in range(mat.shape[1])])
+        df.insert(0, ev.SAMPLE_ID, ids)
+        df.insert(0, ev.DATASET_ID, dataset_id)
+        frames.append(df)
+    pd.concat(frames, ignore_index=True).to_csv(path, index=False)
+
+
+def _no_fetch(task_id, token=None):
+    raise AssertionError("fetch_labels should not have been called")
+
+
+# --- probe: repeated fold-wise scoring ---
+
+
+def test_repeated_cv_score_averages_external_partitions(monkeypatch):
+    labels = _labels(
+        np.array([0, 1, 0, 1]),
+        np.array([0, 1, 0, 1]),
+        repeat_folds=[np.array([1, 0, 1, 0]), np.array([2, 0, 2, 0])],
+    )
+    seen = []
+
+    def fold_score(metric, task_type, y, folds, matrix, classes):
+        seen.append(folds[0])
+        return float(folds[0])
+
+    monkeypatch.setattr(ev, "_fold_score", fold_score)
+    score = ev._repeated_cv_score(
+        metric="auroc",
+        task_type="classification",
+        y=labels[ev.LABEL].to_numpy(),
+        labels=labels,
+        matrix=np.ones((4, 2)),
+        classes=np.array([0, 1]),
+    )
+    assert seen == [0, 1, 2]
+    assert score == 1.0
+
+
+def test_classification_signal_and_null():
+    task, labels, ids, emb = _classification(signal=True)
+    res = ev.score_task(task, labels, _emb_frame(emb, ids))
+    assert res.score > 0.9
+    _, _, ids0, null = _classification(signal=False)
+    res0 = ev.score_task(task, labels, _emb_frame(null, ids0))
+    assert 0.3 < res0.score < 0.7
+
+
+def test_regression_signal_and_null():
+    task, labels, ids, emb = _regression(signal=True)
+    res = ev.score_task(task, labels, _emb_frame(emb, ids))
+    assert res.score > 0.8
+    _, _, ids0, null = _regression(signal=False)
+    res0 = ev.score_task(task, labels, _emb_frame(null, ids0))
+    assert abs(res0.score) < 0.4
+
+
+def test_score_carries_ids_category_and_size():
+    task, labels, ids, emb = _classification(n=30)
+    res = ev.score_task(task, labels, _emb_frame(emb, ids))
+    assert res.task_id == "t001"
+    assert res.dataset_id == "d001"
+    assert res.n_samples == 30
+    assert res.category == "treatment_outcome"
+    assert res.metric == "auroc"
+    assert np.isfinite(res.score)
+
+
+def test_missing_sample_raises():
+    emb = _emb_frame(np.random.default_rng(1).normal(size=(5, 3)))
+    labels = _labels(np.array([0, 1, 0, 1, 0, 1]), _folds(6))
+    with pytest.raises(ev.SubmissionError, match="missing"):
+        ev._align(labels, emb)
+
+
+def test_nan_raises():
+    matrix = np.ones((4, 3))
+    matrix[0, 0] = np.nan
+    labels = _labels(np.array([0, 1, 0, 1]), np.array([0, 1, 2, 3]))
+    with pytest.raises(ev.SubmissionError, match="NaN"):
+        ev._align(labels, _emb_frame(matrix))
+
+
+def test_id_normalisation_int_vs_str():
+    emb = _emb_frame(np.eye(4), ids=["0", "1", "2", "3"])
+    labels = _labels(np.array([0, 1, 0, 1]), np.array([0, 1, 2, 3]), ids=[0, 1, 2, 3])
+    assert ev._align(labels, emb).shape == (4, 4)
+
+
+# --- multi-dataset loader ---
+
+
+def test_multidataset_loader_csv(tmp_path):
+    rng = np.random.default_rng(0)
+    blocks = {
+        "d001": (["a", "b"], rng.normal(size=(2, 4))),
+        "d002": (["0", "1", "2"], rng.normal(size=(3, 4))),
+    }
+    _write_csv(tmp_path / "sub.csv", blocks)
+    out = ev.load_submission(tmp_path / "sub.csv")
+    assert set(out) == {"d001", "d002"}
+    assert ev._to_embedding_frame(out["d001"]).shape == (2, 4)
+    assert list(ev._to_embedding_frame(out["d002"]).index) == ["0", "1", "2"]
+
+
+def test_multidataset_loader_npz(tmp_path):
+    rng = np.random.default_rng(1)
+    ids = np.array(["a", "b", "c", "d"])
+    dsids = np.array(["d001", "d001", "d002", "d002"])
+    emb = rng.normal(size=(4, 5))
+    np.savez(tmp_path / "sub.npz", dataset_ids=dsids, sample_ids=ids, embeddings=emb)
+    out = ev.load_submission(tmp_path / "sub.npz")
+    assert set(out) == {"d001", "d002"}
+    assert ev._to_embedding_frame(out["d001"]).shape == (2, 5)
+
+
+def test_missing_dataset_id_column_raises(tmp_path):
+    df = pd.DataFrame({ev.SAMPLE_ID: ["a", "b"], "e0": [0.1, 0.2]})
+    df.to_csv(tmp_path / "sub.csv", index=False)
+    with pytest.raises(ev.SubmissionError, match="dataset_id"):
+        ev.load_submission(tmp_path / "sub.csv")
+
+
+def test_ragged_padding_dims(tmp_path):
+    blocks = {
+        "d001": (["a", "b"], np.ones((2, 4))),
+        "d002": (["a", "b"], np.ones((2, 6))),
+    }
+    _write_csv(tmp_path / "sub.csv", blocks)
+    out = ev.load_submission(tmp_path / "sub.csv")
+    assert ev._to_embedding_frame(out["d001"]).shape[1] == 4
+    assert ev._to_embedding_frame(out["d002"]).shape[1] == 6
+
+
+def test_sample_id_reused_across_datasets_ok(tmp_path):
+    blocks = {
+        "d001": (["x", "y"], np.ones((2, 3))),
+        "d002": (["x", "y"], np.ones((2, 3))),
+    }
+    _write_csv(tmp_path / "sub.csv", blocks)
+    out = ev.load_submission(tmp_path / "sub.csv")
+    assert ev._to_embedding_frame(out["d001"]).shape == (2, 3)
+    assert ev._to_embedding_frame(out["d002"]).shape == (2, 3)
+
+
+def test_duplicate_within_dataset_raises():
+    df = pd.DataFrame({ev.SAMPLE_ID: ["a", "a"], "e0": [1.0, 2.0], "e1": [3.0, 4.0]})
+    with pytest.raises(ev.SubmissionError, match="duplicate"):
+        ev._to_embedding_frame(df)
+
+
+# --- registry ---
+
+
+def test_load_tasks_registry_duplicate_raises(tmp_path):
+    path = tmp_path / "tasks.yaml"
+    path.write_text(
+        "tasks:\n"
+        "  - {task_id: t1, dataset_id: d001}\n"
+        "  - {task_id: t1, dataset_id: d002}\n"
+    )
+    with pytest.raises(ev.EvaluatorError, match="duplicate"):
+        ev.load_tasks_registry(path)
+
+
+def test_scoreable_tasks_skips_orphans():
+    tasks = [
+        _task("t1", "d001", "classification", "auroc", "G"),
+        _task("t9", "d999", "regression", "pearson", "D"),
+    ]
+    kept = ev.scoreable_tasks(tasks, {"d001"})
+    assert [t["task_id"] for t in kept] == ["t1"]
+
+
+# --- score_all: offline via injected datasets + tasks + fetch_labels ---
+
+
+def _two_task_submission(tmp_path, signal=True):
+    _, cl, cids, cemb = _classification(signal=signal)
+    _, rl, rids, remb = _regression(signal=signal)
+    _write_csv(tmp_path / "sub.csv", {"d001": (cids, cemb), "d002": (rids, remb)})
+    tasks = [
+        _task("t1", "d001", "classification", "auroc", "Gastro"),
+        _task("t2", "d002", "regression", "pearson", "Derm"),
+    ]
+    labels_by = {"t1": cl, "t2": rl}
+    fetch = lambda tid, token=None: labels_by[tid]  # noqa: E731
+    datasets = [{"id": "d001"}, {"id": "d002"}]
+    return tmp_path / "sub.csv", datasets, tasks, fetch
+
+
+def test_score_all_full_coverage_signal(tmp_path):
+    path, datasets, tasks, fetch = _two_task_submission(tmp_path, signal=True)
+    res = ev.score_all(path, datasets=datasets, tasks=tasks, fetch_labels=fetch)
+    assert res["full_coverage"] is True
+    assert res["n_scored"] == 2 and res["n_total"] == 2
+    assert res["coverage"] == 1.0
+    assert res["categories"]["treatment_outcome"]["mean"] > 0.8
+    assert res["categories"]["clinical_scores"]["mean"] > 0.6
+    assert set(res["categories"]) == {"treatment_outcome", "clinical_scores"}
+    assert res["missing"] == [] and res["invalid"] == []
+    assert res["incomplete"] == []
+    assert res["n_datasets_scored"] == 2 and res["n_datasets_total"] == 2
+
+
+def test_score_all_null_is_chance(tmp_path):
+    path, datasets, tasks, fetch = _two_task_submission(tmp_path, signal=False)
+    res = ev.score_all(path, datasets=datasets, tasks=tasks, fetch_labels=fetch)
+    assert res["categories"]["treatment_outcome"]["mean"] < 0.7
+
+
+def test_multi_task_per_dataset(tmp_path):
+    _, cl, cids, cemb = _classification(signal=True)
+    yreg = np.random.default_rng(3).normal(size=len(cids))
+    rl = _labels(yreg, _folds(len(cids)), cids)
+    _write_csv(tmp_path / "s.csv", {"d001": (cids, cemb)})
+    tasks = [
+        _task("t1", "d001", "classification", "auroc", "Gastro"),
+        _task("t2", "d001", "regression", "pearson", "Gastro"),
+    ]
+    labels_by = {"t1": cl, "t2": rl}
+    fetch = lambda tid, token=None: labels_by[tid]  # noqa: E731
+    res = ev.score_all(
+        path=tmp_path / "s.csv",
+        datasets=[{"id": "d001"}],
+        tasks=tasks,
+        fetch_labels=fetch,
+    )
+    assert res["n_total"] == 2 and res["n_scored"] == 2
+    assert res["full_coverage"] is True
+    assert res["n_datasets_total"] == 1 and res["n_datasets_scored"] == 1
+    assert set(res["categories"]) == {"treatment_outcome", "clinical_scores"}
+    assert res["incomplete"] == []
+
+
+def test_missing_dataset_makes_all_its_tasks_missing(tmp_path):
+    _, cl, cids, cemb = _classification()
+    _write_csv(tmp_path / "s.csv", {"d001": (cids, cemb)})
+    tasks = [
+        _task("t1", "d001", "classification", "auroc", "Gastro"),
+        _task("t2", "d002", "regression", "pearson", "Derm"),
+    ]
+    fetch = lambda tid, token=None: {"t1": cl}[tid]  # noqa: E731
+    res = ev.score_all(
+        path=tmp_path / "s.csv",
+        datasets=[{"id": "d001"}, {"id": "d002"}],
+        tasks=tasks,
+        fetch_labels=fetch,
+    )
+    assert res["missing"] == ["d002"]
+    assert res["full_coverage"] is False
+    assert res["n_scored"] == 1 and res["n_total"] == 2
+    assert res["n_datasets_scored"] == 1
+    assert res["incomplete"] == []
+
+
+def test_invalid_task_when_dataset_embedded(tmp_path):
+    _, cl, cids, cemb = _classification(n=60)
+    _write_csv(tmp_path / "s.csv", {"d001": (cids, cemb)})
+    tasks = [
+        _task("t1", "d001", "classification", "auroc", "Gastro"),
+        _task("t2", "d001", "classification", "auroc", "Gastro"),
+    ]
+    bad = _labels(
+        np.array([0, 1, 0, 1]), np.array([0, 1, 2, 3]), ids=["z0", "z1", "z2", "z3"]
+    )
+    fetch = lambda tid, token=None: {"t1": cl, "t2": bad}[tid]  # noqa: E731
+    res = ev.score_all(
+        path=tmp_path / "s.csv",
+        datasets=[{"id": "d001"}],
+        tasks=tasks,
+        fetch_labels=fetch,
+    )
+    assert res["n_scored"] == 1 and res["full_coverage"] is False
+    invalid = res["invalid"][0]
+    assert invalid["task_id"] == "t2" and invalid["dataset_id"] == "d001"
+    assert res["incomplete"] == ["d001"]
+    assert res["n_datasets_scored"] == 0
+
+
+def test_block_invalid_fails_all_its_tasks(tmp_path):
+    df = pd.DataFrame(
+        {
+            ev.DATASET_ID: ["d001", "d001"],
+            ev.SAMPLE_ID: ["a", "a"],
+            "e0": [1.0, 2.0],
+            "e1": [3.0, 4.0],
+        }
+    )
+    df.to_csv(tmp_path / "s.csv", index=False)
+    tasks = [
+        _task("t1", "d001", "classification", "auroc", "Gastro"),
+        _task("t2", "d001", "regression", "pearson", "Gastro"),
+    ]
+    res = ev.score_all(
+        path=tmp_path / "s.csv",
+        datasets=[{"id": "d001"}],
+        tasks=tasks,
+        fetch_labels=_no_fetch,
+    )
+    assert res["n_scored"] == 0
+    reasons = {i["task_id"]: i["reason"] for i in res["invalid"]}
+    assert set(reasons) == {"t1", "t2"}
+    assert "duplicate" in reasons["t1"] and reasons["t1"] == reasons["t2"]
+    assert res["incomplete"] == ["d001"]
+
+
+def test_score_all_unknown_dataset_raises(tmp_path):
+    _, cl, cids, cemb = _classification()
+    _write_csv(
+        tmp_path / "s.csv", {"d001": (cids, cemb), "d999": (["a"], np.ones((1, 8)))}
+    )
+    tasks = [_task("t1", "d001", "classification", "auroc", "Gastro")]
+    with pytest.raises(ev.SubmissionError, match="unknown"):
+        ev.score_all(
+            path=tmp_path / "s.csv",
+            datasets=[{"id": "d001"}],
+            tasks=tasks,
+            fetch_labels=_no_fetch,
+        )
+
+
+def test_incomplete_dataset_is_invalid(tmp_path):
+    _, cl, cids, cemb = _classification(n=60)
+    _write_csv(tmp_path / "s.csv", {"d001": (cids[:-5], cemb[:-5])})
+    tasks = [_task("t1", "d001", "classification", "auroc", "Gastro")]
+    fetch = lambda tid, token=None: cl  # noqa: E731
+    res = ev.score_all(
+        path=tmp_path / "s.csv",
+        datasets=[{"id": "d001"}],
+        tasks=tasks,
+        fetch_labels=fetch,
+    )
+    assert res["n_scored"] == 0
+    assert res["invalid"][0]["task_id"] == "t1"
+    assert "missing" in res["invalid"][0]["reason"]
+    assert res["incomplete"] == ["d001"]
+
+
+def test_scoring_error_is_invalid(tmp_path):
+    n = 20
+    folds = np.repeat(np.arange(5), 4)
+    y = np.zeros(n, dtype=int)
+    y[:2] = 1
+    ids = [f"s{i}" for i in range(n)]
+    emb = np.random.default_rng(0).normal(size=(n, 6))
+    labels = _labels(y, folds, ids)
+    _write_csv(tmp_path / "s.csv", {"d001": (ids, emb)})
+    tasks = [_task("t1", "d001", "classification", "auroc", "Gastro")]
+    fetch = lambda tid, token=None: labels  # noqa: E731
+    res = ev.score_all(
+        path=tmp_path / "s.csv",
+        datasets=[{"id": "d001"}],
+        tasks=tasks,
+        fetch_labels=fetch,
+    )
+    assert res["n_scored"] == 0
+    assert "single class" in res["invalid"][0]["reason"]
+
+
+def test_fetch_failure_raises_evaluator_error(tmp_path, monkeypatch):
+    monkeypatch.setattr(ev, "FETCH_BACKOFF", 0.0)
+    _, cl, cids, cemb = _classification()
+    _write_csv(tmp_path / "s.csv", {"d001": (cids, cemb)})
+    tasks = [_task("t1", "d001", "classification", "auroc", "Gastro")]
+
+    def boom(task_id, token=None):
+        raise ConnectionError("HF unreachable")
+
+    with pytest.raises(ev.EvaluatorError, match="could not load"):
+        ev.score_all(
+            path=tmp_path / "s.csv",
+            datasets=[{"id": "d001"}],
+            tasks=tasks,
+            fetch_labels=boom,
+        )
+
+
+def test_unknown_metric_raises_evaluator_error(tmp_path):
+    _, cl, cids, cemb = _classification()
+    _write_csv(tmp_path / "s.csv", {"d001": (cids, cemb)})
+    tasks = [_task("t1", "d001", "classification", "bogus", "Gastro")]
+    fetch = lambda tid, token=None: cl  # noqa: E731
+    with pytest.raises(ev.EvaluatorError, match="unknown metric"):
+        ev.score_all(
+            path=tmp_path / "s.csv",
+            datasets=[{"id": "d001"}],
+            tasks=tasks,
+            fetch_labels=fetch,
+        )
+
+
+# --- transfer: fit once on the train cohort, score the test cohort ---
+
+
+def _transfer_labels(y, split, ids=None):
+    ids = ids if ids is not None else [f"s{i}" for i in range(len(y))]
+    return pd.DataFrame({ev.SAMPLE_ID: ids, ev.LABEL: y, ev.SPLIT: split})
+
+
+def _transfer_classification(n_train=40, n_test=20, seed=42, signal=True):
+    rng = np.random.default_rng(seed)
+    n = n_train + n_test
+    y = np.array([0, 1] * (n // 2))
+    emb = rng.normal(size=(n, 8))
+    if signal:
+        emb[:, 0] += 3.0 * y
+    split = np.array([ev.SPLIT_TRAIN] * n_train + [ev.SPLIT_TEST] * n_test)
+    ids = [f"s{i}" for i in range(n)]
+    task = _task("t016", "d010", "classification", "auroc", "Gastro")
+    return task, _transfer_labels(y, split, ids), ids, emb
+
+
+def test_transfer_scoring_signal_and_null():
+    task, labels, ids, emb = _transfer_classification(signal=True)
+    res = ev.score_task(task, labels, _emb_frame(emb, ids))
+    assert res.score > 0.8
+    assert res.n_samples == 20
+    task0, labels0, ids0, null = _transfer_classification(signal=False)
+    res0 = ev.score_task(task0, labels0, _emb_frame(null, ids0))
+    assert 0.3 < res0.score < 0.7
+
+
+def test_transfer_single_class_train_raises_submission_error():
+    y = np.array([0, 0, 0, 0, 1, 0])
+    split = np.array([ev.SPLIT_TRAIN] * 4 + [ev.SPLIT_TEST] * 2)
+    ids = [f"s{i}" for i in range(6)]
+    emb = np.random.default_rng(0).normal(size=(6, 5))
+    task = _task("t016", "d010", "classification", "auroc", "Gastro")
+    with pytest.raises(ev.SubmissionError):
+        ev.score_task(task, _transfer_labels(y, split, ids), _emb_frame(emb, ids))
+
+
+def test_load_labels_accepts_repeated_fold_or_split(tmp_path):
+    _labels(
+        np.array([0, 1, 0, 1]),
+        _folds(4),
+        repeat_folds=[np.array([1, 0, 1, 0]), np.array([2, 0, 2, 0])],
+    ).to_csv(tmp_path / "f.csv", index=False)
+    labels = ev.load_labels(tmp_path / "f.csv")
+    assert ev._fold_columns(labels) == ["fold", "fold_1", "fold_2"]
+    _transfer_labels(np.array([0, 1]), ["train", "test"]).to_csv(
+        tmp_path / "s.csv", index=False
+    )
+    assert ev.SPLIT in ev.load_labels(tmp_path / "s.csv").columns
+
+
+def test_load_labels_rejects_both_and_neither(tmp_path):
+    both = pd.DataFrame(
+        {ev.SAMPLE_ID: ["a"], ev.LABEL: [0], ev.FOLD: [0], ev.SPLIT: ["train"]}
+    )
+    both.to_csv(tmp_path / "both.csv", index=False)
+    with pytest.raises(ev.EvaluatorError, match="exactly one"):
+        ev.load_labels(tmp_path / "both.csv")
+    neither = pd.DataFrame({ev.SAMPLE_ID: ["a"], ev.LABEL: [0]})
+    neither.to_csv(tmp_path / "neither.csv", index=False)
+    with pytest.raises(ev.EvaluatorError, match="exactly one"):
+        ev.load_labels(tmp_path / "neither.csv")
+
+
+def test_score_all_transfer_two_tasks(tmp_path):
+    _, l16, ids, emb = _transfer_classification(signal=True)
+    y = l16[ev.LABEL].to_numpy()
+    rev = np.where(
+        l16[ev.SPLIT].to_numpy() == ev.SPLIT_TRAIN, ev.SPLIT_TEST, ev.SPLIT_TRAIN
+    )
+    l17 = _transfer_labels(y, rev, ids)
+    _write_csv(tmp_path / "sub.csv", {"d010": (ids, emb)})
+    tasks = [
+        _task("t016", "d010", "classification", "auroc", "Gastro"),
+        _task("t017", "d010", "classification", "auroc", "Gastro"),
+    ]
+    labels_by = {"t016": l16, "t017": l17}
+    fetch = lambda tid, token=None: labels_by[tid]  # noqa: E731
+    res = ev.score_all(
+        path=tmp_path / "sub.csv",
+        datasets=[{"id": "d010"}],
+        tasks=tasks,
+        fetch_labels=fetch,
+    )
+    assert res["n_total"] == 2 and res["n_scored"] == 2
+    assert res["full_coverage"] is True
+    assert res["n_datasets_total"] == 1 and res["n_datasets_scored"] == 1
+    assert set(res["categories"]) == {"treatment_outcome"}
+
+
+# --- perturbation response decoding ---
+
+
+def _perturbation_task(task_id="t018", dataset_id="d011", pairing="paired"):
+    return {
+        "task_id": task_id,
+        "dataset_id": dataset_id,
+        "task_type": ev.PERTURBATION,
+        "metric": ev.RESIDUAL_SPEARMAN,
+        "category": "perturbation_prediction",
+        "therapeutic_area": "Dermatology",
+        "pairing": pairing,
+        "n_top_de_genes": 4,
+    }
+
+
+def _perturbation_labels(ids, folds):
+    return pd.DataFrame(
+        {
+            ev.SAMPLE_ID: ids,
+            ev.PAIR_ID: [f"p{i}" for i in range(len(ids))],
+            ev.PAIRING: ev.PAIRED,
+            ev.FOLD: folds,
+            f"{ev.FOLD}_1": np.roll(folds, 1),
+            f"{ev.FOLD}_2": np.roll(folds, 2),
+        }
+    )
+
+
+def test_perturbation_constant_embedding_anchors_at_chance():
+    rng = np.random.default_rng(12)
+    n = 30
+    ids = [f"s{i}" for i in range(n)]
+    labels = _perturbation_labels(ids, _folds(n, 3))
+    targets = ev.PerturbationTargets(
+        delta=rng.normal(size=(n, 8)), gene_ids=np.array([f"g{i}" for i in range(8)])
+    )
+    result = ev.score_task(
+        _perturbation_task(), labels, _emb_frame(np.ones((n, 3)), ids), targets
+    )
+    assert result.score == pytest.approx(0.5, abs=1e-12)
+    assert len(result.repeat_scores) == 3
+    assert result.diagnostics == {}
+
+
+def test_perturbation_signal_decodes_hidden_response():
+    rng = np.random.default_rng(4)
+    n = 45
+    ids = [f"s{i}" for i in range(n)]
+    emb = rng.normal(size=(n, 5))
+    weights = rng.normal(size=(5, 8))
+    delta = emb @ weights + rng.normal(scale=0.01, size=(n, 8))
+    labels = _perturbation_labels(ids, _folds(n, 3))
+    targets = ev.PerturbationTargets(delta, np.array([f"g{i}" for i in range(8)]))
+    result = ev.score_task(_perturbation_task(), labels, _emb_frame(emb, ids), targets)
+    assert result.score > 0.9
+    assert result.diagnostics == {}
+
+
+def test_perturbation_decoder_clips_test_coordinates(monkeypatch):
+    seen = {}
+
+    class Decoder:
+        def fit(self, matrix, delta):
+            self.mean = delta.mean(axis=0)
+            return self
+
+        def predict(self, matrix):
+            seen["maximum"] = float(np.max(np.abs(matrix)))
+            return np.tile(self.mean, (len(matrix), 1))
+
+    monkeypatch.setattr(ev, "RidgeCV", lambda alphas: Decoder())
+    matrix = np.array([[0.0], [1.0], [1_000_000.0]])
+    delta = np.array([[1.0, 2.0], [2.0, 1.0], [3.0, 4.0]])
+    score = ev._perturbation_fold(
+        matrix,
+        delta,
+        np.array([True, True, False]),
+        np.array([False, False, True]),
+        2,
+    )
+
+    assert seen["maximum"] == ev.PERTURBATION_TEST_Z_CLIP
+    assert score == pytest.approx(0.5)
+
+
+def test_deg_selection_uses_only_the_supplied_training_rows():
+    delta = np.array(
+        [
+            [8.0, 0.0],
+            [8.0, 0.0],
+            [0.0, 100.0],
+            [0.0, 100.0],
+        ]
+    )
+    source = np.array([True, True, False, False])
+    assert ev._select_degs(delta[source], 1).tolist() == [0]
+    assert ev._select_degs(delta[~source], 1).tolist() == [1]
+
+
+def test_directional_transfer_never_fits_on_target_disease(monkeypatch):
+    matrix = np.arange(24, dtype=float).reshape(6, 4)
+    delta = np.arange(18, dtype=float).reshape(6, 3)
+    labels = pd.DataFrame(
+        {
+            ev.SPLIT: [ev.SPLIT_TRAIN] * 4 + [ev.SPLIT_TEST] * 2,
+        }
+    )
+    seen = {}
+
+    def fold(matrix_arg, delta_arg, train, test, n_top):
+        seen["train"] = np.flatnonzero(train).tolist()
+        seen["test"] = np.flatnonzero(test).tolist()
+        seen["n_top"] = n_top
+        return 0.75
+
+    monkeypatch.setattr(ev, "_perturbation_fold", fold)
+    metrics, n_test = ev._transfer_perturbation_scores(matrix, delta, labels, 2)
+    assert seen == {
+        "train": [0, 1, 2, 3],
+        "test": [4, 5],
+        "n_top": 2,
+    }
+    assert metrics == (0.75,)
+    assert n_test == 2
+
+
+def test_repeated_sample_ids_reuse_one_baseline_embedding():
+    labels = pd.DataFrame({ev.SAMPLE_ID: ["s1", "s1", "s2", "s1"]})
+    embeddings = _emb_frame(np.array([[1.0, 2.0], [3.0, 4.0]]), ["s1", "s2"])
+    aligned = ev._align(labels, embeddings)
+    np.testing.assert_array_equal(
+        aligned,
+        np.array([[1.0, 2.0], [1.0, 2.0], [3.0, 4.0], [1.0, 2.0]]),
+    )
+
+
+def test_mouse_cartesian_partitions_isolate_both_specimens():
+    controls = np.repeat(["c1", "c2", "c3"], 3)
+    perturbed = np.tile(["p1", "p2", "p3"], 3)
+    repeats = ev._cartesian_partitions(controls, perturbed)
+    assert len(repeats) == 6
+    assert all(len(folds) == 3 for folds in repeats)
+    tested_edges = []
+    for folds in repeats:
+        for train, test in folds:
+            held = np.flatnonzero(test)[0]
+            tested_edges.append((controls[held], perturbed[held]))
+            assert train.sum() == 4 and test.sum() == 1
+            assert not np.any(controls[train] == controls[held])
+            assert not np.any(perturbed[train] == perturbed[held])
+    assert set(tested_edges) == set(zip(controls, perturbed))
+    assert len(tested_edges) == 18
+
+
+def test_mouse_task_has_six_regular_weighted_repeat_scores():
+    rng = np.random.default_rng(7)
+    controls = np.repeat(["c1", "c2", "c3"], 3)
+    perturbed = np.tile(["p1", "p2", "p3"], 3)
+    sample_ids = np.repeat(["s1", "s2", "s3"], 3)
+    labels = pd.DataFrame(
+        {
+            ev.SAMPLE_ID: sample_ids,
+            ev.PAIR_ID: [f"pair{i}" for i in range(9)],
+            ev.CONTROL_ID: controls,
+            ev.PERTURBED_ID: perturbed,
+            ev.PAIRING: ev.CARTESIAN,
+        }
+    )
+    embeddings = _emb_frame(np.ones((3, 2)), ["s1", "s2", "s3"])
+    targets = ev.PerturbationTargets(
+        rng.normal(size=(9, 6)), np.array([f"g{i}" for i in range(6)])
+    )
+    result = ev.score_task(
+        _perturbation_task("t020", "d012", ev.CARTESIAN),
+        labels,
+        embeddings,
+        targets,
+    )
+    assert result.score == pytest.approx(0.5, abs=1e-12)
+    assert len(result.repeat_scores) == 6
+    assert result.category == "perturbation_prediction"
+
+
+def test_load_private_perturbation_artifacts(tmp_path):
+    labels = pd.DataFrame(
+        {
+            ev.SAMPLE_ID: ["s1", "s2"],
+            ev.PAIR_ID: ["p1", "p2"],
+            ev.PAIRING: [ev.PAIRED, ev.PAIRED],
+            ev.FOLD: [0, 1],
+        }
+    )
+    labels.to_csv(tmp_path / ev.LABELS_FILENAME, index=False)
+    np.savez_compressed(
+        tmp_path / ev.TARGETS_FILENAME,
+        delta=np.ones((2, 3)),
+        gene_ids=np.array(["1", "2", "3"]),
+    )
+    loaded_labels = ev.load_labels(tmp_path / ev.LABELS_FILENAME)
+    loaded_targets = ev.load_targets(tmp_path / ev.TARGETS_FILENAME)
+    assert ev.LABEL not in loaded_labels
+    assert loaded_targets.delta.shape == (2, 3)
+
+
+def test_score_all_fetches_hidden_targets_only_for_perturbation(tmp_path):
+    rng = np.random.default_rng(31)
+    n = 30
+    ids = [f"s{i}" for i in range(n)]
+    emb = rng.normal(size=(n, 4))
+    targets = ev.PerturbationTargets(
+        emb @ rng.normal(size=(4, 6)), np.array([f"g{i}" for i in range(6)])
+    )
+    labels = _perturbation_labels(ids, _folds(n, 3))
+    _write_csv(tmp_path / "submission.csv", {"d011": (ids, emb)})
+    result = ev.score_all(
+        tmp_path / "submission.csv",
+        datasets=[{"id": "d011"}],
+        tasks=[_perturbation_task()],
+        fetch_labels=lambda task_id, token=None: labels,
+        fetch_targets=lambda task_id, token=None: targets,
+    )
+    assert result["full_coverage"] is True
+    assert (
+        result["categories"]["perturbation_prediction"]["metric"]
+        == ev.RESIDUAL_SPEARMAN
+    )
+    assert result["per_task"][0].diagnostics == {}

test_leaderboard.py

@@ -0,0 +1,292 @@
+"""Unit tests for the board tables and page copy (no network, no Gradio)."""
+
+import re
+
+import pandas as pd
+import pytest
+from conftest import REGISTRY
+from leaderboard import (
+    RESERVED_COLUMNS,
+    TASK_COLUMNS,
+    latest_only,
+    per_task_table,
+    ranked_table,
+    source_repositories,
+    tasks_table,
+    top_models,
+)
+
+ALL_SCORES = (0.8, 0.5, 0.6, 0.4, 0.7)
+
+
+def _full(model: str, at: str, scores=ALL_SCORES) -> list[tuple]:
+    return [(model, tid, s, at) for tid, s in zip(REGISTRY, scores)]
+
+
+def _flagged(model: str, at: str, baseline: bool, scores=ALL_SCORES) -> list[tuple]:
+    return [(model, tid, s, at, baseline) for tid, s in zip(REGISTRY, scores)]
+
+
+def test_full_board_coverage_is_ranked_and_partial_is_not(registry, named, results):
+    df = results(*_full("full", "2026-01-01"), ("partial", "t001", 0.99, "2026-01-01"))
+    board = ranked_table(df, registry, named("bulk RNA"))
+    assert list(board["Model"]) == ["full"]
+
+
+def test_a_partial_model_is_ranked_on_the_board_it_fully_covered(
+    registry, named, results
+):
+    """Covering all of Rheumatology ranks you there, even with Dermatology missing."""
+    df = results(
+        *_full("full", "2026-01-01"),
+        ("rheuma_only", "t005", 0.95, "2026-01-01"),
+    )
+    assert list(ranked_table(df, registry, named("bulk RNA"))["Model"]) == ["full"]
+    rheumatology = ranked_table(df, registry, named("Rheumatology"))
+    assert list(rheumatology["Model"]) == ["rheuma_only", "full"]
+
+
+def test_ranks_are_ordered_by_the_mean_of_the_category_means(registry, named, results):
+    df = results(
+        *_full("better", "2026-01-01", scores=(0.9, 0.9, 0.9, 0.9, 0.9)),
+        *_full("worse", "2026-01-01", scores=(0.2, 0.2, 0.2, 0.2, 0.2)),
+    )
+    board = ranked_table(df, registry, named("bulk RNA"))
+    assert list(board["Model"]) == ["better", "worse"]
+    assert list(board["Rank"]) == [1, 2]
+
+
+def test_one_column_per_category_in_its_native_metric(registry, named, results):
+    df = results(*_full("full", "2026-01-01"))
+    board = ranked_table(df, registry, named("bulk RNA"))
+    assert "Treatment outcome (AUROC)" in board.columns
+    assert "Clinical scores (Pearson)" in board.columns
+    assert "Endotype (AUROC)" in board.columns
+
+
+def test_comparison_columns_are_present_for_every_board(registry, named, results):
+    df = results(*_full("full", "2026-01-01"))
+    assert {"Elo", "Mean score", "Mean rank"} <= set(
+        ranked_table(df, registry, named("bulk RNA")).columns
+    )
+    endotype = ranked_table(df, registry, named("Endotype"))
+    assert {"Elo", "Mean score", "Mean rank"} <= set(endotype.columns)
+    assert "Endotype (AUROC)" in endotype.columns
+
+
+def test_latest_submission_wins_so_scores_cannot_be_shopped(registry, named, results):
+    df = results(
+        *_full("m", "2026-01-01", scores=(0.9,) * 5),
+        *_full("m", "2026-02-01", scores=(0.1,) * 5),
+    )
+    assert set(latest_only(df)["submitted_at"]) == {"2026-02-01"}
+    board = ranked_table(df, registry, named("bulk RNA"))
+    assert board.loc[0, "Treatment outcome (AUROC)"] == pytest.approx(0.1)
+
+
+def test_equal_timestamp_submissions_do_not_mix_scores_or_credits(
+    registry, named, results
+):
+    older = results(*_full("m", "2026-02-01", scores=(0.9,) * 5)).assign(
+        submission_id="2026-02-01T00:00:00.000001-a",
+        institution="Older University",
+        is_author_submission=False,
+        paper_link="https://example.org/older",
+    )
+    newer = results(*_full("m", "2026-02-01", scores=(0.1,) * 5)).assign(
+        submission_id="2026-02-01T00:00:00.000002-b",
+        institution="Newer University",
+        is_author_submission=True,
+        paper_link="https://example.org/newer",
+    )
+    board = ranked_table(pd.concat([older, newer]), registry, named("bulk RNA"))
+    assert board.loc[0, "Treatment outcome (AUROC)"] == pytest.approx(0.1)
+    assert "Author" not in board
+    assert board.loc[0, "Institution"] == "Newer University"
+    assert board.loc[0, "Model"].paper_link == "https://example.org/newer"
+    assert board.loc[0, "Model"].is_author_submission is True
+
+
+def test_nullable_credits_render_as_missing(registry, named, results):
+    df = results(*_full("m", "2026-01-01")).assign(
+        institution=float("nan"),
+        paper_link=pd.NA,
+        is_author_submission=pd.NA,
+    )
+    board = ranked_table(df, registry, named("bulk RNA"))
+    assert pd.isna(board.loc[0, "Institution"])
+    assert board.loc[0, "Model"].paper_link == ""
+    assert board.loc[0, "Model"].is_author_submission is False
+
+
+def test_a_model_scoring_nothing_finite_ranks_below_a_bad_one(registry, named, results):
+    """NaN everywhere is "no score", which must not outrank a negative Pearson."""
+    df = results(
+        *_full("nan-everywhere", "2026-01-01", scores=(float("nan"),) * 5),
+        *_full("bad", "2026-01-01", scores=(-0.2,) * 5),
+    )
+    board = ranked_table(df, registry, named("bulk RNA"))
+    assert list(board["Model"]) == ["bad", "nan-everywhere"]
+    assert board.loc[1, "Elo"] == 1000
+
+
+def test_a_card_shows_a_dash_rather_than_minus_infinity(registry, named, results):
+    df = results(*_full("nan-everywhere", "2026-01-01", scores=(float("nan"),) * 5))
+    top = top_models(df, registry, named("bulk RNA"), 3)
+    assert top[0].elo is None
+
+
+def test_ranked_is_empty_when_nobody_covered_the_board(registry, named, results):
+    df = results(("partial", "t001", 0.9, "2026-01-01"))
+    assert ranked_table(df, registry, named("Rheumatology")).empty
+
+
+def test_per_task_keeps_partial_submissions_with_gaps(registry, named, results):
+    df = results(
+        *_full("full", "2026-01-01"),
+        ("partial", "t002", 0.95, "2026-01-01"),
+    )
+    table = per_task_table(df, registry, named("Gastroenterology")).set_index("Task")
+    assert list(table.index) == [
+        "IBD adalimumab remission",
+        "Crohn SES-CD",
+        "Crohn HBI",
+    ]
+    assert table.loc["Crohn SES-CD", "partial"] == pytest.approx(0.95)
+    assert table.loc["Crohn SES-CD", "Best"] == "partial"
+    assert pd.isna(table.loc["Crohn HBI", "partial"])
+    assert table.loc["Crohn HBI", "Best"] == "full"
+
+
+def test_reserved_names_are_exactly_the_per_task_metadata_columns(
+    registry, named, results
+):
+    """A model named after one of these would overwrite it -- Submit refuses them."""
+    df = results(("m", "t004", 0.5, "2026-01-01"))
+    table = per_task_table(df, registry, named("Dermatology"))
+    assert RESERVED_COLUMNS == set(table.columns) - {"m"}
+
+
+def test_per_task_only_shows_the_board_it_was_asked_for(registry, named, results):
+    df = results(*_full("full", "2026-01-01"))
+    tasks = set(per_task_table(df, registry, named("Dermatology"))["Task"])
+    assert tasks == {"Psoriasis PASI"}
+
+
+def test_per_task_is_empty_when_no_result_touches_the_board(registry, named, results):
+    df = results(("partial", "t001", 0.9, "2026-01-01"))
+    assert per_task_table(df, registry, named("Rheumatology")).empty
+
+
+def test_top_models_are_ordered_and_limited(registry, named, results):
+    df = results(
+        *_full("a", "2026-01-01", scores=(0.9,) * 5),
+        *_full("b", "2026-01-01", scores=(0.5,) * 5),
+        *_full("c", "2026-01-01", scores=(0.1,) * 5),
+    )
+    top = top_models(df, registry, named("bulk RNA"), 2)
+    assert [entry.name for entry in top] == ["a", "b"]
+    assert top_models(df, registry, named("bulk RNA"), 3)[0].elo > 1000
+    assert not any(entry.is_baseline for entry in top)
+
+
+def test_top_models_ignores_models_that_did_not_cover_the_board(
+    registry, named, results
+):
+    df = results(("partial", "t001", 0.99, "2026-01-01"))
+    assert top_models(df, registry, named("bulk RNA"), 3) == []
+
+
+def test_a_baseline_is_ranked_in_place_and_labelled(registry, named, flagged_results):
+    """A PCA that beats a submitted model belongs above it, not in a footnote."""
+    df = flagged_results(
+        *_flagged("pca-50", "2026-01-01", True, scores=(0.9,) * 5),
+        *_flagged("eva", "2026-01-01", False, scores=(0.4,) * 5),
+    )
+    board = ranked_table(df, registry, named("bulk RNA"))
+    assert list(board["Model"]) == ["pca-50 (baseline)", "eva"]
+    assert list(board["Rank"]) == [1, 2]
+
+
+def test_rows_written_before_the_flag_existed_are_not_baselines(
+    registry, named, results
+):
+    df = results(*_full("eva", "2026-01-01"))
+    assert list(ranked_table(df, registry, named("bulk RNA"))["Model"]) == ["eva"]
+
+
+def test_a_model_cannot_bury_a_baseline_by_reusing_its_name(
+    registry, named, flagged_results
+):
+    """Same name, different kind: two entries, and the later one hides nothing."""
+    df = flagged_results(
+        *_flagged("pca-50", "2026-01-01", True, scores=(0.9,) * 5),
+        *_flagged("pca-50", "2026-06-01", False, scores=(0.2,) * 5),
+    )
+    board = ranked_table(df, registry, named("bulk RNA"))
+    assert list(board["Model"]) == ["pca-50 (baseline)", "pca-50"]
+    assert "pca-50 (baseline)" in per_task_table(df, registry, named("Dermatology"))
+
+
+def test_a_resubmission_still_replaces_the_entry_of_the_same_kind(
+    registry, named, flagged_results
+):
+    df = flagged_results(
+        *_flagged("eva", "2026-01-01", False, scores=(0.9,) * 5),
+        *_flagged("eva", "2026-06-01", False, scores=(0.2,) * 5),
+    )
+    board = ranked_table(df, registry, named("bulk RNA"))
+    assert list(board["Model"]) == ["eva"]
+    assert board.loc[0, "Endotype (AUROC)"] == pytest.approx(0.2)
+
+
+def test_per_task_columns_name_the_baseline(registry, named, flagged_results):
+    df = flagged_results(*_flagged("random-32", "2026-01-01", True))
+    table = per_task_table(df, registry, named("Dermatology"))
+    assert "random-32 (baseline)" in table.columns
+    assert table.loc[0, "Best"] == "random-32 (baseline)"
+
+
+def test_top_models_carry_the_baseline_flag(registry, named, flagged_results):
+    df = flagged_results(*_flagged("pca-50", "2026-01-01", True))
+    assert top_models(df, registry, named("bulk RNA"), 3)[0].is_baseline
+
+
+def test_tasks_table_shows_biology_but_never_provenance(registry):
+    table = tasks_table(list(registry.values())).set_index("Task")
+    row = table.loc["IBD adalimumab remission"]
+    assert row["Disease"] == "Crohn Disease, Colitis, Ulcerative"
+    assert row["Tissue"] == "Digestive system"
+    assert row["Patients"] == 90
+    assert row["Metric"] == "AUROC"
+    assert row["Family"] == "Treatment outcome"
+    assert row["Predicts"] == "Will this patient respond?"
+
+
+def test_tasks_table_is_ordered_by_task_id(registry):
+    assert list(tasks_table(list(registry.values()))["Task"])[0] == (
+        "IBD adalimumab remission"
+    )
+
+
+def test_tasks_table_never_leaks_an_accession(registry):
+    rendered = tasks_table(list(registry.values())).to_string()
+    assert not re.search(r"GSE\d+|E-MTAB-\d+|benchmark_", rendered)
+
+
+def test_source_repositories_name_the_archive_not_the_study(registry):
+    repositories = source_repositories(list(registry.values()))
+    assert repositories == ["EMBL-EBI ArrayExpress", "NCBI GEO"]
+    assert not re.search(r"GSE\d+|E-MTAB-\d+", " ".join(repositories))
+
+
+def test_the_unvalidated_licence_field_never_reaches_a_public_page(registry):
+    """One hand-written line per dataset must not read as a checked rights position."""
+    assert "license" in next(iter(registry.values()))
+    assert not any(
+        "Terms of Use" in r for r in source_repositories(list(registry.values()))
+    )
+
+
+def test_empty_registry_yields_an_empty_table_not_a_crash():
+    assert list(tasks_table([]).columns) == TASK_COLUMNS

test_render.py

@@ -0,0 +1,248 @@
+"""Unit tests for the PRIMO page markup (no network, no Gradio).
+
+These guard the guarantees a redesign must not lose: every board is reachable,
+open slices route to Contribute, registry and submission text is escaped, the
+baseline/first-submission states read correctly, the leaderboard bolds the best
+value, provenance never leaks, and public submission credits are safely escaped.
+"""
+
+import re
+
+from boards import build_boards, open_in_group
+from render import SECTIONS, rail_html, render_board, render_boards, render_tasks
+
+
+def _slugs(html: str) -> list[str]:
+    return re.findall(r'href="\?board=([^"]+)"', html)
+
+
+def _boards_html(boards, registry, results):
+    df = results(*[("eva", tid, 0.8, "2026-01-01") for tid in registry])
+    return render_boards(boards, df, registry)
+
+
+# ---------------------------------------------------------------- boards page
+def test_every_board_is_reachable_from_the_boards_page(boards, registry, results):
+    html = _boards_html(boards, registry, results)
+    assert set(_slugs(html)) == {b.slug for b in boards}
+
+
+def test_each_facet_section_shows_with_its_note(boards, registry, results):
+    html = _boards_html(boards, registry, results)
+    assert "Per therapeutic areas" in html
+    assert "Task Category" in html
+    assert "Every task of one omics layer" in html
+    assert "PRIMO evaluates representations of omics samples" in html
+
+
+def test_modality_labels_are_displayed_as_rnaseq(boards, registry, results):
+    html = _boards_html(boards, registry, results)
+    assert "bulk RNAseq" in html
+    assert "single-cell RNAseq" in html
+    assert "Leaderboards" in html
+
+
+def test_open_cards_state_the_slices_nobody_covers(boards, registry, results):
+    html = _boards_html(boards, registry, results)
+    assert "proteomics" in html
+    assert "Oncology" in html
+    assert "OPEN" in html
+
+
+def test_both_open_axes_get_their_own_counter(boards, registry, results):
+    """Modality and Therapeutic Areas each declare three gaps, so each says +3."""
+    assert _boards_html(boards, registry, results).count("+3 open") == 2
+
+
+def test_an_open_card_sends_the_visitor_to_contribute(boards, registry, results):
+    html = _boards_html(boards, registry, results)
+    assert 'href="?tab=contribute"' in html
+    assert "Propose a cohort" in html
+
+
+def test_an_open_card_disappears_once_the_registry_covers_it(registry, results):
+    registry["t006"] = {
+        **registry["t005"],
+        "task_id": "t006",
+        "modality": "single-cell RNA",
+    }
+    boards = build_boards(registry)
+    html = _boards_html(boards, registry, results)
+    assert 'href="?board=single-cell-rna"' in html
+    assert "+2 open" in html
+    assert "proteomics" in html
+
+
+def test_live_cards_teaser_the_leaders(boards, registry, results):
+    html = _boards_html(boards, registry, results)
+    assert "Leading" in html
+    assert "eva" in html
+
+
+def test_a_board_nobody_covered_invites_the_first_submission(boards, registry, results):
+    """A board no model covered in full asks for the first entry, not a leader."""
+    html = render_boards(boards, results(("eva", "t001", 0.8, "2026-01-01")), registry)
+    assert "be the first" in html.lower()
+
+
+def test_a_board_held_only_by_baselines_lists_its_models(
+    boards, registry, flagged_results
+):
+    """A board card lists its leading models without special baseline copy."""
+    df = flagged_results(
+        *[("pca-50", tid, 0.8, "2026-01-01", True) for tid in registry]
+    )
+    html = render_boards(boards, df, registry)
+    assert "be the first" not in html.lower()
+    assert "baseline</span>" in html
+
+
+def test_a_submitted_model_removes_the_challenger_line(
+    boards, registry, flagged_results
+):
+    df = flagged_results(
+        *[("pca-50", tid, 0.8, "2026-01-01", True) for tid in registry],
+        *[("eva", tid, 0.9, "2026-01-01", False) for tid in registry],
+    )
+    html = render_boards(boards, df, registry)
+    assert "baseline</span>" in html
+
+
+def test_cards_carry_their_counts(boards, registry, results):
+    html = _boards_html(boards, registry, results)
+    assert "patients" in html and "cohorts" in html and "diseases" in html
+
+
+def test_registry_text_is_escaped_on_the_boards_page(registry, results):
+    registry["t004"]["diseases"] = ['<img src=x onerror="alert(1)">']
+    boards = build_boards(registry)
+    html = _boards_html(boards, registry, results)
+    assert "<img src=x" not in html
+    assert "&lt;img src=x" in html
+
+
+# ------------------------------------------------------------------- board page
+def test_ranked_table_bolds_the_best_and_captions_full_coverage(
+    boards, registry, named, flagged_results
+):
+    df = flagged_results(
+        *[("eva", tid, 0.9, "2026-01-01", False) for tid in registry],
+        *[("foo", tid, 0.5, "2026-01-01", False) for tid in registry],
+    )
+    html = render_board(named("bulk RNA"), df, registry)
+    assert "are ranked" in html
+    assert "eva" in html and "foo" in html
+    assert "font-weight:700" in html  # the best value is bolded
+
+
+def test_data_tables_expose_sortable_column_headers(boards, registry, named, results):
+    df = results(*[("eva", task_id, 0.8, "2026-01-01") for task_id in registry])
+    html = render_board(named("bulk RNA"), df, registry)
+    assert 'class="pm-sort" data-sort-index="0"' in html
+    assert 'aria-sort="none"' in html
+
+
+def test_ranked_board_shows_only_the_institution_credit(
+    boards, registry, flagged_results
+):
+    df = flagged_results(*[("eva", tid, 0.9, "2026-01-01", False) for tid in registry])
+    df["institution"] = "Scienta"
+    html = render_board(build_boards(registry)[0], df, registry)
+    assert "Institution" in html and "Scienta" in html
+    assert "Team" not in html
+    assert "Author" not in html
+
+
+def test_board_escapes_submission_credit(registry, named, flagged_results):
+    df = flagged_results(*[("eva", tid, 0.9, "2026-01-01", False) for tid in registry])
+    df["institution"] = "<script>alert(1)</script>"
+    html = render_board(named("bulk RNA"), df, registry)
+    assert "<script>" not in html and "&lt;script&gt;" in html
+
+
+def test_author_submission_gets_a_check_chip_and_paper_link(
+    registry, named, flagged_results
+):
+    df = flagged_results(*[("eva", tid, 0.9, "2026-01-01", False) for tid in registry])
+    df["is_author_submission"] = True
+    df["paper_link"] = "https://example.org/paper"
+    html = render_board(named("bulk RNA"), df, registry)
+    assert 'href="https://example.org/paper"' in html
+    assert ">eva</a>" in html
+    assert 'class="pm-author-chip"' in html
+    assert "✓ Authors" in html
+
+
+def test_unsafe_paper_link_is_not_rendered_as_a_link(registry, named, flagged_results):
+    df = flagged_results(*[("eva", tid, 0.9, "2026-01-01", False) for tid in registry])
+    df["paper_link"] = 'javascript:alert("x")'
+    html = render_board(named("bulk RNA"), df, registry)
+    assert "javascript:" not in html
+    assert ">eva<" in html
+
+
+def test_board_keeps_legacy_private_owners_hidden(registry, named, flagged_results):
+    df = flagged_results(*[("eva", tid, 0.9, "2026-01-01", False) for tid in registry])
+    df["hf_username"] = "legacy-private-owner"
+    html = render_board(named("bulk RNA"), df, registry)
+    assert "legacy-private-owner" not in html
+
+
+def test_board_escapes_a_hostile_model_name(registry, named, flagged_results):
+    hostile = "<img src=x onerror=1>"
+    df = flagged_results(
+        *[(hostile, tid, 0.9, "2026-01-01", False) for tid in registry]
+    )
+    html = render_board(named("bulk RNA"), df, registry)
+    assert "<img src=x" not in html
+    assert "&lt;img src=x" in html
+
+
+def test_an_empty_board_invites_the_first_submission(registry, results, named):
+    html = render_board(named("bulk RNA"), results(), registry)
+    assert "be the first" in html.lower()
+
+
+def test_a_missing_board_renders_a_message_not_a_crash(registry, results):
+    html = render_board(None, results(), registry)
+    assert "No board available" in html
+
+
+# ------------------------------------------------------------------- tasks page
+def test_tasks_page_shows_biology_but_never_an_accession(registry):
+    html = render_tasks(registry)
+    assert "Crohn Disease" in html
+    assert "Treatment outcome" in html
+    assert not re.search(r"GSE\d+|E-MTAB-\d+", html)
+
+
+def test_tasks_page_escapes_registry_text(registry):
+    registry["t004"]["diseases"] = ['<img src=x onerror="alert(1)">']
+    html = render_tasks(registry)
+    assert "<img src=x" not in html
+    assert "&lt;img src=x" in html
+
+
+# ------------------------------------------------------------------------ rail
+def test_rail_links_every_board_and_marks_the_active_one(boards):
+    active = boards[0].slug
+    html = rail_html(boards, active, None)
+    assert set(_slugs(html)) == {b.slug for b in boards}
+    assert f'class="pm-link pm-active" target="_self" href="?board={active}"' in html
+    assert "Submit a model" in html
+
+
+def test_rail_groups_contain_their_board_links(boards):
+    html = rail_html(boards, None, None)
+    groups = re.findall(r'<div class="pm-rail-group">(.*?)</div>', html)
+    grouped = "".join(groups)
+    n_open = sum(len(open_in_group(boards, group)) for group in SECTIONS)
+
+    assert set(_slugs(grouped)) == {board.slug for board in boards}
+    assert grouped.count('href="?tab=contribute"') == n_open
+
+
+def test_rail_open_slices_route_to_contribute(boards):
+    html = rail_html(boards, None, None)
+    assert 'href="?tab=contribute"' in html
+    assert "proteomics" in html

test_results.py

@@ -0,0 +1,123 @@
+"""Unit tests for the results schema (no network, no Gradio)."""
+
+import numpy as np
+import pandas as pd
+from results import (
+    INSTITUTION,
+    IS_AUTHOR_SUBMISSION,
+    IS_BASELINE,
+    OWNER,
+    PAPER_LINK,
+    RESULT_COLUMNS,
+    SUBMISSION_COLUMNS,
+    SUBMISSION_ID,
+    display_name,
+    owner_of,
+    with_author_submission_flag,
+    with_baseline_flag,
+    with_institution,
+    with_owner,
+    with_paper_link,
+    with_submission_id,
+)
+
+
+def _frame(**columns) -> pd.DataFrame:
+    return pd.DataFrame({"model_name": ["m"], "score": [0.5], **columns})
+
+
+def _rows(*rows) -> pd.DataFrame:
+    return pd.DataFrame(list(rows), columns=["model_name", IS_BASELINE, OWNER])
+
+
+def test_a_missing_column_means_nobody_is_a_baseline():
+    flagged = with_baseline_flag(_frame())
+    assert list(flagged[IS_BASELINE]) == [False]
+
+
+def test_booleans_survive_the_round_trip():
+    flagged = with_baseline_flag(_frame(**{IS_BASELINE: [True]}))
+    assert list(flagged[IS_BASELINE]) == [True]
+
+
+def test_the_strings_a_csv_gives_back_are_read_as_booleans():
+    """``read_csv`` yields ``"True"``/``"False"`` as soon as one row is blank."""
+    flagged = with_baseline_flag(
+        pd.DataFrame({IS_BASELINE: ["True", "false", "TRUE ", np.nan, ""]})
+    )
+    assert list(flagged[IS_BASELINE]) == [True, False, True, False, False]
+
+
+def test_submission_identity_is_part_of_both_schemas():
+    assert {
+        IS_BASELINE,
+        OWNER,
+        INSTITUTION,
+        IS_AUTHOR_SUBMISSION,
+        PAPER_LINK,
+        SUBMISSION_ID,
+    } <= set(RESULT_COLUMNS)
+    assert {OWNER, INSTITUTION, IS_AUTHOR_SUBMISSION, PAPER_LINK, SUBMISSION_ID} <= set(
+        SUBMISSION_COLUMNS
+    )
+    assert "diagnostics" in RESULT_COLUMNS
+
+
+def test_only_baselines_are_labelled():
+    assert display_name("pca-50", True) == "pca-50 (baseline)"
+    assert display_name("eva-rna-v1", False) == "eva-rna-v1"
+
+
+def test_rows_written_before_the_owner_existed_are_unclaimed():
+    assert list(with_owner(_frame())[OWNER]) == [""]
+    assert list(with_owner(_frame(**{OWNER: [np.nan]}))[OWNER]) == [""]
+
+
+def test_rows_written_before_the_institution_existed_have_no_institution():
+    assert list(with_institution(_frame())[INSTITUTION]) == [""]
+    assert list(with_institution(_frame(**{INSTITUTION: [np.nan]}))[INSTITUTION]) == [
+        ""
+    ]
+
+
+def test_legacy_team_values_are_read_as_institutions():
+    frame = _frame(team=["Legacy Lab"])
+    assert list(with_institution(frame)[INSTITUTION]) == ["Legacy Lab"]
+
+
+def test_explicit_institution_wins_over_legacy_team():
+    frame = _frame(institution=["Current Lab"], team=["Old Lab"])
+    assert list(with_institution(frame)[INSTITUTION]) == ["Current Lab"]
+
+
+def test_legacy_rows_are_not_marked_as_author_submissions():
+    assert list(with_author_submission_flag(_frame())[IS_AUTHOR_SUBMISSION]) == [False]
+    assert list(
+        with_author_submission_flag(_frame(**{IS_AUTHOR_SUBMISSION: [np.nan]}))[
+            IS_AUTHOR_SUBMISSION
+        ]
+    ) == [False]
+
+
+def test_nullable_public_credits_and_submission_ids_normalize_to_blank():
+    frame = _frame(
+        **{PAPER_LINK: [pd.NA], INSTITUTION: [pd.NA], SUBMISSION_ID: [pd.NA]}
+    )
+    assert list(with_paper_link(frame)[PAPER_LINK]) == [""]
+    assert list(with_institution(frame)[INSTITUTION]) == [""]
+    assert list(with_submission_id(frame)[SUBMISSION_ID]) == [""]
+
+
+def test_a_name_is_owned_by_whoever_submitted_it():
+    assert owner_of(_rows(("eva", False, "scienta")), "eva") == "scienta"
+
+
+def test_an_unclaimed_or_unknown_name_is_free():
+    assert owner_of(_rows(("eva", False, "")), "eva") == ""
+    assert owner_of(_rows(("eva", False, "scienta")), "other") == ""
+    assert owner_of(pd.DataFrame(), "eva") == ""
+
+
+def test_publishing_a_baseline_never_locks_the_name_for_submitters():
+    """``pca-50`` the baseline and ``pca-50`` the model are separate entries."""
+    assert owner_of(_rows(("pca-50", True, "scienta")), "pca-50") == ""

test_scoring.py

@@ -0,0 +1,133 @@
+"""Unit tests for the pure scoring policy (no network, no probe)."""
+
+import numpy as np
+import pytest
+from scoring import (
+    TaskScore,
+    category_means,
+    compute_auroc,
+    compute_pearson,
+    compute_residual_sample_spearman,
+    sort_key,
+)
+
+
+def _score(task_id, dataset_id, category, metric, score):
+    return TaskScore(task_id, dataset_id, category, metric, score, 10)
+
+
+def test_compute_auroc_binary():
+    y = np.array([0, 0, 1, 1])
+    proba = np.array([[0.9, 0.1], [0.6, 0.4], [0.3, 0.7], [0.2, 0.8]])
+    assert compute_auroc(y, proba) == pytest.approx(1.0)
+
+
+def test_transfer_auroc_reads_the_column_of_the_class_it_scores():
+    """Test cohort holds 2 of 3 classes: scoring class 1's column would be wrong."""
+    y_true = np.array([0, 0, 2, 2])
+    preds = np.array(
+        [[0.7, 0.2, 0.1], [0.6, 0.3, 0.1], [0.1, 0.3, 0.6], [0.2, 0.2, 0.6]]
+    )
+
+    assert compute_auroc(y_true, preds, np.array([0, 1, 2])) == 1.0
+    assert compute_auroc(y_true, preds[:, ::-1], np.array([0, 1, 2])) == 0.0
+
+
+def test_auroc_survives_a_class_the_training_fold_never_saw():
+    """Zeroed column + renormalisation, instead of sklearn's sum-to-one refusal."""
+    y_true = np.array([0, 0, 1, 1, 2, 2])
+    preds = np.zeros((6, 3))
+    preds[:, 0] = [0.9, 0.8, 0.2, 0.1, 0.2, 0.1]
+    preds[:, 1] = [0.1, 0.2, 0.8, 0.9, 0.3, 0.2]
+
+    score = compute_auroc(y_true, preds, np.array([0, 1, 2]))
+
+    assert 0.0 <= score <= 1.0
+
+
+def test_auroc_refuses_predictions_with_no_mass_on_the_present_classes():
+    y_true = np.array([0, 0, 1, 1])
+    preds = np.zeros((4, 3))
+    preds[:, 2] = 1.0
+
+    with pytest.raises(ValueError, match="no probability"):
+        compute_auroc(y_true, preds, np.array([0, 1, 2]))
+
+
+def test_compute_pearson_and_degenerate():
+    perfect = compute_pearson(np.array([1.0, 2, 3]), np.array([1.0, 2, 3]))
+    assert perfect == pytest.approx(1.0)
+    assert np.isnan(compute_pearson(np.array([1.0, 2, 3]), np.array([5.0, 5, 5])))
+
+
+def test_residual_sample_spearman_anchors_mean_response_at_zero():
+    training_mean = np.array([10.0, 20.0, 30.0, 40.0])
+    truth = training_mean + np.array([[1.0, 3.0, -1.0, 2.0]])
+    baseline = training_mean[None, :]
+
+    assert compute_residual_sample_spearman(
+        truth, truth, training_mean
+    ) == pytest.approx(1.0)
+    assert compute_residual_sample_spearman(
+        truth, baseline, training_mean
+    ) == pytest.approx(0.0)
+
+
+def test_category_means_groups_by_category():
+    scores = [
+        _score("t1", "d1", "treatment_outcome", "auroc", 0.8),
+        _score("t2", "d2", "treatment_outcome", "auroc", 0.6),
+        _score("t3", "d3", "clinical_scores", "pearson", 0.4),
+    ]
+    cats = category_means(scores)
+    assert cats["treatment_outcome"] == {
+        "metric": "auroc",
+        "mean": pytest.approx(0.7),
+        "n_tasks": 2,
+    }
+    assert cats["clinical_scores"]["mean"] == pytest.approx(0.4)
+    assert cats["clinical_scores"]["n_tasks"] == 1
+
+
+def test_category_means_drops_non_finite_from_mean():
+    scores = [
+        _score("t1", "d1", "clinical_scores", "pearson", 0.4),
+        _score("t2", "d2", "clinical_scores", "pearson", float("nan")),
+    ]
+    cats = category_means(scores)
+    assert cats["clinical_scores"]["mean"] == pytest.approx(0.4)
+    assert cats["clinical_scores"]["n_tasks"] == 2
+
+
+def test_category_means_all_non_finite_is_nan():
+    scores = [_score("t1", "d1", "endotype", "auroc", float("nan"))]
+    assert np.isnan(category_means(scores)["endotype"]["mean"])
+
+
+def test_category_means_empty():
+    assert category_means([]) == {}
+
+
+def test_sort_key_is_mean_of_category_means():
+    cats = {
+        "treatment_outcome": {"metric": "auroc", "mean": 0.8, "n_tasks": 1},
+        "clinical_scores": {"metric": "pearson", "mean": 0.2, "n_tasks": 1},
+    }
+    assert sort_key(cats) == pytest.approx(0.5)
+
+
+def test_sort_key_ignores_non_finite_and_empty():
+    cats = {
+        "treatment_outcome": {"metric": "auroc", "mean": 0.8, "n_tasks": 1},
+        "endotype": {"metric": "auroc", "mean": float("nan"), "n_tasks": 1},
+    }
+    assert sort_key(cats) == pytest.approx(0.8)
+
+
+def test_nothing_finite_sorts_last_instead_of_at_zero():
+    """A constant embedding scores NaN everywhere; that must not beat a bad score."""
+    nothing = {"clinical_scores": {"metric": "pearson", "mean": float("nan")}}
+    negative = {"clinical_scores": {"metric": "pearson", "mean": -0.2}}
+    assert sort_key(nothing) == float("-inf")
+    assert sort_key({}) == float("-inf")
+    assert sort_key(nothing) < sort_key(negative)